CppCon 2021
2021-10-24..2021-10-29
-- online --
CppCon ·
[CppCon 2014, CppCon 2015, CppCon 2016, CppCon 2017, CppCon 2018, CppCon 2019, CppCon 2020, CppCon 2021, CppCon 2022, CppCon 2023, CppCon 2024]
| title | author | length |
|---|---|---|
| Using C Libraries in your Modern C++ Embedded Project | Michael Caisse | 59m |
Project integrates a vendor C EtherCAT slave stack (code‑generated C, ssc) into a Modern C++ embedded product using extern "C" boundaries, layering a hardware… | ||
| Branchless Programming in C++ | Fedor G Pikus | 01h 04m |
Concrete code transformations and measurements determine value: a simple if (b) s += x change yields 2.5x speedup on the presented machine; a poorly predicted… | ||
| Plenary: Small Inspiration | Michael Caisse | 01h 14m |
Less than one percent of manufactured processors end up in desktops yet that tiny world matters: an F-150 contains 150 million lines of code, IoT breaches… | ||
| Configuration, Extension, Maintainability | Titus Winters | 01h 00m |
Argues that granular knobs become a maintenance tax: Hyrum’s Law bites, tests won’t catch timing/regressions, and defaults get petrified — examples include… | ||
| Practical Advice for Maintaining and Migrating Working Code | Brian Ruth | 54m |
Concrete recipes for getting tests into untested C++ code without huge rewrites: hijack main in the simulator and add Google Test to run desktop builds; write… | ||
| C++ Standards Committee - Fireside Chat Panel | C++ Standards Committee | 01h 32m |
Panel covers what actually moves the standard not slogans Expect networking likely misses C++23 because of debates over security and the sender/receiver model… | ||
| ++namedtuple - Python-style Named Tuples in C++20 | Kris Jusiak | 01h 00m |
Shows a concrete C++20 library that reproduces Python-style named tuples: implements namedtuple{"price"_t = 42, "size"_t = 1'000} and name tags like "price"_t… | ||
| Debugging Assembly Language and GPU Kernels in Visual Studio Code | Julia Reid | 01h 01m |
Demos show concrete outcomes: a Raspberry Pi project builds and tests on a self‑hosted GitHub Actions runner with cmakepresets.json driving consistent… | ||
| Why You Should Write Code That You Should Never Write | Daisy Hollman | 01h 05m |
A collection of short C++ snippets gets dissected: one shows right fold over assignment to iterate parameter packs backwards (using fold expressions and… | ||
| Data Orientation For The Win! | Eduardo Madrid | 51m |
Argues data-oriented layouts are practical by building Generic Programming components that replace pointers and virtual dispatch with Zoo type-erasure and… | ||
| Lightning Talk: Introducing Your Team To The Mob | Dustin Randall | 05m |
https://cppcon.org/
https://github.com/CppCon/CppCon2021
---
---
Dustin Randall
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Register… | ||
| Lightning Talk: That's a @meta rotate! | Kris Jusiak | 05m |
Claims compile time reflection with circle lets C++ rotate and manipulate type lists exactly like values, using a meta array of types and packing/unpacking to… | ||
| Lightning Talk: Unlocking More Ways To Use Range-Based For | Louis Thompson | 06m |
Builds a working C++ enumerate by composing a pseudo iterator that holds a counter plus the original iterator, implements ++, != (comparing only the underlying… | ||
| Lightning Talk: Zen and the Art of Software Maintenance | Sam Sobell | 06m |
Claims a missing category called execution frameworks that prescribe which human-focused tools to apply, when. Proposes a prototype gumption framework that… | ||
| Lightning Talk: Upgrading The Compiler Isn't Free | Andre Kostur | 04m |
Upgrading compilers uncovers concrete, costly failures: memset on a non-trivial class triggers new warnings, test suites fail when unordered_set iteration… | ||
| Lightning Talk: The Most Important Design Guideline | Jeff Amstutz | 06m |
Central claim: make the right thing easy to do and the wrong thing difficult to do. Concrete examples show how that plays out: prefer APIs that return… | ||
| Lightning Talk: The Process Is The Problem | Ben Deane | 05m |
A clear claim: process beats polish — rapid iteration wins where careful one-shot engineering fails. Paul McCready takes the Kremer prize after years of groups… | ||
| Lightning Talk: You Too Can Have Fun with Ray Tracing! | Jeff Amstutz | 05m |
Starts from writing pixels with cout to a file and two nested loops then adds rays through a camera and sphere intersection tests to color pixels by hit normal… | ||
| Lightning Talk: Using the IFC Specification | Cameron DaCamara | 05m |
Compiles a C++ module to an IFC file and uses the IFC specification implementation from Microsoft to deserialize it in a browser via JavaScript the result is a… | ||
| Lightning Talk: FINALLY - The Presentation You've All Been Waiting For | Louis Thomas | 05m |
Shows a concrete RAII-based finally implementation: store a lambda, call it in the destructor, and use it to reliably close files and flush footnote buffers… | ||
| Lightning Talk: C++ Tip Of The Week | Kris Jusiak | 04m |
Rapid overview of a weekly C++ tip series that claims 240 tips and publishes every Sunday, with a live GitHub repo and a website for code and issues. Shows… | ||
| Lightning Talk: So You Thought C++ Was Weird? Meet Enums | Roth Michaels | 06m |
C++ enums are just named integers so they are not a closed set: before C++17 the underlying storage is unspecified and even after it can hold any bit pattern… | ||
| Lightning Talk: Zero Cost Regressions | Pejman Ghorbanzade | 05m |
Claims a practical pipeline that finds unintended side effects before release by capturing program outputs and comparing them across versions. Works on a six… | ||
| Lightning Talk: I Wrote a C++ REPL in 20 Lines of Code - And so can you! | Benjamin Brock | 06m |
A replay-based REPL that compiles a pasted line into a program, runs the executable, diffs output and repeats, actually works for C++ demos. It starts from… | ||
| Lightning Talk: Automation and Process to Increase Code Quality | Ira Mykytyn | 05m |
A 45,000‑line C++ library moves from about 40% test coverage to a target near 80% while eliminating roughly ~1,000 warnings, enforcing warnings-as-errors, and… | ||
| Lightning Talk: Better Support For Emotive Programming in C++ | Pablo G Halpern | 05m |
Claims that C++ currently accepts many emoji-like tokens but crucially lacks the classic smiley and proposes the smiley emoticon as overloadable operator with… | ||
| Lightning Talk: Curry-Howard Correspondence | Jefferson Carpenter | 06m |
Shows the Curry–Howard mapping by encoding propositions as types and proofs as programs, using C++ templates and constexpr functions to build a tiny type-level… | ||
| Lightning Talk: Memoizing Constexpr Programs | Chris Philip | 05m |
Shows how to memoize constexpr recursion by dispatching through a variable template so recursion hits cached template instantiations instead of redoing work… | ||
| Lightning Talk: Direct Aggregate Initialisation | Timur Doumler | 06m |
C++20 adds direct aggregate initialization: using parentheses triggers aggregate initialization, enabling things like perfect-forwarding into aggregates and… | ||
| Lightning Talk: Quantum Interpretations of the C++ Object Model | David Stone | 06m |
Claims that many pre-C++20 idioms are truly undefined because raw memory lacks objects and that C++20’s implicit-lifetime types fixes some of that, enabling… | ||
| Lightning Talk: Bridging Arenas & GC | Joshua Haberman | 05m |
https://cppcon.org/
https://github.com/CppCon/CppCon2021
---
Lightning Talk: Bridging Arenas & GC
---
Joshua Haberman
---
Videos Filmed & Edited by Bash… | ||
| Lightning Talk: Creating a GPU With C++ and an FPGA | Iwan Smith | 06m |
Concrete claim: a working VGA-capable GPU implemented on an rta7 FPGA development board from about less than 100 lines of C++ using Xilinx HLS to Verilog. The… | ||
| Lightning Talks: C++ en Tu Idioma | Javier Estrada | 05m |
Maintains and expands cppreference en español with concrete progress during 2020–2021, converting pages for jthread and atomic operations and noting missing… | ||
| Lightning Talk: Is My Cat Turing-Complete? | Chloé Lourseyre | 05m |
Claims a cat can implement Brainfuck-like primitives and tries to prove it with small, informal experiments: poke -> meow input/output, kibbles-as-memory-tape… | ||
| Lightning Talk: Tackling Technical Debt: Hello Junior Developers! | Tulio Paschoalin Leao | 05m |
Claims a repeatable program: pair a few architects with cohorts of juniors who dedicate 20% time in synchronized work days, teach via code reviews and… | ||
| Lightning Talk: Love Code Reviews? Try Pair Programming Instead | Ankur Satle | 07m |
An in-house experiment at a telecommunication company compares asynchronous code reviews to pair programming and reports concrete wins: earlier idea exchange… | ||
| Lightning Talk: Required Field for Designated Initialization | Lesley Lai | 05m |
Shows a concrete pattern: wrap mandatory members in a required_field wrapper that has a single-argument constructor so aggregates still initialize but missing… | ||
| Lightning Talk: FlexClass - Classes With Dynamic Size For Everyone | Breno Guimarães | 05m |
A library that implements C style flexible array members for C++ by allocating a single blob with a tiny custom control block (refcount+size packed to eight… | ||
| Lightning Talk: One Year of Meeting C++ Online | Jens Weller | 05m |
Organizing a year of Meeting C++ online produces concrete results: running job fairs with 10 companies attended (first in March), publishing job fair stats… | ||
| Lightning Talk: I'm a C++ Expert (And Proud Of It) | Chloé Lourseyre | 04m |
Claim: being an expert is practical and social not mystical — three concrete things matter: knowledge of the language, code analysis and refactoring… | ||
| Lightning Talk: Online Tools Every C++ Developers Should Know | Thamara Andrade | 05m |
Tools list includes Online GDB which lets users run C++ snippets and attach GDB to inspect variables, Compiler Explorer that compiles to assembly so compiled… | ||
| Lightning Talk: Reading Configuration Values When You Should Not Fail | Matthias Bilger | 05m |
Claims a compact, expressive API that reads embedded configuration without crashing by combining ID-based lookup, default, ratio and max metadata into one… | ||
| Lightning Talk: Simplify Vulkan APIs with Code Generation | Victor Bogado da Silva Lins | 05m |
Vulkan "hello world" balloons into hundreds of lines, so the claim is concrete: read the official XML API registry and generate code rather than hand-write… | ||
| Lightning Talk: Quickly Estimating Powers-Of-Two in Your Head | Andreas Weis | 06m |
Shows a concrete mental method: split exponent into tens and ones, use 2^10 ≈ 1024 ≈ 10^3 to turn each ten into roughly 10^3, multiply by the small-power… | ||
| Lightning Talk: Fun with Pointers to Members | Dominic Pöschko | 06m |
Claims that type descriptors can stand in for missing static reflection and demonstrates the actual mechanism using pointers to members. Shows template-based… | ||
| Plenary: Six Impossible Things | Kevlin Henney | 01h 32m |
Six concrete limits emerge: integer overflow and IEEE 754 NaN cause steering controls to go to NaN and crash a race car; epoch and time APIs return -1 and send… | ||
| C++20: Reaching for the Aims of C++ | Bjarne Stroustrup | 01h 38m |
Claims: C++20 delivers concrete, testable advances — import std boosts compile speed ~10× (nine headers gave ~5×, experiments see 0–80×), modules cut… | ||
| Heterogeneous Modern C++ with SYCL | Michael S Wong, Nevin Liber, Tom Deakin, Gordon Brown | 01h 07m |
Slides claim SYCL 2020 adds ~40 features and aligns with C++17 while remaining backwards compatible, with unified shared memory and group/subgroup algorithms… | ||
| Concurrency Patterns | Rainer Grimm | 01h 02m |
Presents concrete C++ concurrency patterns and code: a thread-safe storage implemented with std::mutex and atomics; a strategized locking approach combining… | ||
| Exceptional C++ | Victor Ciura | 01h 00m |
Deep dive into Windows exception internals: how hardware faults and OS signals become structured exceptions, how the compiler maps C++ throw/unwind to sch… | ||
| Type-and-resource Safety in Modern C++ | Bjarne Stroustrup | 54m |
Claims that complete type-and-resource safety is achievable in modern C++ by following the C++ Core Guidelines and enforcing a small set of rules with static… | ||
| “Constexpr Everything” - The Standard Library, Microkernel, Apps, and Unit Tests | Rian Quinn | 01h 00m |
Claims an AUTOSAR‑compliant hypervisor microkernel, apps and unit tests are implemented in C++20 as constexpr everything, with a bespoke BSL, Clang Tidy‑based… | ||
| Implementing C++ Modules: Lessons Learned, Lessons Abandoned | Cameron DaCamara, Gabriel Dos Reis | 01h 06m |
Implementation report gives concrete claims and working fixes: MSVC adds a persistent translation unit (IFC) on disk, linkers record strong module ownership so… | ||
| GraphBLAS: Building a C++ Matrix API for Graph Algorithms | Benjamin Brock, Scott McMillan | 57m |
A working C++ GraphBLAS API prototypes sparse-matrix containers (2-D key_type, fixed shape, compile-time backend hints), callable algebraic primitives (binary… | ||
| Lessons Learned from Packaging 10,000+ C++ Projects | Bret Brown, Daniel Ruoso | 01h 01m |
Bloomberg claims it coherently builds and integrates 10,000+ C++ packages using mostly CMake plus pkg-config, prebuilt binaries, and a Debian-style… | ||
| C++20 Templates: The next level: Concepts and more | Andreas Fertig | 01h 11m |
Shows concrete, actionable detail: how requires expressions and a new concept keyword replace SFINAE patterns, examples that enforce same-type, noexcept and… | ||
| Your New Mental Model of constexpr | Jason Turner | 01h 05m |
Claim: constexpr is best viewed as moving work from runtime to compile time along a constexpr continuum (0–100%). Tools and standards: C++20 features, CTRE… | ||
| Law of Demeter: A Practical Guide to Loose Coupling | Kris Jusiak | 56m |
Shows concrete C++ examples that break and fix the Law of Demeter and claims applying LoD plus Single Responsibility and Dependency Inversion yields code… | ||
| Understanding and Mastering C++'s Complexity | Amir Kirsh | 58m |
Claims concrete examples and fixes: C++ survives four decades and the talk demonstrates why with real code — argument-dependent lookup makes std::swap visible… | ||
| Evolving an Actor Library Based on Lessons Learned from Large-Scale Deployments | Ben Hindman | 01h 01m |
Built a pre‑C++11 actor+future library called libprocess to scale Apache Mesos to 75,000 physical machines, finds the implementation causes excessive… | ||
| Discovering a User-Facing Concept | Christopher Di Bella | 01h 02m |
Claims that concepts are discovered by analyzing algorithms and demonstrates deriving a user-facing semigroup from a range-based left fold, building layered… | ||
| Just Enough Assembly for Compiler Explorer | Anders Schau Knatten | 01h 03m |
Teaches the concrete bits needed to read Compiler Explorer output: x86_64 calling convention, how the first args live in rdi/rsi and returns in rax, how stack… | ||
| Automatically Process Your Operations in Bulk With Coroutines | Francesco Zoffoli | 01h 05m |
Claim: let per-item code stay simple while C++20 coroutines transparently gather arguments and dispatch bulk calls. Implementation builds a minimal… | ||
| C++11/14 at Scale: What Have We Learned? | Vittorio Romeo | 01h 00m |
Eight years of shipping Modern C++ at scale yields concrete rules not slogans: a company-wide course trains hundreds, a book (Embracing Modern C++ Safely)… | ||
| Back to Basics: Designing Classes (part 1 of 2) | Klaus Iglberger | 01h 01m |
Argues that class design becomes manageable by extracting actual variation points and showing concrete refactor steps: replace sprawling inheritance with the… | ||
| Back to Basics: Designing Classes (part 2 of 2) | Klaus Iglberger | 01h 02m |
Shows concrete rules and gotchas: use value initialization with {} or in-class initializers instead of empty default constructors; prefer member-initializer… | ||
| Failing Successfully: Reporting and Handling Errors | Robert Leahy | 51m |
Argues for precise error contracts: prefer fail fast and fail often, keep low-level APIs returning error codes and hand up rich context so higher layers can… | ||
| Back to Basics: Pointers | Mike Shah | 01h 00m |
Covers concrete claims and demos: what a raw pointer actually stores, toy code that shows dereference, pointers-to-pointers, arrays decaying to pointers… | ||
| Compile-Time Compression and Resource Generation with C++20 | Ashley Roll | 56m |
C++20 constexpr/consteval/constinit plus lambdas-as-types generate real artifacts: a 32-entry lerp sine lookup table built at compile time, Huffman-compressed… | ||
| Implementing static_vector: How Hard Could it Be? | David Stone | 01h 02m |
Stack-allocated static_vector claims std::vector semantics but with inline storage, and the talk drills into real tradeoffs: a size optimization that can be 18… | ||
| Back to Basics: Concurrency | Mike Shah | 01h 02m |
Gentle, example‑driven tour of modern C++ concurrency that actually shows code and failures: uses std::thread and jthread, demonstrates data races with 1000… | ||
| Back to Basics: Move Semantics | Nicolai M. Josuttis | 01h 04m |
Shows concrete code and rules: a vector<string> example demonstrates that replacing copying with move constructors cuts heap allocations and is noticeably… | ||
| Differentiable Programming in C++ | Vassil Vassilev, William Moses | 59m |
Claims that integrating automatic differentiation into the compiler yields concrete speed and compatibility wins: two implementations — Clad (AST-level) and… | ||
| Code Analysis++ | Anastasia Kazakova | 01h 01m |
Survey of what actually works now and what’s experimental: the talk lists concrete tool coverage (Clang/clang-tidy, clang-format, CLion, ReSharper C++, MSVC)… | ||
| Back To Basics: Overload Resolution | Ansel Sermersheim, Barbara Geller | 01h 05m |
Condenses the C++ standard to the concrete rules that decide overload choice: ranking of standard conversions (exact match, promotions vs conversions)… | ||
| Extending and Simplifying C++: Thoughts on Pattern Matching using `is` and `as` | Herb Sutter | 01h 37m |
C++ evolution proposes general pattern matching via operator is queries and operator as casts that unify variant any optional and static type traits; the paper… | ||
| Visualize Time Enabled Data using ArcGIS Qt (C++) and Toolkit | Gela Malek Pour | 19m |
Build uses ArcGIS Runtime for Qt (C++) plus the ArcGIS Toolkit time slider to visualize a time‑enabled hurricane feature layer for Sep–Dec 2005. The demo reads… | ||
| Back to Basics: const and constexpr | Rainer Grimm | 01h 02m |
https://cppcon.org/
https://github.com/CppCon/CppCon2021
---
It is a virtue to program as const as possible in modern C++. Your program is by design way more… | ||
| Misra Parallelism Safety-critical Guidelines for C++11, 17, Then C++20, 23 | Michael S Wong, Andreas Weis, Ilya Berala | 58m |
Group work documents a concrete, tool-focused effort: a phase‑one spreadsheet of ~81 candidate rules, 18 accepted and 20 deferred toward MISRA NEXT for… | ||
| Documentation in the Era of Concepts and Ranges | Christopher Di Bella, Sy Brand | 01h 01m |
Argues that C++20 concepts serve as concepts as shared vocabulary for both compiler errors and human docs, compares real docs (abseil, fmtlib, LLVM, range-v3… | ||
| Spooky Action at a Distance | Victor Ciura | 01h 03m |
Compares concrete Observer implementations used in a real C++ codebase and measures tradeoffs: a simple vector-of-callbacks versus indexed registries and… | ||
| Software Architecture Lessons from Multidimensional Spaces Explorations | Vincent Reverdy | 57m |
Proposes that std::mdspan breaks into element type, extent, layout and accessor and that std::mdspan is a promising start but currently omits iterators and… | ||
| The Upcoming Concurrency TS Version 2 for Low-Latency and Lockless Synchronization | Maged M. Michael, Michael S Wong, Paul E. McKenney | 54m |
ISO C++ formally approves Concurrency TS v2 with concrete, testable interfaces: hazard pointers (domains, protect/try_protect, retire) and RCU RAII readers… | ||
| In-memory and Persistent Representations of C++ | Gabriel Dos Reis | 01h 05m |
Claim: concrete, compiler-neutral in-memory and on-disk representations exist and are usable today. Implementation: an open IPR library under MIT captures a… | ||
| Design Patterns: Facts and Misconceptions | Klaus Iglberger | 51m |
Argument checks several concrete claims: std::make_unique improves exception safety is historically true but obsolete under C++17, std::make_unique fulfills… | ||
| Beyond struct: Meta-programming a struct Replacement in C++20 | John Bandela | 48m |
Claims a workable struct replacement implemented in standard C++20 using a fixed_string non-type template parameter for names, overload resolution and… | ||
| Embracing User Defined Literals Safely for Types that Behave as though Built-in | Pablo G Halpern | 01h 03m |
Shows exactly how to write and choose among cooked, raw, template and string UDLs, using real code: a base‑3 numeric parser turned into a compile‑time… | ||
| Faster, Easier, Simpler Vectors | David Stone | 01h 01m |
Argues that std::vector can be replaced for many workloads and shows concrete implementations: 32‑bit vector, static vector, small‑buffer and stable vector… | ||
| Back to Basics: Templates (part 1 of 2) | Bob Steagall | 01h 01m |
Part 1 explains concrete mechanics: templates are recipes that the compiler parses in phase 7 parses templates and generates in phase 8 instantiates them… | ||
| C++ to the RISCue! A Practical Guide for Embedded C++20 | Kris Jusiak | 57m |
Claims that modern C++20 runs for embedded development entirely with online tools and that a declarative state machine yields smaller faster output. Uses… | ||
| The Preprocessor: Everything You Need to Know and More! | Brian Ruth | 58m |
Preprocessor remains a text‑replacement engine that actually pastes headers into a translation unit (see -E preprocessor dump or Compiler Explorer to inspect… | ||
| Bringing Existing Code to CUDA Using constexpr and std::pmr | Bowie Owens | 01h 00m |
Existing options-pricing code is adapted to run on GPU by changing where and how memory is allocated and by making functions visible to the device: allocation… | ||
| Composable C++: Principles and Patterns | Ben Deane | 01h 01m |
Claims that matter: returning bool or int unlocks composition, and choosing return types (optional, collections) prevents awkward special cases. Examples show… | ||
| Static Analysis and Program Safety in C++: Making it Real | Sunny Chatterjee | 01h 00m |
Static analysis for C++ claims compile‑time safety with no runtime cost and actually ships as a Visual Studio Community Edition feature and a GitHub Action… | ||
| Making the Most Out of Your Compiler | Danila Kutenin | 01h 02m |
Claims: switching compilers and build flags gives measurable wins. Tools: clang with thin LTO, PGO, and -O3 -flto or GCC equivalents; CPU targets like… | ||
| Deploying the Networking TS | Robert Leahy | 52m |
Covers a concrete, deployed system built with Networking TS on top of Boost.Asio that speaks a proprietary datacon protocol to a file‑based time‑series DB… | ||
| PGAS in C++: A Portable Abstraction for Distributed Data Structures | Benjamin Brock | 51m |
Argues that the PGAS model gives a portable C++ abstraction that uses global pointer objects and RDMA to implement distributed data structures. Presents BCL, a… | ||
| The Foundation of C++ Atomics: The Knowledge You Need to Correctly Use C++ Atomics | Filipe Mulonde | 01h 33m |
Covers concrete rules and mechanisms: std::atomic (six memory orderings) and when each actually maps to fences or machine instructions, how a core’s store… | ||
| SIMD in C++20: EVE of a new Era | Joel Falcou, Denis Yaroshevskiy | 01h 00m |
EVE is a portable C++20 SIMD library that targets ARM neon and x86 (sse2…avx‑512) and claims concrete wins: benchmarks show vectorized find ~8 ns versus… | ||
| Typescripten: Generating Type-safe JavaScript Bindings for emscripten | Sebastian Theophil | 01h 01m |
Generates type-safe C++ wrappers from TypeScript declaration files using the TypeScript compiler API and targets emscripten via emscripten/embind so JavaScript… | ||
| Back To Basics: Undefined Behavior | Ansel Sermersheim, Barbara Geller | 01h 02m |
Builds a precise definition of undefined behavior, then shows concrete, surprising instances: an infinite loop with no side effects that is UB, signed integer… | ||
| cudaFlow: Modern C++ Programming Model for GPU Task Graph Parallelism | Tsung-Wei Huang, Dian-Lun Lin | 01h 02m |
A C++ library called cudaFlow wraps NVIDIA CUDA Graph to build and offload large GPU task graphs with thousands of nodes, provides an automatic cudaFlow… | ||
| From Problem to Coroutine: Reducing I/O Latency | Cheinan Marks | 01h 03m |
Uses C++20 coroutines to build a fastq generator that yields each read, moves compute into the coroutine body and resumes on a thread-pool via a… | ||
| Back to Basics: Object-Oriented Programming | Rainer Grimm | 01h 00m |
https://cppcon.org/
https://github.com/CppCon/CppCon2021
---
C++ is an object-oriented programming (OOP) language but also supports generic and functional… | ||
| Back to Basics: Lambdas | Nicolai M. Josuttis | 01h 05m |
Shows exactly what lambdas do and how they differ from functions: the compiler generates a closure type with an operator() and captures become members; lambdas… | ||
| Modern CMake Modules | Bret Brown | 01h 02m |
Bloomberg describes using dozens of single-purpose CMake modules to keep tens of thousands of CMakeLists.txt simple and declarative and reports surprising… | ||
| Building a Lock-free Multi-producer, Multi-consumer Queue for Tcmalloc | Matt Kulukundis | 01h 01m |
Built a lock‑free MPMC queue to replace the mutexed transfer cache inside tcmalloc, using atomics, widened counters to mitigate ABA, unit tests, fuzzing and… | ||
| Design and Implementation of Highly Scalable Quantifiable Data Structures in C++ | Christina Peterson, Victor Cook, Zachary Painter | 58m |
Claims a new correctness condition, quantifiability, and ships lock‑free C++ implementations of a QStack and QQueue using compare_exchange_strong and… | ||
| What's New in Visual Studio: 64-bit IDE, C++20, WSL 2, & More | Marian Luparu, Sy Brand | 01h 07m |
Visual Studio 2022 moves the IDE to 64-bit IDE and claims C++20 feature complete support, demos show modules, coroutines, ranges and hot reload actually… | ||
| Value in a Procedural World | Lisa Lippincott | 01h 30m |
Argues that values are observable patterns of program execution, not platonic things, and supports that with three concrete rules — stability… | ||
| 3D Graphics for Dummies | Chris Ryan | 01h 01m |
A hand-rolled C++ matrix library and software rasterizer demonstrates the actual pipeline: 4x4 transforms, vertex pooling, depth buffer, scanline rasterization… | ||
| Back To Basics: The Special Member Functions | Klaus Iglberger | 01h 02m |
Covers the six special member functions (default ctor, dtor, copy/move ctor and assignment) with concrete rules when the compiler generates or omits them, what… | ||
| Interactive C++ for Data Science | Vassil Vassilev | 57m |
Shows a working interactive C++ stack: Cling as an incremental compiler/JIT that runs full C++ (templates, lambdas, virtual inheritance), xeus-cling for… | ||
| Testing Compile-time Constructs in a Runtime Unit Testing Framework | Igor Bogoslavskyi | 31m |
Claim: a library integrates with GoogleTest integration to compile snippets the test marks as forbidden, using a SHOULD_NOT_COMPILE macro that the tooling… | ||
| A Crash Course in Calendars, Dates, Time, and Time Zones | Marc Gregoire | 31m |
C++20 chrono features get practical exercises and gotchas not just names: compile time ratio arithmetic and the predefined SI aliases, how to build and convert… | ||
| Sums, Products, Exponents, Monoids, Functors, Oh My! | Steve Downey | 57m |
Claims that algebraic type laws make APIs predictable and reusable and demonstrates them with C++ library features: std::variant, std::optional, std::transform… | ||
| The Basics of Profiling | Mathieu Ropert | 01h 00m |
Begins with a clear claim: profiling finds what is actually slow, not what feels slow. Demonstrates two profiler families, sampling vs instrumentation, and… | ||
| Design Idioms from an Alternate Universe | Ivan Čukić | 01h 00m |
Argues that concrete C++ examples beat jargon: model states with std::variant state machine to eliminate invalid combinations, use std::optional::transform… | ||
| The Factory Pattern | Mike Shah | 01h 01m |
Explains a concrete claim: use a factory method to centralize creation and an extensible factory that stores name→callback pairs so new types register at run… | ||
| Back to Basics: Classic STL | Bob Steagall | 01h 02m |
Overview explains the original STL design, claims containers+iterators+algorithms as the core and shows how iterators are the real glue. Demonstrations include… | ||
| Generic Graph Libraries in C++20 | Andrew Lumsdaine, Phil Ratzloff | 01h 01m |
Claims that the C++ Standard Library already supplies the primitives to write generic graph algorithms, using C++20 concepts and ranges and customization point… | ||
| C++20 ❤ SQL | John Bandela | 49m |
Claim: C++20 lets SQL queries be embedded as constexpr SQL strings and annotated with tiny C‑style comments to generate compile‑time parameter and row… | ||
| Back to Basics: Casting | Brian Ruth | 45m |
Explains why C++ keeps four casts and when each actually changes bits, with concrete examples: using static_cast for intentional conversions and inheritance… | ||
| Deducing this Patterns | Ben Deane | 01h 03m |
C++23 adds P0847 "Deducing this", making the implicit object parameter explicit and deducible so member functions learn the static most‑derived type and value… | ||
| Hazard Pointer Synchronous Reclamation Beyond Concurrency TS2 | Maged M. Michael | 54m |
Proposes a concrete replacement for slow global cleanup: a cohorts interface that groups retired objects so destroying a cohort guarantees all its destructors… | ||
| A Case-study in Rewriting a Legacy GUI Library for Real-time Audio Software in Modern C++ | Roth Michaels | 58m |
A concrete case study about rewriting a legacy GUI property system into GlassProperties that uses C++17 compile-time meta-programming to convert runtime type… | ||
| C++20: The Small Pearls | Rainer Grimm | 01h 01m |
https://cppcon.org/
https://github.com/CppCon/CppCon2021
---
C++20 has way more to offer than the big four concepts, ranges, modules, and coroutines.
Here are… | ||
| A (Short) Tour of C++ Modules | Daniela Engert | 57m |
Demonstrates concrete mechanics: the primary module interface and implementation unit separation, the role of the global module fragment, and when the export… | ||
| Embracing PODs Safely Until They Die | Alisdair Meredith, Nina Ranns | 01h 01m |
Deep dive into when C++ types really behave like C data and what can go wrong with concrete code and working demos. Shows a concrete reinterpret_cast trick… | ||
| A Hash Map for Graph Processing Workloads & a Methodology for Transactional Data Structures | Christina Peterson, Kenneth Lamar | 59m |
PMap is a lock‑free, open‑addressing persistent hash map that uses C++11 compare_exchange_strong, in‑place key/value storage, per‑cacheline alignment via… | ||
| Handling a Family of Hardware Devices with a Single Implementation | Ben Saks | 01h 03m |
Claims a single template implementation handles six Arduino Mega timers — two 8-bit and four 16-bit — by extracting differences into timer_traits with type… | ||
| Back to Basics: Compiling and Linking | Ben Saks | 01h 03m |
Explains exactly how preprocessing, compilation, instantiation and linking produce object files and how inline and constexpr functions become allowed multiple… | ||
| Conquering C++20 Ranges | Tristan Brindle | 01h 06m |
C++20 Ranges get concrete: author builds a reusable fibonacci view (infinite subrange from an iterator), implements a custom drop_last_while view that caches… | ||
| Using Coroutines to Implement C++ Exceptions for Freestanding Environments | Eyal Zedaka | 01h 00m |
Claim: implement C++ exceptions for freestanding environments using C++20 coroutines as the core mechanism, removing RTTI and avoiding unwind libraries. The… | ||
| Why does std::format do that? | Charlie Barto | 01h 01m |
Explains why std::format is both fast and compact: implemented in msvc implementation based on {fmt}, it uses type erasure to pack arguments (avoiding… | ||
| Asserting Your Way to Faster Programs | Parsa Amini | 38m |
Empirical results on Bloomberg’s BDE libraries compare assume vs ignore semantics using clang 12.0.1 on x86: compile time and compiler memory use show no… | ||
| C++20 on Xilinx FPGA with SYCL for Vitis | Ronan Keryell | 01h 09m |
Claims that a merged Intel oneAPI DPC++ and triSYCL implementation lets C++20/SYCL compile to Xilinx Alveo FPGA bitstreams, producing single-source C++ SYCL… | ||
| Breaking Dependencies: Type Erasure - A Design Analysis | Klaus Iglberger | 01h 02m |
Claims that replacing inheritance with type erasure significantly reduces coupling and simplifies maintenance by extracting operations from domain types into a… | ||
| Multi Threading Model in Paradox Games: Past, Present and Future | Mathieu Ropert | 01h 00m |
Paradox documents an evolution from an older TBB-based, per-entity parallel_for model used in Europa Universalis IV Hearts of Iron IV and Stellaris to a… | ||
| Software Engineering Is About Tradeoffs | Mateusz Pusz | 01h 02m |
Design decisions center on concrete compromises: exception safety vs performance, dynamic allocations, and standardization vs implementation effort. The talk… | ||
| Cool New Stuff in Gdb 9 and Gdb 10 | Greg Law | 01h 07m |
Shows exactly what’s new and what works: a debuginfod server to fetch separate debug files and source by build-id, improved conditional and tab-completing… | ||
| What Classes We Design and How | Peter Sommerlad | 01h 05m |
Claim: design classes by role not by topic — map Value, Relationship, Manager to the special members to write or omit. Concrete tools and patterns: use… | ||
| Embracing (and also Destroying) Variant Types Safely | Andrei Alexandrescu | 01h 01m |
Claims concrete tradeoffs: variant layout uses alignas plus a raw storage buffer and an active index, and destruction dominates performance so a poor… | ||
| Back To Basics: Debugging Techniques | Bob Steagall | 01h 05m |
Claims concrete numbers: industry studies show 13 hours average to reproduce and fix and hundreds of millions of developer hours lost annually; recommended… | ||
| "unit"_test: Implementing a Macro-free Unit Testing Framework from Scratch in C++20 | Kris Jusiak | 01h 01m |
Claim: a working macro-free C++20 framework is implemented from scratch that makes the shown snippet compile and run. It uses C++20 features — modules concepts… | ||
| C++20’s ＜chrono＞ Calendars and Time Zones in MSVC | Miya Natsuhara | 58m |
C++20’s chrono in MSVC implements calendrical types, clock_cast conversions, and time zone support; utc_clock tracks leap seconds and clock_cast accounts for… | ||
| Custom Views for the Rest of Us | Jacob Rice | 46m |
Implements an all_pairs view that lazily presents every ordered pair (except the diagonal) and uses it to compute pairwise gravitational forces for a toy… | ||
| Code Size Compiler Optimizations and Techniques for Embedded Systems | Aditya Kumar | 55m |
Overview of concrete techniques and measured effects: compilers’ code‑size flags (-Os, -Oz), implemented in LLVM optimizations like hot cold splitting and… | ||
| Embracing `noexcept` Operators and Specifiers Safely | John Lakos | 01h 04m |
Shows concrete behavior: the noexcept operator inspects entire expression (including temporaries and destructors), how that forces copies in a vector push_back… | ||
| Back to Basics: Smart Pointers and RAII | Inbal Levi | 50m |
Covers concrete rules: use make_unique/make_shared to avoid allocation+leak races, prefer factory APIs over taking smart pointers, and use… | ||
| Using Clang LibASTMatchers for Compliance in Codebases | Jonah Jolley | 01h 00m |
Uses Clang LibASTMatchers and libtooling to find concrete instances where alarms are instantiated, distinguishing string literals versus config-member… | ||
| Up to Code | David Sankel | 01h 02m |
Worth watching if interest is in a concrete C++ migration case: an actual utility uldb_dump relink with a noisy logging regression, swapping an old lookup API… | ||
| Finding Bugs Using Path-Sensitive Static Analysis | Gabor Horvath | 52m |
Path‑sensitive static analysis simulates execution, records path conditions and uses polyhedra‑based reasoning plus off‑the‑shelf solvers to prune infeasible… | ||
| C++ Standard Parallelism | Bryce Adelstein Lelbach | 01h 00m |
Roadmap claims: standard C++ gains portable parallelism via concrete pieces — execution policies let parallel algorithms dispatch to vendor libraries… | ||
| Our Adventures With REST API in C++ : Making it Easy | Damien Buhl | 01h 01m |
Claims a usable C++ stack that avoids generated client stubs by parsing OpenAPI at compile time and producing real serializers and call wrappers. Uses… | ||
| The Roles of Symmetry And Orthogonality In Design | Charley Bay | 59m |
https://cppcon.org/
https://github.com/CppCon/CppCon2021
---
An essential aspect in designing C and C++ systems is to validate the execution flow and resource… | ||
| Real-time Programming with the C++ Standard Library | Timur Doumler | 01h 01m |
Audio callbacks arrive every 1–10 milliseconds so worst‑case bounds matter; exceptions can be zero‑cost on many ABIs but Windows 32‑bit pays runtime cost… | ||
| Down the Rabbit Hole: An Exploration of Stack Overflow Questions | Marshall Clow | 01h 01m |
Shows actual Stack Overflow questions and then measures solutions: benchmarks use a logger class that counts comparisons and swaps on libc++ and find… | ||
| Value-oriented Design in an Object-oriented System | Juan Pedro Bolivar Puente | 54m |
An open-source cursor library claims to bridge value-oriented design and object-oriented UIs by providing type‑erasing cursors (lens-like views) that read… | ||
| Template Metaprogramming: Practical Application | Jody Hagins | 01h 03m |
Tutorial shows concrete claims and tools not platitudes it demonstrates managing types as lists and maps and trading an upfront compile time cost for faster… | ||
| Making Libraries Consumable for Non-C++ Developers | Aaron R Robinson | 58m |
Concrete checklist of what breaks and what to ship: enumerate interop routes used (C API, COM, FFI, SWIG, JNI, P/Invoke, C++/CLI, cgo, Objective‑C runtime) and… | ||
| GPU Accelerated Computing on Cross-Vendor Graphics Cards with Vulkan Kompute | Alejandro Saucedo | 01h 02m |
Shows concrete results: uses Vulkan and the Kompute framework to run a simple GPU‑accelerated ML kernel from scratch on AMD, Qualcomm, NVIDIA and mobile GPUs… | ||
| Back to Basics: Templates (part 2 of 2) | Bob Steagall | 01h 07m |
Covers concrete rules and worked examples: implements a template min (with return-type deduction), builds a stack adapter plus a pointer-specialized partial… | ||
| Zen and the Art of Code Lifecycle Maintenance | Phil Nash | 01h 02m |
Six concrete takeaways: define six orthogonal qualities (correctness, applicability, reliability, efficiency, evolvability, reasonability), use the type system… | ||
| How Can Package Managers Handle ABI (In)compatibility in C++? | Todd Gamblin | 58m |
Compares how Conan, vcpkg and Spack handle ABI, demonstrates a solver rewrite using clingo (answer set programming) that reasons over compiler, target and… | ||
| Units Libraries and Autonomous Vehicles: Lessons from the Trenches | Chip Hogg | 01h 02m |
Three years of production use across Uber ATG and Aurora show units libraries do catch mismatches but their primary win is automating the heavy manual tracking… | ||
| The Unit Tests Strike Back: Testing the Hard Parts | Dave Steffen | 01h 02m |
Unit testing often breaks down into a plan A that vaporizes and a sequence of pragmatic fallbacks: use mocks or dependency injection, make external services… | ||
| Evolving a Nice Trick | Patrice Roy | 56m |
A concrete evolution: a generic "close enough" comparator is implemented from C++98 to C++20, starting with tag dispatching and hand‑rolled type traits that… | ||
| Building an Extensible Type Serialization System Using Partial Template Specialization | Pejman Ghorbanzade | 55m |
A compact, pragmatic survey that builds and demos an extensible type-serialization prototype on top of FlatBuffers, showing how partial template specialization… | ||
| Combining Co-Routines and Functions into a Job System | Helmut Hlavacs | 58m |
Claims a working C++20 job system called Vienna Game Job System (VGJS) that schedules both co-routines and plain functions, supports tagged phase scheduling… | ||
| C++23 Standard Library Preview | Jeff Garland | 01h 00m |
C++23 delivers concrete changes: ranges gain zip and fold views plus starts_with and pipe customization; formatting adds std::format compile-time checks and a… | ||
| Back to Basics: Algorithmic Complexity | Amir Kirsh, Adam Segoli Schubert | 55m |
Defines big‑O and counts loops to give concrete claims: amortized O(1) for vector::push_back with exponential growth of capacity; std::nth_element/quickselect… | ||
| Dynamically Loaded Libraries Outside the Standard | Zhihao Yuan | 55m |
Explains practical techniques for using dlopen/LoadLibrary and tools like dumpbin/objdump and Application Verifier to diagnose real problems: delay-loading can… | ||
| Warning: std::find() is Broken! | Sean Parent | 01h 42m |
Claim: std::find’s specification omits the domain of equal so behavior depends on hidden preconditions, producing divergent results for cases like NaN not… | ||
| nothing matches | ||