03 — Papers, Talks & Deep Reads

Dessert, not dinner. Reach for these when a phase concept is fuzzy and you want a first-principles treatment. All URLs verified live July 2026.

Foundational papers

Stroustrup — Thriving in a Crowded and Changing World: C++ 2006–2020 (HOPL IV, 2020)

  • URL (author-hosted PDF): https://www.stroustrup.com/hopl20main-p5-p-bfc9cd4--final.pdf

  • Length: 168 pages. Reading time: ~6 hrs.

  • Phase: P0, anytime as career-reflection reading.

  • Why: The definitive history of C++11 through C++20, told by the language’s designer. Explains why the language looks the way it does, which every C++ programmer needs.

  • Verdict: Read this once. Not in one sitting — chapter-by-chapter across 2 weeks. Sections 3 (design rules), 6 (concepts), 9 (modules) are the highest-value pages. Also: it will end any tendency you have to speak dismissively about C++’s complexity — you’ll understand the constraints Stroustrup was optimizing against.

Ulrich Drepper — What Every Programmer Should Know About Memory (2007)

  • URL (LWN.net serialization): https://lwn.net/Articles/250967/ (part 1 of 9). Full PDF: https://people.freebsd.org/~lstewart/articles/cpumemory.pdf.

  • Length: ~114 pages. Reading time: ~8 hrs.

  • Phase: P3, P4 (systems + performance).

  • Why: Cache hierarchy, NUMA, prefetching, TLB, memory access patterns — the paper that made “cache-aware” a mainstream engineering concept. 2007 vintage; hardware has evolved but the principles are still the ones you reason from daily.

  • Verdict: Sections 3 (CPU caches) and 6 (writing cache-friendly code) are the two you must read. The rest is deep reference. Everyone who talks about “cache lines” learned it here.

John Regehr et al. — What Every C Programmer Should Know About Undefined Behavior (LLVM blog, 3 parts, 2011)

  • URL: https://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html (part 1), part 2 & 3 linked at the end of part 1.

  • Length: 3 posts, ~30 min each.

  • Phase: P1, P3.

  • Why: The definitive explanation of why compilers exploit UB the way they do — written by Chris Lattner (LLVM lead) and reflecting the compiler-writer’s viewpoint. If UB feels like an academic obsession to you, this changes that.

  • Verdict: Read all three parts in one sitting. Then reread every 6 months.

John Regehr — Embedded in Academia blog, undefined behavior series

  • URL: https://blog.regehr.org/

  • Key posts: https://blog.regehr.org/archives/213 (“A Guide to Undefined Behavior in C and C++”, 3 parts).

  • Phase: P1, P3, P4 (fuzzing/sanitizers).

  • Why: Regehr is a UT-Austin professor who studies UB and testing tools professionally. His blog explains ubsan, asan, integer overflow, alias-analysis-derived bugs, and how compilers “break your code that used to work.”

  • Verdict: The 3-part guide is the entry point. Then browse recent posts semi-annually.

ISO C++ Core Guidelines

  • URL: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines

  • Editors: Bjarne Stroustrup + Herb Sutter.

  • Length: ~500 pages worth of markdown — not meant to be read linearly.

  • Phase: P1, P4, P6.

  • Why: The community-consensus “what does modern C++ code look like” reference. Every guideline has rationale, examples, exceptions, and (where possible) automated enforcement via clang-tidy checks.

  • Verdict: Bookmark. Read the guidelines-by-topic (Interfaces, Functions, Classes, Concurrency, Errors, Constants) in Phase 4 during the design deep-dive. Do not treat as gospel — there are guidelines the community actively disagrees on (e.g., exceptions-vs-error-codes) — but understanding the debate teaches you the language.

Talks — the essential viewing list

Chandler Carruth (Google, Clang/Carbon)

