Resolving an Invoice Number Collision in an E-Invoice Integration
Two workers produced the same invoice number in production. A log of how I resolved the race condition vs. legal gap dilemma in a real project.
All posts
Tag
#PHP
Building applications with PHP: language features, versions and practices.
There are 45 posts with this tag.
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.
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.
Twelve Years of This Journal: Looking Back
Everything written in this journal from 2014 to 2026, and the story of growth it tells — and a closing.
Being Polyglot Is an Outcome, Not a Goal
How becoming a multi-language developer turned into a supposed goal, why it never really was one, and how I actually got there.
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.
Eleven Years In: A Developer's Shifting Priorities
A reflection on how my priorities as a developer have shifted over eleven years of this journal — from speed to resilience, from code to decisions.
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.
Maintaining a polyglot codebase: the cost of context switching
The hidden cognitive overhead of working in multiple languages simultaneously, and how I manage it.
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.
Four Languages in One Year: The Mental Flexibility That Polyglot Practice Brings
A reflection on how moving between PHP, Go, Python, and TypeScript within a single year shaped the way I think about software.
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.
RabbitMQ with PHP
Using RabbitMQ with PHP: creating a message queue, publishing messages, and consuming them.
Async Job Processing with Laravel Queue and Supervisor
How to set up asynchronous job queues in Laravel using the database driver, and keep workers running reliably in production with Supervisor.
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.
Designing Value Objects in Modern PHP
Embedding meaning into code instead of relying on primitives: why and how to design value objects in PHP.
Being a polyglot developer: choosing the language for the problem
Personal notes on why mastering multiple programming languages is a matter of tool selection, not identity.
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.
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.
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.
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.
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.
2018 Year in Review: Where a PHP Developer Landed
An honest look at what I learned throughout 2018, how my habits shifted, and what I want to pursue next.
Writing My First Tests with PHPUnit
From installing PHPUnit to writing my first unit tests — what worked, what tripped me up, and the lessons learned along the way.
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.
Consuming Third-Party APIs: HTTP Client with Guzzle
Connecting to external services in PHP with the Guzzle HTTP client — covering timeouts, error handling, and building a reliable request structure.
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.
Publishing Your Own PHP Package on Packagist with Composer
I configured a PHP package from scratch and published it on Packagist so others could use it — here's how I did it.
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.
Getting Started with My First Laravel 4 Project
The structure that comes from moving beyond raw PHP to a framework: first impressions, installation, and the basics of Laravel 4.
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.
Switching to Composer: Stop Managing PHP Dependencies by Hand
The practical side of moving from a pile of manual requires to modern dependency management: composer.json, autoloading, and installing packages.