CppCon 2020
2020-09-14..2020-09-18
-- online --
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, compiler engineers, tooling engineers, software architects, embedded systems engineers, test engineers
topics
type traits implementation; template metaprogramming techniques; CMake and VS Code workflows; vcpkg and devcontainer setups; class layout and padding; move semantics in containers; parallel and concurrency safety guidelines; name lookup and overload resolution; SOLID for templates and concepts; Boost.STLInterfaces iterators; zero-copy messaging format; just-in-time compilation systems
| title | author | length |
|---|---|---|
| Template Metaprogramming: Type Traits (part 1 of 2) | Jody Hagins | 01h 00m |
Walks through implementing many std type traits from first principles, showing actual code patterns: integral_constant and true_type/false_type as… | ||
| Template Metaprogramming: Type Traits (part 2 of 2) | Jody Hagins | 59m |
Continues implementing standard type traits from first half by showing concrete code: counts like 14 primary type categories, examples needing up to 12 or 64… | ||
| Collaborative C++ Development with Visual Studio Code | Julia Reid | 01h 00m |
Demonstrates concrete workflows: configures and builds an open-source CMake project, submits and merges a PR from VS Code, and reproduces builds on macOS and a… | ||
| Back to Basics: Class Layout | Stephen Dewhurst | 01h 00m |
Explains how compilers actually lay out C++ objects: field offsets, padding, vptr/vtable entries and thunks, and how those choices break memcmp-based… | ||
| The Hidden Secrets of Move Semantics | Nicolai M. Josuttis | 01h 06m |
Shows concrete code and measurements: copying vs moving strings with addresses printed, examples proving const disables move, and a container implementation… | ||
| The Future of C++ Parallel and Concurrency Safety Guidelines | Michael S Wong, Ilya Burylov | 01h 01m |
Documents present nearly 100 rules split into nine sections with about 81 drafted now, classifying rules as decidable or undecidable for static analysis… | ||
| Calling Functions: A Tutorial | Klaus Iglberger | 01h 01m |
Covers the concrete mechanics that determine which function the compiler actually calls: name lookup, template argument deduction, then overload resolution… | ||
| Breaking Dependencies: The SOLID Principles | Klaus Iglberger | 01h 03m |
Argues that SOLID are universal guidelines not just OOP rules and proves it with concrete C++ examples: concrete claim that SOLID applies to templates and… | ||
| Making Iterators, Views and Containers Easier to Write with Boost.STLInterfaces | Zach Laine | 52m |
Claims that Boost.STLInterfaces actually generates correct iterators, views and sequence containers with far less code, implemented as CRTP bases mirroring… | ||
| Plenary: The Beauty and Power of "Primitive" C++ | Bjarne Stroustrup | 01h 00m |
A tiny library maps typed objects to and from bytes with zero copying, a simple IDL of “flats”, a parser/generator and a runtime of accessors called a message… | ||
| Test Driven C++ | Phil Nash | 01h 02m |
Sixty minutes show how Test Driven Development in C++ actually works: using Catch/Catch2 and CLion the demo implements a Snakes-and-Ladders board, exercises… | ||
| Just-in-Time Compilation | JF Bastien | 01h 00m |
Survey of papers and systems across 60 years names concrete claims, tools, and measured effects: polymorphic inline caching (median 11×, some reports 27×)… | ||
| Back to Basics: The Abstract Machine | Bob Steagall | 57m |
Explains the concrete claim that C++ programs target a defined C++ abstract machine and that conforming implementations must match its observable behavior, not… | ||
| Back to Basics: The Structure of a Program | Bob Steagall | 01h 02m |
Covers exactly what the compiler and linker do: conversion of each .cpp into one object file, phases 1–9 of translation, and how macros/includes produce huge… | ||
| Code Samples That Compile Even More Easily | Clare Macrae | 05m |
A concrete workflow for keeping Markdown examples compiled and up to date using mdsnippets: embed snippet-marked tests directly in source, drop the paired… | ||
| SICP Cover Demystified | Conor Hoekstra | 05m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
SICP (Structure and Interpretation of Computer Programs) is "the best computer science book in the… | ||
| Build Everything From Source: A Case Study in Fear | Dave Steffen | 08m |
An upgrade from gcc 4.8.5 → gcc 9 exposes intermittent file corruption in a 500,000-line legacy system because a prebuilt custom hdf5 RPM was compiled with… | ||
| Reasoning with function signatures | Gabriel Aubut-Lussier | 06m |
Argues that assuming pure functions (no side effects) makes code predictable, reproducible and locally reasoned and shows a concrete model of a compiler as a… | ||
| Can software developers draw pictures? | Honey Sukesan | 07m |
Quick survey of free text-to-diagram tools with a linked GitHub of examples and demos. Shows converting plain text specs into class, sequence and architecture… | ||
| Become A Game Developer In 5 Minutes Or Less | Mathieu Ropert | 07m |
Claims a five minute crash course and then shows the concrete minimal game: main loop: input, update, render with updates driven by elapsed time or by frame… | ||
| C++ Community Surveys | Jens Weller | 05m |
A continuous survey platform is live at survey.meetingcpp.com that collects ongoing C++ usage stats with single‑ and multiple‑choice modes, a matrix (combined)… | ||
| What's My Object? | Staffan Tjernstrom | 06m |
Examines making objects appear across process boundaries and shows why std::variant and C-style discriminated unions fail: huge autogenerated headers, bloated… | ||
| What did I learn teaching C++ to beginners | Alex Voronov | 06m |
A short module on the standard library reveals that iterators confuse beginners after spending class time on referencing incrementing and comparisons and still… | ||
| C++20 Lambdas: Familiar Template Syntax | Ben Deane | 05m |
C++20 adds a template head to lambdas so code that used helper functions just to destructure types can be replaced by an immediately-invoked familiar template… | ||
| How We Used To Be | Ben Deane | 06m |
An overview of a 1969 language survey that catalogs 120 languages with over 800 bibliographic references and example code for major families claims high level… | ||
| Drinking from the Fire Hose: Keeping up with the evolving landscape of C++ | Brian Ruth | 05m |
C++ standards accelerate from C++98 to C++20: ~760 → ~1800 pages, so practical survival means adopting concrete habits: track names like RAII, CRTP, RVO… | ||
| Macro-Free Testing With C++20 | Kris Jusiak | 06m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
If this lightning talk we will follow the Beyonce Rule - 'If you liked it then you "should put… | ||
| C++ Dependency Management the Meson Way | Jussi Pakkanen | 05m |
Meson demonstrates building a working SDL2 multiplatform app by combining automatic downloads from a wrap database with small Meson build patches, converting… | ||
| Build all the things with Spack: a package manager for more than C++ | Todd Gamblin | 07m |
Spack is a Python‑DSL package manager that builds combinatorial variants — e.g., install HDF5 with specific GCC 8.3, MPI, BLAS/LAPACK and target CPU like… | ||
| How to Cook a Chicken | Sy Brand | 05m |
Calculations use a 0.4 kg hand and 11 m/s slap giving 24.2 J per slap, which changes 1 kg faux chicken by 0.0089 °C so cooking (Δ205 °C) needs 23,242 slaps or… | ||
| Why C++ for Large Scale Systems? | Ankur Satle | 05m |
Argues that C++ earns its place in large-scale systems by delivering concrete benefits: proven use from space probes to the LHC and hyperscale data centers… | ||
| How To Profile Compilation Duration? | Thomas Lourseyre | 05m |
Project starts with full build + tests at 15 minutes and grows to ≈1 hour; profiling uses -ftime-report (g++) and -ftime-trace (clang) plus Boost profile… | ||
| Why Conan (part II, 5 reasons to use Conan in 2020) | Diego Rodriguez-Losada | 05m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
After 4 years doing the “Why not Conan” and “Why Conan” lightning talks, the project has already… | ||
| Unicorns | Mathieu Ropert | 05m |
History traces unicorn lore from the Indus Valley to Aristotle to medieval Christian allegory then to scams selling narwhal tusks as miraculous horn and Marco… | ||
| cppinclude - Tool for analyzing includes in C++ | Oleg Fedorenko | 05m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
* Current situation in C++ headers, when touch header, that are included in a lot of files, need… | ||
| If You Build It, Will They Come? | Javier Estrada | 06m |
About ten months of work updates es.cppreference.com from a 2013 port to current C++17 coverage, with over 100 type traits fully translated, roughly 50… | ||
| How many languages a (C++) expert should speak ? | Thomas Lourseyre | 05m |
A four-level chart classifies languages as expert, practical, occasional, hello-world and shows the useful zone is the first three levels; the claim is that… | ||
| A 'Lighting' Talk - 3 Point Lighting For Video in 5 Minutes | Jim Roper | 06m |
Explains a practical three‑point setup: key light as the main illumination, fill light to soften the opposite side, and an optional backlight to separate… | ||
| Songs of My People | Tony Van Eerd | 03m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Tony presents an amusing take on a classic ABBA song! With many references to C++!
---
Tony Van… | ||
| Back to Basics: Design Patterns | Mike Shah | 48m |
Fixes a screensaver bug by replacing hardcoded spawn bounds (300×300) with a singleton configuration manager implemented via a C++11 static-local instance so… | ||
| Back to Basics: Move Semantics | David Olsen | 59m |
Covers exactly how rvalue references and std::move turn expensive copies into cheap transfers, when the compiler auto-generates move ctor/assign or deletes… | ||
| Back to Basics: Smart Pointers | Rainer Grimm | 01h 07m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020/blob/main/Presentations/back_to_basics_smart_pointers/back_to_basics_smart_pointers__rainer_grimm__cppc… | ||
| Modern C++ Safety and Security At 20 | Matthew Butler | 01h 02m |
C++20 introduces concrete safety wins and caveats: concepts move interface checks to compile time and cut runtime errors, atomic<std::shared_ptr> provides a… | ||
| Monoids, Monads, and Applicative Functors: Repeated Software Patterns | David Sankel | 58m |
Shows concrete C++ implementations: treat std::vector, std::optional and std::function as monoids/functors and implement std::optional monoid and parser… | ||
| Making Games Start Fast: A Story About Concurrency | Mathieu Ropert | 01h 02m |
Uses Intel VTune to find heavy mutex contention inside the filesystem layer (fizsfest) and shows that a single global lock causes ~50 seconds of spin-wait on a… | ||
| The Shapes of Multi-Dimensional Arrays | Vincent Reverdy | 01h 02m |
Claims that C++20 non-type template parameters make a compact, composable shape DSL possible and demonstrates a proof‑of‑concept that injects… | ||
| Plenary: Neighborhoods Banding Together: Reasoning Globally about Programs | Lisa Lippincott | 01h 09m |
Local correctness proofs get collated into link-time tables and checked with an n log n graph algorithm: sort/unique build a forest, categorize edges as… | ||
| Pipes: How Plumbing Can Make Your C++ Code More Expressive | Jonathan Boccara | 01h 01m |
A small C++ library called pipes implements a push model alternative to ranges, with a working GitHub repo and unit tests shown live. It delivers an efficient… | ||
| A Multi-threaded, Transaction-Based Locking Strategy for Containers | Bob Steagall | 01h 03m |
Presents a C++17 implementation of strict timestamp ordering for transactional locking on elements (std::vector elements hold an atomic pointer to a… | ||
| The Science of Unit Tests | Dave Steffen | 55m |
Argues unit tests function as small scientific instruments: write tests to falsify “code is correct” hypotheses, not to prove implementations; demonstrates the… | ||
| C++ Committee's Library Evolution Working Group Panel | Ben Craig | 01h 02m |
Panelists map short-term freestanding direction to paper p0829 and flag the single most likely C++23 change as language-level removal of required operator new… | ||
| The Surprising Costs of void() (and Other Not-Quite-Innocuous Evils) | Patrice Roy | 01h 02m |
Shows that plain void() functions with no inputs or outputs often hide mutations and global-state plumbing, leading to unclear interfaces and wasted work… | ||
| Managarm: A Fully Asynchronous OS Based on Modern C++ | Alexander van der Grinten | 01h 01m |
Managarm is a working microkernel OS written in modern C++ that makes every I/O asynchronous and uses a single blocking syscall to wait for completions; it… | ||
| C++20 Ranges in Practice | Tristan Brindle | 01h 06m |
C++20 Ranges get applied to three concrete problems: finding min (with GCC 10 support), summing squares (replacing eager transform+accumulate with a… | ||
| OO Considered Harmful | Phil Nash | 58m |
Argues C++ is multi‑paradigm not primarily OO and demonstrates concrete alternatives: historical Simula examples, Smalltalk/Objective‑C message passing, and… | ||
| C++ Community Organizers Panel | Jon Kalb | 01h 02m |
Panel gives concrete playbook: smaller meetups work as regular coffee or 20-person coding labs with 30-minute problems and retrospectives; surveys double… | ||
| C++ Committee's Library Evolution Working Group | Bryce Adelstein Lelbach | 01h 01m |
Discussion lays out concrete progress and process: executors aim for C++23 but need more review, the incubator and mailing-list reviews speed papers, and the… | ||
| Fuzzing Class Interfaces for Generating and Running Tests with libFuzzer | Barnabás Bágyi | 41m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020/blob/main/Presentations/fuzzing_class_interfaces_for_generating_and_running_tests_with_libfuzzer/fuzzin… | ||
| C++20: An (Almost) Complete Overview | Marc Gregoire | 59m |
C++20 arrives as a large, concrete spec: modules processed once that cut rebuilds and let headers be imported, a full ranges library with lazy views and… | ||
| Plenary: Performance Matters | Emery Berger | 01h 01m |
Shows that CPU layout noise can swamp compiler gains: repeated LLVM layout randomization (Stabilizer) plus ANOVA finds -O2 vs -O3 indistinguishable from noise… | ||
| Empirically Measuring, & Reducing, C++’s Accidental Complexity | Herb Sutter | 01h 21m |
Catalogs 533 language rules and finds ~360 are accidental complexity, ~150 essential, and 25 essentially unavoidable; parameter passing (≈23%) and… | ||
| Closing the Gap between Rust and C++ Using Principles of Static Analysis | Sunny Chatterjee | 01h 01m |
Compares Rust guarantees to concrete C++ checks implemented and demoed: live MSVC code analysis rules for casting, exhaustive switch/match, converting C-style… | ||
| Back to Basics: Templates (part 1 of 2) | Andreas Fertig | 01h 05m |
Covers concrete template patterns: function, class and method templates; shows a constexpr size(T (&)[N]) that preserves array size with std::array example… | ||
| 40 Years Of Evolution from Functions to Coroutines | Rainer Grimm | 01h 07m |
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
The evolution of a callable stands for the evolution of C++. Here are the main evolution… | ||
| Back to Basics: Templates (part 2 of 2) | Andreas Fertig | 01h 03m |
Walks through concrete template recipes: a variadic min function that unpacks a parameter pack and uses recursion guarded by constexpr if, then replaces that… | ||
| A Physical Units Library For the Next C++ | Mateusz Pusz | 01h 08m |
mp-units is a header-only C++20 library (release 0.6.0, available on Conan and Compiler Explorer) that encodes units as types to guarantee compile-time safety… | ||
| Back to Basics: Pointers and Memory | Ben Saks | 01h 01m |
Explains exact rules: arrays decay to pointers only in expressions and not on assignment, pointer arithmetic advances by sizeof(element) so p + k moves k… | ||
| Modern Software Needs Embedded Modern C++ Programming | Michael Wong | 01h 00m |
Argument: embedded systems deserve Modern C++ but must match compiler constraints, so migration splits into three Ages that map features to available… | ||
| 2020: The Year of Sanitizers? | Victor Ciura | 01h 00m |
Shows how ASan on Visual Studio 2019 actually gets enabled for MSVC projects and what the compiler plus runtime do to instrument code. Measures runtime costs… | ||
| C++20 STL Features: One Year of Development on GitHub | Stephan T. Lavavej | 01h 00m |
Microsoft's STL implementation ships about 50 C++20 features added via GitHub in one year with integer comparison functions, atomic_ref, std::span and erase_if… | ||
| Dealing with Embedded Limitations | Ben Saks | 01h 00m |
Panel goes through concrete limits and fixes: toolchains are often years-old because of recertification (Lynx compilers named), the standard library is largely… | ||
| Embedded: Customizing Dynamic Memory Management in C++ | Ben Saks | 01h 03m |
Shows how to replace global and per-type allocation by defining class-specific operator new and matching deletes, including the no-throw overload, and how the… | ||
| Building an Intuition for Composition | Sy Brand | 57m |
Shows how to spot and expose concrete composition patterns in C++ so APIs do real work: uses std::accumulate / std::reduce and fold expressions to explain… | ||
| C++ Standards Committee Fireside Chat | Herb Sutter | 01h 03m |
Panelists recap that C++20 shipped and the committee sticks to a schedule-based C++23 push while prioritizing bug fixes and cautious work on reflection and… | ||
| Building a Coroutine based Job System without Standard Library | Tanki Zhang | 52m |
Builds a coroutine-based job system using only C++20 language coroutines (no stdlib), a custom token/promise pair, a token dispatcher as initial_suspend, and a… | ||
| Exploration of C++20 Meta Programming | Inbal Levi | 58m |
Concrete C++20 features and effects: concepts and new type_traits (notably is_constant_evaluated) move logic to compile time and make constraints readable… | ||
| Halide: A Language for Fast, Portable Computation on Images and Tensors | Alex Reinking | 57m |
Halide is a C++-embedded DSL that separates algorithm from schedule and uses tiling, vectorization and compute_at to trade locality, parallelism and redundant… | ||
| Back to Basics: Algebraic Data Types | Arthur O'Dwyer | 01h 10m |
C++17 algebraic data types are shown as concrete tools: std::pair and std::tuple are product types with predictable memory footprint and padding; std::variant… | ||
| Back To Basics: Lambda Expressions | Barbara Geller, Ansel Sermersheim | 01h 01m |
Covers concrete C++11→20 changes: capture semantics happen at lambda evaluation, so capturing int x by value prints the original value; move capture makes… | ||
| Cross-Platform Pitfalls and How to Avoid Them | Erika Sweet | 01h 00m |
Covers concrete cross‑platform workflows: uses CMake as the single generator, shows adding a missing dependency via a vcpkg.json manifest, and demonstrates… | ||
| The Many Shades of reference_wrapper | Zhihao Yuan | 28m |
std::reference_wrapper models a rebindable reference that mimics language reference semantics while being a small pointer-sized type. It binds only to lvalues… | ||
| Effective Remote C++ Development with Codespaces | Nick Uhlenhuth | 28m |
Showcases GitHub Codespaces creating a managed cloud dev environment from a repo, launching VS Code in the browser, auto-installing extensions and tools from… | ||
| Back to Basics: Unit Tests | Ben Saks | 01h 02m |
Walks an existing C++ program from zero tests to a small suite that proves the scanner returns a no_more token on empty input, using istringstream for input… | ||
| Practical Memory Pool Based Allocators For Modern C++ | Misha Shalem | 01h 02m |
An allocator instruments every allocation site at compile time and an external LLVM-based pass scans the generated LLVM bitcode to extract type sizes and call… | ||
| Dynamic Polymorphism with Metaclasses and Code Injection | Sy Brand | 01h 00m |
Argues that virtual inheritance can be replaced by type erasure implemented via static reflection plus code injection and metaclasses, showing a prototype… | ||
| Constructing Generic Algorithms: Principles and Practice | Ben Deane | 01h 03m |
Starts from a raw recursive divide‑and‑conquer: pick mid, partition in place around the expected value, recurse on the half with the gap, and show the cost… | ||
| Just-in-Time Compilation: The Next Big Thing? | Ben Deane, Kris Jusiak | 01h 04m |
Shows a practical clang-jit (P1609) workflow that turns runtime strings into types, compiles targeted functions on demand, and promotes runtime data into… | ||
| Heterogeneous Programming in C++ with SYCL 2020 | Michael Wong, Gordon Brown | 01h 00m |
SYCL 2020 standardizes unified shared memory (USM) for pointer-based data, adds a CUDA backend via DPC++ so SYCL can target NVIDIA GPUs, and raises the minimum… | ||
| C++20 String Formatting Library: An Overview and Use with Custom Types | Marc Gregoire | 33m |
C++20 introduces std::format and the std::formatter customization point for formatting text. The talk covers how to specialize std::formatter to print custom… | ||
| Quickly Testing Qt Desktop Applications with Approval Tests | Clare Macrae | 57m |
You get a concrete recipe: split the app into a static ui library split so tests link the UI code without changing source, use Catch2 with a custom main that… | ||
| Design Patterns for Handling/Reporting Errors in C++ - Parallel Algorithms & Executors | Mark Hoemmen | 30m |
C++17 parallel algorithms and forthcoming P0443 executors cannot safely propagate exceptions across parallel boundaries, so the talk shows concrete patterns… | ||
| Get Off My Thread: Techniques for Moving Work to Background Threads | Anthony Williams | 01h 03m |
Argues that spawning a thread per event is hopeless and recommends either a dedicated background thread for ordered single threaded processing or a thread pool… | ||
| A Relaxed Guide to memory_order_relaxed | Paul E. McKenney, HANS BOEHM | 59m |
Explains that memory_order_relaxed permits simple load/store code and can be two orders of magnitude faster on weakly ordered CPUs like ARM, but the C++ model… | ||
| The Networking TS from Scratch: I/O Objects | Robert Leahy | 58m |
Shows how to implement a baseline I/O object from the Networking TS by building an asynchronous condition variable called async_event, a type‑erasing movable… | ||
| Back to Basics: Exceptions | Klaus Iglberger | 01h 02m |
Explains why exceptions are widely banned and how to use them safely by showing concrete techniques: prefer RAII and unique_ptr for resource management, make… | ||
| Exceptions Under the Spotlight | Inbal Levi | 55m |
Surveys show over 54% of projects (especially embedded) cannot use C++ exceptions freely; a microbenchmark reports 435x slower throws vs return codes on thrown… | ||
| Back to Basics: Concurrency | Arthur O'Dwyer | 01h 04m |
Explains concrete C++ mechanisms: std::thread starts immediately, data races on plain variables are undefined behavior, atomics avoid UB for simple counters… | ||
| No Touchy! A Case Study of Software Architecture with Immutable Objects | Borislav Stanimirov | 01h 05m |
ViewRay builds a C++17 multi‑process, multi‑thread control stack for MRI‑guided radiotherapy that uses React‑Redux style immutable state so every change is a… | ||
| Taskflow: A Parallel and Heterogeneous Task Programming System Using Modern C++ | Tsung-Wei Huang | 01h 01m |
Taskflow is a C++14 library that implements a task graph runtime with cudaFlow / CUDA Graph integration, condition tasks for cycles and iterative control, and… | ||
| Not Leaving Performance On The Jump Table | Eduardo Madrid | 01h 13m |
Shows that std::function incurs about 79% overhead versus raw function pointers in real benchmarks (function pointer ~46 μs, std::function ~81–86 μs) and that… | ||
| Structure and Interpretation of Computer Programs: SICP | Conor Hoekstra | 01h 06m |
Summarizes SICP by showing concrete C++ translations: implements pair-as-function and notes the meta‑circular evaluator idea, solves four exercises — sum of… | ||
| Lakos’20: The “Dam” Book is Done! | John Lakos | 01h 02m |
After twenty years of practice the book claims a concrete method for creating Large-Scale C++ Volume I that makes software reuse scalable: design physical… | ||
| Adventures in SIMD-Thinking (part 2 of 2) | Bob Steagall | 01h 01m |
Implements small-kernel convolution and UTF-8→UTF-32 conversion using Intel intrinsics (SSE, AVX, AVX2, AVX-512), broadcasting kernel coefficients into… | ||
| Functional Error and Optional-value Handling with STX | Basit Ayantunde | 49m |
STX is a header-only C++ library (no-std, no-RTTI, no-exceptions) providing a configurable panic handler with runtime hooks and compile-time defaults, plus… | ||
| Adventures in SIMD-Thinking (part 1 of 2) | Bob Steagall | 57m |
Builds a small C++ API around AVX-512 intrinsics (unaligned and masked loads/stores, permute/rotate/shift, fused multiply-add) and implements a… | ||
| Introducing Microsoft’s New Open Source Fuzzing Platform | Michael Walker, Justin Campbell | 52m |
Microsoft releases OneFuzz, an open source, self‑hosted Azure platform that runs libFuzzer-based tests with ASan and sancov, launches cloud jobs from a… | ||
| Some Things C++ Does Right | Patrice Roy | 57m |
Argues that C++ rewards value-based by default reasoning and composes powerful primitives into concise solutions: shows std::remove_if + sequence constructor… | ||
| How C++20 Changes the Way We Write Code | Timur Doumler | 01h 02m |
Claims C++20 reshapes C++ as much as C++11, centering on the coroutines, concepts, ranges, and modules quartet. Coroutines produce compiler-generated frames, a… | ||
| What is an ABI, and Why is Breaking it Bad? | Marshall Clow | 01h 06m |
ABI means the platform-level binary contract: parameter passing, object layout, vtable layout, exception and symbol semantics. Examples include adding/removing… | ||
| Retiring the Singleton Pattern: Concrete Suggestions for What to use Instead | Peter Muldoon | 01h 02m |
Shows how to remove hidden singletons by introducing small wrapper types (e.g. comWrapper) passed as parameters with a default obtained via lazy factory like… | ||
| nothing matches | ||