CppCon 2019
2019-09-15..2019-09-20
Aurora, 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, C++ library authors, compiler and toolchain engineers, test and QA engineers, embedded developers, Windows Visual C++ engineers
topics
modern C++ macros; std::integral_constant type programming; undefined behavior detection with clang-tidy and sanitizers; fold expressions for variadic reduction; ray tracing with Monte Carlo and denoising; CRTP and generalized double dispatch; single-header C++ unit test frameworks; build2 cross-platform packaging and CI; C++ ranges slide and stride; __builtin_expect usage and clang-misexpect; Boost.Predef in constexpr contexts; improving template error diagnostics with camomilla
| title | author | length |
|---|---|---|
| Let's cmakeify the C++ standard library | Jussi Pakkanen | 03m |
Proposal replaces every C++ type with std::string and shows how that yields one true data structure and single allocation for all; examples include integers… | ||
| Why is C++ so Slow? | Boris Kolpackov | 05m |
C++ development is slow mainly because of the language, tooling and especially build systems and package management; build2 focuses on making anyone a… | ||
| Modern C++ Macros | Jens Weller | 05m |
Argues that preprocessor macros can be made standard conforming for modern C++ and demonstrates three concrete macro patterns that replace boilerplate without… | ||
| This One Weird Trick: std::integral_constant | Jorg Brown | 05m |
Uses std::integral_constant to move computed values into types so recursion becomes compile-time and eliminates runtime calls even with no optimizations… | ||
| Detecting Programs That Rely on Undefined Behavior | Geoffrey L. Viola | 05m |
Undefined behavior can cause observable wrong output: a small snippet dereferencing past a std::array index prints garbage yet compilers give no warning… | ||
| Postmodern Meta C++ | Kris Jusiak | 05m |
Quick tour of concrete C++ techniques that the codebase actually compiles and runs: uses C++17 reflection-ish tricks plus structure bindings to turn tuples… | ||
| Beautiful Folds | Manuel Bergler | 05m |
Shows how C++17 fold expressions replace handwritten variadic template recursion to produce clearer, safer code; demonstrates concrete patterns for variadic… | ||
| Tell Me Lies, Tell Me Lies, Tell Me Sweet Little Lies | Jody Hagins | 05m |
Code contains concrete lies: a compile-time query says a type is constructible via static_assert and detection idioms but construction fails at use, so… | ||
| Ray Tracing In Minutes | Tanki Zhang | 07m |
Shows how to implement a minimal ray tracer that casts one ray per pixel from the camera, performs intersection tests, and evaluates the rendering equation by… | ||
| Generalised Double Dispatch | Barath Kannan | 05m |
Implements a CRTP visitor set that replaces dynamic_cast and two-vtable lookups with compile-time resolution, using template recursion and… | ||
| 650 line C++ unit test library (easy to use) | Wahid Tanner | 05m |
Shows a tiny single-header C++ unit test library that teaches beginners by example using a string-splitting demo, finds a real bug for empty input, and… | ||
| Algorithm Magic | René Rivera | 05m |
A live card trick demonstrates C++ STL algorithms: a 24-card deck initialized with iota, shuffled, a volunteer selects and replaces a card, then the deck… | ||
| Function Extraction with Lambda Expressions | Hayun Ezra Chung | 04m |
Shows a concrete recipe to extract code by wrapping the fragment in an immediately-invoked lambda, compile, then iteratively remove captures so the compiler… | ||
| Crowd Review | Mathieu Ropert | 05m |
A live crowd review shows several short C++ snippets that either fail to compile or embody decades-old habits: book claims C++11/14/17 yet examples use C-style… | ||
| Make impossible state unrepresentable | Lesley Lai | 05m |
Use the type system to eliminate impossible states: model per-Q indices as an optional index so the struct shrinks from 24 bytes -> 12 bytes, removes duplicate… | ||
| C++20 - or not | Staffan Tjernstrom | 04m |
C++20 ships a huge set of features and many small fixes; notable arrivals include std::source_location and finally better enum typedefs for naming enum… | ||
| clang-misexpect - Managing your __builtin_expect(ations) | Paul Kirth | 05m |
Adds clang/LLVM diagnostics that compare __builtin_expect annotations against PGO-collected basic-block counters and warn when the annotation contradicts… | ||
| 23 Ranges: slide & stride | Conor Hoekstra | 05m |
Three proposed C++23 range adaptors expose a two-parameter signature (size and range) and produce a range of ranges: sliding (overlapping windows), chunk… | ||
| C++ and Objective C++ Gotachs | Nipun Jindal | 04m |
Clang auto-fixes a void cast to an Objective‑C object by inserting __bridge, which lets ARC release the object prematurely and creates a use‑after‑free when… | ||
| An Introduction to hpxMP... | Tianyi Zhang | 05m |
HPXMP is a drop-in OpenMP runtime that replaces libgomp via LD_PRELOAD the HPXMP shared library and delegates threading and synchronization to the HPX… | ||
| Language as an Ultimate Approach to Problem Solving | Alex Voronov | 04m |
Central claim: solving problems means find a language where the solution is obvious rather than tweaking one familiar tool. Evidence is practical: expand… | ||
| Dynamite the Monoliths! Taming dependency cycles in a 20-year old... | Paul Licameli | 06m |
A Perl script analyzes a 20‑year‑old Audacity codebase (~280,000 LOC, tens of millions of downloads) to find and collapse dependency cycles so they can be… | ||
| Code Samples that Actually Compile | Clare Macrae | 04m |
Makes code examples in markdown actually compile by extracting real code from the repository using the tool MD snippets. Source files get marker comments like… | ||
| My Temporary Materialization Misconception | Steffan Tjernstrom | 05m |
Sees C++17 elision failing: constructing a vector of unique_ptr<Dispatcher> triggers many unexpected move (and sometimes copy) constructor calls when objects… | ||
| My favorite feature in Visual C++ Update 3 | Jonathan Caves | 06m |
Visual C++ Update 3 adds a small but concrete debugger option: a right‑click toggle to hide call‑stack arguments so the stack shows only frames, not massive… | ||
| Keep Your Friends under control | Phil Nash | 04m |
Placing a free function as an inline friend inside a class makes it hidden from the enclosing namespace so it is only found by ADL, which cuts the huge list of… | ||
| Unit Testing: Prefer Children Over Friends | Michael T. Starks | 05m |
Advocates replacing test-only friend access with small subclasses that expose just what tests need, using a concrete example: a PlayerStats object that should… | ||
| Making sense of terrible template errors with 'camomilla' | Vittorio Romeo | 03m |
Command line tool camomilla is a small Python script that rewrites fat C++ template errors by collapsing template arguments to configurable levels so deeply… | ||
| Embedded Debugging with Visual Studio | Brian Ruth | 05m |
Visual Studio 2019 supports open‑folder C/C++ workflows by adding tasks.vs.json for custom build commands and launch.vs.json for debugger launch config… | ||
| I SPY with my little eye Boost.Predef in a constexpr world | Joel Falcou | 05m |
A tiny library called spy provides a constexpr-compatible Boost.Predef clone that exposes objects like spy::gcc and spy::os so code can write if constexpr… | ||
| Leaving No Input Unsanitized | Gabriel Aubut-Lussier | 05m |
Claims a design that forbids direct access to raw inputs and forces explicit enumeration of every input source and shape, implemented as declarative input… | ||
| Back to Basics: Object-Oriented Programming | Jon Kalb | 01h 00m |
Argues that runtime polymorphism in C++ still matters for “millions” of legacy users and gives concrete rules: model public inheritance as an is-a… | ||
| Back to Basics: Function and Class Templates | Dan Saks | 01h 03m |
Covers concrete mechanics: writing function and class templates (swap, rational, bitset), how the compiler performs template instantiation versus an explicit… | ||
| Back to Basics: RAII and the Rule of Zero | Arthur O'Dwyer | 01h 02m |
Explains why RAII prevents leaks and double-frees using a hand-built NaiveVector that first leaks, then double-deletes, then is fixed with a destructor, copy… | ||
| Back to Basics: Type Erasure | Arthur O'Dwyer | 49m |
Explains how to implement type erasure step-by-step: start with representation and behavior split using void plus function pointers, build a reference form (no… | ||
| Everyday Efficiency: In-Place Construction (Back to Basics?) | Ben Deane | 01h 02m |
Everyday rules for avoiding needless copies and allocations: string moves often cost as much as copies (bench shows ~20% slower moves for small strings), copy… | ||
| Back to Basics: Exception Handling and Exception Safety | Ben Saks | 01h 02m |
Explains concrete rules: throw objects by value and catch by reference, prefer std::exception subclasses like std::out_of_range, and use RAII to close files… | ||
| Back to Basics: Lambdas from Scratch | Arthur O'Dwyer | 52m |
Explains lambdas as compiler-generated unnamed class objects with an operator() and shows assembly via Godbolt to prove it; walks concrete examples from C… | ||
| Back to Basics: Smart Pointers | Arthur O'Dwyer | 01h 01m |
Explains how C++ smart pointers actually work: unique_ptr holds a raw pointer and a deleter (used to wrap C APIs like OpenSSL), shared_ptr stores a separate… | ||
| Back to Basics: Understanding Value Categories | Ben Saks | 54m |
Explains why lvalues, prvalues and xvalues matter for code generation and errors, shows that class prvalues need storage while scalar prvalues often don’t, and… | ||
| Back to Basics: Move Semantics (part 2 of 2) | Klaus Iglberger | 54m |
Explains that forwarding references (T&& in a deducing context) become lvalue references for lvalue args and rvalue references for rvalues via reference… | ||
| Back to Basics: Test-driven Development | Fedor Pikus | 01h 01m |
Covers practical TDD for C++ with concrete tools and outcomes: builds a simple Sudoku solver and small insertion sort to demonstrate unit tests with Google… | ||
| Back to Basics: Const as a Promise | Dan Saks | 01h 02m |
Argues that const is a promise that turns runtime errors into compile-time checks and warns to use it proactively, not as reactive linting; demonstrates… | ||
| Back to Basics: Move Semantics (part 1 of 2) | Klaus Iglberger | 55m |
Explains why and how to implement move semantics: rvalue references and std::move are the mechanism, std::forward for perfect forwarding, and move ctor/assign… | ||
| Back to Basics: Virtual Dispatch and its Alternatives | Inbal Levi | 40m |
Compares virtual table indirect calls (pointer derefs then indirect call) against CRTP and std::variant with visitor, benchmarks on a 10,000×10,000 pixel image… | ||
| C++20: C++ at 40 | Bjarne Stroustrup | 01h 31m |
Forty-year C++ history leads to concrete C++20 deliverables: modules (import std) reduces rebuilds and targets ~5–10x compile speedups; concepts for generic… | ||
| Sorting Algorithms: Speed Is Found In The Minds of People | Andrei Alexandrescu | 01h 30m |
Examines crisp, measured tweaks to sorting for hundreds‑element arrays: binary insertion cuts comparisons but loses time due to branch mispredicts; branchless… | ||
| Applied WebAssembly: Compiling and Running C++ in Your Web Browser | Ben Smith | 01h 30m |
Ported Clang and LLD to WebAssembly so a full C++ compile+link pipeline runs client-side in the browser, using a WASI-like capability layer, an in-memory… | ||
| Better Code: Relationships | Sean Parent | 01h 20m |
Crashes usually trace to mismanaged relationships, so the presentation demonstrates concrete fixes: model ownership and witnessed relationships to track… | ||
| De-fragmenting C++: Making Exceptions and RTTI More Affordable and Usable | Herb Sutter | 01h 33m |
C++ currently pays for exceptions and RTTI even when unused; proposal makes error reporting static by default, dynamic by opt-in via a new throws annotation… | ||
| Range Algorithms, Views and Actions: A Comprehensive Guide | Dvir Yitzchaki | 57m |
Covers concrete C++ tools and results: shows range-v3 plus C++20 ranges, demonstrates composable views and actions like iota filter transform join… | ||
| From STL to Ranges: Using Ranges Effectively | Jeff Garland | 01h 01m |
Coverage of C++20 ranges with concrete code, three implementations tested (range-v3, cmcstl2, nanorange), and production experience on GCC/Linux; demonstrates… | ||
| Behind the Scenes of a C++ Build System | Jussi Pakkanen | 33m |
Meson is used to show concrete solutions: Ninja drives processes but Windows forces fragile quoting and use of response files; cross compilation and… | ||
| Reducing Template Compilation Overhead, Using C++11, 14, 17, and 20. | Jorg Brown | 47m |
Investigates concrete ways to cut heavy template compile costs: replaces deep recursive template instantiations with memoized templates and… | ||
| What a View! Building Your Own (Lazy) Range Adaptors (part 1 of 2) | Chris Di Bella | 50m |
Three incremental C++ implementations parse Rust-style Unicode escapes like \U{...}: a raw loop, a range-based algorithm, then a lazy range adapters version… | ||
| Some Programming Myths Revisited | Patrice Roy | 01h 01m |
Argues that several entrenched C++ rules deserve re-evaluation: goto considered harmful is overstated because break/continue/switch handle structured jumps… | ||
| What a View! Building Your Own (Lazy) Range Adaptors (part 2 of 2) | Chris Di Bella | 56m |
Implements a non‑standard lazy range adaptor called stride_view that skips elements by a user step, including a hand‑rolled iterator type, sentinel handling… | ||
| The Smart Pointers I Wish I Had | Matthew Fleming | 51m |
Shows a concrete fix: convert non-owning raw pointers to a typed non-owning pointer (uses the C++20 observer_ptr idea, implemented a custom… | ||
| Modern Linux C++ debugging tools - under the covers | Greg Law | 57m |
Explains how Linux debuggers use ptrace stops via signals and breakpoints patched with int3, how DWARF (use -g3 for macros) and CFI/CFA map optimized code back… | ||
| Great C++ is_trivial | Jason Turner | 55m |
Defines exactly which type traits let the compiler elide work and shows concrete assembly and compiler behaviors: ints and trivial aggregates compile to… | ||
| An Overview of Standard Ranges | Tristan Brindle | 01h 01m |
C++20 adds concept-constrained algorithms, range-based overloads that accept whole containers, and lazy composable adapters called views|filter|transform that… | ||
| When C++ Style Guides Contradict | Nicolai Josuttis | 55m |
C++ style guides give conflicting, actionable rules: some require hidden friends to avoid accidental implicit conversions (a real bug in path operators that… | ||
| From Algorithm to Generic, Parallel Code | Dietmar Kühl | 49m |
Parallel inclusive scan is implemented from a textbook algorithm into several concrete backends: a naive recursive version using std::async that runs about… | ||
| A State of Compile Time Regular Expressions | Hana Dusikova | 59m |
http://CppCon.org
Discussion & Comments: https://www.reddit.com/r/cpp/
Presentation Slides, PDFs, Source Code and other presenter materials are available at… | ||
| How to Herd 1,000 Libraries | Robert Schumacher | 31m |
vcpkg enforces reproducible sources by preferring git commit IDs and verifying archives with sha-512 hashes, falling back to git clones for hosts that embed… | ||
| Abusing Your Memory Model for Fun and Profit | Samy Al Bahra, Paul Khuong | 55m |
Four practical tricks that shave real latency: a transformation makes any open‑address hash table wait‑free for writers and statistically wait‑free readers on… | ||
| Lifetime analysis for everyone | Gabor Horvath, Matthias Gehre | 59m |
Clang implements Herb Sutter–inspired lifetime checks that run as fast, statement-local diagnostics and ship as clang 10 default, with the same rules available… | ||
| Argument dependent lookup (ADL): name taxonomy, customization points & use cases | Kostas Kyrimis | 51m |
Explains exactly when ADL adds associated namespaces/entities (class, enum, underlying types, template arguments, pointer-to-member rules) and shows how… | ||
| Leveraging Modern C++ in Quantitative Finance | Daniel Hanson | 50m |
Shows a concrete Monte Carlo option pricer implemented with C++11/C++17 features: Mersenne Twister 64 engine, standard normal distribution, lambda-driven path… | ||
| Making Testing C++ Binaries Practical @ Facebook Scale: A CI Story | Mark Isaacson | 59m |
Facebook scales C++ CI by using Buck-style build graph queries and object-file caching to cut work dramatically: limiting reverse-dependency traversal to two… | ||
| Non-conforming C++: the Secrets the Committee Is Hiding From You | Miro Knejp | 52m |
Shows concrete nonstandard compiler tricks: GCC case ranges, unnamed struct/union members, omitted-operand conditional (an Elvis-like operator), designated… | ||
| Meta++: Language Support for Advanced Generative Programming | Andrew Sutton | 59m |
Project claims C++-level static reflection and source-code injection that let meta programs generate class members, deferred until the meta-program end. A… | ||
| Abseil's Open Source Hashtables: 2 Years In | Matt Kulukundis | 54m |
Abseil’s flat hash tables use 16-wide SSE probes with an h1/h2 split to avoid EQ calls, yielding about 5–10% faster finds but 10–20% slower hot inserts in… | ||
| Pattern Matching: A Sneak Peek | Michael Park | 01h 03m |
Proposal P1371 r1 brings pattern matching to C++ as a statement and expression form and shows concrete syntax and semantics: P1371 r1 documents inspect blocks… | ||
| How to Write a Heap Memory Profiler | Milian Wolff | 01h 05m |
Shows how to build a Linux proof‑of‑concept heap profiler that injects code with LD_PRELOAD and GOT patching, looks up original allocators via dlsym/DL_NEXT… | ||
| Time Travel: Applying Gradual Typing to Time Types with Clang's LibTooling | Hyrum Wright | 01h 01m |
Google runs clang-tidy and Clang's libTooling over ~250M lines to migrate ints/doubles to absl::Time/absl::Duration, using expression simplifiers… | ||
| The Dawn of a New Error, (C++ error-handling and exceptions) | Phil Nash | 58m |
Proposal p0709 implements zero-overhead deterministic exceptions by turning throws into a return-channel value isomorphic to std::expected plus a lightweight… | ||
| Infiltrating a Code Base: Moving Toward a Better C | Brian Ruth | 27m |
Practical steps for migrating C code toward safer, low-overhead C++: replace fragile macros → real functions (compiler shows identical inlining), prefer scoped… | ||
| Generators, Coroutines and Other Brain Unrolling Sweetness | Adi Shavit | 31m |
Hands-on tour of C++20 coroutines showing generators that are lazy, composable and practical: builds an OpenCV spiral pixel generator and an RGB HSV color… | ||
| Catch ⬆️: Unicode for C++23 | JeanHeyd Meneide | 01h 00m |
C++ is gaining a concrete Unicode plan for C++23: Study Group 16 standardizes char16_t as UTF‑16 and char32_t as UTF‑32 after surveying ~100 compilers, defines… | ||
| A C++ Approach to Physical Units | Mateusz Pusz | 01h 05m |
A C++20 header-only library implements dimensional analysis with compile-time safety and no runtime overhead, using concepts, class types as non-type template… | ||
| Using Freestanding C++ for C++17 in Shellcode, UEFI, Embedded & Unikernels | Rian Quinn | 55m |
Shows how to run full C++17 with libc++ and Newlib in freestanding environments by building a static PIE toolchain and a custom ELF header-only loader that… | ||
| EDSL Infinity Wars: Mainstreaming Symbolic Computation | Joel Falcou, Vincent Reverdy | 01h 04m |
A C++ EDSL is presented that separates storage from symbolic formulas by using stateless expression templates, encodes symbol names as a 64-bit integral… | ||
| Better Code with C++ Attributes | Ben Saks | 01h 01m |
Explains concrete attributes and their effects: [[noreturn]] prevents return-path code generation and avoids unreachable-code surprises but causes undefined… | ||
| Maintainability and Refactoring Impact of Higher-Level Design Features | Titus Winters | 01h 01m |
Argument: types are harder to refactor than functions and templates harder still, with Concepts effectively impossible to change once published. Demonstrated… | ||
| The One-Decade Task: Putting std::atomic in CUDA. | Olivier Giroux | 01h 06m |
A ten‑year engineering effort implements std::atomic in CUDA, with a concise claim: provide C++ atomics on GPUs by formalizing a GPU memory model, proving… | ||
| TMI on UDLs: Mechanics, Uses, and Abuses of User-Defined Literals | Stephen Dewhurst | 32m |
Explains all six UDL kinds, shows cooked literals versus raw literal operator parsing, and demonstrates a literal operator template that gets the character… | ||
| Compiled C++ Coding Standards | Valentin Galea | 26m |
A coding standard lives as actual H and CPP files inside the repo so rules compile as code and become searchable, reviewable templates rather than separate… | ||
| Converting to C++20 Modules | Nathan Sidwell | 49m |
Converts tinyxml2 using GCC experimental modules to show an incremental path: create a header unit mapping file, generate a CMI (compiled module interface)… | ||
| Small is beautiful: Techniques to minimise memory footprint | Steven Pigeon | 32m |
Describes a compact pointer class that stores addresses relative to data or stack bases, using configurable bit widths (example: 36-bit pointers) so tree nodes… | ||
| Expression Templates for Efficient, Generic Finance Code | Bowie Owens | 30m |
Shows a small expression-template library that replaces costly temporaries with cheap descriptor objects, using C++17 features like auto return type deduction… | ||
| Inference in C++: The big picture | Michael Spertus | 01h 00m |
C++ evolves inference across standards (auto in C++11, generic lambdas C++14, CTAD in C++17, Concepts in C++20) and the claim is that using them together… | ||
| Contract use: Past, Present, and Future | Joshua Berne | 01h 12m |
Bloomberg runs a macro-based contract facility for ~15 years, open-sourced in BDE, that implements three assertion tiers (assert/opt/safe) plus a DSLs review… | ||
| Type punning in modern C++ | Timur Doumler | 01h 00m |
Compares concrete techniques — reinterpret_cast and unions cause undefined behaviour; memcpy is the portable fix — using the Quake fast inverse‑sqrt as a… | ||
| A Unifying Abstraction for Async in C++ | Eric Niebler, Daisy Hollman | 01h 02m |
Argues that the proposed Sender/Receiver model becomes a low‑overhead unifying abstraction for async in C++, showing concrete mechanics: compose lazy senders… | ||
| The Best Parts of C++ | Jason Turner | 59m |
Survey of roughly 25 major features across C++98–C++20 shows concrete wins: make_unique (C++14) fixes common allocation idioms, guaranteed copy elision (C++17)… | ||
| What Programmers Should Know About Memory Allocation | S. Al Bahra, H. Sowa, P. Khuong | 01h 01m |
Shows that swapping allocators changes real performance: MySQL scales differently across allocators and Firefox cuts memory by 20% reduction switching to… | ||
| Freestanding C++ - Past, Present, and Future | Ben Saks | 01h 03m |
Defines which library pieces are guaranteed on bare-metal: only a small header set plus C stdlib functions abort, atexit and exit are required, while C++… | ||
| Programming with C++ Modules: Guide for the Working | Gabriel Dos Reis | 01h 04m |
Modules become first-class in C++20 and promise big compile-time wins: the compiler writes a binary module description so modules compile once and reuse… | ||
| A Short Life span＜＞ For a Regular Mess - std::span | Victor Ciura | 01h 02m |
Argues that std::span is a borrow type with shallow-copy semantics, not a regular container: equality operators were removed rather than commit to confusing… | ||
| Error Handling is Cancelling Operations | Andrzej Krzemieński | 01h 00m |
Argument: error handling — whether error codes, errno, exceptions, or error monads — functions to cancel dependent operations so upstream success becomes a… | ||
| Rethinking the Way We Do Templates in C++ | Mateusz Pusz | 01h 01m |
Implements a Physical Units Library and shows concrete fixes: replace deep class-template aliasing with inherited strong typedefs plus a manual dumb casting… | ||
| 10 Techniques to Understand Existing Code | Jonathan Boccara | 58m |
Ten concrete tactics claim to make a messy C++ codebase readable fast: follow UI/IO "purple wormholes" into handlers, use call stacks and flame graphs to… | ||
| Efficient GPU Programming with Modern C++ | Gordon Brown | 01h 06m |
Demonstrates concrete SYCL code for a 512×512 image convolution on an Intel HD GPU using the OpenCL backend and a separate device compiler; switching to… | ||
| Upgrade from "permissive C++" to "modern C++" with Visual Studio 2019 | Nick Uhlenhuth | 25m |
Shows how Visual Studio 2019 moves a legacy codebase to strictly conformant C++: flip the permissive- flag to catch late-parsed errors, use quick actions to… | ||
| "Mostly Invalid": flat_map, Exception Guarantees, and the STL | Arthur O'Dwyer | 01h 13m |
Shows concrete failures: a throwing comparator or hasher breaks priority_queue and unordered_set invariants and yields a mostly invalid state where find and… | ||
| The C++ ABI From the Ground Up | Louis Dionne | 54m |
Explains the Itanium C++ ABI details that matter: name mangling, calling conventions, class and vtable layout, RTTI and exception wiring, and how tiny source… | ||
| Building Modules | Michael Spencer | 01h 04m |
Explains three concrete build strategies—textual modules, implicit build, and explicit build—and measures their trade-offs: modules trade serialization for… | ||
| Reflections: Compile-time Introspection of Source Code | Andrew Sutton | 01h 08m |
Proposal: a static reflection system for C++ that exposes source-level declarations as a single compile-time meta value, implemented in a clang fork and demoed… | ||
| Atomics, Locks, and Tasks (part 1 of 2) | Rainer Grimm | 53m |
Shows an atomic counter example to argue that C++ atomics only solve simple per-operation correctness and do not maintain multi-step invariants, so data races… | ||
| Atomics, Locks, and Tasks (part 2 of 2) | Rainer Grimm | 01h 04m |
Compares raw threads, futures/promises, and task-based APIs and shows concrete fixes and numbers: a 100 million element inner product runs ~2.5–3 s single… | ||
| There Are No Zero-cost Abstractions | Chandler Carruth | 01h 00m |
Argument: claiming zero-cost abstractions is false and dangerous. Case study: adding arena allocation to protocol buffers (rolled out from late 2013) shifts… | ||
| Destructor Case Studies: Best Practices for Safe and Efficient Teardown | Pete Isensee | 01h 01m |
Destructors must be minimal and correct: prefer best destructor is no destructor by using RAII (unique_ptr, scoped handles) so ownership is explicit, avoid… | ||
| Asynchronous Programming in Modern C++ | Hartmut Kaiser | 01h 02m |
A C++ library called HPX implements an asynchronous task model using Standard-like futures, work‑stealing scheduling and co_await futures so functions return… | ||
| Next generation unit testing using static reflection | Manu Sánchez | 49m |
Claims a working unittest proof-of-concept for C++14 that uses compile-time static reflection to discover tests and non‑intrusively mock methods. It wires… | ||
| Safe Software for Autonomous Mobility With Modern C++ | Andreas Pasternak | 31m |
A safe real-time C++ framework for autonomous driving is implemented and integrated with ROS 2, targeting ISO 26262 constraints: compile-time fixed string… | ||
| The Design of the C++ Runtime for AWS Lambda | Marco Magdy | 32m |
Explains how the C++ runtime makes native code run reliably on AWS Lambda by bundling exact system libs and invoking the program through ld-linux.so with a… | ||
| Naming is Hard: Let's Do Better | Kate Gregory | 01h 00m |
Argues that good names must convey the actual behavior: prefer partial_sort vs top_n when callers want the top N, use get/set for simple accessors and use… | ||
| Higher-order functions in Modern C++: existing techniques and function_ref | V. Romeo | 01h 01m |
Covers practical higher-order patterns and proposes function_ref as a lightweight, non-owning callable reference implemented as a void plus function pointer… | ||
| A Critical Look at the Coding Standards Landscape | Michael Price | 01h 02m |
Many public C and C++ standards exist but they often mismatch project context: MISRA C++ 2008 targets C++03 and freestanding implementations and is not… | ||
| Faster Code Through Parallelism on CPUs and GPUs | David Olsen | 53m |
Survey of parallel models compares C++ threads, OpenMP, OpenACC, CUDA, Kokkos and C++17 parallel algorithms with concrete kernels: brute‑force… | ||
| Objects vs Values: Value Oriented Programming in an Object Oriented World | Tony Van Eerd | 01h 02m |
Argues that converting many mutable objects into copyable value types and exposing a single set_channel style API with an in/out relationship cuts… | ||
| C++20: The small things | Timur Doumler | 01h 03m |
C++20 tightens and fills gaps: it adds designated initializers, redefines aggregates so they cannot have user-declared constructors, and permits parenthesis… | ||
| The Networking TS in Practice: Patterns for Real World Problems | Robert Leahy | 59m |
Examines concrete recipes using Boost.Asio and the Networking TS to build composed asynchronous operations: implements an async_wait_then_write and a correct… | ||
| Value Proposition: Allocator-Aware (AA) Software | John Lakos | 01h 13m |
Argues that a company-wide allocator-aware software infrastructure (BDE, BT-verified tools, PMR polymorphic memory resource) delivers nearly first-class… | ||
| Getting Allocators out of Our Way | Alisdair Meredith, Pablo Halpern | 01h 01m |
Shows how C++ polymorphic allocators (pmr) plus a compiler-supported “allocator-aware” class model eliminate most boilerplate: a stack-buffer +… | ||
| The C++20 Standard Library: Beyond Ranges | Jeff Garland | 01h 00m |
Survey of C++20 library changes concentrates on concrete features and caveats: std::format (from fmt) adds Python‑style formatting but throws runtime errors on… | ||
| Compiler Explorer: Behind The Scenes | Matt Godbolt | 01h 00m |
A web service that started as a shell script now runs on AWS with Node.js and Docker, serving about 1.17M compiles/week, hosting 400+ compilers (≈250 GB of… | ||
| Hello World From Scratch | Peter Bindels, Sy Brand | 59m |
Shows a line-by-line build from source text to running binary: preprocessor expansion, lexer → tokens, parser → AST, semantic checks, lowering to LLVM IR… | ||
| If You Can't Open It, You Don't Own It | Matthew Butler | 59m |
Examples start with pacemakers and insulin pumps being reachable over Wi‑Fi, move to ShadowHammer infecting about 500,000 systems, then a researcher scanning… | ||
| Algorithm Intuition (part 1 of 2) | Conor Hoekstra | 01h 01m |
Walks through concrete STL uses: generates sequences with iota, computes sums with accumulate/transform_reduce, finds both extremes with min_max_element… | ||
| Algorithm Intuition (part 2 of 2) | Conor Hoekstra | 01h 01m |
Covers 11 numeric STL algorithms (calls out 111 algorithms total) and shows concrete rewrites: use transform_reduce to compute adjacent differences without… | ||
| C++20: What's in it for you? | Marc Gregoire | 01h 01m |
A rapid, concrete tour of C++20 features and what works now: modules replace includes and compile once, ranges give lazy views and pipeable adapters… | ||
| This Videogame Programmer Used the STL and You Will Never Guess What Happened Next | Mathieu Ropert | 57m |
A production CPU‑bound game uses the STL and finds concrete tradeoffs: vector wins for hot data because of cache locality and sometimes outperforms map/set for… | ||
| Removing Metaprogramming From C++, Part 1 of N: constexpr Function Params | David Stone | 01h 00m |
Proposes letting a function parameter be marked as constexpr so callers can pass compile-time values without templates, adds an is_constant_expression check… | ||
| Using C++20's Three-way Comparison ＜=＞ | Jonathan Müller | 58m |
C++20's three-way comparison (<=>) lets classes delegate comparison logic to the compiler by writing a defaulted <=>, which yields lexicographic member-wise… | ||
| Don't Package Your Libraries, Write Packagable Libraries! (Part 2) | Robert Schumacher | 26m |
Covers concrete rules that make C++ libraries easy to package: how componentized builds, clear public headers, single LICENSE file and SPDX metadata speed… | ||
| Mesh: Automatically Compacting Your C++ Application's Memory | Emery Berger | 36m |
A plug-in malloc replacement that compacts C/C++ heaps without source changes or pointer-fixing, enabled by an environment variable, claims provable… | ||
| Path Tracing Three Ways: A Study of C++ Style | Matt Godbolt | 56m |
Three versions of a toy path tracer are implemented and compared: object‑oriented, functional (C++ ranges, tl::optional) and data‑oriented, with source on… | ||
| Floating-Point ＜charconv＞: Making Your Code 10x Faster With C++17's Final Boss | Stephan T. Lavavej | 01h 00m |
C++17's charconv adds to_chars/from_chars for fast, locale-free conversion and uses Ulf Adams' Ryu and Ryu-printf variants to produce shortest round-trip… | ||
| C++ Class Natures in Their Canonical Form and How to Find Them | Peter Sommerlad | 01h 01m |
Categorizes C++ classes into four concrete natures — value types, polymorphic types, designating types, and managing types — and shows how each nature dictates… | ||
| Faster Compile Times and Better Performance: Bringing Just-in-Time Compilation to C++ | Hal Finkel | 01h 01m |
ClangJIT implements deferred instantiation by embedding serialized AST/modules and compiler state in object files, letting the program supply non‑type template… | ||
| Releasing C++ Toolchains Weekly in a 'Live at Head' World | Jorge Gorbe Moya, Jordan Rupprecht | 01h 03m |
Google's C++ production toolchain releases new compiler builds almost every week by ingesting upstream commits, building two-stage PGO binaries, running… | ||
| std::midpoint? How Hard Could it Be? | Marshall Clow | 01h 03m |
P0811 adds std::midpoint to C++20 and the actual work is careful engineering: integer midpoint uses make_unsigned, swap-if-a> b and unsigned difference to… | ||
| C++ ...Easy, Elegant, Powerful! | Charley Bay | 51m |
Claim: C++ makes large systems easier to reason about and scale by mapping domain types directly to hardware and enforcing invariants at compile time. It… | ||
| test_resource: The pmr Detective | Attila Fehér | 57m |
pmr::test_resource is a C++17 polymorphic memory resource (based on Bloomberg’s bslma::TestAllocator) that detects leaks, buffer overruns/underruns, double… | ||
| Polymorphism != Virtual: Easy, Flexible Runtime Polymorphism Without Inheritance | John Bandela | 49m |
Demonstrates a C++17 technique that provides runtime polymorphism without inheritance by shipping a polymorphic single-header (~247 lines) that builds… | ||
| Minimal Structured Logging for Autonomous Vehicles | Robert Keelan | 29m |
A fast structured logger separates metadata (file, format, type descriptors) from per-instance fields, assigns a unique ID via a static linked list pre-main… | ||
| Starting and Running C++ User Groups | Jens Weller | 58m |
Started a local C++ group in 2011 and runs Meeting C++ since 2012, claims dozens of active groups worldwide and a monthly crawl that lists ~30 groups rising to… | ||
| Memory Resources in a Heterogeneous World | Michał Dominiak | 01h 00m |
C++17 std::pmr proves awkward for GPUs because its virtual functions embed raw pointers, so Thrust implements thrust::mr (templated on fancy pointer types) and… | ||
| Killing Uninitialized Memory: Protecting the OS Without Destroying Performance | J. Bialek, S. Block | 56m |
A compiler-level mitigation named InitAll automatically zero-initializes POD structures on the stack across Windows and Hyper‑V, shipping to customers in May… | ||
| Dependency Management at the End of the Rainbow | Corentin Jabot | 58m |
Argues C++ needs shared naming, consistent environments and a single orchestration layer rather than rehashed package managers, cites npm’s left-pad outage and… | ||
| How to Implement Your First Compiler Feature:The Story of Concepts in Clang | Saar Raz | 55m |
Implements C++20 Concepts in Clang end-to-end: parses concept definitions, adds AST nodes, wires requires clauses, abbreviated templates and the new requires… | ||
| Data in the Type System: Complex Non-Type Template Parameters in C++20 | Jeff Snyder | 54m |
C++20 adds class-type NTTPs so class objects can be template arguments (removing the need for the non-standard "forbidden UDL"), with requirements: literal… | ||
| Are We Macro-free Yet? | Zhihao Yuan | 49m |
Describes removing macros from a C++17 codebase by replacing conditional compilation with compile-time booleans (e.g. has_blast variable), moving… | ||
| Structured Concurrency: Writing Safer Concurrent Code with Coroutines... | Lewis Baker | 48m |
Argues that using C++20 coroutines with a lazy task type and composable algorithms yields deterministic, exception-safe concurrency: calls no longer implicitly… | ||
| The Truth of a Procedure | Lisa Lippincott | 01h 02m |
Programs model procedures as formal sentences and truth is decided by a two-player game where the implementation (center court) and interfaces… | ||
| Reading Binary Data with Style: A Serialization Framework for C++17 | Tony Wasserka | 57m |
Experimental header-only C++17 library blobify converts user structs to compact binary blobs and back, automating construction (including non-trivial… | ||
| A new tool for fighting against Hyrum’s law in ... concept-driven design | D. Hollman | 29m |
Argues that Hyrum’s law is controllable by shipping models that intentionally break implicit behavior, demonstrates this with a container iterator invalidation… | ||
| Using Integers as Arrays of Bitfields a.k.a. SWAR Techniques | Eduardo Madrid | 55m |
A C++11 library implements SWAR (treating 64-bit words as arrays of bitfields) to brute-force Texas Hold’em equities and it actually classifies ~2 billion… | ||
| What is C++ | Chandler Carruth, Titus Winters | 58m |
Argues that C++ prioritizes resource-critical performance and inherits C’s separate-compilation model, which produces real surprises like ill-formed no… | ||
| unique_pseudofunction: N overloads for the price of 1 | Filipp Gelman | 40m |
Implements unique_pseudofunction: a move-only type-erased callable that supports multiple overloads of operator() instead of one, with a custom compile-time… | ||
| Embrace Modern Technology: Using HTML 5 for GUI in C++ | Borislav Stanimirov | 58m |
Argues that HTML5 can serve as a native C++ GUI and demonstrates three concrete approaches: a local HTTP server with WebSockets using libraries like… | ||
| Writing Safety Critical Automotive Software for High Perf AI Hardware | Michael Wong | 57m |
Summary of concrete claims and work: automotive ML and sensor stacks produce 120 TB/month of sensor data and industry uses a billion‑mile metric; analyses cite… | ||
| Will Your Code Survive the Attack of the Zombie Pointers? | Wong, McKenney, Michael | 01h 01m |
C and C++ currently make any pointer to an object invalid at the end of that object’s lifetime, which breaks long‑standing concurrent patterns such as Smith… | ||
| C++ as a First Language... Really? | Patrice Roy | 01h 00m |
Argues C++ is viable as a first language by running the same beginner exercises in C++, C#, Java and Python: sphere volume, Pythagoras, odd/even, functions and… | ||
| Deep CMake for Library Authors | Craig Scott | 01h 02m |
Shows how to make shared libraries robust across platforms using concrete CMake features and commands: set GCC/Clang flags -fvisibility=hidden and… | ||
| C++ Standard Library "Little Things” | Billy O'Neal | 32m |
Covers concrete small library additions and real tradeoffs: feature-test macros distinguish header presence from usable features; exchange avoids move-from… | ||
| C++ Design Patterns: From C++03 to C++17 | Fedor Pikus | 01h 00m |
Follows several concrete pattern evolutions: a Builder variant uses initializer_list plus move semantics to let templates synthesize boilerplate instead of… | ||
| “How to Choose the Right Standard Library Container, and Why You Should Want Some More” | Alan Talbot | 01h 02m |
Three concrete case studies compare list, vector, deque, a homegrown shifty vector, and colony on real tests (10k widgets, queue ≈10). Visual Studio 2017… | ||
| How to Refactor Millions of Line of Code Without Alienating Colleagues | Fred Tingaud | 56m |
Shows how to use Clang-Tidy extension API to write custom AST matchers and automated fix‑its, with concrete wins and limits: removing a dead parameter across… | ||
| C++ Code Smells | Jason Turner | 59m |
Argues that hundreds of C++ best-practice rules collapse into a handful of actionable smells: missing const, ignored compiler warnings, and heavy use of moves… | ||
| Concurrency in C++20 and Beyond | Anthony Williams | 01h 04m |
C++20 adds cooperative cancellation via stop_token/stop_source with condition_variable_any and stop_callback integration, plus a new jthread auto-request-stop… | ||
| A Series of Unfortunate Bugs | Satabdi Das | 30m |
Four post-mortems show real failures and concrete fixes: an integer-promotion undefined behavior causes a decade-old database crash and is fixed with a… | ||
| High performance graphics and text rendering on the GPU for... | Geller, Sermersheim | 59m |
A small open source library called CS paint sits on top of Vulkan and collapses the roughly 700 lines of Vulkan setup into a few C++ calls, letting a C++17… | ||
| Unicode: Going Down the Rabbit Hole | Peter Bindels | 48m |
Covers why Unicode is messy: historical scripts, Han unification tradeoffs, surrogate pairs limiting planes to 1.1 million, and emoji made of joiners and… | ||
| Latest & Greatest in Visual Studio 2019 for C++ developers | Marian Luparu, Sy Brand | 01h 04m |
Visual Studio 2019 shows concrete upgrades: CMake native experience loads folders, lists CMake targets and configures builds; vcpkg integrate install pulls… | ||
| Spectre/C++ | Zola Bridges, Devin Jeanpierre | 56m |
Describes a practical mitigation suite that compiles attacker-controlled loads into masked operations: Speculative Load Hardening (SLH) inserts masking and… | ||
| Concepts in C++20: Revolution or Evolution | Rainer Grimm | 01h 00m |
C++20 concepts let templates state precise, compiler-checked requirements to produce targeted diagnostics instead of long error dumps. The talk demonstrates… | ||
| Quickly Testing Legacy C++ Code with Approval Tests | Clare Macrae | 01h 02m |
Shows how to lock down legacy behavior fast using ApprovalTests.cpp: a header-only C++11 library that plugs into Google Test, Catch and doctest, generates… | ||
| Practical C++ Modules | Boris Kolpackov | 01h 01m |
C++20 modules arrive with three practical migration paths: include translation, header-unit importation, or full named modules that produce a binary module… | ||
| The Business Value of a Good API | Bob Steagall | 01h 01m |
Covers concrete costs (3.6 billion people affected and ~$1.7T lost from 2017 software failures) and argues APIs drive either technical debt vs software capital… | ||
| Behind Enemy Lines - Reverse Engineering C++ in Modern Ages | Gal Zaban | 37m |
Shows how compiled C++ actually looks: uses Binary Ninja, MSVC calling conventions and registers, and dynamic breakpoints to trace virtual calls. Rebuilds… | ||
| When C++ Zero-Cost Abstraction fails: how-to Fix Your Compiler | Adrien Guinet | 26m |
A C++ zero-cost abstraction stops LLVM from vectorizing a trivial element-wise add, causing Python-generated code to run about 45 μs vs 110 μs (C vs Python… | ||
| What's New in Visual Studio Code - Remote Dev, IntelliSense, Build/Debug... | T. Raj | 30m |
Visual Studio Code shows concrete C++ advances: the C/C++ extension adds build and debug active file that detects CL or GCC, writes tasks/launch JSON, and runs… | ||
| (Ab)using Compiler Tools | Réka Kovács | 24m |
Two practical binary tools are demonstrated: bloaty McBloatface inspects ELF/Mach-O files to attribute disk vs VM size to sections and symbols, shows how… | ||
| How to Hold a T | CJ Johnson | 27m |
Containers separate allocation and construction: T is the wrong type to hold a T, so use an unrelated storage type (char buffer or a union) and manually… | ||
| C++20 Concepts: A Day in the Life | Saar Raz | 01h 07m |
Shows a concrete C++20 Concepts implementation in Clang implementation and uses it to replace runtime virtual dispatch with compile-time resolution for a… | ||
| Committee Fireside Chat | Lisa Lippincott | 01h 33m |
Panel lays out concrete progress and tradeoffs: modules in C++20 already remove many include-guard problems; reflection and generation are the linchpins that… | ||
| Deprecating volatile | JF Bastien | 01h 01m |
Argues for deprecating many volatile uses in C and C++, documents actual edits accepted for C++20 (language and library papers split), shows LLVM semantics… | ||
| Avoid Misuse of Contracts! | Rostislav Khlebnikov | 58m |
Argues that contract checks exist to catch programmer bugs: in a correct program function contracts are never violated and removing contract checks must not… | ||
| The C++20 Synchronization Library | Bryce Adelstein Lelbach | 01h 07m |
Summarizes the C++20 sync additions and shows a working bounded-depth tasking runtime: uses std::atomic::wait/notify, std::atomic_ref, counting_semaphore… | ||
| C++ Sanitizers & Fuzzing for the Windows Platform Using New Compilers... | Jim Radigan | 50m |
Microsoft compilers gain AddressSanitizer support and an enhanced open-source runtime that hooks malloc/new/memcpy, produces shadow bytes, and reports zero… | ||
| C++ Standardization | Peter Bindels | 07m |
C++ standardization proceeds by concrete steps: announce ideas on the std‑e, std‑papers mailing lists, write a paper and submit it four weeks before a meeting… | ||
| A Conversion Story: Improving from_chars and to_chars in C++17 | Javier Estrada | 09m |
Provides tiny wrapper templates that eliminate the end pointer by taking arrays by reference or containers with contiguous storage and calling… | ||
| Cato the Elder | Mathieu Ropert | 05m |
Argument: most C++ build files are overcomplicated and can be rewritten to about 1/5 the length, which makes packaging, changing build configuration, and… | ||
| v.~uint32_t(); | Matthis Kruse | 06m |
Shows tiny, concrete C++ surprises: calling uint32_t destructor compiles because small integer types have trivial (zero) destructors; placement-new a… | ||
| Building happiness in your life | Steve Robinson | 05m |
A cross platform C++ game called Stack Blocks demonstrates a real build setup rather than a toy example it compiles for iOS Android and desktop using Conan +… | ||
| Highlighting C++ with C++ is… Hard | Marcin Zdun | 05m |
A static C++ highlighter is built with heavy template metaprogramming, a Boost.Spirit-like parser implemented in templates to emit color spans, and the project… | ||
| Functional Programming without the Functions | Norm Birkett | 05m |
Claims a concrete framework called Value Oriented Programming that replaces functions with named values managed by a value factory which knows types… | ||
| ISO/IEC 14882 | Timur Doumler | 08m |
A rapid tour of the ISO C++ text that points to specific clauses and surprises rather than vague themes, using the N4810 draft as the source and the index as… | ||
| Text | Corentin Jabot | 08m |
Claims that text encodes 5,000 years of human writing and therefore needs Unicode, not ad hoc subsets; recommends UTF-8 for storage and transfer, cites ICU… | ||
| Catching New Tricks | Martin Hořeňovský | 04m |
http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available… | ||
| I need a volunteer who is not afraid of failure | Sy Brand | 04m |
A live demo shows two tasks—hold several toy frogs and keep hands flat on your head—are essentially impossible for one person but succeed when split between… | ||
| Why Conan? 5 reasons to use Conan package manager | Diego Rodriguez-Losada | 03m |
Conan positions itself as a production C++ package manager with concrete claims: >1,000 GitHub issues/month of engagement, 75% very or extremely satisfied user… | ||
| std::any_of Is the most important function added to C++ | Ólafur Waage | 05m |
Example shows a vector and predicate passed to std::any_of and a one‑line template implementation, then argues that countless ad hoc loops that return a… | ||
| A tale of two allocations | Pranay Kumar | 05m |
http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available… | ||
| Anything can be a Constexpr if you try hard enough | Zoe Carver | 03m |
Shows a working constexpr implementation of std::array<T,0>::data() when T may not be default‑constructible, not just a theory. Starts from aligned char buffer… | ||
| Using a Smart Event Dispatcher in C++ | Pranay Kumar | 04m |
Covers implementing an event dispatcher in C++ that avoids the lapsed listener problem by storing observers as weak_ptr vector and cleaning dead entries before… | ||
| OSM Scout library - Swiss knife for geographic data (in C++) | Lukas Karas | 05m |
http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available… | ||
| Fixing C++ with Epochs | Vittorio Romeo | 05m |
Proposes using modules as an opt‑in per‑module edition system so code starts with a directive selecting a version and modules with different versions compile… | ||
| Arguments over Arguments you already know this... | Adi Shavit | 05m |
A tiny command-line parser called argh parses positional args, flags, and value lists by streaming directly into variables and prints exactly what the examples… | ||
| Awesome Macros That Do Nothing | Louis Thomas | 05m |
Proposes using simple C++ macros as documentation-only annotations to show parameter direction and ownership, applied to an example function with five pointers… | ||
| Simple RPC Server for Database Access | Noel Tchidjo | 05m |
A minimal C++ RPC server exposing database operations using a JSON-over-TCP protocol. It uses Boost.Asio (or standalone Asio) for networking, SQLite as the… | ||
| Reducing immediate dangling? | Peter Sommerlad | 05m |
Immediate dangling from temporaries is prevented by ref-qualifying member functions using the C++11 feature, not by vague coding hygiene; examples include… | ||
| observe me not - a short story about smart pointers | Mark Zeren | 05m |
Shows that taking a smart pointer by const reference causes an extra dependent load and that the cheap fix is to accept a raw pointer at the callee. Implements… | ||
| Alternate Priorities | Chris Uzdavinis | 06m |
Reduces an implementation that computes the maximum horizontal or vertical distance between points from 214 bytes to 87 bytes. Changes the algorithm to a… | ||
| Programs Vs Puzzles | Ran Regev | 05m |
Compares building software to assembling a 5,000-piece puzzle and shows concrete failure modes: separating pieces hides a design problem, limited table space… | ||
| atomic_try_update - A more, better compare-and-swap | Matthew Fleming | 05m |
Provides small wrapper functions that replace manual CAS loops with a lambda that computes the new value and optionally whether to perform the swap… | ||
| Finding Strings in Large Files | Ondrej Dobias | 05m |
Search of gigabytes of mostly-binary files with very few partial matches is faster with heuristics than with naive std::search: a Boyer‑Moore‑Horspool style… | ||
| Lifetime and Ownership - Ownership is Decided Locally | Jefferson Carpenter | 09m |
Proposes a smart pointer called "putter" that uses a boolean strong flag to decide deletion, has no atomic ref count, and makes copies defaults to weak… | ||
| nothing matches | ||