CppCon, The C++ Conference

CppCon, The C++ Conference 2025 Prabhu Missier: "First Principles While Designing C++ Applications" youtu.be/8mLo5gXwn4k C++ is widely used in critical real-time systems across various domains such as Aerospace, Automotive and Defense to name a few and these systems usually have long lifecycles with extended maintenance cycles. Serious thought must be put into designing and implementing reliable, secure and maintainable solutions. This talk focuses on the author's first-hand experience with designing and implementing critical real-time systems in C++. Getting your class design right is a key factor in building a robust performant system with a strong foundation. This talk will focus on getting your basics right regardless of which version of C++ you are using. Drawing from his experience, the speaker will discuss aspects of class design, exploring composition and inheritance, monolithic and minimal classes, abstract interfaces, non-member functions, public and private members, safe overriding, virtual and non-virtual functions, implicit conversions, PIMPL idiom, data hiding and more and how to get these right. A quick overview of widely accepted core C++ guidelines will round off the talk. The information presented will be applicable to most systems built using C++. A key takeaway for the audience will be a good understanding of critical C++ concepts needed to build a software system which is reliable, performant, extendable and maintainable. --- Prabhu Missier Prabhu Missier has built safety critical real time applications in the Avionics, Automotive Electronics, Data management and Network Security domains using C++. He has had stints at Honeywell, Siemens, Dell-EMC and IBM working in different geographies. He currently manages Software Development at BAE Systems - a leading multi-national defense contractor and guides Software development. He also runs a Software Development studio which teaches IT skills and programming. Apart from tinkering with Android and Arduino he loves trekking in beautiful South Australia where he lives.

CppCon, The C++ Conference 2025 - Bartosz Moczulski: "Fix C++ Stack Corruptions with the Shadow Stack Library" youtu.be/-Qg0GaONwPE Fatal stack micro-corruptions, mysterious segmentation faults, and bus errors tamed live on stage, come and see! Operating systems, compilers, libraries, and C++ language itself provide multiple tools and abstractions to protect against memory corruptions, both for heap and stack. Standard containers like std::array or std::vector can check rages when accessing members (except the [] operator, by design). GNU C Library (glibc) features MALLOC CHECK . Compilers come with address sanitizers and stack protectors onboard. Linux has mprotect(). Lastly, Valgrind can detect hard-to-imagine misbehaviors, although often at a cost that is impossible or impractical to accept. And would you believe that all these countermeasures are sometimes just not enough?! There are treacherous scenarios that can sneak through all of these defense lines and frame perfectly innocent functions like pthread mutex unlock() into a nasty segmentation fault. To understand why and how it can happen we will take a deep dive into the fascinating world of calling convention and even disassemble one or two functions to inspect the machine code generated by the compiler. Finally, I will present Shadow Stack - a novel technique and a C/C++ library that can help identify and fix the true source of tricky stack corruptions by recursively narrowing the search scope of the function call graph. --- Bartosz Moczulski Bartosz Moczulski /pronounce: bar-tosh mo-chool-skee/ is a software engineer and consultant with 20 years of commercial experience in the digital TV industry and a proud holder of MSc degree in Computer Science from Wroclaw University of Technology (Poland). Bartosz is a big fan of the GNU/Linux ecosystem and open-source in general. He likes to call himself a Linux detective and rarely leaves a bug investigation unsolved. Bartosz has years of experience in C (GStreamer), C++ (WebKit), Linux security, and software integration in embedded systems (Yocto/OpenEmbedded, Buildroot), seeking an opportunity to pick some Rust soon. He is never afraid to descend to the assembler level or to spawn Ghidra or Radare2 when the situation demands it. All this time he is not losing sight of the bigger picture and can engage in projects at the architectural level. Bartosz is also passionate about knowledge sharing and ran numerous well-received internal trainings and workshops in the companies he used to work for. In his spare time, he likes to make wine and maintain his home lab, running a number of self-hosted services; both of these activities for the benefit of his friends and family. His current passion is medieval calligraphy which, being a left-hander, he has to write upside-down. He prefers a quill over a broad-edge nib and his favorite letters are ſ (long s) and þ (thorn).

