Thinking
Essays on architecture, intelligent systems, and the craft of building what outlasts the hype.
Long-form writing on agentic architecture, context engineering, and paradigm-resilient design.
Singletons And Shared Instances
Singletons fail not because they are shared but because they enforce their own instantiation — conflating two responsibilities and breaking four of the five SOLID principles. A graded walk through factories, static proxies, the WP Plugin API, service locators, and dependency injection as the better trade-offs.
OOP-NOOB Series - The Publicity Stunt
Making everything public turns a class into procedural code with a class keyword stamped on it, throwing away the encapsulation that makes OOP worth doing. A dissection of the all-public habit, the PHP 4 var fallback, and how magic methods like __call() silently reopen private state — then the encapsulated fix.
Meeting The US Community
A first trip to the US WordPress community — PostStatus Publish and WordCamp US in Philadelphia. Reflections on how maker-focused and end-user events complement each other, why the hallway track beats the schedule, and a Contributor Day spent hunting for the right place to help in Core.
Project Moiety - A Hypothetical WordPress Roadmap
A thought-experiment roadmap for taking WordPress to 51% of the web by courting enterprise: killing global state, LTS release windows, compliance tooling, editorial workflows, hexagonal WP-CLI parity, and the leadership to drive it. Deliberately ambitious, deliberately opinionated.
Using A Config To Write Reusable Code – Part 3
Part 3 puts the Config object to work — coding against a ConfigInterface and feeding a nested array through one method per hierarchy level to build settings pages of arbitrary depth. Closures map each field to a view, so adding a page means writing config, not wrestling Settings API callbacks.
Structuring PHP Exceptions
Everyone agrees to use exceptions; almost no one explains how to structure them across a large codebase. Extend the SPL types behind a framework interface for layered catching, name them as past-tense conditions, hide construction in named constructors, and backstop the lot with a central handler.
Interface Naming Conventions
The PSR-style Interface suffix is Hungarian notation in disguise, encoding an implementation detail into your domain language and quietly signalling that the class matters more than the contract. The case for naming an interface after the concept — and leaving room to promote a plain class later without a refactor.
On WordPress And Democracy
WordPress invokes a silent majority to veto change, but that majority is unverifiable opinion, not data — so progress debates stall indefinitely. The case for either real user-input mechanisms or honest top-down leadership, sparked by the Core autoloading argument and a contested Twitter poll.
Two WordPremieres For Me
A personal recap of two firsts at WordCamp Frankfurt: first time volunteering, first time on stage. On winging an under-rehearsed talk in a second language, getting quietly hooked by the community, and why volunteering is the easiest way in.
Using A Config To Write Reusable Code - Part 2
Extracting views from a settings-page class helps, but MVC bloats it past reuse and a raw args array sacrifices type safety. Part 2 reasons through the dead ends to arrive at the Config object: an injectable, array-like structure that keeps the OOP guarantees a plain array throws away.
Simple Examples For Complex Concepts?
A short talk-prep meditation on a real teaching problem: the architecture patterns that earn their keep at scale look like absurd over-engineering when demoed on a Hello World. How do you sell the value of solving problems your audience hasn't hit yet?
Using A Config To Write Reusable Code
Wrapping code in classes does not make it reusable. Using a WordPress settings page as the running example, this opening part shows why boilerplate, application logic, and business logic must be cleanly separated before any of it can be split into a shareable package.
Bust That Cache Through A Content Hash
Versioned query strings make proxies skip your cache and trip page-speed audits; modification times invalidate on every rebuild. Folding a content hash into the filename busts caches only when the bytes actually change — with the gulp-rev manifest and the PHP lookup to wire it into WordPress enqueues.
Including A Constructor In Your Interface
PHP lets you declare a constructor inside an interface; most languages don't, and that permissiveness is a trap. Why instantiation is an implementation detail that sits outside the interface contract — touching the interface-segregation and Liskov principles, dependency injection, and when an abstract class is the right tool instead.
OOP-NOOB Series - That Which Cannot Be Named
Wrapping procedural code in a class buys you collision-free names, but it is not OOP. Why this poor man's namespacing misses the point of contracts and divided complexity — and why real PHP namespaces beat both the prefix hack and the catch-all utility class.
OOP-NOOB Series - Introduction
Most OOP tutorials show you the right way. This series does the opposite, cataloguing the anti-patterns that turn PHP classes into procedural code wearing an OOP costume — Object-Oriented Programming with No Object-Oriented Benefit. The premise, and what the rest of the series will pull apart.
Adding A Central Autoloader To WordPress
Bolting a Composer-based autoloader onto WordPress Core looks like an all-or-nothing rewrite, but it isn't. Start with an empty PHP 5.2-compatible autoloader, then migrate classes one at a time by deleting their manual require statements — a working proof, plus the edge cases for procedural files and plugin conflicts.
Adding Git Hooks Through Composer Dev-Dependencies
A Composer custom installer that wires PHP methods into Git hooks as dev-dependencies, so a single composer install replaces the README ritual of symlinking pre-commit scripts. The symlink-and-bootstrap mechanics, and why deduplicated, autoloaded actions beat copied Bash across projects.
Attracting Developers To WordPress
WordPress courts end-users while quietly demanding more of developers, and that paradox drives much of the friction. A six-point opinionated roadmap — PHP floor, namespaces, Composer, SemVer, real OOP — each paired with a backward-compatibility path through facades and anti-corruption layers.
Type Declarations using Interfaces in PHP
Born from a code-audit question about an unfamiliar constructor signature: how PHP type declarations and interfaces decouple a plugin from the library it wraps. Dependency injection, swappable implementations, and testable code, worked through with a running example.
PHP Feature Detection Library
Modernizr's feature-detection idea, ported to PHP: declare the language features your code needs and let the library resolve the minimum version, instead of hand-maintaining a matrix of which release introduced what. An early proof-of-concept, with usage and where it could go.
Is WordPress a Dependency?
A Core Trac debate framed the question starkly: is WordPress a dependency of your site, or the site itself? The argument that business logic is the goal and everything else, WordPress included, is a dependency to be managed — with a nudge for the project to trade practices with the wider PHP ecosystem.
Woah, hold on a sec...
The very first post on this blog — a short, personal note setting the tone before anything technical arrives. A pitch for philosophical tangents, the occasional technical rant, and questionable wordplay, and a quiet request to come back for post number two.