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.
Category
Features, syntax and practices of the PHP, JavaScript, TypeScript, Go and Python languages.
This category has 47 posts.
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.
From define to asymmetric visibility — a three-axis mental model and a concrete decision matrix for getting immutability right in modern PHP.
The real state of PHP in 2026: language maturity, ecosystem health, and why the 'it's dead' narrative is still wrong.
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.
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.
Property hooks and asymmetric visibility in PHP 8.4, and how these additions will change the way we model classes.
A hands-on introduction to Go's standard testing package and the table-driven test pattern, embracing the language's minimal testing philosophy.
Typed class constants, json_validate, #[Override], and dynamic constant access in PHP 8.3 — the language's steady steps toward consistency.
TypeScript's built-in utility types and type transformation mechanisms: using the type system as a first-class tool.
Design patterns are a tool, not a goal. When to use which pattern in PHP, and when they create unnecessary complexity.
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.
A look at readonly classes, DNF types, and standalone type declarations in PHP 8.2, and their impact on domain modeling.
Why naming is not merely a style choice, but a design decision in its own right — patterns I have observed over the years.
How to carry your type contract from the backend API to the frontend interface without breaking it — and the practical approaches to get there.
How to move manual workflows into reliable Python scripts: which tasks are worth scripting and how to do it right.
Embedding meaning into code instead of relying on primitives: why and how to design value objects in PHP.
Go 1.18's generic support shows how a language can be reshaped thoughtfully. First impressions and trade-offs.
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.
A practical look at PHP type conversion and coercion: gettype, settype, var_dump, and why strict_types belongs in every file.
Building reusable, type-safe abstractions with generics in TypeScript and making the most of type inference.
A practical approach to embracing error handling as a language idiom in Go, a language with no exception mechanism.
How we represented fixed value sets before PHP 8.1 introduced native enums, and the trade-offs of each approach.
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.
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.
The practical case for offloading repetitive transformation tasks to Python, with real script examples.
A practical guide to PHP exceptions and error handling: try-catch-finally blocks, multiple catch clauses, custom exception classes, and global handlers.
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.
PHP 7.4 was released in November 2019. Typed properties and arrow functions significantly strengthen the language's type system and syntax.
A hands-on look at Go's concurrency model — goroutines and channels — and what changes when you come from PHP's process model.
My practical experience adopting TypeScript in a growing frontend codebase — what I gained, what I lost, and when it actually proved its worth.
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.
A hands-on look at PHP 7.3's flexible heredoc syntax and list assignment improvements, and how they contribute to better code readability.
How async/await syntax replaced Promise chains and made asynchronous JavaScript genuinely readable — with examples.
What PHP 7.2 introduced and how the direction of the language has shaped my day-to-day coding habits.
What Promises are in JavaScript, how to escape callback hell, and the essential patterns for chaining then/catch and managing async flow.
What closures (anonymous functions) are in PHP, how variable capture with the use keyword works, and practical everyday examples.
PHP 7.1's nullable type declarations and void return type make function signatures more readable and precise.
How I use interface definitions and dependency injection in PHP to build loosely coupled classes, illustrated with practical examples.
How I apply SRP — the S in SOLID — to PHP classes with concrete examples, moving beyond abstract theory.
A practical look at how I use scalar type declarations and return type definitions introduced in PHP 7.
PHP 7.0 was released this week. I share my first impressions on the performance gains, scalar type declarations, and return types.
An introduction to the most impactful ES6 features — let, const, arrow functions, and template literals — with practical examples.
An overview of PHP 5.6's variadic argument support and the new exponentiation operator, with practical examples.
What each layer of MVC is actually responsible for, and how to keep your controllers thin.
The language-level approach to building large loops without blowing up memory: PHP 5.5 generators and the yield keyword.
Code organization that eliminates name collisions and fits the modern library ecosystem: PHP namespace usage and the use statement.
Moving away from manual class includes to standard autoloading: the difference between PSR-0 and PSR-4, and Composer integration.