Is PHP Dead? The 2026 Picture, by the Numbers
A view from 18 years of PHP development — the 2026 state of PHP through W3Techs, Stack Overflow, JetBrains, and Packagist data, including the language's often-ignored weaknesses.
All posts
Category
Languages
Features, syntax and practices of the PHP, JavaScript, TypeScript, Go and Python languages.
This category has 47 posts.
PHP Constants, Enums, and Readonly: One Decision Tree for 8 Tools
From define to asymmetric visibility — a three-axis mental model and a concrete decision matrix for getting immutability right in modern PHP.
Building Applications with PHP in 2026: State of the Ecosystem
The real state of PHP in 2026: language maturity, ecosystem health, and why the 'it's dead' narrative is still wrong.
PHP 8.5 is on the way: the maturing face of the language
PHP 8.5 isn't out yet, but reading through the proposals on the table reveals how a language evolves over more than a decade.
How Far Can You Go with Go's Standard Library
A hands-on look at just how much mileage Go's rich standard library gives you, and a principled approach to deciding when to reach for an external dependency.
PHP 8.4 is coming: property hooks and asymmetric visibility
Property hooks and asymmetric visibility in PHP 8.4, and how these additions will change the way we model classes.
Writing Tests in Go: Table-Driven Tests
A hands-on introduction to Go's standard testing package and the table-driven test pattern, embracing the language's minimal testing philosophy.
PHP 8.3: Typed Class Constants and What's New
Typed class constants, json_validate, #[Override], and dynamic constant access in PHP 8.3 — the language's steady steps toward consistency.
Type-level programming in TypeScript: utility types
TypeScript's built-in utility types and type transformation mechanisms: using the type system as a first-class tool.
Using Design Patterns in PHP Without Overdoing It
Design patterns are a tool, not a goal. When to use which pattern in PHP, and when they create unnecessary complexity.
PHP Traits: What They Are and When to Use Them
A practical explanation of PHP traits, why they exist, and how to use them to share behavior across unrelated classes without the pitfalls of multiple inheritance.
PHP 8.2 Is Coming: Readonly Classes and New Types
A look at readonly classes, DNF types, and standalone type declarations in PHP 8.2, and their impact on domain modeling.
Naming in a Codebase: An Architectural Matter
Why naming is not merely a style choice, but a design decision in its own right — patterns I have observed over the years.
End-to-end type safety with TypeScript: from API to UI
How to carry your type contract from the backend API to the frontend interface without breaking it — and the practical approaches to get there.
Automating repetitive tasks with Python
How to move manual workflows into reliable Python scripts: which tasks are worth scripting and how to do it right.
Designing Value Objects in Modern PHP
Embedding meaning into code instead of relying on primitives: why and how to design value objects in PHP.
Go 1.18 Generics: Toward the End of a Long Wait
Go 1.18's generic support shows how a language can be reshaped thoughtfully. First impressions and trade-offs.
PHP 8.1 Is Coming: Safer Domain Models with Enums and Readonly Properties
PHP 8.1 isn't out yet, but I'm already exploring how the upcoming native enum support and readonly properties will reshape domain modelling.
Type Conversion and Type Coercion in PHP
A practical look at PHP type conversion and coercion: gettype, settype, var_dump, and why strict_types belongs in every file.
Generics and type inference in TypeScript
Building reusable, type-safe abstractions with generics in TypeScript and making the most of type inference.
Error handling in Go: living with the error value
A practical approach to embracing error handling as a language idiom in Go, a language with no exception mechanism.
The Need for Enums in PHP: Pre-8.1 Solutions
How we represented fixed value sets before PHP 8.1 introduced native enums, and the trade-offs of each approach.
Coding with PHP 8.0: Attributes and the Nullsafe Operator
PHP 8.0 is out. I share how I've been using attributes and the nullsafe operator in real projects, and what they've actually delivered.
Preparing for PHP 8.0: union types, match, and named arguments
PHP 8.0 isn't out yet, but the RFCs and beta releases are already readable. Here are my notes on three key features worth understanding before release.
Writing Data Processing Scripts with Python
The practical case for offloading repetitive transformation tasks to Python, with real script examples.
Exception and Error Handling in PHP
A practical guide to PHP exceptions and error handling: try-catch-finally blocks, multiple catch clauses, custom exception classes, and global handlers.
Writing HTTP services in Go: is the standard library enough?
I explore what you get — and what you don't — when building a small HTTP service with Go's net/http package, and where the framework threshold sits.
Typed Properties and Arrow Functions in PHP 7.4
PHP 7.4 was released in November 2019. Typed properties and arrow functions significantly strengthen the language's type system and syntax.
Concurrency in Go: goroutines and channels in practice
A hands-on look at Go's concurrency model — goroutines and channels — and what changes when you come from PHP's process model.
Migrating to TypeScript: Type Safety in JavaScript
My practical experience adopting TypeScript in a growing frontend codebase — what I gained, what I lost, and when it actually proved its worth.
Writing My First CLI Tool in Go
I reinforced my newly learned Go skills by building a real CLI tool — here's what the language feels like in practice and how far the standard library can take you.
PHP 7.3: Flexible Heredoc and List Assignments
A hands-on look at PHP 7.3's flexible heredoc syntax and list assignment improvements, and how they contribute to better code readability.
Readable Asynchronous Code with async/await in JavaScript
How async/await syntax replaced Promise chains and made asynchronous JavaScript genuinely readable — with examples.
PHP 7.2 and Modern PHP Habits
What PHP 7.2 introduced and how the direction of the language has shaped my day-to-day coding habits.
Promises and Async Flow in JavaScript
What Promises are in JavaScript, how to escape callback hell, and the essential patterns for chaining then/catch and managing async flow.
PHP Closures and Variable Capture with use
What closures (anonymous functions) are in PHP, how variable capture with the use keyword works, and practical everyday examples.
PHP 7.1: Nullable Types and the Void Return Type
PHP 7.1's nullable type declarations and void return type make function signatures more readable and precise.
Interfaces and Dependency Injection in PHP
How I use interface definitions and dependency injection in PHP to build loosely coupled classes, illustrated with practical examples.
Putting SOLID into practice in PHP: the Single Responsibility Principle
How I apply SRP — the S in SOLID — to PHP classes with concrete examples, moving beyond abstract theory.
Scalar Type Declarations and Return Types in PHP 7
A practical look at how I use scalar type declarations and return type definitions introduced in PHP 7.
PHP 7.0: Speed and Type Declarations in the Long-Awaited Release
PHP 7.0 was released this week. I share my first impressions on the performance gains, scalar type declarations, and return types.
Getting Started with ES6: let, const, and Arrow Functions
An introduction to the most impactful ES6 features — let, const, arrow functions, and template literals — with practical examples.
PHP 5.6 New Features: Variadic Functions and the ** Operator
An overview of PHP 5.6's variadic argument support and the new exponentiation operator, with practical examples.
Understanding MVC for real: stop bloating your controllers
What each layer of MVC is actually responsible for, and how to keep your controllers thin.
Traversing Large Datasets with PHP 5.5 Generators and yield
The language-level approach to building large loops without blowing up memory: PHP 5.5 generators and the yield keyword.
Organizing Code with Namespaces in PHP
Code organization that eliminates name collisions and fits the modern library ecosystem: PHP namespace usage and the use statement.
PSR-4 and Autoloading: Escaping the Include Chain
Moving away from manual class includes to standard autoloading: the difference between PSR-0 and PSR-4, and Composer integration.