CppCon, The C++ Conference 2025 - Thursday Plenary/Keynote: Vittorio Romeo: "More Speed & Simplicity: Practical Data-Oriented Design in C++" youtu.be/SzjJfKHygaQ Data-Oriented Design (DOD) presents a different way of thinking: prioritizing data layout not only unlocks significant performance gains via cache efficiency but can also lead to surprising simplicity in the code that actually processes the data. This talk is a practical introduction for C++ developers familiar with OOP. Through a step-by-step refactoring of a conventional OOP design, we’ll both cover how data access patterns influence speed and how a data-first approach can clarify intent. We’ll measure the performance impact with benchmarks and analyze how the refactored code, particularly the data processing loops, can become more direct and conceptually simpler. Key techniques like Structure-of-Arrays (SoA) vs. Array-of-Structures (AoS) will be explained and benchmarked, considering their effects on both execution time and code clarity. We’ll pragmatically weigh the strengths (performance, simpler data logic) and weaknesses of DOD, highlighting how it can complement, not just replace, OOP. We’ll also demonstrate that DOD doesn’t necessitate abandoning robust abstractions, showcasing C++ techniques for creating safe, expressive APIs that manage both complexity and performance. Let’s learn how thinking “data-first” can make your C++ code faster and easier to reason about! --- Vittorio Romeo Vittorio Romeo (B.Sc. Computer Science, 9+ YoE at Bloomberg) works on mission-critical C++ infrastructure and provides Modern C++ training to hundreds of fellow employees. He began programming around the age of 8 and became a C++ enthusiast shortly after discovering the language. Vittorio created several open-source C++ libraries and games, published many video courses and tutorials, actively participates in the ISO C++ standardization process, and maintains the popular SFML library. He co-authored the acclaimed "Embracing Modern C++ Safely" book (published in January 2022) with J. Lakos, R. Khlebnikov, and A. Meredith. Vittorio is an active member of the C++ community with an ardent desire to share his knowledge and learn from others: he presented and offered workshops over 20 times at international C++ conferences (including CppCon, C++Now, ++it, ACCU, C++ On Sea, C++ Russia, and Meeting C++), covering topics of various nature. He also maintains a website with advanced C++ articles and a YouTube channel featuring well-received modern C++11/14 tutorials. Lastly, he's active on StackOverflow, taking great care in answering interesting C++ question (90k reputation). When he's not writing code, Vittorio enjoys weightlifting, playing volleyball, scuba diving, canyoning, gaming, and enjoying sci-fi content.

CppCon, The C++ Conference 2025 Sarthak S.: "Duck Typing, the C++ Way: How Type Erasure Bends the Rules" youtu.be/HkoQAjwMyOc Type erasure is one of C++'s most underrated yet powerful idioms - allowing you to write flexible, generic code while hiding concrete type information behind a unified interface. In this talk, we’ll dive deep into how type erasure enables runtime polymorphism without inheritance, and draw parallels to duck typing in dynamic languages, but with C++ static safety guarantees. In this talk, we’ll explore how the C++ Standard Library leverages type erasure in tools like std::function and std::shared ptr, making it possible to store, dispatch, and manage heterogeneous objects with minimal friction. Along the way, we’ll uncover the inner workings of these abstractions by handcrafting a simplified version of std::function from scratch. We’ll also examine how std::shared ptr uses type erasure to maintain type safety while enabling polymorphic deletion. But it’s not all abstraction and elegance - we’ll peel back the layers to expose the hidden performance costs, memory allocations, and vtable machinery that come with these type-erased constructs. Through profiling and real-world scenarios, we’ll evaluate when type erasure is worth the trade-off, and when alternatives like templates or CRTP might be more appropriate. By the end of the session, you’ll not only understand how type erasure works under the hood, but also gain the intuition to wield it judiciously - writing cleaner, more flexible, and performance-aware modern C++ code. --- Sarthak Sehgal Sarthak Sehgal is a C++ Software Engineer at a high-frequency options market-making firm based in Chicago. He is passionate about low-level programming, performance optimization, and their applications in financial systems. Outside of work, he shares insights on C++ and finance on his blog, sartech.substack.com