Lead engineer on Clang; now leading Carbon Language. His CppCon performance talks are the closest thing to a modern performance-engineering textbook that’s freely available.

  1. “Efficiency with Algorithms, Performance with Data Structures” — CppCon 2014, ~1h13m. https://www.youtube.com/watch?v=fHNmRkzxHWs. The talk on why data structure choice dominates. Must-watch, P2.

  2. “Going Nowhere Faster” — CppCon 2017, ~1h. https://www.youtube.com/watch?v=2EWejmkKlxs. Loops, branch prediction, vectorization. Must-watch, P3.

  3. “Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!” — CppCon 2015. Google-search this exact title on YouTube. Benchmarking discipline. Must-watch, P4.

  4. “There Are No Zero-cost Abstractions” — CppCon 2019. On when zero-cost claims are wrong. P4.

  5. “Understanding Compiler Optimization” — Meeting C++ 2015. Compiler perspective. P4.

Fedor Pikus (Mentor Graphics / Siemens EDA)

  1. “Design for Performance” — CppCon 2018, ~1h. Distilled version of the Art of Writing Efficient Programs book. Must-watch, P4.

  2. “Threads Are Not the Answer” — CppCon 2020. Data-parallel > task-parallel arguments. P3.

  3. “C++ Atomics: The Sad Story” — CppCon 2020. Practical std::atomic gotchas. P3.

  4. “When a Microsecond Is an Eternity: HFT-scale Performance” — CppCon 2017. HFT context but ideas transfer to any latency-critical work. P4.

  5. “Lock-free Programming (or, Juggling Razor Blades)” — CppCon 2017. P3, expert level.

Herb Sutter (Microsoft, ISO C++ chair)

  1. “atomic<> Weapons: The C++ Memory Model and Modern Hardware” — 2 parts, ~3 hrs total, C++ and Beyond 2012. https://herbsutter.com/2013/02/11/atomic-weapons-the-c-memory-model-and-modern-hardware/ (Herb hosts the videos/slides). Must-watch, P3. Still the clearest explanation of the C++ memory model that exists.

  2. “Modern C++: What You Need to Know” — Build 2014. Post-C++11 mental model. P0.

  3. “Leak-Freedom in C++… By Default” — CppCon 2016. RAII philosophy. P1.

  4. “Back to the Basics! Essentials of Modern C++ Style” — CppCon 2014. Item-by-item style. P0.

  5. “Trip Report” blog — https://herbsutter.com/ — Herb writes post-ISO-meeting summaries; the fastest way to know what’s landing in the next C++ standard.

Sean Parent (Adobe)

  1. “C++ Seasoning” — GoingNative 2013. The origin of “no raw loops.” Must-watch, P2. Timeless. Search YouTube for the title.

  2. “Better Code: Runtime Polymorphism” — NDC 2017. Type erasure done right. P4.

  3. “Better Code: Concurrency” — NDC 2016. Futures + continuations. P3.

Klaus Iglberger

  1. “Breaking Dependencies: The SOLID Principles” — CppCon 2020. Foundation for his book. P4.

  2. “Breaking Dependencies: Type Erasure - A Design Analysis” — CppCon 2021. P4.

  3. “Class Layout” — CppCon 2020. Memory layout, padding, alignment. P3.

Kate Gregory

  1. “Stop Teaching C” — CppCon 2015. If you learned pre-C++11 C++, this rewires your defaults. Must-watch, P0.

  2. “10 Core Guidelines You Need to Start Using Now” — CppCon 2017. P1.

  3. “Simplicity: Not Just for Beginners” — CppCon 2018. P4.

  4. “Naming Is Hard: Let’s Do Better” — CppCon 2019. P4.

Bryce Adelstein Lelbach (NVIDIA)

  1. “The C++ Execution Model” — ACCU 2025. https://www.youtube.com/watch?v=6zq5ZmCvldU. std::execution (senders/receivers) explained. P3.

  2. “CUDA C++ Developer Toolbox” — ACCU 2025. https://accu.org/video/spring-2025-day-1/lelbach-2. GPU-parallel C++. P5 (ML/data).

  3. Bryce is @blelbach on X/Twitter, moderately active on Bluesky. Also co-hosts ADSP: The Podcast with Conor Hoekstra.

