CppCon 2018
2018-09-23..2018-09-28
Bellevue, United States
CppCon ·
[CppCon 2014, CppCon 2015, CppCon 2016, CppCon 2017, CppCon 2018, CppCon 2019, CppCon 2020, CppCon 2021, CppCon 2022, CppCon 2023, CppCon 2024]
who it's for
C++ developers, library authors, toolchain engineers, build engineers, systems programmers, QA and test engineers, technical writers
topics
C++17 std::optional; std::basic_string as container; copy elision and RVO; trivially relocatable types; constexpr and operator overloading; chrono library evolution; Clang on Windows toolchain; PyTorch C++ frontend; task-based parallelism (Cpp-Taskflow); Qt signals and Coroutines TS; practical std::recursive_directory_iterator; conan C++ package management
| title | author | length |
|---|---|---|
| Can I has grammar? | Timur Doumler | 07m |
Reads the C++ standard grammar (about 20 pages) and shows concrete, compile-tested corner cases: extern nesting ambiguity that different compilers accept or… | ||
| Machine Learning in C++ with PyTorch | Peter Goldsborough | 04m |
PyTorch gains a native C++ Frontend built on the same C++ backend with tensors, CUDA support and automatic differentiation, so C++ code mirrors Python… | ||
| You're Not as Smart as You Think You Are | Phil Nash | 07m |
Claims that human cognition has strict limits: an inattentional blindness demo where roughly half miss a gorilla even though there are 16 passes, a… | ||
| Copy Elision | Jon Kalb | 05m |
Explains the concrete claim that compilers generally construct return objects in caller storage so copies are elided, using low‑level stack‑frame diagrams and… | ||
| This is Why We Can’t Have Nice Things | Jon Kalb | 05m |
Argument: adopt east const so declarations read consistently: const applies to what's on its left. Evidence: examples show pointer-to-function… | ||
| std::basic_string: for more than just text | Brian Ruth | 05m |
Claims that std::basic_string is a general-purpose contiguous container, not just text, and shows using it for bits, named bit directions, and aggregating… | ||
| Almost Always Avoiding auto | Staffan Tjernstrom | 05m |
Claims that using auto everywhere causes debugging pain and surprising types, demonstrates with real debugging scenarios: chasing excessive return-value chains… | ||
| Let's learn programming by inventing it | Ólafur Waage | 05m |
Clear claim: programming can be learned by inventing features and using Iterative Learning rather than memorizing language lore. Evidence: a walk through K&R… | ||
| The Shape of a Program | James McNellis | 05m |
Argues that complexity is usefully measured by the area under the indentation and demonstrates concrete refactorings that reduce it: invert nested ifs into… | ||
| Fast Parallel Programming using Modern C++ | Tsung-Wei Huang | 05m |
Claims a concrete library: header-only C++ library Cpp-Taskflow that expresses task graphs, schedules work and hides threads and locks. Demonstrates a… | ||
| std::optional | Simon Brand | 01m |
A 20 or 30 second lightning talk demonstrates that adding a monads‑style interface simplifies handling a present or absent value in std::optional. The demo… | ||
| Clang on Windows: It's a Thing | Zach Turner | 05m |
Demonstrates that clang-cl and lld-link run as native Linux programs, producing PE32+ executables, COFF objects, and MSVC PDBs that match md5sums for build… | ||
| Thank You (I’m sorry that it’s taken me so long to say it) | Walter E. Brown | 13m |
A brief, personal thank-you that names mentors and recalls concrete moments: learning GOTRAN and the era of 1800 punch cards per compile, a teacher who… | ||
| Trivially Relocatable | Arthur O'Dwyer | 08m |
Argument: certain types can be treated as bitwise-movable so relocation becomes a single memcpy instead of move-then-destroy loops. Demonstration: compiler… | ||
| Cache Warming: Warm Up The Code | Jonathan Keinan | 05m |
Claim: pre-executing rarely used hot paths reduces latency but naive warming pollutes caches and skews branch predictors. Demo uses synthetic calls at ~10 Hz… | ||
| The Bad Big Wolf Meets Riding Hood Little Red | Borislav Stanimirov | 06m |
Claim: natural adjective order predicts readability and const int vs int const placement in C++. Uses the explicit acronym GSSSACPM (general opinion specific… | ||
| How to create slides about CMake with CMake? | Mateusz Pusz | 04m |
A CMake-based workflow produces slide decks and verifies embedded code; a reusable library builds over 1000 slides organized into chapters, keeps content… | ||
| Workflow hacks for developers | Anny Gakhokidze | 04m |
Trello becomes a lightweight tracker with Trello backlog/paused/testing/blocked lists that separate work in progress from things sent for 3–9 hour remote… | ||
| Curly Function Call Syntax | Tony Wasserka | 05m |
Claim: replace parentheses with braces for function calls by wrapping the call in a class whose constructor forwards arguments. Tool: a small CurlyCall wrapper… | ||
| Fixing Two-Phase Initialization | Andreas Weis | 05m |
Claims a concrete idiom: a preconstruct member function that does all fallible work and returns a construction token carrying the initialized state, then a… | ||
| Dangling in French and English | Mark Elendt | 04m |
Code demonstrates that taking a char from string::c_str() inside a std::vector then push_backing more elements can either be safe or crash depending on small… | ||
| ＜chrono＞ Then and Now | Howard Hinnant | 03m |
Chronology support in C++ moves from algebraic durations and time_points to concrete calendar and zone features: C++20 adds durations for days weeks months… | ||
| [Boost].DI - Inject all the things! | Kris Jusiak | 05m |
Claims a small generated header library called [BOOST].DI that is not part of Boost and requires no STL, able to deduce constructors and inject by value… | ||
| Forwarding Values... and Backwarding Them Too? | Ezra Chung | 05m |
Claims a concrete fix for the “backwarding” problem: preserve lvalue, xvalue and prvalue results from a deep caller back to the call site by using… | ||
| The perfect job interview (well, maybe) | Nimrod Sapir | 05m |
Eight concrete hiring habits that change outcomes not buzzwords or examples The interviewer makes interviews a learning opportunity and will even suggest the… | ||
| Wise Enum: A C++ Smart Enum For All Your Reflective Enum Needs | Nir Friedman | 05m |
A tiny C++ library called Wise Enum claims to give real enums to-string/from-string with std::optional, iteration via wise_enum::range, and compile-time… | ||
| Generating UI with C++, boost & Qt | Jens Weller | 05m |
Prototype generates Qt UI from C++ types instead of hand wiring controls: uses Verdigris to avoid moc, inspects Boost.Fusion ADAPT_STRUCT and iterates with… | ||
| Qt Signals and the Coroutines TS | Jeff Trull | 05m |
Claim: Qt signals become awaitables so sequencing needs no ad hoc state. Implementation uses the Coroutines TS plus metaprogramming to produce either void, a… | ||
| Especially nasty bug in our network scanner | Martin Šmarda | 05m |
Avast’s network scanner fails to probe MQTT devices because a supposed binary MQTT CONNECT header is assembled from a C++ string literal that contains a UTF-8… | ||
| Constexpr and operator overloading: Why everything is terrible | CJ Johnson | 04m |
Implements an optional backport for C++11 that breaks when stored T overloads operator&; using plain & on unioned storage triggers wrong codegen… | ||
| Why not Conan (part III)? | Diego Rodriguez-Losada | 04m |
Five quick claims: Conan feels too complex and nondeclarative, arguing for scripting hacks instead of clear recipes; company policy favoring source builds over… | ||
| Communicating via Diagnostics: Observations and Tips for Authors | Walter E. Brown | 07m |
Diagnostics matter: state the violated contract, the actual value and the valid range, and give a clear corrective step; call out precondition failures and… | ||
| Set it and forget it! | Matthew von Arx | 05m |
A 400,000 line SVN codebase spanning 40 CMake projects becomes a reproducible pipeline: convert history to Git, host on GitLab, centralize builds with Jenkins… | ||
| SG14: CppCon Report | John McFarlane | 05m |
SG14 meets face to face and digs into specific proposals: object relocation via memcpy where allowed, a smart pointer for external reference counts aimed at… | ||
| Zero-Overhead Compiler Pessimization | Chuck Wilcox | 04m |
Shows that simple microbenchmarks vanish under optimization: the optimizer removes the increment and leaves only timing calls unless the code forces observable… | ||
| Talk to me! The art of reporting a bug (and handling the feedback) | Anastasia Kazakova | 08m |
Concrete rules and concrete failures: provide a repeatable sample and exact steps, try the compiler and debugger as standalone tools, attach logs and list… | ||
| Wandbox: Online programming language testing environment | Takatoshi Kondo | 05m |
Wandbox is an online language testing environment that runs multiple compilers and toolchains and actually executes code. It supports multiple compilers… | ||
| What Bug Hunting Taught Me About Hunting Bugs | Adi Shacham Shavit | 04m |
Three concrete debugging rules map to field entomology: avoid touching live systems by using simulations and passive observation, instrument with an… | ||
| Test coverage | Arvid Norberg | 03m |
Argues that test coverage must be honest: count only the functions a test actually verifies and exclude test code, frameworks, helpers and mocks, otherwise the… | ||
| docs.microsoft.com Needs You! | Colin Robertson | 05m |
Content lives on docs.microsoft.com as Markdown hosted on GitHub, each page showing an edit button and issue links so mistakes get fixed by forking, committing… | ||
| Feedback on practical use of C++17 std::recursive_directory_iterator | Noel Tchidjo | 04m |
Implements API patches on gcc and clang that add a lambda filter and a regex filter to std::recursive_directory_iterator, runs filesystem benchmarks over… | ||
| SG14: The Story So Far | John McFarlane | 05m |
Study Group 14 organizes regular teleconferences and face‑to‑face meetings to reconcile committee work with needs from game development high‑frequency trading… | ||
| rof_egnar reversed adapter for(auto x:reversed(range)) | Peter Sommerlad | 05m |
Describes a reversible range-for adapter that initially keeps references and therefore uses-after-free when fed temporaries; testing counts constructions and… | ||
| “Concepts: The Future of Generic Programming (the future is here)” | Bjarne Stroustrup | 01h 39m |
Concepts are now usable, implemented in GCC and Clang and slated for C++20, and they let templates be constrained by readable predicates rather than fragile… | ||
| “Patterns and Techniques Used in the Houdini 3D Graphics Application ” | Mark Elendt | 01h 27m |
Houdini runs on decades-old C++ with a custom low‑level library stack, a node‑based procedural engine, and GPU kernels via OpenCL; engineers build… | ||
| “Simplicity: Not Just For Beginners” | Kate Gregory | 01h 29m |
Argues that code should explain itself and gives concrete tactics: use RAII to eliminate missed cleanup bugs, prefer templates/encapsulation over copy‑paste to… | ||
| “Thoughts on a more powerful and simpler C++ (5 of N)” | Herb Sutter | 01h 39m |
Argues two concrete efforts: a Lifetime profile that statically diagnoses common dangling cases (string_view, iterators, raw pointers) with a released 1.0 spec… | ||
| “State Machines Battlefield - Naive vs STL vs Boost” | Kris Jusiak | 01h 00m |
Benchmarks compare naive if/else and switch (about 64 lines of code, very well inlined) versus object‑oriented vtable approach (about 220 lines of generated… | ||
| “Spectre: Secrets, Side-Channels, Sandboxes, and Security” | Chandler Carruth | 01h 28m |
Speculative execution lets transient instructions touch secrets and encode them in a cache-timing side channel; a live demo shows out-of-bounds speculative… | ||
| “Closing Panel: Spectre” | Matt Miller, Chandler Carruth | 43m |
Discussion covers concrete mitigations, tradeoffs and timelines: OS fixes and microcode updates (IBRS/IBPB), firmware interfaces on ARM, and compiler/runtime… | ||
| “Nano-coroutines to the Rescue! (Using Coroutines TS, of Course)” | G. Nishanov | 01h 04m |
Shows that using nano-coroutines built on Coroutines TS (MSVC and Clang implementations) turns random-memory join lookups into an interleaved prefetch… | ||
| "Compiling Multi-Million Line C++ Code Bases Effortlessly with the Meson Build System" | Jussi Pakkanen | 34m |
Meson is a Python-based build system that claims practical scalability to Chromium-sized, multi-million-line C++ code bases while staying snappy: a simple… | ||
| “A Little Order: Delving into the STL sorting algorithms” | Fred Tingaud | 27m |
Benchmarks on Quick‑Bench and local compilers show finding the median of a 1,000,000 element vector with std::nth_element plus std::sort is three times faster… | ||
| “Compile-time programming and reflection in C++20 and beyond” | Louis Dionne | 01h 09m |
Roadmap for C++ compile-time programming: C++20 expands constexpr to allow allocation in constexpr, limited try/catch and virtual calls plus promotion of… | ||
| “These Aren't the COM Objects You're Looking For” | Victor Ciura | 01h 00m |
Windows COM is 25 years old but using C++17 plus the C++/WinRT projection radically shrinks boilerplate and beats handwritten ABI code in size and speed… | ||
| “Ensuring Exception Safety Through Testing" | Jon Cohen | 58m |
Describes a concrete testing system that uses a global counter to deterministically throw the nth exception, an error-tracker to catch internally handled… | ||
| “Easy::Jit: A Just-in-Time compilation library for C++” | Juan Manuel Martinez Caamaño | 26m |
A C++ library that exposes runtime specialization by embedding LLVM bitcode via a clang optimizer plugin and exposing a single header easy::jit.h; it… | ||
| “CUDA Kernels with C++” | Michael Gopshtein | 54m |
Shows concrete C++ applied to CUDA: template kernels replace duplicated int/float kernels, and type-safe DevicePtr vs raw pointers prevents host/device pointer… | ||
| “Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics” | Bob Steagall | 01h 10m |
A DFA-based converter that uses three lookup tables and simple C++ code converts UTF-8 to UTF-32 while decoding, not as two steps, and uses SSE2 intrinsics to… | ||
| “Sane and Safe C++ Classes” | Peter Sommerlad | 01h 04m |
Categorizes C++ types into value, empty, managing, pointing and polymorphic classes and gives concrete rules for special member functions and ownership… | ||
| "UEFI Applications With Modern C++" | Morris Hafner | 30m |
UEFI applications compile with a lightweight toolchain using efilib, MinGW GCC and linker flags to produce COFF EFI binaries run under OVMF/QEMU. The talk… | ||
| “Source Instrumentation for Monitoring C++ in Production” | Steven Simpson | 01h 00m |
Advocates adding source instrumentation into production builds so logs become structured logging rather than human-only text, emitting traces on operation end… | ||
| “Safe Numerics” | Robert Ramey | 01h 05m |
Boost.SafeNumerics uses operator overloading and template metaprogramming to make integers that either trap at compile time or throw at runtime, with… | ||
| “Avoiding Disasters with Strongly Typed C++” | Arno Lepisk | 41m |
C++ typedefs only alias types; using tiny wrapper structs and templates produces NamedType and type_safe style strong types that the compiler enforces… | ||
| “Understanding Optimizers: Helping the Compiler Help You” | Nir Friedman | 01h 04m |
Explains why compilers inline and when they won’t, with concrete examples: std::sort often turns a function pointer call into an indirect call but wrapping the… | ||
| “What to Expect from a Next-Generation C++ Build System” | Boris Kolpackov | 01h 02m |
Argues for a native, C++-extensible build system and demonstrates build2 doing it: a mostly declarative language, uniform model, and concrete features —… | ||
| “What Do We Mean When We Say Nothing At All?” | Kate Gregory | 01h 01m |
Covers concrete ways silence in C++ communicates intent: use C++17 attributes like [[fallthrough]] to mark intentional switch fallthrough, [[maybe_unused]] to… | ||
| “Latest and Greatest in the Visual Studio Family for C++ Developers 2018” | Steve Carroll, Marian Luparu | 01h 00m |
Visual Studio 2017/15.x now targets Windows and Linux from one IDE: open folder with CMake toolchain integration, Remote Headers IntelliSense via rsync, and… | ||
| “Regular Types and Why Do I Care ?” | Victor Ciura | 52m |
Explains why STL expects value-like types, shows std::sort actually requires a strict weak ordering (example: a naive 2D point comparator yields unordered… | ||
| “Don't package your libraries, write packagable libraries!” | Robert Schumacher | 33m |
Lessons from packaging over 700+ libraries in vcpkg: prefer mainstream buildsystems (CMake/MSBuild), honor CMake defaults like BUILD_SHARED_LIBS, avoid bespoke… | ||
| “Parsing C++” | Timur Doumler, Dmitry Kozhevnikov | 53m |
C++ parsing requires semantic name lookup and often arbitrary lookahead so parsers must perform type lookup, evaluate constexprs and handle template-dependent… | ||
| “What Could Possibly Go Wrong?: A Tale of Expectations and Exceptions” | Brand, Nash | 01h 03m |
Conference session compares concrete error-handling techniques and shows which actually trade safety, speed and clarity: benchmarks claim table-based… | ||
| “Modern C++ in Embedded Systems - The Saga Continues” | Michael Caisse | 01h 09m |
Argues that contemporary C++ compiles and debugs cleanly on bare‑metal Renesas hardware and was used to build brushless‑motor controllers for a… | ||
| “Operator Overloading: History, Principles and Practice” | Ben Deane | 01h 02m |
History and concrete rules for operator overloading, with C++17 fold expressions and the new C++20 three-way (spaceship) comparison, showing where it generates… | ||
| “105 STL Algorithms in Less Than an Hour” | Jonathan Boccara | 58m |
Covers all 105 algorithms in the STL as of C++17 and groups them into logical regions on a map; demonstrates concrete calls like std::make_heap / push_heap /… | ||
| “Pessimistic Programming” | Patrice Roy | 52m |
Benchmarks of a million iterations show exceptions for rare errors can be as fast as optionals in the common case but catastrophically slower in the worst… | ||
| “Datum: A Compact Bitwise Copyable Variant Type” | Rishi Wani | 26m |
Datum is an eight byte compact variant on 32-bit that uses NaN-boxing of IEEE-754 doubles to represent regular doubles natively and repurpose NaN payload space… | ||
| “Making New Friends” | Dan Saks | 01h 02m |
Shows a concrete technique: put non-member operator definitions inside a class template as friend functions so each instantiation manufactures its own friend… | ||
| “Save $$ Testing Code the Playback-Based Way” | William Clements | 29m |
Advocates recording every API call, arguments and return values into JSON artifacts and replaying them against the library to catch breaking changes; a… | ||
| “Debugging Linux C++” | Greg Law | 58m |
Demos show specific Linux C++ techniques: GDB reverse debugging (process record) and dynamic printf plus Python scripting to call inferiors, set… | ||
| “The Landscape and Exciting New Future of Safe Reclamation for High Performance” | Paul McKenney, Maged Michael | 58m |
Concurrency TS2 defines concrete APIs: rcu_obj_base with rcu_reader and rcu_synchronize / rcu_barrier for retire-or-wait semantics, and a hazard pointer API… | ||
| “Enough string_view to Hang Ourselves” | Victor Ciura | 01h 02m |
Argues that std::string_view is a useful zero-copy glue for mixed string APIs but repeatedly causes real bugs: dangling references from storing views, a… | ||
| “How to Teach C++ and Influence a Generation” | Christopher Di Bella | 59m |
Argues for concrete teaching moves: start with five types (one integer, one real, string, char, bool) and add vector and scoped enums for practical beginners… | ||
| “C++ Dependency Management: from Package Consumption to Project Development” | Boris Kolpackov | 01h 03m |
Demonstrates build2 by building a portable UUID library and executable using concrete commands: bdep new, bdep init, bdep update, then CI with bdep ci and… | ||
| “The C++ Execution Model” | Bryce Adelstein Lelbach | 56m |
C++ defines an abstract machine of threads evaluating code in a flat storage space, not modeling caches or NUMA; memory_order_consume is ignored here. Rules… | ||
| “Concepts and Contracts: When, What, and How” | Michael Price | 01h 01m |
Goal: implement a library function template that accepts exactly one positive integral parameter and rejects zero, negatives, chars, bools, non-integers, and… | ||
| “Range-Based Text Formatting For a Future Range-Based Standard Library” | Arno Schoedl | 56m |
think-cell implements a range-based formatter that treats values as lazily generated character ranges, adds an internal iteration model plus customization… | ||
| “How to Write Well-Behaved Value Wrappers” | Simon Brand | 53m |
Shows how implementing wrappers like std::optional or pair actually breaks or costs performance: missing noexcept makes std::vector turn moves into copies… | ||
| “High-Radix Concurrent C++” | Olivier Giroux | 56m |
Demonstrates a C++ radix-26 trie using atomic counts and atomic pointers with a test‑and‑set insertion that yields a starvation-free algorithm, ports to CUDA… | ||
| “How C++ Debuggers Work” | Simon Brand | 01h 01m |
Covers how Linux x86_64 debuggers inspect ELF and DWARF to map source to addresses, uses ptrace + int3 to implement software breakpoints by replacing a byte… | ||
| “Secure Coding Best Practices: Your First Line Is The Last Line Of Defense (1 of 2)” | Matthew Butler | 01h 00m |
Walks through concrete C/C++ mistakes (unsafe strncpy use, unchecked std::string lengths, std::copy heap overflow, dangerous cast to enums) and shows a live… | ||
| “Secure Coding Best Practices: Your First Line Is The Last Line Of Defense (2 of 2)” | Matthew Butler | 01h 03m |
Static analyzers like CppCheck and Clang‑Tidy catch correctness issues but miss many security flaws; security scanners such as Coverity, Sonar, PVS Studio… | ||
| “Contract Programming in C++(20) (part 1 of 2)” | Alisdair Meredith | 01h 03m |
Defines contracts as explicit preconditions/postconditions/invariants, explains the C++ standard’s 1,500‑page contract promise and undefined behavior… | ||
| “Contract Programming in C++(20) (part 2 of 2)” | Alisdair Meredith | 01h 05m |
C++20 adds concrete contract features: expects/ensures/assert attributes attach pre/postconditions and inline checks; attributes parse always and have three… | ||
| Crafting EDSL In C++ using Metaprogramming, Operator Overloading, & Lambda Expressions | Gilang Hamidy | 01h 02m |
Builds a runtime EDSL in C++ that implements an asynchronous block for Tizen apps using only C++ features: template metaprogramming, operator overloading… | ||
| “Modern C++ Testing with Catch2” | Phil Nash | 55m |
Catch2 rebases Catch on C++11 only, ships as a single-header with CATCH_CONFIG_MAIN or CATCH_CONFIG_RUNNER, and gives expression‑template assertions… | ||
| “Modern C++ Design (part 1 of 2)” | Titus Winters | 01h 02m |
Argues that the real atom of C++ API design is the overload set and that copy vs move should be treated as that overload set (move as an optimization of copy)… | ||
| “A Semi Compile/Run-time Map with (Nearly) Zero Overhead Lookup” | Fabian Renn Giles | 25m |
A semi compile-/run-time associative map stores where values live at compile-time using a templated global and constexpr lambda keys, then uses static local… | ||
| “Open is Good - yomm2: Fast, Orthogonal Open Methods” | Jean-Louis Leroy | 32m |
Library yomm2 implements open multi-methods as free functions that add polymorphic behavior to existing class hierarchies without modifying them, supporting… | ||
| “What's new in Visual Studio Code for C++ development” | Rong Lu | 31m |
Visual Studio Code adds concrete C++ features: out‑of‑box IntelliSense for workspace headers, recursive includePath (glob search) and compilerPath… | ||
| “Multi-Precision Arithmetic for Cryptology in C++, at Run-Time and at Compile-Time” | Niek J. Bouman | 31m |
A new C++17 header-only library (ctbignum, Apache‑2, GitHub) provides compile-time big-integer computations for 100–500 bit operands and uses… | ||
| “C++ in Elvenland” | Serge Guelton | 59m |
Walks a compiled C++ binary from ELF header through sections and symbols, and shows live demos with objdump and readelf and using objcopy embedding to pack… | ||
| “Using Compile-time Code Generation to build an LLVM IR Pattern Matcher” | Pablo Halpern | 01h 00m |
A C++11 library that encodes LLVM IR match patterns as constexpr expression templates and operator-overloaded syntax produces a specialized pattern-matcher at… | ||
| Better Tools in Your Clang Toolbox | Victor Ciura | 01h 01m |
An open‑source Visual Studio extension Clang Power Tools brings clang‑tidy, clang‑format and LLVM compilation into MSVC workflows and a PowerShell CI script… | ||
| Writing Standard Library Compliant Data Structures and Algorithms | Marc Gregoire | 01h 02m |
Starts by implementing a simple find_all iterator-based algorithm that moves from a vector-only API to one taking input and output iterators, returns the… | ||
| OOP Is Dead, Long Live Data-oriented Design | Stoyan Nikolov | 01h 01m |
Compares Chromium’s object-oriented animation path (6+ inheritance layers, virtual interpolation, per-animation heap objects) to a data-first redesign used in… | ||
| Concepts As She Is Spoke | Arthur O'Dwyer | 01h 07m |
Clear-eyed tour of C++2a Concepts syntax and semantics, with concrete compiler status (GCC supports the Concepts TS via -fconcepts, Clang has a fork, MSVC… | ||
| C++ Function Templates: How Do They Really Work? | Walter E. Brown | 01h 00m |
Claim: function templates are blueprints not functions, compilers synthesize signatures and instantiate definitions only as needed from calls. Crucial… | ||
| An Allocator is a Handle to a Heap | Arthur O'Dwyer | 01h 03m |
Claim: an allocator is not a heap but a cheap handle to a heap: std::pmr::polymorphic_allocator holds a pointer to a std::pmr::memory_resource and copying the… | ||
| Touring the Tips of the Week Series | Jon Cohen, Matt Kulukundis | 20m |
Overview of the C++ Tip of the Week series with concrete rules: copies vs moves follow a name-counting rule (one name → move, two names → copy), prefer value… | ||
| The Nightmare of Initialization in C++ | Nicolai Josuttis | 01h 00m |
Claims that there are 19 ways to initialize an int and shows real breakage: copy vs direct vs brace vs auto+brace produce different types and overload… | ||
| Surprises in Object Lifetime | Jason Turner | 01h 01m |
Concrete surprises: implicit wrappers like reference_wrapper and string_view produce dangling references with no compiler warnings, returning or binding to… | ||
| user-defined statically-checked call graph constraints in C++ | Andrew Nelson | 27m |
A static analyzer called Funqual parses C++17 with libClang, builds a whole-program call graph, and enforces user-written rules like restrict_indirect_call. It… | ||
| Frozen data structures in C++14 | Serge Guelton | 58m |
Frozen provides header-only replacements for map/set/unordered_map/unordered_set that are truly immutable and constructed at compile time via constexpr… | ||
| Git, CMake, Conan - How to ship and reuse our C++ projects | Mateusz Pusz | 01h 01m |
Compares concrete CMake patterns and Conan commands for reproducible C++ packaging: shows how modern CMake targets and generator expressions avoid header/flag… | ||
| Overloading: The Bane of All Higher-Order Functions | Simon Brand | 22m |
Explains why passing overloaded functions or function templates into higher‑order code fails and shows concrete workarounds and proposals: function templates… | ||
| Make It Fixable: Preparing for Security Vulnerability Reports | Patricia Aas | 29m |
Companies must provide a clear contact channel for vulnerability reports and plan to actually deliver fixes: build systems, signing, and a reliable auto-update… | ||
| Undefined Behavior is Not an Error | Barbara Geller, Ansel Sermersheim | 57m |
Core claim: undefined behavior is not an error — the compiler may legally treat UB as “code not present,” leading to surprising results. Real examples: a… | ||
| Unwinding the Stack: Exploring How C++ Exceptions Work on Windows | James McNellis | 01h 06m |
Shows exactly how Visual C++ turns throw into a structured exception: the runtime calls CxxThrowException with throw info and an exception object, the common… | ||
| Woes of Scope Guards and Unique_Resource - 5+ years in the making | Peter Sommerlad | 01h 02m |
A generic RAII wrapper (unique_resource) evolves through ~13 papers and nine major revisions, adding CTAD, if constexpr paths and scope guards… | ||
| Lightweight 2D graphics with io2d | Guy Davidson | 57m |
io2d is a lightweight C++ 2D graphics reference implementation that claims cross‑platform builds for Windows, OS X, iOS and Linux and is available on vcpkg; it… | ||
| Debug C++ Without Running | Anastasiia Kazakova | 53m |
Explains concrete IDE features that reveal hidden C++ code without compiling: step-by-step macro substitution and unwindable typedef expansion in… | ||
| Emulating the Nintendo 3DS: Generative & Declarative Programming in Action | Tony Wasserka | 57m |
Describes a concrete system to auto-generate 3DS IPC serialization: declarative command descriptions (command id + normal/special/request/response tuples)… | ||
| Expect the expected | Andrei Alexandrescu | 59m |
Proposal and prototype for a discriminated-union error type that unifies local error returns and centralized exceptions by storing either the result or an… | ||
| DynaMix: A New Take on Polymorphism | Borislav Stanimirov | 01h 00m |
A C++ library that composes objects from runtime mixins added/removed at runtime and exposes unicast and multicast messages with message priorities and global… | ||
| Modern C++ Design (part 2 of 2) | Titus Winters | 58m |
Argues concrete rules for parameter passing and type design: when to use rvalue-references, reference-qualified overloads, and how to express maybe move… | ||
| Return Value Optimization: Harder Than It Looks | Arthur O'Dwyer | 27m |
Explains where the return slot lives in typical calling conventions, why C++03/C++11/C++17 rules sometimes elide, sometimes move, and sometimes silently copy… | ||
| Talking to Typelists | Stephen Dewhurst | 30m |
Demonstrates how legacy typelist meta‑algorithms get reused for modern variadic type and index sequences by automatically translating formats, predicates, and… | ||
| Why and How to Roll Your Own std::function Implementation | Tom Poole | 32m |
Reimplements std::function inside JUCE with a vtable-style type eraser, benchmarks showing parity with libstdc++ and up to ~30% speed improvement when forcing… | ||
| Co- and Contra-: Adding a Little Variance | Michał Dominiak | 31m |
Claims that C++ lacks principled co/contravariance and that practical emulation is possible but brittle: shows language examples (C#, Scala, Java using… | ||
| Better C++ using Machine Learning on Large Projects | Nicolas Fleury, Mathieu Nayrolles | 35m |
Machine learning scores commits at pre-commit time using ~40 features (file age, lines added, author experience) and flags high-risk changes; the model reports… | ||
| Memory Tagging and how it improves C/C++ memory safety | Kostya Serebryany | 31m |
Memory tagging attaches small tags to pointers and memory and catches mismatches to find bugs with low overhead: hardware SPARC ADI uses 4-bit tags per 64… | ||
| Fancy Pointers for Fun and Profit | Bob Steagall | 01h 02m |
Shows how to implement synthetic pointers that satisfy the standard’s pointer-like requirements and back std::allocator to build relocatable heaps; provides… | ||
| Smart References: There and Back Again | Erik Valkering | 31m |
Header-only smartref library emulates operator-dot and implements Unified Call Syntax, claiming zero runtime and memory overhead by using CRTP and inlined… | ||
| The Networking TS in Practice: Testable, Composable Asynchronous I/O in C++ | R. Leahy | 58m |
Explains how the Networking TS (Boost.Asio) yields testable, composable async I/O by building a composed operation async_wait_then_write that chains timer wait… | ||
| Named Arguments from Scratch | Richard Powell | 54m |
Live coding builds a small named-arguments library in C++17 using Boost.Hana and Compiler Explorer, showing an adapter that accepts a hana::map of keys to… | ||
| C++ Modules | Nathan Sidwell | 59m |
Implementation in GCC produces object files plus a binary module interface (BMI) and uses -fmodules-ts to read serialized interfaces; an experimental… | ||
| Effective replacement of dynamic polymorphism with std::variant | Mateusz Pusz | 29m |
Compares three FSM implementations — single dynamic dispatch, double dispatch (visitor/CRTP) and several std::variant designs — by building a TCP-like state… | ||
| Refactoring Legacy Codebases with LibTooling | James Bennett | 24m |
Describes using LibTooling with Clang AST matchers to write automated refactors that run on large legacy codebases, including creating a compile_commands… | ||
| Inside Visual C++' Parallel Algorithms | Billy O'Neal | 01h 02m |
Visual C++ implements C++17 parallel algorithms by partitioning ranges, scheduling work on Windows Thread Pool calls like CreateThreadpoolWork, and merging… | ||
| Signed integers are two's complement | JF Bastien | 01h 00m |
Claim: signed integer storage is narrowed to one true representation: two's complement, while arithmetic semantics (overflow) remain unspecified for now… | ||
| Implementing the C++ Core Guidelines’ Lifetime Safety Profile in Clang | Matthias Gehre, Gabor Horvath | 01h 08m |
Clang-based checker implements Herb Sutter’s Lifetime Safety Profile using Clang AST/type trees and control-flow graphs and flags use-after-invalidation and… | ||
| Using Template Magic to Automatically Generate Hybrid CPU/GPU-Code | Elmar Westphal | 59m |
Template-based wrappers let the same C++ code compile either into a CPU loop or a CUDA kernel by using a cudaMallocManaged allocator for transparent memory and… | ||
| Design for Performance | Fedor Pikus | 01h 04m |
A practitioner recounts measured design wins: using Google Benchmark and GCC with AVX2 intrinsics to turn a textbook matrix–vector loop from ~3 GB/s equivalent… | ||
| Custom Overload Sets and Inline SFINAE for Truly Generic Interfaces | Vincent Reverdy | 55m |
Shows how C++17 features (void_t, template deduction guides, invoke, constexpr if, decltype(auto) on lambdas) let code pick the first compilable option, pick… | ||
| What do you mean "thread-safe"? | Geoffrey Romer | 54m |
Defines an API race as two concurrent operations that violate an object's contract (broader than a data race), classifies types as thread-safe or… | ||
| Early Modern C++: How to Handle a C++03 Codebase in $CURRENT_YEAR | Mathieu Ropert | 48m |
Argues that Modern C++ principles—zero-cost abstractions, strong typing, concepts-like generic code and RAII—predate C++11 and that many C++11/14/17… | ||
| Interactive C++ Compilation (REPL) Done in a Tiny and Embeddable Way | Viktor Kirilov | 30m |
A tiny embeddable REPL compiles submitted C++ into shared-plugin snapshots, links them to the running executable, and initializes globals in top-to-bottom… | ||
| How to Argue(ment) | Richard Powell | 54m |
Catalogs about 42 syntactic ways to pass parameters then narrows them to ~16 useful cases, with concrete names and rules: prefer snapshot by value when cheap… | ||
| Let's Intercept OpenGL Function Calls...for Logging! | Mike Shah | 30m |
A working OpenGL logger is built that records 100% of API calls by interposing or injecting code and writing compact traces; strategies include simple… | ||
| A Modern C++ Programming Model for GPUs using Khronos SYCL | Gordon Brown | 01h 01m |
SYCL is presented as a standard C++ single‑source model layered on OpenCL 1.2 (SYCL 1.2.1) with an implementation (ComputeCpp) that compiles device lambdas to… | ||
| Grill the Committee | Marshall Clow, Titus Winters | 01h 27m |
Progress on modules name-lookup fixes and a plan to let modules export incomplete types narrow major pain points, but only a small subset of executors has any… | ||
| C++ Cryptozoology - A Compendium of Cryptic Characters :: #2 | Adi Shavit | 30m |
Covers specific C++ oddities with concrete consequences: shows abominable function types used to forward multiple method prototypes, notes copy‑on‑write is… | ||
| Scaling Financial Transaction using 0MQ and JSON | Kevin Carpenter | 38m |
Migrating legacy PowerBuilder services to Linux/C++ uses 0MQ (CPPZMQ) and nlohmann/json to cut message size by ~35% versus XML, drop a DB refresh from 90 to 10… | ||
| Dealing with aliasing using contracts | Gabor Horvath | 37m |
Shows that LLVM emits extra loads when parameters may alias and that C’s restrict enables vectorization, then proposes using contracts plus a new unique span… | ||
| Teaching Old Compilers New Tricks: Transpiling C++17 to C++11 | Tony Wasserka | 32m |
A libclang-based tool called clang-from-the-future reads C++17 and emits equivalent C++11 source by performing libclang AST rewriting and a custom… | ||
| Get rich quick! Using Boost.Beast WebSockets and Networking TS | Vinnie Falco | 01h 01m |
Claims that single‑developer WebSocket games earned tens of millions and hit ~$100k/day; shows a working C++11 Boost.Beast server and a one‑file… | ||
| Liberating the Debugging Experience with the GDB Python API | Jeff Trull | 29m |
Shows how gdb’s Python API plus external libraries build concrete debugging tools: uses frame decorators and frame filters to collapse verbose template… | ||
| Rapid Prototyping of Graphics Shaders in Modern C++ | Valentin Galea | 49m |
Claims a C++ library lets you compile GLSL as C++ so shader code runs on the CPU with full debugging and quick prototyping. Implementation uses templated… | ||
| Class Template Argument Deduction for Everyone | Stephan T. Lavavej | 01h 01m |
C++17’s Class Template Argument Deduction (CTAD) automatically infers template parameters for many STL types (std::pair, std::array, std::vector, lock guards)… | ||
| Concepts in 60: Everything you need to know and nothing you don't | Andrew Sutton | 01h 11m |
Concepts arrive as a way to constrain templates so the compiler checks syntactic requirements at use and prevents bizarre instantiations; the Concepts TS is… | ||
| Building a C++ Reflection System in One Weekend Using Clang and LLVM | Arvid Gerstmann | 46m |
Builds a runtime C++ reflection system over a weekend using Clang LibTooling and LLVM that parses ASTs, matches classes/fields annotated with an attribute, and… | ||
| integral types | Andrei Zlate-Podani | 29m |
Shows concrete failures: a template in Boost property_tree bug truncates wide characters to 8 bits and misparses hex character references; Boost.Accumulators… | ||
| Compute More in Less Time Using C++ Simd Wrapper Libraries | Jefferson Amstutz | 01h 03m |
Shows concrete C++ SIMD wrapper patterns: a pack<T,Width> abstraction, practical APIs for load/store/gather/scatter, masked stores for tails, and vectorized… | ||
| Development strategies: You've written a library - now what? | Marshall Clow | 01h 17m |
Library maintenance focuses on concrete practices: keep documentation and examples for getting started, run unit tests on every change with continuous… | ||
| Initialization, Shutdown, and constexpr | Greg Falcon | 01h 01m |
Explains why global objects fail at startup or shutdown by walking the actual rules: four storage durations, static initialization order fiasco, distinction of… | ||
| Static analysis for concurrent C++ in Visual Studio | Anna Gringauze | 24m |
ConcurrencyCheck is a static analyzer replacing LocalEspC in Visual Studio that runs on MSVC and flags data races, deadlocks, stale-data and inconsistent lock… | ||
| C++ Everywhere with WebAssembly | Damien Buhl | 32m |
Shows that you can bind C++17 to HTML5 and run the same ABI on browser and server by compiling to WebAssembly with Emscripten and the nxxm toolchain, including… | ||
| Class template argument deduction in C++17 | Timur Doumler | 01h 00m |
Class template argument deduction (CTAD) in C++17 is explained as a two-step deduction process: synthesize function-like deduction candidates from… | ||
| Better Code: Human Interface | Sean Parent | 59m |
Claims that a UI must “Don’t Lie” by accurately conveying code semantics and shows concrete fixes: Photoshop contains a full 3‑D engine, timeline editor and an… | ||
| Moving Faster: Everyday efficiency in modern C++ | Alan Talbot | 01h 00m |
Argues that performance almost always matters and gives concrete fixes: count heap allocations, treat cache misses as the new floating point divides, prefer… | ||
| Large-Scale Changes at Google: Lessons Learned From 5 Yrs of Mass Migrations | H. Wright | 01h 00m |
Google runs migrations across a single monorepo of 2 billion lines of code with ~60k changes/day and hundreds of millions of C++ lines, and succeeds by using… | ||
| Clangd: architecture of a scalable C++ language server | Ilya Biryukov | 52m |
Clangd is an LLVM/Clang-based Language Server Protocol implementation that targets editor integration and large codebases by combining a compiler-driven AST… | ||
| Easy to Use, Hard to Misuse: Declarative Style in C++ | Ben Deane | 01h 01m |
Argues that fewer statements and more expressions make C++ code easier to reason about, showing concrete rewrites: replace assignment-in-conditions with… | ||
| The Most Valuable Values | Juan Pedro Bolivar Puente | 59m |
Argues that value semantics belong at the architectural level and demonstrates a concrete C++ implementation: a unidirectional data flow using std::variant for… | ||
| Standard Library Compatibility Guidelines (SD-8) | Titus Winters | 01h 01m |
A new standing document SD-8 records that the committee reserves the right to add names, members, overloads, default arguments and change return types in… | ||
| Software Security | Patricia Aas, Matt Miller, Matt Butler | 01h 01m |
Panelists argue that C++ remains powerful but not safe by default, and most real fixes are procedural: set up a security hotline, use continuous deployment and… | ||
| The Salami Method for Cross Platform Development | Adi Shavit | 01h 00m |
Proposes slicing a cross‑platform C++ system into thin transparent layers so platform nastiness lives only at the borders; implements a single C++ OpenCV… | ||
| Concurrency Challenges of Interrupt Service Routines | Odin Holmes | 01h 01m |
Shows that Interrupt Service Routines on Cortex-class MCUs inject execution by saving a few registers and jumping via the nested vector interrupt controller… | ||
| Scripting at the Speed of Thought: Lua and C++ with sol3 | JeanHeyd Meneide | 01h 01m |
A C++ binding library that replaces tuple-heavy compile‑time plumbing with a runtime-backed registry, sol2/sol3 exposes C++ classes as Lua usertypes with… | ||
| The Bits Between the Bits: How We Get to main() | Matt Godbolt | 01h 04m |
Linux executables assemble from per-file ELF sections that the compiler emits and the linker stitches together; using objdump, gdb and readelf the talk traces… | ||
| Interfaces Matter | John Woolverton | 36m |
Chronicles how C++ containers keep getting tugged between performance hacks and safe interfaces: shows why copy‑on‑write breaks in practice, why RVO/copy… | ||
| Applied Best Practices | Jason Turner | 01h 03m |
Builds a constexpr ARM emulator plus GUI, ELF parser and tiny linker that actually compiles and steps code at compile time so unit tests that compile are… | ||
| Feather: A Modern C++ Web Development Framework | Yu Qi | 31m |
Feather bundles three C++ libraries—cinatra, ormpp, render—plus AOP glue to build web apps; a “hello world” is five lines and a production site (purecpp.org)… | ||
| C++ Modules and Large-Scale Development | John Lakos | 59m |
Argues that C++ modules mainly reshape architecture not just compile times, listing concrete requirements: modules must be purely additive, hierarchical… | ||
| Build Systems: a Simple Solution to a Complicated Problem | Peter Bindels | 49m |
Claims a simpler C++ build flow by reading all source with cpp-dependencies to derive file- and component-level includes and then running a single tool called… | ||
| Bringing C++ 17 Parallel Algorithms to a standard library near you | Thomas Rodgers | 31m |
Intel donates a near-complete C++17 parallel algorithms implementation and integration work adapts it into libstdc++/libc++ by cleaning macros/ADL… | ||
| nothing matches | ||