CppCon, The C++ Conference 2025 Barry Revzin: "Practical Reflection With C++26" youtu.be/ZX_z6wzEOG0 With the adoption of Reflection for C++26, the landscape of what is possible has shifted. This talk will focus on implementing Struct-of-Arrays for an arbitrary aggregate, but will also take some detours to cover some techniques that will prove useful for solving a wide range of problems. --- Barry Revzin Barry is a senior C++ developer at Jump Trading in Chicago, a technology and engineering-driven trading firm. After programming for many years, he got really into the nuances and intricacies of C++ by being unreasonably active on StackOverflow (where is he is the top contributor in every standard from C++14 up through C++26). A lot of his C++ knowledge comes from just answering questions that he doesn’t know the answers to, especially when he answers them incorrectly at first. His C++ involvement escalated when he started attending standards committee meetings in 2016, having written dozens of papers for C++20, C++23, and now C++26. You might know him from such features as deducing this, packs in structured bindings, explicit(bool), conditionally trivial special member functions, packs in structured bindings, and now, reflection. Outside of the C++ world, Barry is an obsessive swimming fan. He writes fun data articles for SwimSwam and also used to do analysis for the DC Trident, a professional swim team with multiple Olympic Gold Medalists (including Katie Ledecky and Natalie Coughlin).

CppCon, The C++ Conference 2025 - Back to Basics: Chandranath Bhattacharyya & Kathleen B.: "How To Improve C++ Code Reviews" youtu.be/mMrIwY1n74g Code reviews are meant to improve software quality, but do we keep repeating the same mistakes? This talk dives into concrete examples of common mistakes and, more importantly, provides actionable best practices to avoid them. We'll explore frequently recurring issues identified in C++ code reviews, spanning fundamental practices like header management, naming, documentation, and scope control, impacting code clarity and correctness. The session will also address common pitfalls in leveraging core language features such as control flow, range-based for loops, enum class , and namespace management. We will examine improvements for parameter passing, return type handling (including std::optional and std::expected ), and crucial aspects of class design, covering initialization, member functions, special members, and comparison operators, alongside encapsulation principles. Finally, we'll touch upon frequent misunderstandings in move semantics, forwarding, effective STL usage (containers, strings, algorithms, smart pointers, variants), and the proper application of const -correctness and compile-time programming. By analyzing these real-world code review insights, attendees will gain practical knowledge to write more robust and maintainable C++ code. --- Chandranath Bhattacharyya Anything C++ :-) --- Kathleen Baker Kathleen is a software engineer at Microsoft, currently working on the Edge browser team. She joined Microsoft after completing her undergraduate degree at the University of Alberta.

CppCon, The C++ Conference 2025 - Back to Basics: Jeff Garland: "C++ Concepts" youtu.be/NpuNUGifL1M C++20 introduced concepts as a first-class language feature, formalizing a long-standing tradition of template-based constraints in modern C++. Concepts offer a new level of clarity, safety, and expressiveness—and they’re now fully supported by compilers and the standard library. This tutorial takes a practical, hands-on approach to understanding and applying concepts in real-world C++ projects. We'll begin with the fundamentals: understanding concept definitions and the requires keyword. Then we'll explore the application of concepts from a library user point of view. Including as a variable declaration, return values, and function parameters. And finally, we'll survey and apply c++20 standard library concepts to typical development of a typical c++ class. In Part II, we'll dig into writing custom concepts. We’ll refactor a function to work with concepts, using this as a springboard to examine design choices when applying concepts to function interfaces. We’ll also design a reusable concept to demonstrate how concepts can improve the structure and clarity of libraries that work with families of related types. Finally, we’ll reflect on how concepts can influence overall design patterns in C++, including their potential to improve readability, diagnostics, and long-term maintainability. --- Jeff Garland Jeff Garland has worked on many large-scale, distributed software projects over the past 30+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks. Mr. Garland’s interest in Boost started in 2000 as a user. Since then he has developed Boost.date_time, become a moderator, served as a review manager for several libraries (including asio and serialization), administered the Boost wiki, and served as a mentor for Google Summer of Code. Mr. Garland holds a Master’s degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is co-author of Large Scale Software Architecture: A Practical Guide Using UML. He is currently Principal Consultant for his own company: CrystalClear Software, Inc and assistant chair of the Library Working Group for the C++ standards committee.

