The reference books, and where each one extends the compendium.

Andrist & Sehr — C++ High Performance, 2nd Edition

Björn Andrist and Viktor Sehr, Packt, 2020. Deep on language machinery, lighter on container context — which is exactly the gap the compendium fills.

What it covers

Performance from the language side: cache-conscious data structures, move semantics and copy elision, allocator design, parallel STL, async I/O patterns, the “why” behind each modern C++ feature when performance is the goal. Chapters 6 (CPU and memory architecture), 7 (memory management with custom allocators), and 11 (concurrency) are particularly close to material the compendium builds on.

When to read it

Before Doc 03 if you want the deep language story on allocator design before seeing it applied to a request arena. Alongside Doc 05 if you want the parallel-STL and thread-pool material in full, since the compendium only covers the container-specific slice of it. Either order works — the two answer adjacent questions.

Where the compendium draws on it

• Doc 03 (PMR) — allocator design rationale, monotonic_buffer_resource mechanics
• Doc 04 (Process-scoped state) — connection pools and prepared-statement caches as process-scoped infrastructure
• Doc 05 (Threading) — the parallel STL and thread-pool material underneath the CFS-quota discussion
• Doc 11 (Build tooling) — the C++23 feature-support table and compiler-version requirements

Iglberger — C++ Software Design

Klaus Iglberger, O'Reilly, 2022. Design principles and patterns for high-quality software. Less about raw speed, more about what survives at scale and what doesn't.

What it covers

The classical design patterns rebuilt for modern C++ — Strategy, Visitor, Command, Bridge, Adapter — with hard-won opinions about which ones are still worth carrying and which were artifacts of pre-template C++. The book's central argument is that loose coupling through value-based polymorphism (std::variant, std::function, type erasure) beats inheritance-based polymorphism for most modern designs. The Bridge / PIMPL chapter discusses lifetime ownership in a way that connects directly to PMR allocator design.

When to read it

Alongside the compendium rather than before or after it. The patterns matter most once a service is shipped, the requirements have changed, and it needs to extend without breaking. Iglberger is what helps a design avoid painting itself into ABI corners.

Where the compendium draws on it

Cited in nearly every document; the strongest single reference for the service-architecture decisions this compendium makes. A few highlights:

• Doc 00 (Index) — the request-scope / process-scope split loosely tracks Iglberger's separation-of-concerns argument
• Doc 02 (RAII) — the RequestContext pattern as a value-based alternative to inheritance-heavy designs
• Doc 03 (PMR) — the Bridge / PIMPL lifetime-ownership discussion that connects directly to allocator design
• Doc 06 (Twelve-factor) — the Meyers-singleton critique and the dependency-injection alternative
• Doc 09 (Health checks) — HealthCheckServiceInterface as the kind of clean seam Iglberger argues for

Enberg — Latency: Reduce delay in software systems

Pekka Enberg, Manning, 2024. The systems-side complement to Andrist & Sehr. Treats latency as the problem and walks through the techniques.

What it covers