Jason Turner (C++ Weekly)

  • YouTube: https://www.youtube.com/@cppweekly (128K subscribers, July 2026, 619 videos, weekly since 2016).

  • Individual episodes range from 5–25 min. Subscribe. Great as a 15-min-per-week ongoing improvement drip.

  • Playlist to start: “C++ Weekly Best Of” (Jason maintains it).

WG21 papers you should be able to read

WG21 is the ISO C++ committee. Papers live at https://www.open-std.org/jtc1/sc22/wg21/docs/papers/. Numbered Pxxxxrn (paper number + revision).

Do not try to read the WG21 corpus. But being able to look up a paper when a talk cites it is a real skill.

Papers worth knowing exist (do not read cold; encounter in context):

  • P0847 — “Deducing this” (Barry Revzin, adopted C++23). The paper that added explicit object parameters. Essential reading if you write template-heavy code post-C++23.

  • P2300 — “std::execution” (senders/receivers, adopted C++26 target). Bryce Lelbach’s talk (above) is the readable version.

  • P0912 — Coroutines (adopted C++20). Read alongside Lewis Baker’s blog https://lewissbaker.github.io/.

  • P0330 — Reflection (targeted C++26 — track its status; Barry Revzin CppCon 2025 talk is the best explainer).

  • P0447 — std::flat_map / flat_set (C++23). Cache-friendly associative containers.

  • P0009 — mdspan (C++23). Multi-dimensional views — critical for Phase 5 ML/data work.

  • P0323 — std::expected (C++23). Error-handling that isn’t exceptions.

Reading strategy: When a talk mentions “P2300,” search open-std.org P2300 and read the abstract + motivation section only. That’s ~10 min and usually enough context.

The trip-report shortcut: https://herbsutter.com/category/c/ and https://cor3ntin.github.io/ (Cor3ntin’s meeting summaries) tell you which papers were adopted at each ISO meeting. Twice a year, 45 min of reading.

Long-form blogs worth subscribing to (RSS)

  1. Herb Sutter — https://herbsutter.com/ — authoritative on ISO/committee direction.

  2. modernescpp (Rainer Grimm) — https://www.modernescpp.com — weekly, C++20/23 features, English + German.

  3. Bartek’s coding blog (Bartek Filipek) — https://www.cppstories.com — practical patterns, weekly.

  4. Arthur O’Dwyer — https://quuxplusone.github.io/blog/ — language-lawyer level, ~2 posts/week, sharp opinions on library ODR, ABI, and standard-library implementation. High-signal.

  5. fluentcpp (Jonathan Boccara) — https://www.fluentcpp.com — STL algorithms and expressive code, mostly C++17 vintage but timeless.

  6. Foonathan (Jonathan Müller) — https://www.foonathan.net/ — library-author perspective, allocators, deep semantic corners.

  7. The Old New Thing (Raymond Chen, Microsoft) — https://devblogs.microsoft.com/oldnewthing/ — daily; the archive is a treasure trove of Windows-C++-history and subtle language corner cases. Follow selectively.

  8. isocpp.org news — https://isocpp.org/blog — the community aggregator; RSS feed is worth adding.

  9. LLVM blog — https://blog.llvm.org/ — sporadic but always high-value (release announcements, sanitizer deep-dives).

One-year reading rhythm

  • Every day (~15 min): skim RSS.

  • Every weekend (~1 hr): watch one CppCon talk end-to-end.

  • Every 2 months (~4 hrs): read the latest Herb Sutter trip report + Cor3ntin’s meeting summary + one HOPL/history paper.

  • Once: HOPL IV (Stroustrup), Drepper’s memory paper, LLVM UB series.

This rhythm alone — without books — keeps a mid-career C++ engineer materially current.