CppCon 2022
2022-09-11..2022-09-16
-- 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 |
|---|---|---|
| C++ in Constrained Environments | Bjarne Stroustrup | 01h 30m |
Argues that practical C++ for constrained systems means concrete techniques not slogans: applies C++ Core Guidelines, moves work to compile time (example… | ||
| Principia Mathematica - The Foundations of Arithmetic in C++ | Lisa Lippincott | 01h 29m |
This work gives concrete, machine-checkable interfaces and proofs for C++ integer arithmetic: extended function syntax with a prologue/epilogue, formal… | ||
| C++20’s Coroutines for Beginners | Andreas Fertig | 01h 02m |
Starts from plain functions and shows C++20 coroutines actually working: implements a generator wrapper type with promise_type, an iterator for range‑based… | ||
| What’s New in C++23 | Sy Brand | 56m |
Shows concrete C++23 additions and how they behave: std::generator yields an easy coroutine-based infinite sequence, deducing this collapses four boilerplate… | ||
| The Imperatives Must Go! [Functional Programming in Modern C++] | Victor Ciura | 58m |
Claim: modern C++ already absorbs FP ideas and shows concrete code. Demonstrations include fmap for std::optional and lifted functions, use of Boost.hof and… | ||
| Compilation Speedup Using C++ Modules: A Case Study | Chuanqi Xu | 44m |
A modularized real project is built and measured with clang and a hand written makefile; demo builds show up to about 4× speedup at -O0 and an average around… | ||
| Deciphering C++ Coroutines - A Diagrammatic Coroutine Cheat Sheet | Andreas Weis | 01h 03m |
Step‑by‑step walkthrough of C++20 coroutine mechanics with copy‑paste skeletons: constructs a minimal coroutine and shows why the compiler requires a… | ||
| C++23 - What's In It For You? | Marc Gregoire | 01h 01m |
A concise inventory of concrete C++23 changes: language tweaks like deducing this, if consteval, multidimensional subscript operators, new integer literal… | ||
| Functional Composable Operations with Unix-Style Pipes in C++ | Ankur Satle | 01h 02m |
Prototype implements a C++11 generic pipe operator that composes any T with a Callable, shows a real Kafka init chain using libRdKafka and unique_ptr for RAII… | ||
| Back to Basics: Debugging in C++ | Mike Shah | 01h 01m |
Argues programmers spend roughly 35–50% of time debugging and often budget 50–75% for it, then demonstrates concrete debugging work: compile with -g and -Wall… | ||
| Back to Basics: Templates in C++ | Nicolai M. Josuttis | 01h 02m |
Covers concrete, up-to-date rules and examples: function and class templates, return-type deduction for mixed-type my_max, class template argument deduction… | ||
| How Microsoft Uses C++ to Deliver Office - Huge Size, Small Components | Zachary Henkel | 01h 03m |
Office contains about 100M lines of native C++ inside a ~350M LOC repo and a ~50 TB release archive, and building every platform/arch/config requires 2 million… | ||
| Taking a Byte Out of C++ - Avoiding Punning by Starting Lifetimes | Robert Leahy | 58m |
Claim: C++23 introduces start_lifetime_as to explicitly begin object lifetimes so bytes can back objects without UB from type punning. Shows concrete… | ||
| C++ Performance Portability - A Decade of Lessons Learned | Christian Trott | 01h 02m |
Claims decade-long lessons from developing Kokkos: one-source C++ mapping to CUDA HIP SYCL OpenMP, used by ~900 developers across ~150–250 HPC projects and by… | ||
| Back to Basics: C++ Move Semantics | Andreas Fertig | 01h 02m |
Explains concrete rules and worked examples: why mark noexcept move ctors, how to write efficient move constructor and move assignment using… | ||
| import CMake, CMake and C++20 Modules | Bill Hoffman | 55m |
CMake ships an experimental C++20 modules workflow in CMake master that uses per‑target file sets and compiler scanning to emit JSON dependency files, collates… | ||
| HPX - A C++ Library for Parallelism and Concurrency | Hartmut Kaiser | 01h 02m |
HPX is a C++ standards library that implements lightweight tasks, a work-stealing scheduler, futures, and sender/receiver plumbing (p2300) to orchestrate… | ||
| Back to Basics: Cpp Value Semantics | Klaus Iglberger | 48m |
Argues for preferring value semantics over reference semantics, replacing pointer-and-inheritance visitor code with a std::variant-based vector of values… | ||
| Help! My Codebase has 5 JSON Libraries - How Generic Programming Rescued Me | Christopher McArthur | 20m |
Codebase actually runs with RapidJSON, CPPRESTSDK, PicoJSON, nlohmann and Boost JSON and that fragmentation forces a practical solution: template the JWT logic… | ||
| Using Incredibuild to Accelerate Static Code Analysis and Builds | Jonathan "Beau" Peck | 47m |
A demo shows Incredibuild using process virtualization and a single binary agent to distribute compilation, CI and static analysis across initiator coordinator… | ||
| Understanding Allocator Impact on Runtime Performance in C++ | Parsa Amini | 51m |
Claim: using a monotonic buffer resource with a local buffer reduces execution time by cutting memory loads and resisting heap diffusion. Evidence comes from a… | ||
| C++ Concurrency TS 2 Use Cases and Future Direction | Michael S Wong, Maged M. Michael, Paul E. McKenney | 55m |
C++ Concurrency TS 2 already standardizes hazard pointers and RCU with minimal subsets slated for C++26, and additional facilities like snapshot_ptr… | ||
| C++ Lambda Idioms | Timur Doumler | 01h 05m |
Covers concrete techniques and gotchas: how closure types are generated, the unary-plus trick for forcing conversion to function pointer, using… | ||
| ISO C++ Standards Committee Panel Discussion | Herb Sutter | 01h 27m |
Panelists state concrete outcomes and pain points: C++23 lands import std so the standard library becomes a module, modules adoption shows much faster builds… | ||
| Can C++ be 10x Simpler & Safer? | Herb Sutter | 01h 54m |
Claims an executable experiment: cppfront transpiles cpp2 to C++20 and runs on major compilers, producing readable C++ output. It introduces an alternate… | ||
| High Speed Query Execution with Accelerators and C++ | Alex Dathskovsky | 43m |
A hardware SoC for big‑data queries claims at least x60 speedup versus CPU by running a novel massively parallel non‑von‑Neumann MFC plus dedicated… | ||
| Taking Static Type-Safety to the Next Level - Physical Units for Matrices | Daniel Withopf | 01h 02m |
A concrete library called typesafe Matrix embeds distinct physical units and coordinate‑frame tags into Eigen-backed vectors and matrices, inferring element… | ||
| Understanding C++ Coroutines by Example: Generators (Part 1 of 2) | Pavel Novikov | 01h 01m |
Step‑by‑step construction of a working C++20 generator: compiler transformation into a frame with promise_type, how yield_value and return_void map to… | ||
| Understanding C++ Coroutines by Example: Generators (Part 2 of 2) | Pavel Novikov | 01h 03m |
Concrete implementation of C++20 coroutines for generators shows the exact promise changes, an implements iterator-based generators design with begin/end… | ||
| Undefined Behavior in the STL | Sandor Dargo | 01h 04m |
Argues that undefined behavior lives inside the STL by design and gives concrete, actionable examples: bounds-checked at versus unchecked operator[] shows… | ||
| Back to Basics: C++ Testing | Amir Kirsh | 01h 02m |
Covers concrete practices: use Google Test (gtest) and gmock with fixtures and parameterized tests, write assertions with expect vs assert and matchers, and… | ||
| C++ MythBusters | Victor Ciura | 01h 00m |
Claims and evidence land fast: printf/sprintf hits a locale mutex and is slow on macOS so switching to fmt yields 3–4× speedup on macOS and ~20× on Windows in… | ||
| Refresher on Containers, Algorithms and Performance in C++ | Vladimir Vishnevskii | 01h 01m |
Standard containers behave very differently in real workloads: continuous storage gives cache-friendly random access while node-based containers pay allocation… | ||
| WebAssembly: Taking Your C++ and Going Places | Nipun Jindal, Pranay Kumar | 52m |
Claims that WebAssembly runs C++ on the web about 4.2× faster than JavaScript and compiles with Emscripten (emcc); demos show a logger that writes to… | ||
| Purging Undefined Behavior & Intel Assumptions in a Legacy C++ Codebase | Roth Michaels | 01h 03m |
Shows concrete fixes not fluff: uses clang sanitizers (ASan/UBSan) and thread sanitizer to find use‑after‑free, uninitialized-data and race bugs; adds… | ||
| C++ Function Multiversioning in Windows | Joe Bialek, Pranav Kant | 01h 03m |
Claim: compiler and Windows 11 loader collaborate to pick the best implementation at load time by embedding metadata and a BDD that fixes up direct calls so… | ||
| C++ for Enterprise Applications | Vincent Lextrait | 01h 05m |
Claim: a C++ metaframework implements an ontology-based referential integrity faster than relational databases, with layered templates (~300k lines of template… | ||
| Back to Basics: C++ Smart Pointers | David Olsen | 49m |
Covers concrete rules: use std::unique_ptr for single ownership (move‑only, noexcept, use release/reset/get), use std::shared_ptr for shared ownership (control… | ||
| Using Modern C++ to Eliminate Virtual Functions | Jonathan Gopel | 01h 01m |
Claims that as of C++20 no statically linked program needs virtual functions, and replaces runtime polymorphism with C++20 Concepts and CTAD. Implements… | ||
| Graph Algorithms and Data Structures in C++20 | Phil Ratzloff, Andrew Lumsdaine | 01h 02m |
Claims that graph algorithms can be expressed generically in C++20 by mapping graph type requirements onto existing range-of-ranges concepts and using… | ||
| Case For a Standardized Package Description Format for External C++ Libraries | Luis Caro Campos | 59m |
The ISO C++ survey shows most projects build third-party source with the project, which explains why build times remain a top pain point. The proposal argues… | ||
| Back to Basics: C++ API Design | Jason Turner | 01h 01m |
Argues for concrete rules: mark getters no discard, mark non‑throwing functions no accept, prefer returning unique_ptr or an expected‑style type over raw… | ||
| UPDATED: Scalable and Low Latency Lock-free Data Structures in C++ | Alexander Krizhanovsky | 55m |
Claims a Hash Trie hybrid lock-free cache-conscious C++ implementation that targets millions of lookups/inserts with low tail latency and compares… | ||
| C++ Coding with Neovim | Prateek Raman | 01h 00m |
Neovim plus built-in LSP is configured to run clangd (installed via Mason) against a project with a compile_commands.json so clangd indexing attaches and gives… | ||
| An Introduction to Multithreading in C++20 | Anthony Williams | 01h 07m |
C++20 gives concrete tools not platitudes: use std::jthread with std::stop_token for managed threads (destructor requests stop then joins), prefer parallel… | ||
| Embracing Trailing Return Types and `auto` Return SAFELY in Modern C++ | Pablo G Halpern | 01h 02m |
Compares trailing-return syntax vs omitted/auto return with concrete code: uses decltype(auto) to preserve value category, shows a units library and… | ||
| MDSPAN - A Deep Dive Spanning C++, Kokkos & SYCL | Nevin Liber | 58m |
MDSPAN is a non‑owning multidimensional array reference ported from Kokkos::View and now slated for C++23 after seven years and 17 revisions, with a companion… | ||
| A Lock-Free Atomic Shared Pointer in Modern Cpp | Timur Doumler | 01h 02m |
Claims a portable, practical implementation of a lock-free std::atomic<std::shared_ptr> and explains how it actually works: a split refcount algorithm plus… | ||
| Managing External API’s in Enterprise Systems | Peter Muldoon | 01h 03m |
Migrates a wide legacy comms API into a constrained wrapper that uses move-only response carriers (unique_ptr), replaces callbacks with futures/promises, and… | ||
| The Hidden Performance Price of C++ Virtual Functions | Ivica Bogosavljevic | 49m |
Shows measured costs, not a rant: a short virtual call costs about 20% extra (153 ms vs 126 ms) while long calls are almost identical (32.09 s vs 31.84 s)… | ||
| 10 Years of Meeting C++ - Historical Highlights and the Future of C++ | Jens Weller | 49m |
Meeting C++ runs for ten years, grows from C++11-era meetings into a platform with a yearly conference, a miniCpp platform, user‑group maps and a continuous… | ||
| Back to Basics: RAII in C++ | Andre Kostur | 44m |
Claims that RAII, when applied correctly, eliminates leaks, use-after-release and double disposal for most resources and demonstrates this with… | ||
| The Most Important Optimizations to Apply in Your C++ Programs | Jan Bielak | 01h 05m |
Covers concrete, actionable optimizations: LTO and PGO for build pipelines, replacing malloc and using llvm-bolt for binary layout, annotations like… | ||
| Introduction to Hardware Efficiency in Cpp | Ivica Bogosavljevic | 01h 00m |
Code is either CPU‑bound or memory‑bound and the talk shows concrete fixes and measurements: use profilers VTune uProf perf to classify bottlenecks, convert… | ||
| From C++ Templates to C++ Concepts - Metaprogramming: an Amazing Journey | Alex Dathskovsky | 53m |
Traces template metaprogramming from C++98 to C++20 and implements a working container detector first with SFINAE, tag dispatch, enable_if, void_t, declval and… | ||
| Back to Basics: Master C++ Value Categories With Standard Tools | Inbal Levi | 51m |
Clear claim: value category is a property of an expression, not an object. Examples show a single line producing two objects when a const return blocks a move… | ||
| GPU Performance Portability Using Standard C++ with SYCL | Hugh Delaney, Rod Burns | 31m |
Claims that standard C++ with SYCL runs on Nvidia AMD and Intel GPUs and delivers native-like speed are backed by concrete tooling and results: compilation via… | ||
| Optimizing A String Class for Computer Graphics in Cpp | Zander Majercik, Morgan McGuire | 28m |
SIMDString is a drop-in std::string replacement tuned for graphics that embeds small strings on the object, uses SIMD intrinsics, and relies on a custom… | ||
| Breaking Dependencies - C++ Type Erasure - The Implementation Details | Klaus Iglberger | 01h 01m |
Shows two ~20 line implementations for owning and non-owning wrappers, then builds a real shape wrapper with a templated constructor, clone-based copy, and an… | ||
| A Faster Serialization Library Based on Compile-time Reflection and C++ 20 | Yu Qi | 23m |
A serialization library called struct pack uses compile-time reflection in C++20 to avoid per-field type tags, generate a compile-time MD5 type hash placed at… | ||
| Contemporary C++ in Action | Daniela Engert | 01h 20m |
A compact client‑server video streamer is actually built, using libav, SDL, ASIO executors and C++20/23 features (generators, coroutines, expected, modules… | ||
| The Dark Corner of STL in Cpp: MinMax Algorithms | Šimon Tóth | 27m |
Shows that calling std::min/std::max leads to dangling references when overloads return const references, and that C++14 initializer_list overloads fix… | ||
| Breaking Enigma With the Power of Modern C++ | Mathieu Ropert | 01h 03m |
Shows a practical attempt to recover an M4 Enigma message (P10 3681) on a modern desktop, using C++20 and a 16-core CPU. Claims and measurements: compile-time… | ||
| C++ in the World of Embedded Systems | Vladimir Vishnevskii | 55m |
Claims that modern C++ is practical for constrained and real‑time embedded systems and shows how to make that true: compile‑time MMIO metaprogramming for… | ||
| 10 Tips for Cleaner C++ 20 Code | David Sackstein | 58m |
Builds a small VOD app and iteratively refactors it so you can see each change: splits a bulky readMovies into readMovie + lazy generator via C++20 coroutines… | ||
| Killing C++ Serialization Overhead & Complexity | Eyal Zedaka | 01h 00m |
Claims a C++20, macro‑less serializer (zpp bits) that matches or beats handwritten code in benchmarks (handwritten ~830 ms, zpp bits ~827–879 ms after tweaks)… | ||
| What's New in Conan 2.0 C/C++ Package Manager | Diego Rodriguez-Losada | 01h 04m |
Conan 2.0 claims about 80% of the codebase is new and delivers concrete features: a dual package‑ID model that distinguishes embedded vs non‑embedded binaries… | ||
| Fast, High-Quality Pseudo-Random Numbers for Non-Cryptographers in C++ | Roth Michaels | 56m |
Benchmarks compare std::mt19937 against modern alternatives and find zoshiro128+ and PCG produce similar perceptual audio results but run faster and with… | ||
| Modern C++: C++ Patterns to Make Embedded Programming More Productive | Steve Bush | 01h 00m |
Shows concrete patterns: a declarative gpio definition and small functor-based chipselect that centralizes intent; constexpr thermistor lookup (256 floats… | ||
| LLVM Optimization Remarks | Ofek Shilon | 57m |
A practical tour of optimization remarks shows a working toolchain: use opt-viewer (HTML output, Compiler Explorer panel) to turn Clang’s YAML logs into… | ||
| Value Semantics: Safety, Independence, Projection, & Future of Programming | Dave Abrahams | 01h 01m |
Argues that value semantics = regularity + independence, not just a slogan, and shows concretely how reference semantics causes lifetime errors, race… | ||
| What Can Compiler Benchmarks Reveal About Metaprogramming Implementation Strategies | Vincent Reverdy | 01h 04m |
Builds a portable single-header metabench that generates millions of unique type permutations, runs on C++17 and C++20, and times compile cost via external… | ||
| memory-safe C++ | Jim Radigan | 01h 06m |
A new compiler and runtime claim to make C and C++ memory safe without changing source code, combining static analysis with an improved AddressSanitizer that… | ||
| A Pattern Language for Expressing Concurrency in Cpp | Lucian Radu Teodorescu | 01h 04m |
Claim: C++ can get structured concurrency by adopting senders/receivers (P2300) as primitives, matching five structured‑programming principles. Tools and… | ||
| What Is an Image? - Cpp Computer Graphics Tutorial, (GPU, GUI, 2D Graphics and Pixels Explained) | Will Rosecrans | 01h 04m |
Explains concrete claims and tradeoffs: how to compute memory for n pixels, why RGB 24-bit vs RGBA 32-bit alignment makes RGBA iterate faster (RGB ~4s vs RGBA… | ||
| Nth Pack Element in C++ - A Case Study | Kris Jusiak | 01h 01m |
Compares concrete implementations for grabbing the nth element of a variadic pack, builds and runs benchmarks with metabench and Compiler Explorer, and… | ||
| Back to Basics: Standard Library Containers in Cpp | Rainer Grimm | 01h 04m |
Claims and measurements land the decision: std::vector and std::array are your best friends for sequences with contiguous layout and cache wins (benchmark… | ||
| GPU Accelerated Computing & Optimizations on Cross-Vendor Graphics Cards with Vulkan & Kompute | Alejandro Saucedo | 01h 00m |
Uses Vulkan SDK and Kompute to build a runnable GPU ML pipeline from scratch that executes on over 1000 GPUs across AMD Qualcomm NVIDIA, replaces the 500–2000… | ||
| Optimizing Binary Search | Sergey Slotin | 58m |
Claims concrete speedups over std::lower_bound with measurable tradeoffs: up to ~15× faster on small arrays and ~7× on large ones. Achieves this by replacing… | ||
| Sockets - Applying the Unix Readiness Model When Composing Concurrent Operations in C++ | Filipp Gelman | 55m |
Claim: the Unix readiness model is practical to compose concurrent C++ operations by making senders and awaitables look like sockets. Implements a… | ||
| C++ Coroutines, from Scratch | Phil Nash | 59m |
Claims C++20 coroutines cut complex async boilerplate and speed database-style object loading by converting a serial 10-roundtrip loader into batched loads and… | ||
| Generating Parsers in C++ with Maphoon - Part 1 of 2 | Hans de Nivelle | 42m |
Tool generates C++17 parser generator code and runtime automata, producing LALR parsers plus a tokenizer that mixes generated automata with handwritten token… | ||
| Back to Basics: Object-Oriented Programming in C++ | Amir Kirsh | 01h 00m |
Covers concrete C++ practices: use a constructor initialization list (four cases require it), prefer the rule of zero for resource management and immediately… | ||
| "It's A Bug Hunt" - Armor Plate Your Unit Tests in Cpp | Dave Steffen | 01h 01m |
Argues that unit tests must be measurable tools: maximize accuracy and precision by choosing cases via equivalence partitioning, checking boundaries (the… | ||
| Reviewing Beginners' C++ Code | Patrice Roy | 01h 01m |
Covers practical, repeatable tactics for giving fast, fair feedback on beginners’ C++: a short taxonomy of real mistakes (magic constants, bad comments, wrong… | ||
| Observability Tools C++: Beyond GDB and printf - Tools to Understand the Behavior of Your Program | Ivica Bogosavljevic | 44m |
Flame graphs via speedscope + perf (99Hz sampling) show where time actually goes; heap profiling with Heaptrack: 19MB peak, ~200k allocations reveals… | ||
| Fast C++ by using SIMD Types with Generic Lambdas and Filters | Andrew Drakeford | 54m |
A small framework implements contiguous aligned padded vectors (VACXX), generic lambdas and filters/views and generates dense AVX2/AVX512 intrinsics; it claims… | ||
| New in Visual Studio Code! Clang-Tidy, makefile, CMake, GitHub, & More | Marian Luparu, Sinem Akinci | 01h 04m |
Live demo shows a full C++ project (OpenTTD) configured, built and debugged on a vanilla Mac and on Windows+WSL then run in parallel, with vcpkg manifest… | ||
| Overcoming C++ Embedded Development Tooling Challenges | Marc Goodner | 55m |
Claims concrete fixes: use VC package artifacts to declare and activate compilers, use cmake presets and toolchain files to find compilers on PATH, and run… | ||
| Using Modern C++ to Revive an Old Design | Jody Hagins | 01h 02m |
https://cppcon.org/
---
Using Modern C++ to Revive an Old Design - Jody Hagins - CppCon 2022
https://github.com/CppCon/CppCon2022
In 1984, Dennis Ritchie… | ||
| Personal Log - Where No Init Has Gone Before in C++ | Andrei Zissu | 54m |
Claim: C++17 can execute uncalled local code by instantiating a template on a consteval-compatible function pointer so a compile-time hash replaces literal log… | ||
| tipi.build A New C++ Package Manager | Damien Buhl | 57m |
tipi.build claims a cloud-first C++ package manager with a global build cache that stores build artifacts (not full executables), spins up remote build… | ||
| Architecting Multithreaded Robotics Applications in C++ | Arian Ajdari | 37m |
Claim: a C++ tool named Lambda C++ library hides threads so robotics engineers think linearly while using multicores. It implements pre‑parallelized linear… | ||
| Pragmatic Simplicity - Actionable Guidelines To Tame Cpp Complexity | Vittorio Romeo | 01h 11m |
Interactive session shows concrete rules: derive use the most limited tool for the job from casting, emplace_back vs push_back, scope_lock pitfalls, ranges vs… | ||
| Back to Basics: The C++ Core Guidelines | Rainer Grimm | 01h 03m |
Claims that the Core Guidelines boil down to concrete rules for interfaces, functions, classes, concurrency and templates and lists 350 rules (roughly 600–700… | ||
| Simulating Low-Level Hardware Devices in Cpp | Ben Saks | 01h 01m |
Claims that C++ can simulate memory-mapped device registers so the same register-level code runs on desktop and target hardware. Uses operator overloading… | ||
| Reproducible Developer Environments in C++ | Michael Price | 01h 00m |
Evaluates two concrete solutions by measurable criteria: a 10‑point rubric (examples: reproducible builds, versioned images), an example Contoso baseline… | ||
| The Surprising Complexity of Formatting Ranges in Cpp | Barry Revzin | 58m |
Argument: adding range and tuple support to std::format and {fmt} exposes many concrete edge cases not solved by restating the topic. The work shows a C++23… | ||
| How to Use C++ Dependency Injection to Write Maintainable Software | Francesco Zoffoli | 01h 03m |
Concrete rules for C++ dependency injection: prefer constructor or function parameters over setters, pass read‑only data as value or const reference and… | ||
| The Observer Design Pattern in Cpp | Mike Shah | 01h 02m |
Concrete C++ code evolves from a naive single-function handler to interface-based observers to a keyed map of observer lists (example3.cpp uses shared_ptrs)… | ||
| Smarter Cpp Atomic Smart Pointers - Efficient Concurrent Memory Management | Daniel Anderson | 01h 01m |
Argues that combining atomic shared_ptr semantics with deferred reclamation (Hazard pointers or RCU) yields RAII-style APIs that match deferred-reclamation… | ||
| C++ Package Manager - C++ Dependencies Don't Have To Be Painful! | Augustin Popa | 01h 03m |
Survey data shows a majority of C++ developers still manage libraries manually while 19% adoption for both vcpkg and Conan climbs year‑over‑year. vcpkg’s… | ||
| Cross-Building Strategies in the Age of C++ Package Managers | Luis Caro Campos | 37m |
Claims that modern Cpp package managers like Conan and vcpkg can orchestrate cross-builds by supplying compiler toolchains, profiles and sysroots and by… | ||
| Back to Basics - Name Lookup and Overload Resolution in C++ | Mateusz Pusz | 01h 02m |
Explains exactly how name lookup and overload resolution produce surprising behavior: unqualified lookup stops at the first scope found so a later overload can… | ||
| Reflection in C++ - Past, Present, and Hopeful Future | Andrei Alexandrescu | 01h 06m |
Claim: C++ gains usable compile‑time reflection that turns types into manipulable values and back, enabling concrete features: std::meta value APIs, a… | ||
| Nobody Can Program Correctly - Lessons From 20 Years of Debugging C++ Code | Sebastian Theophil | 52m |
Twenty years of real bug hunts condense to concrete moves: increase reports with crash reporting backends (Google crashpad), reproduce with stress tests and… | ||
| GitHub Features Every C++ Developer Should Know | Michael Price | 50m |
Shows concrete workflows using GitHub Actions to run a six‑job matrix (six builds plus two analysis checks), demonstrates GitHub hosted runners up to 64… | ||
| Using C++14 in an Embedded “SuperLoop” Firmware | Erik Rainey | 01h 31m |
Claims that C++14 is practical in a tightly constrained superloop firmware with concrete limits: deployed Prime Air firmware runs on a hexacopter with six… | ||
| C++ Class Template Argument Deduction - History, Uses, & Enabling it for Classes | Marshall Clow | 01h 03m |
C++17 CTAD explains why the language now fills class template arguments for you, how the compiler generates implicit vs explicit deduction guides, and when to… | ||
| Linux Debuginfo Formats - DWARF, ELF, dwo, dwp - What are They All? | Greg Law | 01h 03m |
Explains what each format actually contains and how tools use it: DWARF holds type and variable info, ELF sections and note build IDs identify binaries, split… | ||
| C++20’s [[likely]] Attribute - Optimizations, Pessimizations, and [[unlikely]] Consequences | Amir Kirsh, Tomer Vromen | 01h 04m |
C++20’s [[likely]]/[[unlikely]] changes only when the compiler actually alters code layout or emits different assembly: it affects the compiler branch… | ||
| Back to Basics: Declarations in C++ | Ben Saks | 01h 03m |
Explains concrete rules rather than vague tips: why constexpr requires an initializer with examples of object definitions vs non-defining extern declarations… | ||
| New in Visual Studio 2022 - Conformance, Performance, Important Features | Marian Luparu, Sy Brand | 01h 00m |
Visual Studio 2022 17.3 runs natively on arm64 and the MSVC compiler also runs natively while still targeting x86/x64/arm64; more than 600 vcpkg libraries… | ||
| Cute C++ Tricks, Part 2.5 of N - Code You Should Learn From & Never Write | Daisy Hollman | 59m |
Dissects 25-line C++ snippets that teach and tempt: shows the actual hacks, why they work, and when they fail. Demonstrates partial specialization via lambda… | ||
| Implementing Understandable World Class Hash Tables in C++ | Eduardo Madrid, Scott Bruce | 01h 05m |
Claims world‑class performance backed by open source code, microbenchmarks and Compiler Explorer disassembly: a Robin Hood probing invariant implemented with… | ||
| Val: A Safe Language to Interoperate with C++ | Dimitri Racordon | 01h 01m |
Claims a new language that is safe-by-default and enforces mutable value semantics while remaining a zero-cost-abstraction companion for C++. The prototype… | ||
| Bringing a Mobile C++ Codebase to the Web | Li Feng | 28m |
Claim: adding full WebAssembly support to Djinni lets the same interface definitions expose existing C++ to JavaScript/TypeScript with almost no C++ changes… | ||
| Rules for Radical Cpp Engineers - Improve Your C++ Code, Team, & Organization | David Sankel | 01h 01m |
Uses political-activism tactics (Saul Alinsky and Ella Baker style) to get technical change: concrete wording like speak their language and filing a formal… | ||
| Quantifying Dinosaur Pee - Expressing Probabilities as Floating-Point Values in C++ | John Lakos | 01h 01m |
Reproduces the birthday problem, discovers a floating‑point trap where IEEE‑754 doubles pin the collision probability to 1 (breaks at n ≈ 184), and fixes it by… | ||
| Breaking Dependencies - The Visitor Design Pattern in Cpp | Klaus Iglberger | 01h 02m |
Argues the Visitor pattern tradeoff with concrete code and microbenchmarks: classic visitor uses two virtual calls per operation and suffers large slowdowns; a… | ||
| C++ Algorithmic Complexity, Data Locality, Parallelism, Compiler Optimizations, & Some Concurrency | Avi Lachmish | 48m |
Concrete claims, measurements, and fixes: traversing a 4096×4096 double matrix rowwise takes row: 21 ms vs column: 912 ms, measured with valgrind; L1=32 KB… | ||
| Parallelism Safety-Critical Guidelines for C++ | Michael S Wong, Andreas Weis, Ilya Burylov | 01h 01m |
A working group produces concrete, checkable rules for parallelism safety: a public spreadsheet and phase‑one analysis yield 24 rules ready with MISRA… | ||
| Binary Object Serialization with Data Structure Traversal & Reconstruction in Cpp | Chris Ryan | 51m |
Claims a minimally intrusive, portable C++14/17 serialization that deduces types with Template Argument Deduction (TAD), uses SFINAE/std::enable_if<> (and can… | ||
| Structured Networking in C++ | Dietmar Kühl | 57m |
Demonstrates a concrete implementation of the p2300 senders/receivers model to make networking structured: coroutines build async Echo server tasks, connect… | ||
| A Tour of C++ Recognised User Type Categories | Nina Ranns | 54m |
Concrete rules and gotchas for when user types actually gain special behaviour across C++ versions: precise definitions and examples for aggregate types… | ||
| How C++23 Changes the Way We Write Code | Timur Doumler | 01h 33m |
C++23 claims to finish C++20 while adding workaday wins: it standardizes std::expected error-or-value monad for composable, non‑exception short‑circuiting… | ||
| Bringing a Mobile C++ Codebase to the Web | Li Feng | 28m |
Djinni gains full WebAssembly support so the same IDL and generated bindings reuse Snapchat’s large mobile C++ codebase to produce Snapchat for Desktop Web… | ||
| Using std::chrono Calendar Dates for Finance in Cpp | Daniel Hanson | 51m |
C++20’s calendar types are usable for real finance work: the talk shows using std::chrono year_month_day and year_month_day_last plus systime conversions to… | ||
| Take Advantage of All the MIPS - SYCL & C++ | Michael S Wong, Hugh Delaney, Ronan Keryell, Nevin Liber, Jakub Chlanda | 01h 01m |
SYCL claims you can write one C++ source that targets CPUs, GPUs, FPGAs and DSPs and the examples actually back that up: frontends and runtimes like DPC++… | ||
| Aliasing in C++ - Risks, Opportunities and Techniques | Roi Barkan | 52m |
Examples show real failures: a naive loop-copy breaks overlapping buffers, std::memmove survives but strcpy/copy_n are undefined in those cases, and compilers… | ||
| Lightning Talk: Who is Looking for a C++ Job? | Jens Weller | 05m |
An online C++ job fair runs for two years and hosted four events in 2021 and five so far in 2022, with employers sitting at virtual tables and candidates… | ||
| Lightning Talks: -std=c++20 -- Will This C++ Code Compile? | Tulio Leao | 05m |
Seven concrete portability gotchas for moving to C++20, each with a failing snippet and a fix: new keywords like requires and concept breaking identifier… | ||
| Lightning Talk: Programming is Fun in Cpp! | Pier-Antoine Giguère | 05m |
A tiny realtime ray tracer written in C++ renders into an image buffer shown in a simple GUI with checkboxes and sliders and hits interactive frame rates by… | ||
| Lightning Talk: Effective APIs in Practice in C++ | Thamara Andrade | 05m |
Five quick, actionable claims: five concrete tips that change APIs rather than restate principles. Better names reduce ambiguity, strong types force callers to… | ||
| Lightning Talk: C++ on Fly - C++ on Jupyter Notebook | Nipun Jindal | 06m |
Demonstrates a working Jupyter setup that runs real C++ code via xeus-cling (Cling + LLVM) and shows concrete commands to install with conda or spin up a ready… | ||
| Lightning Talk: Finding Whether a Number is a Power of 2 | Ankur Satle | 05m |
Several concrete checks appear: a loop that counts ones by rotating, generating candidates and testing equality, the classic n & (n-1) == 0 trick from K&R, and… | ||
| Lightning Talk: The Decade Long Rewind: Lambdas in C++ | Pranay Kumar | 06m |
Survey of lambda changes from C++11→C++20 with concrete claims and examples: lambdas produce unique unnamed closure types so two identical lambdas have… | ||
| Lightning Talk: Using This Correctly it's [[unlikely]] at Best | Staffan Tjernstrom | 05m |
C++20 attributes likely and unlikely are concrete compiler hints that aim to bias code layout and inlining rather than magically speed hot paths. The claim is… | ||
| Lightning Talk: Developer Grief | Thamara Andrade | 04m |
Claims that debugging follows five stages of grief: denial (blaming the user or hoping the Jira ticket is wrong), anger during root-cause work with a debugger… | ||
| Lightning Talk: find-move-candidates in Cpp | Chris Cotter | 05m |
A clang-based tool built on clang meta tool and lib tooling scans a compilation database and flags or inserts std::move suggestions where the last use of a… | ||
| Lightning Talk: C++20 - A New Way of Meta-Programming? | Kris Jusiak | 06m |
Five concrete C++20 techniques for template metaprogramming: compile-time branching with requires/constraints and if constexpr that selects overloads… | ||
| Lightning Talk: Adventures in Benchmarking Timestamp Taking in Cpp | Nataly Rasovsky | 05m |
Benchmarks compare clock_gettime vs rdtsc and use QuickBench then real servers; initial QuickBench numbers show 85× slower for clock_gettime, but running… | ||
| Lightning Talk: 10 Things an Entry-Level Software Engineer Asks You to Do | Katherine Rocha | 04m |
Ten concrete onboarding requests land: set up development environment and point to passwords and guides, walk through the design process and the code structure… | ||
| Lightning Talk: majsdown: Metaprogramming? In my Slides? | Vittorio Romeo | 05m |
A Markdown flavor embeds ES2020/ES6 code and runs it via a C++20 preprocessor that links to the C/C++ QuickJS engine. It generates concrete outputs: automatic… | ||
| Lightning Talk: Const Mayhem in C++ | Ofek Shilon | 06m |
Claims and concrete surprises: const methods legally modify members via a pointer-initialized member that increments memory and runs on major compilers, a… | ||
| Lightning Talk: Now in Our Lifetimes Cpp | Staffan Tjernstrom | 04m |
C++23 adds last‑second support for creating objects in raw memory so code that reads data from a file or a message queue can legally start object lifetimes… | ||
| Lightning Talk: Best Practices Every C++ Programmer Needs to Follow | Oz Syed | 06m |
Emphasizes concrete habits: enforce memory ownership and matching search for mismatched new/delete, implement destructors and the rule of three (copy ctor… | ||
| Lightning Talk: Dependency Injection for Modern C++ | Tyler Weaver | 03m |
Argues that taking functions as parameters replaces heavy interface-and-mocking setups and shows concrete code: pass a std::function into an Optimizer/cost… | ||
| Lightning Talk: C++ Debug Performance is Improving: What Now? | Vittorio Romeo | 06m |
Claims that debug builds are getting faster backed by examples: using std::byte can produce heavier assembly compared to char, an std::move added in a C++20… | ||
| Lightning Talk: How to Win at Coding Interviews | David Stone | 06m |
A concrete three-step protocol claims five minutes of prep suffices: repeat the question, write the interface, then use a hashmap for most problems. The claim… | ||
| Lightning Talk: The Lambda Calculus in C++ Lambdas | David Stone | 06m |
Claims an actual lambda calculus implemented in C++ lambdas using plain C++ syntax, notably uses auto and return and a successor function to build Church… | ||
| Lightning Talk: Ref, C++ const ref, immutable ref? | Francesco Zoffoli | 03m |
Claims that const reference is read-only view but still points at mutable data and can be changed through globals or const_cast; shows repeated compare checks… | ||
| Lightning Talk: Finding the Average of 2 Integers | Tomer Vromen | 05m |
A concrete claim: a function average that converts ints to double by multiplying by 1.0 and adds then divides produces wrong results for some inputs. The… | ||
| Lightning Talk: Cpp Change Detector Tests | Guy Bensky | 05m |
change detector tests intentionally fail on any non-trivial code change and are used to surface concrete differences: an AI pet image classifier example shows… | ||
| Lightning Talk: The Future of C++ | Neil Henderson | 04m |
A short, comedic set of concrete proposals and jokes that actually name replacements: renaming `noexcept` to No Worries, `c-string` to G string, RAII to scope… | ||
| Lightning Talk: Cute Approach for Polymorphism in C++ | Liad Aben Sour Asayag | 06m |
Claims a concrete pattern: replace per-element virtual calls with one virtual call per vector by making the virtual method take a span of many elements… | ||
| Lightning Talk: Embrace Leaky Abstractions in C++ | Phil Nash | 05m |
Claim: all abstractions are leaky and that reality shows it — numbers evolve over millennia (zero, division, imaginary numbers appear centuries later), so even… | ||
| Lightning Talk: Modernizing SFML in Cpp | Chris Thrasher | 04m |
Upgrades a 15‑year C++03 SFML codebase to C++03→C++17 showing concrete changes: replaces custom threading primitives with std::thread/std::mutex, swaps ad‑hoc… | ||
| Lightning Talk: Standard Standards for C++ | Ezra Chung | |
Claims that "standard C++" is many things not one, with the official spec currently named ISO C++20, implementations that pick and mix features, and widespread… | ||
| Lightning Talk: MP: Template Meta-Programming in C++ | Kris Jusiak | 05m |
Claims that template meta programming fits into C++20 and std::ranges and can be sketched in 5 minutes. Implements compile time rotate and slice using ranges… | ||
| Lightning Talk: Wisdom in Keywords | Jon Kalb | 02m |
https://cppcon.org/
---
Lightning Talk: Wisdom in Keywords - Jon Kalb - CppCon 2022
Jon Kalb’s lightning talk is a presentation given without saying a single… | ||
| nothing matches | ||