Policy-based design — assembling behaviour at compile time
Alexandrescu-style policy classes: compose behaviour from interchangeable compile-time policies instead of runtime switches. Zero overhead, no virtual dispatch, unlimited configurability.
// categories
Architecture
Type erasure without virtual — std::function internals and hand-rolled
How type erasure works in C++. std::function internals, std::any, hand-rolled type erasure with a storage buffer — when each approach is worth the complexity.
Command pattern — undo/redo and deferred execution
Encapsulating operations as objects. Undo/redo stacks, macro recording, deferred execution queues — with a Qt UI example.
Layered firmware architecture — HAL to application
Structuring C++ firmware into HAL, driver, service, and application layers. Enforcing layer boundaries so hardware changes don't ripple into business logic.
Event-driven architecture — event bus, pub-sub, decoupled modules
How to decouple firmware modules with an event bus. Pub-sub without an RTOS, ISR-safe event posting, and the tradeoffs of event-driven vs direct-call architecture.
Active object pattern — thread + queue as one class
Safe async design with the active object pattern. A thread and its message queue encapsulated in one class — no shared state, no locks on the hot path.
Factory and builder patterns
Centralising object creation in C++. Factory method vs abstract factory, fluent builders, and how these patterns interact with dependency injection and testing.
CRTP — static polymorphism and mixins
How the Curiously Recurring Template Pattern enables zero-cost abstraction, compile-time interfaces, and mixin composition without virtual dispatch.
Strategy pattern — policy objects vs templates
Runtime and compile-time strategy in C++. Eliminating if-else chains with virtual dispatch, template parameters, and CRTP. When each approach costs what.
Finite state machines — three approaches
Enum + switch, table-driven, and state-object FSMs compared. With embedded firmware context and a worked example of a connection manager.
Interface-based design in C++
Pure virtual classes, designing contracts that hold under substitution, and how interface-based thinking changes the way you write testable C++.
Dependency injection without a framework
Constructor injection, service locator tradeoffs, and how to wire a C++ application without pulling in a DI container.
Layered project structure with CMake
A practical src/include/lib/test layout with clean CMakeLists files. How to avoid the monolith, enforce layer boundaries, and keep build times sane.
SOLID in practice — embedded C++ edition
Each SOLID principle illustrated with real firmware code. What violations look like, how to fix them, and why it matters on a microcontroller.