C++ Video Archive
Want Early Access to ALL CppCon 2023 Videos?
Click Here For More Information
Filter
Your selections:
Things Happening in SG14… – Patrice Roy – CppCon 2023
A Long Journey of Changing std::sort Implementation at Scale – Danila Kutenin – CppCon 2023
Customization Methods: Connecting User and Library Code – Inbal Levi
Lifetime Safety in C++: Past, Present and Future – Gabor Horvath – CppCon 2023
Back to Basics: Debugging in Cpp – Greg Law – CppCon 2023
Expressive Compile-time Parsers in C++ – Alon Wolf – CppCon 2023
Back to Basics: Functions in C++ – Mike Shah – CppCon 2023
Finding Your Codebases C++ Roots – Katherine Rocha – CppCon 2023
How Visual Studio Code Helps You Develop More Efficiently in C++ – Alexandra Kemper and Sinem Akinci
New in Visual Studio: CMake Debugger, Better Diagnostics, and Video Games – David Li & Mryam Girmay
Robots Are After Your Job: Exploring Generative AI for C++ – Andrei Alexandrescu
Cooperative C++ Evolution – Toward a Typescript for C++ – Herb Sutter
Coping With Other People’s Code – Laura Savino
Libraries: A First Step Toward Standard C++ Dependency Management – Bret Brown & Bill Hoffman
Delivering Safe C++ – Bjarne Stroustrup – CppCon 2023
Deciphering C++ Coroutines – A Diagrammatic Coroutine Cheat Sheet – Andreas Weis – CppCon 2022
Can C++ be 10x Simpler & Safer? – Herb Sutter – CppCon 2022
ISO C++ Standards Committee Panel Discussion – Hosted by Herb Sutter – CppCon 2022
C++ Lambda Idioms – Timur Doumler – CppCon 2022
C++ Concurrency TS 2 Use Cases and Future Direction – Michael Wong, Maged Michael, Paul McKenney
Understanding Allocator Impact on Runtime Performance in C++ – Parsa Amini – CppCon 2022
Using Incredibuild to Accelerate Static Code Analysis and Builds – Jonathan “Beau” Peck CppCon 2022
Help! My Codebase has 5 JSON Libraries – How Generic Programming Rescued Me – Christopher McArthur
Back to Basics: Cpp Value Semantics – Klaus Iglberger – CppCon 2022
HPX – A C++ Library for Parallelism and Concurrency – Hartmut Kaiser – CppCon 2022
import CMake, CMake and C++20 Modules – Bill Hoffman – CppCon 2022
Back to Basics: C++ Move Semantics – Andreas Fertig – CppCon 2022
C++ Performance Portability – A Decade of Lessons Learned – Christian Trott – CppCon 2022
Taking a Byte Out of C++ – Avoiding Punning by Starting Lifetimes – Robert Leahy – CppCon 2022
C++ Package Manager – C++ Dependencies Don’t Have To Be Painful! – Augustin Popa
How Microsoft Uses C++ to Deliver Office – Huge Size, Small Components – Zachary Henkel – CppCon 2022
Back to Basics: Templates in C++ – Nicolai Josuttis – CppCon 2022
Back to Basics: Debugging in C++ – Mike Shah – CppCon 2022
Functional Composable Operations with Unix-Style Pipes in C++ – Ankur Satle – CppCon 2022
C++23 – What’s In It For You? – Marc Gregoire – CppCon 2022
Optimizing Binary Search – Sergey Slotin – CppCon 2022
GPU Accelerated Computing & Optimizations on Cross-Vendor Graphics Cards with Vulkan & Kompute
Back to Basics: Standard Library Containers in Cpp – Rainer Grimm – CppCon 2022
Nth Pack Element in C++ – A Case Study – Kris Jusiak – CppCon 2022
What Is an Image? – Cpp Computer Graphics Tutorial, (GPU, GUI, 2D Graphics and Pixels Explained)
A Pattern Language for Expressing Concurrency in Cpp – Lucian Radu Teodorescu – CppCon 2022
-memory-safe C++ – Jim Radigan – CppCon 2022
What Can Compiler Benchmarks Reveal About Metaprogramming Implementation Strategies Vincent Reverdy
Value Semantics: Safety, Independence, Projection, & Future of Programming – Dave Abrahams – CppCon 2022
LLVM Optimization Remarks – Ofek Shilon – CppCon 2022
Modern C++: C++ Patterns to Make Embedded Programming More Productive – Steve Bush – CppCon 2022
Fast, High-Quality Pseudo-Random Numbers for Non-Cryptographers in C++ – Roth Michaels – CppCon 2022
What’s New in Conan 2.0 C/C++ Package Manager – Diego Rodriguez-Losada – CppCon 2022
Killing C++ Serialization Overhead & Complexity – Eyal Zedaka – CppCon 2022
10 Tips for Cleaner C++ 20 Code – David Sackstein – CppCon 2022
C++ in the World of Embedded Systems – Vladimir Vishnevskii – CppCon 2022
Breaking Enigma With the Power of Modern C++ – Mathieu Ropert – CppCon 2022
The Dark Corner of STL in Cpp: MinMax Algorithms – Šimon Tóth – CppCon 2022
Contemporary C++ in Action – Daniela Engert – CppCon 2022
A Faster Serialization Library Based on Compile-time Reflection and C++ 20 – Yu Qi – CppCon 2022
Breaking Dependencies – C++ Type Erasure – The Implementation Details – Klaus Iglberger CppCon 2022
Optimizing A String Class for Computer Graphics in Cpp – Zander Majercik, Morgan McGuire CppCon 22
GPU Performance Portability Using Standard C++ with SYCL – Hugh Delaney & Rod Burns – CppCon 2022
Back to Basics: Master C++ Value Categories With Standard Tools – Inbal Levi – CppCon 2022
From C++ Templates to C++ Concepts – Metaprogramming: an Amazing Journey – Alex Dathskovsky
Introduction to Hardware Efficiency in Cpp – Ivica Bogosavljevic – CppCon 2022
The Most Important Optimizations to Apply in Your C++ Programs – Jan Bielak – CppCon 2022
Back to Basics: RAII in C++ – Andre Kostur – CppCon 2022
10 Years of Meeting C++ – Historical Highlights and the Future of C++ – Jens Weller – CppCon 2022
The Hidden Performance Price of C++ Virtual Functions – Ivica Bogosavljevic – CppCon 2022
Managing External API’s in Enterprise systems – Pete Muldoon – CppCon 2022
A Lock-Free Atomic Shared Pointer in Modern Cpp – Timur Doumler – CppCon 2022
MDSPAN – A Deep Dive Spanning C++, Kokkos & SYCL – Nevin Liber – CppCon 2022
Embracing Trailing Return Types and `auto` Return SAFELY in Modern C++ – Pablo Halpern – CppCon 2022
An Introduction to Multithreading in C++20 – Anthony Williams – CppCon 2022
C++ Coding with Neovim – Prateek Raman – CppCon 2022
Scalable and Low Latency Lock-free Data Structures in C++ – Alexander Krizhanovsky – CppCon
Back to Basics: C++ API Design – Jason Turner – CppCon 2022
Case For a Standardized Package Description Format for External C++ Libraries – Luis Caro Campos
Graph Algorithms and Data Structures in C++20 – Phil Ratzloff & Andrew Lumsdaine – CppCon 2022
Using Modern C++ to Eliminate Virtual Functions – Jonathan Gopel – CppCon 2022
Back to Basics: C++ Smart Pointers – David Olsen – CppCon 2022
C++ for Enterprise Applications – Vincent Lextrait – CppCon 2022
C++ Function Multiversioning in Windows – Joe Bialek and Pranav Kant – CppCon 2022
Purging Undefined Behavior & Intel Assumptions in a Legacy C++ Codebase – Roth Michaels CppCon 2022
WebAssembly: Taking Your C++ and Going Places – Nipun Jindal & Pranay Kumar – CppCon 22
Refresher on Containers, Algorithms and Performance in C++ – Vladimir Vishnevskii – CppCon 2022
C++ MythBusters – Victor Ciura – CppCon 2022
Back to Basics: C++ Testing – Amir Kirsh – CppCon 2022
Undefined Behavior in the STL – Sandor Dargo – CppCon 2022
Understanding C++ Coroutines by Example: Generators (Part 2 of 2) – Pavel Novikov – CppCon 2022
Understanding C++ Coroutines by Example: Generators (Part 1 of 2) – Pavel Novikov – CppCon 2022
Taking Static Type-Safety to the Next Level – Physical Units for Matrices – Daniel Withopf CppCon 22
The Hidden Performance Price of C++ Virtual Functions – Ivica Bogosavljevic – CppCon 2022
High Speed Query Execution with Accelerators and C++ – Alex Dathskovsky – CppCon 2022
Aliasing in C++ – Risks, Opportunities and Techniques – Roi Barkan – CppCon 2022
Take Advantage of All the MIPS – SYCL & C++ – Wong, Delaney, Keryell, Liber, Chlanda – CppCon 2022
Using std::chrono Calendar Dates for Finance in Cpp – Daniel Hanson – CppCon 2022
Bringing a Mobile C++ Codebase to the Web – Li Feng – CppCon 2022
How C++23 Changes the Way We Write Code – Timur Doumler – CppCon 2022
A Tour of C++ Recognised User Type Categories – Nina Ranns – CppCon 2022
Structured Networking in C++ – Dietmar Kühl – CppCon 2022
Binary Object Serialization with Data Structure Traversal & Reconstruction in Cpp – Chris Ryan
Parallelism Safety-Critical Guidelines for C++ – Michael Wong, Andreas Weis, Ilya Burylov – CppCon22
C++ Algorithmic Complexity, Data Locality, Parallelism, Compiler Optimizations, & Some Concurrency
Breaking Dependencies – The Visitor Design Pattern in Cpp – Klaus Iglberger – CppCon 2022
Quantifying Dinosaur Pee – Expressing Probabilities as Floating-Point Values in C++ – John Lakos
Rules for Radical Cpp Engineers – Improve Your C++ Code, Team, & Organization – David Sankel
Val: A Safe Language to Interoperate with C++ – Dimitri Racordon – CppCon 2022
Implementing Understandable World Class Hash Tables in C++ – Eduardo Madrid & Scott Bruce – CppCon 2022
Cute C++ Tricks, Part 2.5 of N – Code You Should Learn From & Never Write – Daisy Hollman – CppCon22
New in Visual Studio 2022 – Conformance, Performance, Important Features – Marian Luparu & Sy Brand
Back to Basics: Declarations in C++ – Ben Saks – CppCon 2022
![C++20’s [[likely]] Attribute - Optimizations, Pessimizations, and [[unlikely]] Consequences - CppCon](https://cppcon.programmingarchive.com/wp-content/uploads/2023/09/rjpk3hkcouamaxresdefault-768x432.jpg)
C++20’s [[likely]] Attribute – Optimizations, Pessimizations, and [[unlikely]] Consequences – CppCon
Linux Debuginfo Formats – DWARF, ELF, dwo, dwp – What are They All? – Greg Law – CppCon 2022
C++ Class Template Argument Deduction – History, Uses, & Enabling it for Classes – Marshall Clow
Using C++14 in an Embedded “SuperLoop” Firmware – Erik Rainey – CppCon 2022
GitHub Features Every C++ Developer Should Know – Michael Price – CppCon 2022
Nobody Can Program Correctly – Lessons From 20 Years of Debugging C++ Code – Sebastian Theophil
Reflection in C++ – Past, Present, and Hopeful Future – Andrei Alexandrescu – CppCon 2022
Back to Basics – Name Lookup and Overload Resolution in C++ – Mateusz Pusz – CppCon 2022
Cross-Building Strategies in the Age of C++ Package Managers – Luis Caro Campos – CppCon 2022
Smarter Cpp Atomic Smart Pointers – Efficient Concurrent Memory Management – Daniel Anderson CppCon
The Observer Design Pattern in Cpp – Mike Shah – CppCon 2022
How to Use C++ Dependency Injection to Write Maintainable Software – Francesco Zoffoli CppCon 2022
The Surprising Complexity of Formatting Ranges in Cpp – Barry Revzin – CppCon 2022
Reproducible Developer Environments in C++ – Michael Price – CppCon 2022
Simulating Low-Level Hardware Devices in Cpp – Ben Saks – CppCon 2022
Back to Basics: The C++ Core Guidelines – Rainer Grimm – CppCon 2022
Pragmatic Simplicity – Actionable Guidelines To Tame Cpp Complexity – Vittorio Romeo – CppCon 2022
Architecting Multithreaded Robotics Applications in C++ – Arian Ajdari – CppCon 2022
tipi.build A New C++ Package Manager – Damien Buhl – CppCon 2022
Personal Log – Where No Init Has Gone Before in C++ – Andrei Zissu – CppCon 2022
Using Modern C++ to Revive an Old Design – Jody Hagins – CppCon 2022
Overcoming C++ Embedded Development Tooling Challenges – Marc Goodner – CppCon 2022
New in Visual Studio Code! Clang-Tidy, makefile, CMake, GitHub, & More Marian Luparu, Sinem Akinci
Fast C++ by using SIMD Types with Generic Lambdas and Filters – Andrew Drakeford – CppCon 2022
Observability Tools C++: Beyond GDB and printf – Tools to Understand the Behavior of Your Program
Reviewing Beginners’ C++ Code – Patrice Roy – CppCon 2022
“It’s A Bug Hunt” – Armor Plate Your Unit Tests in Cpp – Dave Steffen – CppCon 2022
Back to Basics: Object-Oriented Programming in C++ – Amir Kirsh – CppCon 2022
Generating Parsers in C++ with Maphoon (& Tokenizers) – Part 2 of 2 – Hans de Nivelle – CppCon 2022
Generating Parsers in C++ with Maphoon – Part 1 of 2 – Hans de Nivelle – CppCon 2022
C++ Coroutines, from Scratch – Phil Nash – CppCon 2022
Sockets – Applying the Unix Readiness Model When Composing Concurrent Operations in C++ CppCon 2022
Compilation Speedup Using C++ Modules: A Case Study – Chuanqi Xu – CppCon 2022
![The Imperatives Must Go! [Functional Programming in Modern C++] - Victor Ciura - CppCon 2022](https://cppcon.programmingarchive.com/wp-content/uploads/2023/10/m5huoz4sgjemaxresdefault-768x432.jpg)
The Imperatives Must Go! [Functional Programming in Modern C++] – Victor Ciura – CppCon 2022
What’s New in C++23 – Sy Brand – CppCon 2022
C++20’s Coroutines for Beginners – Andreas Fertig – CppCon 2022
Principia Mathematica – The Foundations of Arithmetic in C++ – Lisa Lippincott – CppCon 2022
C++ in Constrained Environments – Bjarne Stroustrup – CppCon 2022
A Crash Course in Calendars, Dates, Time, and Time Zones – Marc Gregoire – CppCon 2021
Implementing C++ Modules: Lessons Learned, Lessons Abandoned – Cameron DaCamara & Gabriel Dos Reis
Warning: std::find() is Broken! – Sean Parent – CppCon 2021
Dynamically Loaded Libraries Outside the Standard – Zhihao Yuan – CppCon 2021
Back to Basics: Algorithmic Complexity – Amir Kirsh & Adam Segoli Schubert – CppCon 2021
C++23 Standard Library Preview – Jeff Garland – CppCon 2021
Combining Co-Routines and Functions into a Job System – Helmut Hlavacs – CppCon 2021
Building an Extensible Type Serialization System Using Partial Template Specialization – CppCon 2021
Data Orientation For The Win! – Eduardo Madrid – CppCon 2021
Why You Should Write Code That You Should Never Write – Daisy Hollman – CppCon 2021
Evolving a Nice Trick – Patrice Roy – CppCon 2021
The Unit Tests Strike Back: Testing the Hard Parts – Dave Steffen – CppCon 2021
Units Libraries and Autonomous Vehicles: Lessons from the Trenches – Chip Hogg – CppCon 2021
How Can Package Managers Handle ABI (In)compatibility in C++? – Todd Gamblin – CppCon 2021
Zen and the Art of Code Lifecycle Maintenance – Phil Nash – CppCon 2021
Finding Bugs Using Path-Sensitive Static Analysis – Gabor Horvath – CppCon 2021
Up to Code – David Sankel – CppCon 2021
Using Clang LibASTMatchers for Compliance in Codebases – Jonah Jolley – CppCon 2021
Back to Basics: Smart Pointers and RAII – Inbal Levi – CppCon 2021
Embracing `noexcept` Operators and Specifiers Safely – John Lakos – CppCon 2021
Code Size Compiler Optimizations and Techniques for Embedded Systems – Aditya Kumar – CppCon 2021
Debugging Assembly Language and GPU Kernels in Visual Studio Code – Julia Reid – CppCon 2021
Custom Views for the Rest of Us – Jacob Rice – CppCon 2021
C++20’s ＜chrono＞ Calendars and Time Zones in MSVC – Miya Natsuhara – CppCon 2021
“unit”_test: Implementing a Macro-free Unit Testing Framework from Scratch in C++20 – Kris Jusiak
Back To Basics: Debugging Techniques – Bob Steagall – CppCon 2021
Embracing (and also Destroying) Variant Types Safely – Andrei Alexandrescu – CppCon 2021
What Classes We Design and How – Peter Sommerlad – CppCon 2021
Cool New Stuff in Gdb 9 and Gdb 10 – Greg Law – CppCon 2021
Software Engineering Is About Tradeoffs – Mateusz Pusz – CppCon 2021
Multi Threading Model in Paradox Games: Past, Present and Future – Mathieu Ropert – CppCon 2021
Breaking Dependencies: Type Erasure – A Design Analysis – Klaus Iglberger – CppCon 2021
A Case-study in Rewriting a Legacy GUI Library for Real-time Audio Software in Modern C++
Hazard Pointer Synchronous Reclamation Beyond Concurrency TS2 – Maged Michael – CppCon 2021
Deducing this Patterns – Ben Deane – CppCon 2021
Back to Basics: Casting – Brian Ruth – CppCon 2021
C++20 ❤ SQL – John Bandela – CppCon 2021
Generic Graph Libraries in C++20 – Andrew Lumsdaine & Phil Ratzloff – CppCon 2021
Back to Basics: Classic STL – Bob Steagall – CppCon 2021
The Factory Pattern – Mike Shah – CppCon 2021
Design Idioms from an Alternate Universe – Ivan Čukić – CppCon 2021
The Basics of Profiling – Mathieu Ropert – CppCon 2021
Sums, Products, Exponents, Monoids, Functors, Oh My! – Steve Downey – CppCon 2021
Testing Compile-time Constructs in a Runtime Unit Testing Framework – Igor Bogoslavskyi – CppCon 21
++namedtuple – Python-style Named Tuples in C++20 – Kris Jusiak – CppCon 2021
Interactive C++ for Data Science – Vassil Vassilev – CppCon 2021
Back To Basics: The Special Member Functions – Klaus Iglberger – CppCon 2021
PGAS in C++: A Portable Abstraction for Distributed Data Structures – Benjamin Brock – CppCon 2021
Deploying the Networking TS – Robert Leahy – CppCon 2021
Making the Most Out of Your Compiler – Danila Kutenin – CppCon 2021
Static Analysis and Program Safety in C++: Making it Real – Sunny Chatterjee – CppCon 2021
Composable C++: Principles and Patterns – Ben Deane – CppCon 2021
Bringing Existing Code to CUDA Using constexpr and std::pmr – Bowie Owens – CppCon 2021
The Preprocessor: Everything You Need to Know and More! – Brian Ruth – CppCon 2021
C++ to the RISCue! A Practical Guide for Embedded C++20 – Kris Jusiak – CppCon 2021
Back to Basics: Templates (part 2 of 2) – Bob Steagall – CppCon 2021
Back to Basics: Templates (part 1 of 2) – Bob Steagall – CppCon 2021
Faster, Easier, Simpler Vectors – David Stone – CppCon 2021
Embracing User Defined Literals Safely for Types that Behave as though Built-in – Pablo Halpern
Beyond struct: Meta-programming a struct Replacement in C++20 – John Bandela – CppCon 2021
Design Patterns: Facts and Misconceptions – Klaus Iglberger – CppCon 2021
C++ Standards Committee – Fireside Chat Panel – CppCon 2021
Back to Basics: Concurrency – Mike Shah – CppCon 2021
Implementing static_vector: How Hard Could it Be? – David Stone – CppCon 2021
Practical Advice for Maintaining and Migrating Working Code – Brian Ruth – CppCon 2021
Compile-Time Compression and Resource Generation with C++20 – Ashley Roll – CppCon 2021
Back to Basics: Pointers – Mike Shah – CppCon 2021
Configuration, Extension, Maintainability – Titus Winters – CppCon
Failing Successfully: Reporting and Handling Errors – Robert Leahy – CppCon 2021
Back to Basics: Designing Classes (part 2 of 2) – Klaus Iglberger – CppCon 2021
Back to Basics: Designing Classes (part 1 of 2) – Klaus Iglberger – CppCon 2021
C++11/14 at Scale: What Have We Learned? – Vittorio Romeo – CppCon 2021
Automatically Process Your Operations in Bulk With Coroutines – Francesco Zoffoli – CppCon 2021
Just Enough Assembly for Compiler Explorer – Anders Schau Knatten – CppCon 2021
Discovering a User-Facing Concept – Christopher Di Bella – CppCon 2021
Evolving an Actor Library Based on Lessons Learned from Large-Scale Deployments – Benjamin Hindman
Understanding and Mastering C++’s Complexity – Amir Kirsh – CppCon 2021
Law of Demeter: A Practical Guide to Loose Coupling – Kris Jusiak – CppCon 2021
Your New Mental Model of constexpr – Jason Turner – CppCon 2021
Plenary: Small Inspiration – Michael Caisse – CppCon 2021
C++20 Templates: The next level: Concepts and more – Andreas Fertig – CppCon 2021
GPU Accelerated Computing on Cross-Vendor Graphics Cards with Vulkan Kompute – Alejandro Saucedo
Making Libraries Consumable for Non-C++ Developers – Aaron R Robinson – CppCon 2021
Template Metaprogramming: Practical Application – Jody Hagins – CppCon 2021
Value-oriented Design in an Object-oriented System – Juan Pedro Bolivar Puente – CppCon 2021
Down the Rabbit Hole: An Exploration of Stack Overflow Questions – Marshall Clow – CppCon 2021
Real-time Programming with the C++ Standard Library – Timur Doumler – CppCon 2021
The Roles of Symmetry And Orthogonality In Design – Charley Bay – CppCon 2021
C++20 on Xilinx FPGA with SYCL for Vitis – Ronan Keryell – CppCon 2021
Asserting Your Way to Faster Programs – Parsa Amini – CppCon 2021
Why does std::format do that? – Charlie Barto – CppCon 2021
Using Coroutines to Implement C++ Exceptions for Freestanding Environments – Eyal Zedaka – CppCon 21
Branchless Programming in C++ – Fedor Pikus – CppCon 2021
Our Adventures With REST API in C++ : Making it Easy – Damien Buhl – CppCon 2021
Conquering C++20 Ranges – Tristan Brindle – CppCon 2021
C++ Standard Parallelism – Bryce Adelstein Lelbach – CppCon 2021
Back to Basics: Compiling and Linking – Ben Saks – CppCon 2021
Handling a Family of Hardware Devices with a Single Implementation – Ben Saks – CppCon 2021
A Hash Map for Graph Processing Workloads & a Methodology for Transactional Data Structures – CppCon
Embracing PODs Safely Until They Die – Alisdair Meredith & Nina Ranns – CppCon 2021
A (Short) Tour of C++ Modules – Daniela Engert – CppCon 2021
C++20: The Small Pearls – Rainer Grimm – CppCon 2021
What’s New in Visual Studio: 64-bit IDE, C++20, WSL 2, & More – Marian Luparu & Sy Brand – CppCon 21
Design and Implementation of Highly Scalable Quantifiable Data Structures in C++ – CppCon 2021
Building a Lock-free Multi-producer, Multi-consumer Queue for Tcmalloc – Matt Kulukundis – CppCon 21
Modern CMake Modules – Bret Brown – CppCon 2021
Back to Basics: Lambdas – Nicolai Josuttis – CppCon 2021
Back to Basics: Object-Oriented Programming – Rainer Grimm – CppCon 2021
From Problem to Coroutine: Reducing I/O Latency – Cheinan Marks – CppCon 2021
cudaFlow: Modern C++ Programming Model for GPU Task Graph Parallelism – CppCon 2021
Back To Basics: Undefined Behavior – Ansel Sermersheim & Barbara Geller – CppCon 2021
Typescripten: Generating Type-safe JavaScript Bindings for emscripten – Sebastian Theophil
SIMD in C++20: EVE of a new Era – Joel Falcou & Denis Yaroshevskiy – CppCon 2021
The Foundation of C++ Atomics: The Knowledge You Need to Correctly Use C++ Atomics – Filipe Mulonde
3D Graphics for Dummies – Chris Ryan – CppCon 2021
Value in a Procedural World – Lisa Lippincott – CppCon 2021
Using C Libraries in your Modern C++ Embedded Project – Michael Caisse – CppCon 2021
In-memory and Persistent Representations of C++ – Gabriel Dos Reis – CppCon 2021
The Upcoming Concurrency TS Version 2 for Low-Latency and Lockless Synchronization – CppCon 2021
Software Architecture Lessons from Multidimensional Spaces Explorations – CppCon 2021
Spooky Action at a Distance – Victor Ciura – CppCon 2021
Documentation in the Era of Concepts and Ranges – Christopher Di Bella & Sy Brand – CppCon 2021
Misra Parallelism Safety-critical Guidelines for C++11, 17, Then C++20, 23 – CppCon 2021
Back to Basics: const and constexpr – Rainer Grimm – CppCon 2021
Visualize Time Enabled Data using ArcGIS Qt (C++) and Toolkit – Gela Malek Pour – CppCon 2021
Extending and Simplifying C++: Thoughts on Pattern Matching using `is` and `as` – Herb Sutter
Back To Basics: Overload Resolution – CppCon 2021
Code Analysis++ – Anastasia Kazakova – CppCon 2021
Differentiable Programming in C++ – Vassil Vassilev & William Moses – CppCon 2021
Back to Basics: Move Semantics – Nicolai Josuttis – CppCon 2021
Lessons Learned from Packaging 10,000+ C++ Projects – Bret Brown & Daniel Ruoso – CppCon 2021
GraphBLAS: Building a C++ Matrix API for Graph Algorithms – Benjamin Brock & Scott McMillan
“Constexpr Everything” – The Standard Library, Microkernel, Apps, and Unit Tests – Rian Quinn
Type-and-resource Safety in Modern C++ – Bjarne Stroustrup – CppCon 2021
Exceptional C++ – Victor Ciura – CppCon 2021
Concurrency Patterns – Rainer Grimm – CppCon 2021
Heterogeneous Modern C++ with SYCL 2020 – Michael Wong, Nevin Liber, Tom Deakin & Gordon Brown
C++20: Reaching for the Aims of C++ – Bjarne Stroustrup – CppCon 2021
Plenary: Six Impossible Things – Kevlin Henney – CppCon 2021
Working with Asynchrony Generically: A Tour of C++ Executors (part 2/2) – Eric Niebler – CppCon 21
Working with Asynchrony Generically: A Tour of C++ Executors (part 1/2) – Eric Niebler – CppCon 21