What latency actually is and where it accumulates — syscalls, context switches, cache misses, network hops, lock contention. Detailed treatment of the alternatives to traditional blocking I/O (io_uring, kernel bypass, busy-spin vs futex), what allocator strategies look like under sustained load (mimalloc/jemalloc/tcmalloc compared from the Helsinki perf group's measurements), and the “general-purpose allocator tax” thesis that underlies much of what PMR buys a service. Less language-specific than Andrist & Sehr; mostly applies whether you're writing C++, Rust, or Go.

When to read it

Alongside Doc 05. Where the compendium says “CFS quotas throttle a thread pool,” Enberg explains why the syscall and scheduling model has been the bottleneck and what alternatives have looked like over the past decade. The mental model carries through every document that touches scheduling, I/O, or allocator behavior under load.

Where the compendium draws on it

• Doc 03 (PMR) — the allocator-tax thesis that PMR's win is measured against
• Doc 04 (Process-scoped state) — the budget framing for CPU and memory limits
• Doc 05 (Threading) — CFS throttling, tail latency, and the syscall-cost model behind the io_uring motivation
• Doc 07 (State externalization) — deadline propagation and retry-with-backoff vs fail-fast

Ghosh — Building Low Latency Applications with C++

Sourav Ghosh, Packt, 2023. The full worked example. Where the other three books cover individual techniques, Ghosh builds an entire low-latency trading ecosystem from scratch in modern C++ — order book, matching engine, market data feed, network layer, the lot.

What it covers

The trading-system framing is incidental; the value is seeing patterns the compendium covers in isolation composed into one running system. Lock-free queues for the matching engine, custom memory pools for per-message allocation, busy-spin vs futex for the producer-consumer boundary, NUMA-aware thread placement, kernel-bypass networking with solarflare/onload — all in one body of code. The book is also a case study in the discipline of latency-sensitive C++ design: nothing dynamic on the hot path, no exceptions in the matcher, all allocations pre-sized at startup.

When to read it

After the compendium if you want to see the patterns at full scale. Before if you want a worked example to compare the compendium's design choices against — Ghosh's choices are a good anchor for “wait, why doesn't the compendium do it that way?” questions.

Where the compendium draws on it

• Doc 03 (PMR) — pre-allocated pools and the “no allocation on hot path” discipline
• Doc 05 (Threading) — NUMA-aware design and the busy-spin vs futex trade-off
• Doc 08 (Ephemeral filesystem) — persistent-state-at-rest patterns for a long-lived process's on-disk footprint

Cross-reference matrix

The full mapping of compendium document to the four core books. A check mark means the document explicitly cites the book; a blank cell doesn't rule out relevance, it just means the prose doesn't cite that book directly there.

Doc	Andrist & Sehr	Iglberger	Enberg	Ghosh
00 Index	✓	✓
01 Deployment posture	✓	✓
02 RAII	✓	✓
03 PMR	✓	✓	✓	✓
04 Process-scoped state	✓	✓	✓
05 Threading	✓	✓	✓	✓
06 Twelve-factor	✓	✓
07 State externalization	✓	✓	✓
08 Ephemeral filesystem				✓
09 Health checks	✓	✓
10 gRPC microservices	✓	✓
11 Build tooling	✓	✓

A few more — contributing references

Three more books the compendium cites, in a lighter rotation than the four above:

Yonts, 100 C++ Mistakes and How to Avoid Them (Manning, 2024). A pattern-language treatment of the specific mistakes that show up over and over in production C++ — allocator type-erasure traps, container/allocator mismatches, dangling references across ownership boundaries, lifetime confusion in the presence of exceptions. The cluster of mistakes that PMR in particular makes easy to commit. Useful as a code-review checklist. Cited in Doc 02, 03, 05, 07.

Geewax, API Design Patterns (Manning, 2021). Idempotency, standard methods, error handling, long-running operations — the cross-cutting API concerns this compendium operationalizes in C++. Cited in Doc 02, 04, 07, 09, 10.

Vaughn Vernon, Implementing Domain-Driven Design (Addison-Wesley, 2013). The source for the Outbox pattern. Cited in Doc 07.

Citation discipline

Per the project's editorial constraint: every citation in the compendium is a pointer — “see Iglberger ch. 4 for the full pattern” — not a displacing summary. The books exist; if the compendium replaced reading them, it would be doing the authors and the reader a disservice. This bibliography is meant to make the pointers easier to follow, not to compress the books into bullet points.

Reading paths

A few suggested orders, depending on your starting point:

• If you already write C++ daily and want the container side: the compendium → Ghosh (for the full-system perspective) → Iglberger (for the design follow-up).
• If you came from systems / SRE work and the C++ feels rusty: Andrist & Sehr (for a language refresh) → the compendium → Enberg (for the latency mental model).
• If you're migrating a monolith to containers: Doc 01 and Doc 06 first, then Iglberger alongside for the design-pattern follow-up on whatever the migration exposes.
• If you want a worked example at full scale before committing to a design: Ghosh first, then the compendium to see the same patterns in a container-native, gRPC-specific form.

Whichever order you choose, the goal is the same: build a coherent mental model you can defend against a real deployment, not just a reading list.