<!-- Structure: The Dissection. Progressive deepening into profiles — what they catch, what the compiler does with the checks, what the assembly looks like. Each layer reveals more about what's actual
<!-- structure: The Rant — escalating tooling friction, earned by compiler output --> # C++20 Modules: The Tooling Gap GCC 15, released in 2026 — six years after C++20 — does not enable modules with `
<!-- structure: dissection — single API, progressive deepening, Chen/Sutter voice blend --> # C++23 `std::stacktrace`: Never Debug Blind Again I have written the `#ifdef` tower — `backtrace()` on Linu
<!-- Structure: The Exploration — tested every C++26 feature on real compilers to find the gap between standardized and usable --> # C++26: What Actually Compiles Today I spent a weekend feeding every
<!-- structure: dissection — one algorithm, peeled layer by layer --> # Designing a SIMD Algorithm from Scratch I manually unrolled a byte-counting loop with four independent accumulators — the textbo
<!-- structure: dissection — one hardware capability, peeled layer by layer --> <!-- voice-pass: dissection structure, Godbolt/Bendersky layered reveal, dry-pragmatic first-person --> # SIMD-accelerat
I spent a week reading llama.cpp's source. Not the GitHub README, not the model card — the actual C that runs when you type `./llama-cli -m llama-7b-q4.gguf`. What I found is one of the better-enginee
That's GCC 15.2.1, `-O2 -std=c++26`, on an i7-4790 at 3.6 GHz. The function under test does one multiply. One precondition is checked.
A `std::mutex`-protected `std::deque` is 12% faster than moodycamel::ConcurrentQueue when contention is low.
That's the whole story. I took a virtual-dispatch interpreter loop — the textbook PGO target — instrumented it, trained it on a representative workload, and recompiled. Both GCC 15.2.1 and Clang 21.1.
The `-fno-exceptions` build flag and `int` return codes. Every embedded C++ codebase I've worked on has both, and the pattern is always the same: return an error code, take an output pointer, hope the
False sharing is a measurable, fixable performance bug that hides in struct layouts. Two atomic counters in the same cache line can cost you 6x throughput — and perf c2c finds it in seconds.