CppCon, The C++ Conference 2025 - Eric Brumer: "Your Optimized Code Can Be Debugged - Here's How With MSVC C++ Dynamic Debugging" youtu.be/YnbO140OXuI Debugging optimized code is challenging: game developers (among others) regularly feel the pain of "variable was optimized away" messages in a debugger, stepping being erratic, and breakpoints not getting hit. Existing solutions like -Og or -O1 may not provide the right tradeoff between performance & debuggability, and iterating with pragma optimize off causes toil just to inspect the value in a variable, or to make the call stack understandable. Visual Studio 2022 17.14's C++ Dynamic Debugging solves this problem: with minimal compile-time overhead, your code runs as optimized but you perform debugging actions on unoptimized code. Code remains fast while also being as easy to debug. This talk will cover effective use of this tooling to make the most out of debugging optimized code. It will also cover underlying technical details of C++ Dynamic Debugging which make the feature powerful, easy to use, and fast to build. --- Eric Brumer Eric is an engineering manager on the Microsoft C++ Team, working on the compiler back-end.

CppCon, The C++ Conference 2025 - Kevin Carpenter: Back to Basics: "Custom Allocators Explained - From Basics to Advanced" youtu.be/RpD-0oqGEzE Effective memory management is crucial for building efficient and reliable C++ applications. Custom memory allocators provide a powerful tool for optimizing memory usage, reducing fragmentation, and improving performance. This talk will explore the intricacies of memory allocation in C++, from the basics of dynamic memory management to the implementation of custom allocators. Attendees will gain insights into the standard allocator model, techniques for designing custom allocators, and practical examples of their use in real-world applications. Join us to unlock the full potential of memory management in your C++ projects. --- Kevin Carpenter Kevin Carpenter, an experienced Software Engineer, excels in crafting high-availability C++ solutions for Linux and Windows, with expertise in transaction software, financial modelling, and system integration. As a Software Engineering Manager, he ensures secure, high-speed credit card transactions. In his prior position, he played a lead role in developing an interest rate risk model for large credit unions, enhancing legacy code, and optimizing ERP data integration.

CppCon, The C++ Conference 2025 - Robert Leahy: "std::execution in Asio Codebases: Adopting Senders Without a Rewrite" youtu.be/S1FEuyD33yA Asynchronous programming in C++ is undergoing a major shift. While Asio and the Networking TS have long served as the foundation for production async systems, the standardization of std::execution in C++26 introduces a new, composable model for expressing asynchronous operations. But for many existing codebases, a full rewrite is not realistic. This talk explores the migration pathway from Asio and the Networking TS toward std::execution through the creation of isolated “bubbles” of sender-based code. Strategies will be demonstrated to allow these bubbles to fully leverage existing asynchronous operations, combining the expressiveness of std::execution with the maturity and stability of Asio-based systems. Attendees will learn practical techniques for integrating std::execution into real-world codebases, including how to manage differences in cancellation and error handling semantics. By focusing on incremental adoption, this talk provides a clear and realistic roadmap for modernizing asynchronous C++ code without disrupting what already works. --- Robert Leahy Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After spending 4.5 years in full stack web development he pivoted to financial infrastructure in late 2016 whereafter he spent nearly nine years at a start up working on next generation financial market data storage and retrieval mechanisms. In 2019 he became involved in the ISO C++ committee with a particular focus on library evolution. Since summer 2025 he has worked as a core developer at Hudson River Trading.