CppCon Video Archive
All CppCon 2026 Attendees Will Get Early Access To All Main Conference Sessions and Lightning Talks!
Filter
Your selections:
Profiles for Simplicity and Guarantees – Bjarne Stroustrup – CppCon 2026
Clean code! Horrible Performance? – Sandor Dargo – CppCon 2025
From C+ to C++: Modernizing a GameBoy Emulator – Tom Tesch – CppCon 2025
CTRACK: C++ Performance Tracking and Bottleneck Discovery – Grischa Hauser – CppCon 2025
Persistence Squared: Persisting Persistent Data Structures – Juan Pedro Bolivar Puente – CppCon 2025
Beyond the Big Green Button: Demystifying the Embedded Build Process – Morten Winkler Jørgensen – CppCon 2025
groov: Asynchronous Handling of Special Function Registers – Michael Caisse – CppCon 2025
Rust/C++ Interop Challenges – Victor Ciura – CppCon 2025
Constexpr STL Containers: Challenges and a Limitless Allocator Implementation – Sergey Dobychin – CppCon 2025
Graphics Programming with SDL 3 – Mike Shah – CppCon 2025
Work Contracts in Action: Advancing High-performance, Low-latency Concurrency – Michael Maniscalco
Dynamic Asynchronous Tasking with Dependencies – Tsung-Wei (TW) Huang – CppCon 2025
Interesting Upcoming Low-Latency, Concurrency, and Parallelism Features from Wroclaw 2024, Hagenberg 2025, and Sofia 2025 – Paul E. McKenney, Maged Michael, Michael Wong – CppCon 2025
Beyond Sequential Consistency – Christopher Fretz – CppCon 2025
Type Traits without Compiler Intrinsics – The Promise of Static Reflection – Andrei Zissu – CppCon 2025
The Wonderful World of Designing a USB Stack Using Modern C++ – Madeline Schneider – CppCon 2025
Back to Basics: Move Semantics – Ben Saks – CppCon 2025
Panel: What We Learned About AI Tools For C++ Engineers – Hosted by Guy Davidson – CppCon 2025
ISO C++ Standards Committee Panel Discussion 2025 – Hosted by Herb Sutter – CppCon 2025
Practical Reflection – Barry Revzin – CppCon 2025
Duck Typing, the C++ Way: How Type Erasure Bends the Rules – Sarthak Sehgal – CppCon 2025
Sanitize It Before You Ship It: Catching Hidden Concurrency Bugs in C++ – Vishnu G Nath
Back to the Standard: From CUDA and Pragmas to GPU-Accelerated Parallel C++ – Elmar Westphal – CppCon 2025
Modern C++ for Embedded Systems: From Fundamentals to Real-Time Solutions – Rutvij Girish Karkhanis
The Pattern Matching We Already Have – Braden Ganetsky – CppCon 2025
End-to-End Latency Metrics From Distributed Trace – Kusha Maharshi – CppCon 2025
C++26 Reflection for JSON Serialization – A Practical Journey – Daniel Lemire & Francisco Geiman Thiesen – CppCon 2025
Building a Career Off-Road – Sherry Sontag – CppCon 2025
Wait is it POSIX? Investigating Different OS and Library Implementations for Networking – Katherine Rocha – CppCon 2025
From Pure ISO C++20 To Compute Shaders – Koen Samyn – CppCon 2025
Knockin’ on Header’s Door: An Overview of C++ Modules – Alexsandro Thomas – CppCon 2025
Seamless Static Analysis with Cppcheck: From IDE to CI and Code Review – Daniel Marjamäki – CppCon 2025
It’s Dangerous to Go Alone: A Game Developer Tutorial – Michael Price – CppCon 2025
Leverage AI Agents to Refactor and Modernize Code – Jubin Chheda – CppCon 2025
Cache Me Maybe – Optimize Your Code By Utilizing Your Cache – Michelle D’Souza – CppCon 2025
Back to Basics: Concepts – Jeff Garland – CppCon 2025
C++ ♥ Python – Alex Dathskovsky – CppCon 2025
Agentic Debugging Live! – Without a Safety Net – Daisy Hollman & Mark Williamson – CppCon 2025
Threads vs Coroutines: Understanding the Concurrency Models of C++ – Conor Spilsbury – CppCon 2025
Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption – Damien Buhl – CppCon 2025
Achieving Peak Performance for Matrix Multiplication – Aliaksei Sala – CppCon 2025
C++ Parallel Programming Models – Eran Gilad – CppCon 2025
First Principles While Designing C++ Applications – Prabhu Missier – CppCon 2025
Shadow Stack: Forget Memory Corruptions, Ultimate C and C++ Safety – Bartosz Moczulski – CppCon 2025
Best Practices for AI Tool Use – Jason Turner – CppCon 2025
Back to Basics: Common C++ Code Review Feedback – Chandranath Bhattacharyya & Kathleen Baker – CppCon 2025
MSVC C++ Dynamic Debugging: How We Enabled Full Debuggability of Optimized Code – Eric Brumer – CppCon 2025
Back to Basics: Custom Allocators – Kevin Carpenter – CppCon 2025
Back To Basics: C++ Strings and Character Sequences – Nicolai Josuttis – CppCon 2025
std::execution in Asio Codebases: Adopting Senders Without a Rewrite – Robert Leahy – CppCon 2025
A Case-study in Rewriting a Legacy Gui Library for Real-time Audio Software in Modern C++ (Reprise) – Roth Michaels – CppCon 2025
Back to Basics: static, inline, const, and constexpr – Andreas Fertig – CppCon 2025
Parallel Range Algorithms: The Evolution of Parallelism in C++ – Ruslan Arutyunyan – CppCon 2025
How to Avoid Headaches with Simple CMake – Bret Brown – CppCon 2025
An Introduction to the new C++ 26 “Reflection” Feature – Inbal Levi – CppCon 2025
Zero-Overhead Abstractions: Building Flexible Vector Math Libraries with C++20 Concepts and Customization Points – Greg von Winckel – CppCon 2025
The Programmer CEO – Greg Law – CppCon 2025
Compiler Explorer: The Features You Never Knew Existed – Matt Godbolt – CppCon 2025
Connecting C++ Tools to AI Agents Using the Model Context Protocol (MCP) – Ben McMorran – CppCon 2025
Networks in C++ – Ignas Bagdonas – CppCon 2025
Mastering the Code Review Process – Pete Muldoon – CppCon 2025
Cross-Platform Package Management for Modern C++ Development with Pixi – Ruben Arts – CppCon 2025
Using Floating-point in C++: What Works, What Breaks, and Why – Egor Suvorov – CppCon 2025
To Err is Human: Robust Error Handling in C++26 – Sebastian Theophil – CppCon 2025
C++ Performance Tips: Cutting Down on Unnecessary Objects – Prithvi Okade & Kathleen Baker – CppCon 2025
Engineering the Software, from DevEx to Delivery – Malin Stanescu – CppCon 2025
Modern CMake: Past, Present, and Future – Bill Hoffman – CppCon 2025
LLMs in the Trenches: Boosting System Programming with AI – Ion Todirel – CppCon 2025
Lazy and Fast: Ranges Meet Parallelism in C++ – Daniel Anderson – CppCon 2025
C++26 – What’s In It For You? – Marc Gregoire – CppCon 2025
Making C++ Safe, Healthy, and Efficient – John Lakos – CppCon 2025
Back to Basics: Ranges – Mike Shah – CppCon 2025
How to Tame Packs, std::tuple, and the Wily std::integer_sequence – Andrei Alexandrescu – CppCon 2025
API Structure and Technique: Learnings from Code Review – Ben Deane – CppCon 2025
15 Years Doing C++ Standardization Work: A Personal Retrospective – Nevin Liber – CppCon 2025
Cache-Friendly C++ – Jonathan Müller – CppCon 2025
Engineers Are Users Too: A Case Study in Design Thinking for Infrastructure – Grace Alwan – CppCon 2025
Rust Trait Runtime Polymorphism in C++ – Eduardo Madrid – CppCon 2025
Debugging C++ Coroutines in GDB – Zartaj Majeed – CppCon 2025
Building a High-Performance Binary Serialization Format with In-Place Modification – Hamish Morrison – CppCon 2025
What’s New in Visual Studio for C++ Developers in 2025 – Augustin Popa & David Li – CppCon 2025
What’s New for C++ in VS Code: CMake Improvements and GitHub Copilot Agents – Alexandra Kemper – CppCon 2025
Modern C++ for Robust Bundle Adjustment: From Outliers to Optimization – Vishnu Sudheer Menon – CppCon 2025
Implementing Your Own Atomics – Ben Saks – CppCon 2025
Inherently Unsafe: Practical Approaches for Writing Safer C++ – Assaf Tzur-El – CppCon 2025
Creating a Declarative UI Library in C++ – Richard Powell – CppCon 2025
The Missing Step: Making Data Oriented Design One Million Times Faster – Andrew Drakeford – CppCon 2025
Declarative Refactoring for the Masses – Andy Soffer – CppCon 2025
Building Secure C++ Applications: A Practical End-to-End Approach – Chandranath Bhattacharyya & Bharat Kumar – CppCon 2025
Where’d All that RAM Go? Measuring Objects With Ownership-Aware Memory Profiling in C++ – Alecto Irene Perez – CppCon 2025
Challenges and Benefits of Upgrading Sea of Thieves From C++14 to C++20 – Keith Stockdale – CppCon 2025
Back to Basics: Friendship – Mateusz Pusz – CppCon 2025
Performance Optimization for Automatic Differentiation in C++ – Steve Bronder – CppCon 2025
Building Robust Inter-Process Queues in C++ – Jody Hagins – CppCon 2025
Performance Is Not a Number: Avoiding Microbenchmarking Pitfalls – Kris Jusiak – CppCon 2025
Performance of std::expected With Monadic Operations – Vitaly Fanaskov – CppCon 2025
How to Affect the Future of C++ Standard in 60 Minutes – River Wu – CppCon 2025
Back to Basics: Refactoring – Amir Kirsh – CppCon 2025
Catching Bugs Early: Validating C++ Contracts with Static Analysis – Peter Martin & Mike Fairhurst
The Joy of C++26 Contracts (and Some Myth-Conceptions) – Herb Sutter – CppCon 2025
Cutting C++ Exception Time by +90% – Khalil Estell – CppCon 2025
Enhancing Exception Handling and Debugging Using C++23 std::stacktrace – Erez Strauss – CppCon 2025
Implement Standard Library: Design Decisions, Optimisations and Testing in Implementing Libc++ – Hui Xie – CppCon 2025
Could We Handle an ABI Break Today? – Luis Caro Campos – CppCon 2025
std::optional＜T&＞ — Optional Over References – Steve Downey – CppCon 2025
C++: Some Assembly Required – Matt Godbolt – CppCon 2025
More Speed & Simplicity: Practical Data-Oriented Design in C++ – Vittorio Romeo – CppCon 2025
Reflection: C++’s Decade-Defining Rocket Engine – Herb Sutter – CppCon 2025
Crafting the Code You Don’t Write: Sculpting Software in an AI World – Daisy Hollman – CppCon 2025
Concept-based Generic Programming – Bjarne Stroustrup – CppCon 2025
Leveraging C++ for Efficient Motion Planning: RRT Algorithm for Robotic Arms – Aditi Pawaskar – CppCon 2024
To Int or to Uint, This is the Question – Alex Dathskovsky – CppCon 2024
Guide to Linear Algebra With the Eigen C++ Library – Daniel Hanson – CppCon 2024
Security Beyond Memory Safety – Using Modern C++ to Avoid Vulnerabilities by Design – Max Hoffmann
Code Generation from Unified Robot Description Format (URDF) for Accelerated Robotics – Paul Gesel
Cost of C++ Abstractions in C++ Embedded Systems – Marcell Juhasz – CppCon 2024
Perspectives on Contracts for C++ – Lisa Lippincott – CppCon 2024
How to Hide C++ Implementation Details – Amir Kirsh – CppCon 2024
How to Quickly Convert Floating-Point Numbers in C++ – Cassio Neri – CppCon 2024
Implementing C++ Reflection Using the New C++20 Tooling Opportunity: Modules – Maiko Steeman – CppCon 2024
Boosting Software Efficiency in C++: A Case Study of 100% Performance Improvement in an Embedded C++ System – Gili Kamma – CppCon 2024
Newer Isn’t Always Better: Investigating C++ Legacy Design Trends and Their Modern Replacements – Katherine Rocha – CppCon 2024
Modern C++ Development – Limitations and Problems in std::function and Similar Constructs: Mitigations and Alternatives – Amandeep Chawla – CppCon 2024
Back to Basics: Rvalues and Move Semantics in C++ – Amir Kirsh – CppCon 2024
Template-less Metaprogramming in C++ – Kris Jusiak – CppCon 2024
C++ Sender Patterns to Wrangle C++ Concurrency in Embedded Devices – Michael Caisse – CppCon 2024
Monadic Operations in Modern C++: A Practical Approach – Vitaly Fanaskov – CppCon 2024
Back to Basics: Lifetime Management in Cpp – Phil Nash – CppCon 2024
spanny 2: Rise of C++ std::mdspan – Griswald Brooks – CppCon 2024
Why Is My C++ Build So Slow? Compilation Profiling and Visualization – Samuel Privett – CppCon 2024
Deciphering C++ Coroutines Part 2 – Mastering Asynchronous Control Flow – Andreas Weis – CppCon 2024
Lightweight Operator Fusion Using Data-Centric Function Interfaces in C++ – Manya Bansal – CppCon
Adventures with C++ Legacy Codebases: Tales of Incremental Improvement – Roth Michaels – CppCon 2024
Modern C++ Error Handling – Phil Nash – CppCon 2024
Moved-from Objects in C++ – Jon Kalb – CppCon 2024
C++ Data Structures That Make Video Games Go Round – Al-Afiq Yeong – CppCon 2024
Cross-Platform Floating-Point Determinism Out of the Box – Sherry Ignatchenko – CppCon 2024
C++/Rust Interop: A Practical Guide to Bridging the Gap Between C++ and Rust – Tyler Weaver – CppCon
Back to Basics: Object-Oriented Programming in C++ – Andreas Fertig – CppCon 2024
Ranges++: Are Output Range Adaptors the Next Iteration of C++ Ranges? – Daisy Hollman – CppCon 2024
Session Types in C++ – A Programmer’s Journey – Miodrag Misha Djukic – CppCon 2024
Numerical Integrators From Scratch in C++ – Vincent Reverdy – CppCon 2024
Recent Concurrency and Parallelism Proposals to the C++ Standard Committee – Paul E. McKenney, Maged Michael & Michael Wong – CppCon 2024
import CMake; // Mastering C++ Modules – Bill Hoffman – CppCon 2024
Rollback System in C++ for Online Multiplayer Games – Elias Farhan – CppCon 2024
Bridging the Gap: Writing Portable C++ Programs for CPU and GPU – Thomas Mejstrik – CppCon 2024
Beyond Compilation Databases to Support C++ Modules: Build Databases – Ben Boeckel – CppCon 2024
Performance Optimization in Software Development – Being Friendly to Your Hardware – Ignas Bagdonas
Implementing Particle Filters with C++ Ranges – Nahuel Espinosa – CppCon 2024
Blazing Trails: Building the World’s Fastest GameBoy Emulator in Modern C++ – Tom Tesch – CppCon 2024
C++ 20 Innovations: High-Performance Cross-Platform Architecture in C++ – Noah Stein – CppCon 2024
SuperCharge Your Intra-Process Communication Programs With C++20 and Contract-Concept-Implementation Pattern – Arian Ajdari – CppCon 2024
Making Hard C++ Tests Easy: A Case Study From the Motion Planning Domain – Chip Hogg – CppCon 2024
Build Safer Modern C++ Application: Mix Assertion, Logging, Unit Testing and Fuzzing with ZeroErr – Xiaofan Sun – CppCon 2024
Building Safe and Reliable Surgical Robotics with C++ – Milad Khaledyan – CppCon 2024
C++ Under the Hood: Internal Class Mechanisms – Chris Ryan – CppCon 2024
Refactoring C++ Code for Unit testing with Dependency Injection – Peter Muldoon – CppCon 2024
How to Design a Slimmer Vector of Variants in C++ – Christopher Fretz – CppCon 2024
Back to Basics: Functional Programming and Monads in C++ – Jonathan Müller – CppCon 2024
Secrets of C++ Scripting Bindings: Bridging Compile Time and Run Time – Jason Turner – CppCon 2024
How to Improve the Safety of C++ Code With a Quantities & Units Library – Mateusz Pusz – CppCon 2024
The Beman Project: Bringing C++ Standard Libraries to the Next Level – David Sankel – CppCon 2024
Cpp Contracts – How Contracts in C++26 Can Improve C++ Code Safety and Correctness – Timur Doumler
Associative Iteration – Composing Ancient Mathematical Knowledge Into Powerful Bit-fiddling Techniques – Jamie Pond – CppCon 2024
How to Use string_view in C++ – Basics, Benefits, and Best Practices – Jasmine Lopez & Prithvi Okade – CppCon 2024
Using Modern C++ to Build XOffsetDatastructure: A Zero-Encoding and Zero-Decoding High-Performance Serialization Library in the Game Industry – Fanchen Su – CppCon 2024
Designing C++ Code Generator Guardrails: A Collaboration Among Outreach and Development Teams and Users – CB Bailey & Sherry Sontag – CppCon 2024
Vectorizing a Computational Fluid Dynamics (CFD) Code in C++ Using std::simd – Olaf Krzikalla – CppCon 2024
Application of C++ in Computational Cancer Modeling – Ruibo Zhang – CppCon 2024
How to Use the Sender/Receiver Framework in C++ to Create a Simple HTTP Server – Dietmar Kühl – CppCon 2024
Work Contracts – Rethinking Task Based Concurrency and Parallelism for Low Latency C++ – Michael A Maniscalco – CppCon 2024
Async Stacks: Making Senders and Coroutines Debuggable – Ian Petersen & Jessica Wong – CppCon 2024
C++ Safety And Security Panel 2024 – Hosted by Michael Wong – CppCon 2024
C++ Design Patterns – The Most Common Misconceptions (2 of N) – Klaus Iglberger – CppCon 2024
Techniques to Optimise Multithreaded Data Building During C++ Game Development – Dominik Grabiec – CppCon 2024
The Most Important C++ Design Guideline is Testability – Jody Hagins – CppCon 2024
LLVM’s Realtime Safety Revolution: Tools for Modern Mission Critical Systems – Christopher Apple & David Trevelyan – CppCon 2024
C++ Game Development – Many Ways to Kill an Orc (or a Hero) – Patrice Roy – CppCon 2024
What’s New in Visual Studio for C++ Developers – Michael Price & Mryam Girmay – CppCon 2024
What’s New for Visual Studio Code: Performance, GitHub Copilot, and CMake Enhancements – Sinem Akinci & Alexandra Kemper – CppCon 2024
10 Problems Large Companies Have Managing C++ Dependencies and How to Solve Them – Augustin Popa
Fast and Small C++ – When Efficiency Matters – Andreas Fertig – CppCon 2024
Taming C++ Filter View in C++ Programming – Nicolai Josuttis – CppCon 2024
Introduction to Wait-free Algorithms in C++ Programming – Daniel Anderson – CppCon 2024
C++ Reflection Is Not Contemplation – Andrei Alexandrescu – CppCon 2024
Reusable Code, Reusable Data Structures – Sebastian Theophil – CppCon 2024
Back to Basics: Concepts in C++ – Nicolai Josuttis – CppCon 2024
User API & C++ Implementation of a Multi Producer, Multi Consumer, Lock Free, Atomic Queue – Erez Strauss – CppCon 2024
C++ Shared Libraries and Where To Find Them – Luis Caro Campos – CppCon 2024
Leveraging C++20/23 Features for Low Level Interactions – Jeffrey Erickson – CppCon 2024
So You Think You Can Hash – Victor Ciura – CppCon 2024
Common Package Specification (CPS) in Practice: A Full Round Trip Implementation in Conan C++ Package Manager – Diego Rodriguez-Losada Gonzalez – CppCon 2024
C++ RVO: Return Value Optimization for Performance in Bloomberg C++ Codebases – Michelle Fae D’Souza
C++ Relocation: Blazing Fast Save And Restore, Then More! – Eduardo Madrid – CppCon 2024
What’s Eating my RAM? – C++ Memory Management – Jianfei Pan – CppCon 2024
Coroutines and Structured Concurrency in Practice – Dmitry Prokoptsev – CppCon 2024
Building Cppcheck – What We Learned from 17 Years of Development – Daniel Marjamäki – CppCon 2024
Back to Basics: Generic Programming – David Olsen – CppCon 2024
Compile-Time Validation – Alon Wolf – CppCon 2024
Hidden Overhead of a Function API – Oleksandr Bacherikov – CppCon 2024
Back to Basics: Debugging and Testing – Greg Law & Mike Shah – CppCon 2024
Back to Basics: Function Call Resolution – Ben Saks – CppCon 2024
C++26 Preview – The Smaller Features – Jeff Garland – CppCon 2024
Reflection Based Libraries to Look Forward to – Saksham Sharma – CppCon 2024
Message Handling with Boolean Algebra – Ben Deane – CppCon 2024
Back to Basics: Almost Always Vector – Kevin Carpenter – CppCon 2024
What Volatile Means (and Doesn’t Mean) – Ben Saks – CppCon 2024
Back to Basics: Unit Testing – Dave Steffen – CppCon 2024
Gazing Beyond Reflection for C++26 – Daveed Vandevoorde – CppCon 2024
When Nanoseconds Matter: Ultrafast Trading Systems in C++ – David Gross – CppCon 2024
Embracing an Adversarial Mindset for C++ Security – Amanda Rousseau – CppCon 2024
ISO C++ Standards Committee Panel Discussion 2024 – Hosted by Herb Sutter – CppCon 2024
C++ Exceptions for Smaller Firmware – Khalil Estell – CppCon 2024
Peering Forward — C++’s Next Decade – Herb Sutter – CppCon 2024
Back to Basics: Testing in C++ – Phil Nash – CppCon 2023
Back to Basics: Initialization in C++ – Ben Saks – CppCon 2023
Safety and Security for C++: Panel Discussion – Hosted by Michael Wong – CppCon 2023
Great C++ is_trivial: trivial type traits – Jason Turner – CppCon 2023
Building Bridges: Leveraging C++ and ROS for Simulators, Sensor Data and Algorithms – Cesar Gerardo Bravo Conejo & Divya Aggarwal – CppCon 2023
Khronos APIs for Heterogeneous Compute and Safety: SYCL and SYCL SC – CppCon 2023
Plug-in Based Software Architecture for Robotics – Abishalini Sivaraman & Anthony Baker – CppCon 2023
Iteration Revisited: A Safer Iteration Model for Cpp – Tristan Brindle – CppCon 2023
Powered by AI: A Cambrian Explosion for C++ Software Development Tools – Emery Berger – CppCon 2023
C++ Object Lifetime: From Start to Finish – Thamara Andrade – CppCon 2023
Embracing CTAD – Nina Ranns – CppCon 2023
Getting Started with C++ – Michael Price – CppCon 2023
Abstraction Patterns for Cross Platform Development Using C++ – Al-Afiq Yeong – CppCon 2023
C++ Memory Model: from C++11 to C++23 – Alex Dathskovsky – CppCon 2023
C++ in the Developing World: Why it Matters – Mathew Benson – CppCon 2023
Single Producer Single Consumer Lock-free FIFO From the Ground Up – Charles Frasch – CppCon 2023
Undefined Behavior in C++: What Every Programmer Should Know and Fear – Fedor Pikus – CppCon 2023
Concurrency TS2: Improved C++ Concurrency and Lock-free Programming – Maged Michael & Michael Wong
Symbolic Calculus for High-performance Computing From Scratch Using C++23 – Vincent Reverdy – CppCon
Back to Basics: Iterators in C++ – Nicolai Josuttis – CppCon 2023
Is std::mdspan a Zero-overhead Abstraction? – Oleksandr Bacherikov – CppCon 2023
Exploration of Strongly-typed Units in C++: A Case Study from Digital Audio – Roth Michaels – CppCon 2023
A Common Package Specification: Getting Build Tools to Talk to Each Other – Lessons Learned – CppCon 2023
Building Effective Embedded Systems in C++: Architectural Best Practices – Gili Kamma – CppCon 2023
Designing Fast and Efficient List-like Data Structures – Yannic Bonenberger – CppCon 2023
Advanced SIMD Algorithms in Pictures – Denis Yaroshevskiy – CppCon 2023
Coroutine Patterns: Problems and Solutions Using Coroutines in a Modern Codebase – Francesco Zoffoli
Monads in Modern C++ – Georgi Koyrushki & Alistair Fisher – CppCon 2023
How to Build Your First C++ Automated Refactoring Tool – Kristen Shaker – CppCon 2023
Applicative: The Forgotten C++ Functional Pattern – Ben Deane – CppCon 2023
ISO C++ Standards Committee Panel Discussion – Hosted by Herb Sutter – CppCon 2023
Better CMake: A World Tour of Build Systems – Better C++ Builds – Damien Buhl & Antonio Di Stefano
Behavioral Modeling in HW/SW Co-design Using C++ Coroutines – Jeffrey Erickson & Sebastian Schoenberg
Better Code: Exploring Validity in C++ – David Sankel – CppCon 2023
Optimizing Away C++ Virtual Functions May Be Pointless – Shachar Shemesh – CppCon 2023
Six Ways for Implementing Math Expressions Calculator in C++ – Amir Kirsh – CppCon 2023
Writing Python Bindings for C++ Libraries: Easy-to-use Performance – Saksham Sharma – CppCon 2023
Better Code: Contracts in C++ – Sean Parent & Dave Abrahams – CppCon 2023
Back to Basics: Forwarding References – How to Forward Parameters in Modern C++ – Mateusz Pusz 2023
Tips on Surveying the C++ Community – Anastasia Kazakova – CppCon 2023
Building Consensus on a Set of Rules for Our Massive C++ Codebase – Sherry Sontag – CppCon 2023
Back to Basics: The Rule of Five in C++ – Andre Kostur – CppCon 2023
An Introduction to Tracy Profiler in C++ – Marcos Slomp – CppCon 2023
C++ Regular, Revisited – Victor Ciura – CppCon 2023
The Absurdity of Error Handling: Finding a Purpose for Errors in Safety-Critical SYCL – Erik Tomusk – CppCon 2023
Robotics at Compile Time: Optimizing Robotics Algorithms With C++’s Compile-Time Features – Stephen Brawner – CppCon 2023
BehaviorTree.CPP: Task Planning for Robots and Virtual Agents – Davide Faconti – CppCon 2023
More Ranges Please – Roi Barkan – CppCon 2023
Leveraging a Functional Approach for More Testable & Maintainable ROS 2 Code – Bilal Gill – CppCon 23
Why Loops End – Lisa Lippincott – CppCon 2023
C++23: An Overview of Almost All New and Updated Features – Marc Gregoire – CppCon 2023
Evolution of a Median Algorithm – Pete Isensee – CppCon 2023
Leveraging the Power of C++ for Efficient Machine Learning on Embedded Devices – Adrian Stanciu – CppCon 2023
Can C++ Data-oriented-design be Improved? – Ollivier Roberge – CppCon 2023
Advancing cppfront with Modern C++: Refining the Implementation of is, as, and UFCS – Filip Sajdak – CppCon 2023
Back to Basics: C++ Concurrency – David Olsen – CppCon 2023
Object Introspection: A C++ Memory Profiler – Jonathan Haslam & Aditya Sarwade – CppCon 2023
Expressing Implementation Sameness and Similarity – Polymorphism in Modern C++ – Daisy Hollman
C++ Modules: Getting Started Today – Andreas Weis – CppCon 2023
std::linalg: Linear Algebra Coming to Standard C++ – Mark Hoemmen – CppCon 2023
Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better – Peter Muldoon – CppCon 2023
Things Happening in SG14… – Patrice Roy – CppCon 2023
Noexcept? Enabling Testing of Contract Checks in C++ – Pablo Halpern & Timur Doumler – CppCon 2023
Linkers, Loaders and Shared Libraries in Windows, Linux, and C++ – Ofek Shilon – CppCon 2023
C++20 Modules: The Packaging and Binary Redistribution Story – Luis Caro Campos – 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
Lock-free Atomic Shared Pointers Without a Split Reference Count? It Can Be Done! – Daniel Anderson
Back to Basics: (Range) Algorithms in C++ – Klaus Iglberger – CppCon 2023
Taro: Task Graph-Based Asynchronous Programming Using C++ Coroutine – Dian-Lun Lin – CppCon 2023
The Au C++ Units Library: Handling Physical Units Safely, Quickly, & Broadly – Chip Hogg – CppCon 23
A Fast, Compliant JSON Pull Parser for Writing Robust Applications – Jonathan Müller
File I/O for Game Developers: Past, Present, and Future with C++ – Guy Davidson – CppCon 2023
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
Effective Ranges: A Tutorial for Using C++2x Ranges – Jeff Garland – CppCon 2023
A Journey Into Non-Virtual Polymorphism in C++ – Rudyard Merriam – CppCon 2023
Cache-friendly Design in Robot Path Planning with C++ – Brian Cairl
Thinking Functionally in C++ – Brian Ruth – CppCon 2023
Back to Basics: Functions in C++ – Mike Shah – CppCon 2023
Continuous Regression Testing for Safer and Faster Refactoring in C++ – Pejman Ghorbanzade – CppCon
“Distributed Ranges”: Model for Building Distributed Data Structures, Algorithms & Views – Ben Brock
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
std::simd: How to Express Inherent Parallelism Efficiently Via Data-parallel Types – Matthias Kretz
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
Filter
Your selections:
Lightning Talk: Constraining Automated Trading Risk with Linux Signals – Max Huddleston CppCon 2023
Lightning Talk: Forbidden C++ – Ali Almutawa – CppCon 2023
Lightning Talk: Making Friends With CUDA Programmers (please constexpr all the things) Vasu Agrawal
Lightning Talk: Detecting Constant Folding to Prevent Substitution Failure – Patrick Roberts – CppCon 2023
Lightning Talk: Undefined Behavior – Toolkit to Improve Communication With Clients – Laura Kostur
Lightning Talk: Program Complexity and Thermodynamics – Vadim Alexandrov – CppCon 2023
Lightning Talk: Is Polymorphism in C++ Really That Bad? – Paul Tsouchlos – CppCon 2023
Lightning Talk: Enhancing C++ exceptions with Context – Shachar Shemesh – CppCon 2023
Lightning Talk: Writing a Better std::move – Jonathan Müller – CppCon 2023
Lightning Talk: Know Your Audience: Who’s Building Your C++ Code – Chris Thrasher – CppCon 2023
Lightning Talk: (Fine) Wine and MSVC: What Could Possibly Go Wrong? – Yannic Staudt – CppCon 2023
Lightning Talk: Let’s Fix Sparse Linear Algebra with C++. It’ll Be Fun and Easy! – Benjamin Brock
Lightning Talk: Higher-Order Template Metaprogramming with C++23 – Ed Catmur – CppCon 2023
Lightning Talk: The Responsibility of C++ – Neil Henderson – CppCon 2023
Lightning Talk: Whitespace: A Humorous Short Talk – Dan Curran – CppCon 2023
Lightning Talk: Thread Safety With synchronized_value in C++ – Jørgen Fogh – CppCon 2023
Lightning Talk: You Should Use AddressSanitizer – Brody Holden – CppCon 2023
Lightning Talk: Filling the Bucket: Reading Code, C++ Code Interviews & Exams – Amir Kirsh – CppCon
Lightning Talk: C++ and the Next Generation: How to Support Women and Families in Tech – Sara Boulé
Lightning Talk: Spanny: Abusing C++ mdspan Is Within Arm’s Reach – Griswald Brooks – CppCon 2023
Lightning Talk: Help! My Expression Template Type Names Are Too Long! – Braden Ganetsky CppCon 2023
Lightning Talk: Interfaces in C++ – Megh Parikh – CppCon 2023
Lightning Talk: Un-Undefining Undefined Behavior in C++ – Jefferson Carpenter – CppCon 2023
Lightning Talk: A Fast, Concurrent Data Loader for Time-Series Data – Glenn Philen – CppCon 2023
Lightning Talk: ClangFormat Is Not It – Anastasia Kazakova – CppCon 2023
Lightning Talk: The Power of Silence and Music in Agile Software – Valentina Ricupero – CppCon 2023
Lightning Talk: Implementing Coroutines Using C++17 – Alon Wolf – CppCon 2023
Lightning Talk: Introverts: Speak! – Rudyard Merriam – CppCon 2023