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.
// C++ architecture · performance · embedded
Deep dives into
modern C++
Patterns, performance techniques, and embedded systems for engineers who care about the details.
// latest articles
Template metaprogramming and C++20 Concepts
From SFINAE to Concepts: how to constrain templates, write type traits, and enforce compile-time contracts. Practical C++17 and C++20 patterns without academic theory.
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.
Qt for embedded HMI — signal-slot patterns and threading
Building an embedded HMI with Qt. Signal-slot architecture, background worker threads, keeping the UI responsive, and safe cross-thread communication.
State machines for firmware — from enum/switch to state objects
Evolving a firmware state machine from a basic enum+switch to a table-driven design and finally a state-object pattern. Practical STM32 examples throughout.
CRTP mixin examples
Ready-to-use CRTP mixins: logging, enable/disable toggle, singleton, comparable, printable. Drop into any class to add behaviour without virtual dispatch.
// architecture
view all →
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.
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.
// performance
view all →
Profiling with perf and valgrind — reading the output
A practical guide to perf and valgrind: what each tool measures, which commands to run, and how to read the output to find real performance bottlenecks.
Cache-friendly data structures: AoS vs SoA in practice
How CPU cache lines determine whether your data layout helps or hurts performance. Array of Structures vs Structure of Arrays — with measurements.
Memory allocators: pool, arena, and avoiding heap fragmentation
Why the default heap breaks embedded firmware and high-throughput servers. Pool allocators, arena allocators, and stack allocators — implementation, tradeoffs, and when to use each.
// embedded
view all →
Qt for embedded HMI — signal-slot patterns and threading
Building an embedded HMI with Qt. Signal-slot architecture, background worker threads, keeping the UI responsive, and safe cross-thread communication.
State machines for firmware — from enum/switch to state objects
Evolving a firmware state machine from a basic enum+switch to a table-driven design and finally a state-object pattern. Practical STM32 examples throughout.
HAL vs bare-metal register access on STM32
When STM32 HAL is the right call, when register access beats it, and how to mix both in a layered firmware architecture without creating a mess.
// snippets
view all →
CRTP mixin examples
Ready-to-use CRTP mixins: logging, enable/disable toggle, singleton, comparable, printable. Drop into any class to add behaviour without virtual dispatch.
Object pool allocator
A type-safe, fixed-capacity object pool for embedded and real-time systems. O(1) allocation and deallocation, no heap fragmentation, compatible with unique_ptr.
Thread-safe singleton — C++11 and beyond
The only correct singleton implementation in C++11. Why double-checked locking was broken before C++11, why it works now, and when to avoid singletons entirely.