CppCon Academy is your gateway to leveling up as a C++ professional. We’re offering an exceptional lineup of onsite and online classes before and after the main conference.
Led by world-class instructors, these immersive courses are designed to give you practical, cutting-edge knowledge that will supercharge your C++ skills and help you stay ahead in a constantly evolving industry. Whether you want to master advanced C++ templates, enhance your concurrency expertise, or refine your design practices, there’s a class tailored to boost your career and deepen your expertise.
Important Information
Class registration and conference registration are separate. Attendees can register for either one or both. Class sizes are limited and may sell out.
Onsite classes are held at the Gaylord Rockies, Aurora, Colorado. Lunch is included for all full-day onsite classes.
For individuals whose organization requires it, a certificate of completion is available for classes attended. For information, contact the conference registrar.
Privacy Notice
In order to facilitate communications preparing students for class sessions, we share class attendee email addresses with instructors (and vice versa). By default we use the email address that you use for registration. If you’d like to use a different email address for the class than what you use for registration, please note that in the appropriate field during registration.
Schedule Overview
Onsite classes: Gaylord Rockies, Aurora, Colorado
- Saturday, September 12th – Sunday, September 13th from 09.00 – 17.00 MDT
- Saturday September 19th – Sunday, September 20th from 09.00 – 17.00 MDT
Online classes:
- Wednesday, September 9th – Friday, September 10th from 09.00 – 15.00 MDT.
- Monday, September 21st – Wednesday, September 23rd from 09.00 – 15.00 MDT.
- Saturday, September 26th – Sunday, September 27th from 09.00 – 17.00 MDT.
Available Classes
Classes are listed in chronological order. They are grouped into Pre-Conference Classes and Post-Conference Classes.
Pre-Conference Classes
[Online] Modern C++: When Efficiency Matters
Instructor: Andreas Fertig
Duration: Three Days
Abstract: You will learn about various features of modern C++, how they work, where to use them, and how they translate to code. With that knowledge, you understand what each feature brings you and its costs regarding code size and performance.
You will learn how to write less code and get the same result. Less code helps you to save human resources when it comes to maintenance and debugging.
In times where a lot of applications are battery-powered, saving run-time is a great asset. As part of this class, you will learn to control the footprint and the speed of your binary.
You will learn all topics with exercises and live demos in C++ Insights and Compiler Explorer.
Tags: efficiency, performance, internals
[Online] System Architecture And Design Using Modern C++
Instructor: Charley Bay
Duration: Three Days
Abstract: This course is intended for intermediate and advanced C++ engineers with experience making architectural and design decisions, or who are evolving into roles that demand proficiency in system-level analysis and decision making. We will focus on Modern C++ and deeply explore successes and failures in projects and systems from a variety of industries. And, we will discover that some crossroads are universal, despite the unique concerns that may present pragmatic challenges and cause technical implications to be ranked differently based on the specific domain to which the solution is applied.
Tags: architecture, design, Modern C++
[Onsite] Advanced and Modern C++ Programming: The Tricky Parts
Instructor: Nicolai Josuttis
Duration: Two Days
Abstract: Whenever I give C++ training I run into the same topics of “half knowledge”. We use a lot of pretty complicated features (e.g., templates, move semantics, and smart pointers) in our day-to-day programming without full understanding. Most of the time this works fine, but sometimes not. Even vectors and strings may cause surprises (e.g., to understand when and how memory is allocated).
This tutorial will discuss all these “tricky fundamental” C++ features application programmers see and use day by day. We will motivate them, understand them, and see how they should be used in practice. As a result, you will understand C++ a lot better and advance to the next level of an experienced C++ programmer.
As a long-time member of the C++ standards committee and experienced trainer, Nicolai will also give useful background information about purpose and design decisions.
Tags: move semantics, memory management, SSO, lambdas, universal references, shared pointers, PMR, special members
[Onsite] AI++ 101 : Build a C++ Coding Agent from Scratch
Instructor: Jody Hagins
Duration: One Day
Abstract: Remember writing a compiler in university? Not a real compiler, but something that handled a subset of a language and generated naive code. You’d never ship it. But decades later, you still understand how compilers work because you built one.
That’s what we’re doing here. In one intensive day, you will build a working AI coding agent in C++. Not Claude Code. Not Cursor. A simple thing you fully understand, that talks to an LLM, defines tools, executes them, and runs the same agentic loop that powers every AI coding assistant on the market.
This workshop emerged from my own AI/C++ journey. I watched AI stumble through C++ like a freshman who skipped the first three weeks of class, until I discovered the problem wasn’t the models, it was me. The breakthrough came from understanding what’s actually happening under the hood.
In this workshop, you will write a fully functioning agent harness in C++. Like those university compilers, it will not be production ready, but will serve as a laboratory for learning how generative AI large language models can be used as C++ programmers.
Tags: AI, LLM, agentic programming, tool calling, code generation
[Onsite] C++ Best Practices
Instructor: Jason Turner
Duration: Two Days
Abstract: “C++ Best Practices” is designed to help programmers elevate the quality of their C++ code. This course is intended for developers who have a beginner to intermediate knowledge of C++. You will learn how to write programs that perform well by default, are easier to maintain, memory safe, and have better compile times. We will cover best practices for new features added in C++17/20/23 and how to use the tools available to maintain code quality. Come prepared to interact and discuss.Tags: best practices, safety, tooling, constexpr
[Onsite] Essential GDB and Linux System Tools
Instructor: Mike Shah
Duration: One Day
Abstract: Developers spend more of their time debugging code, than actually writing code. So why do we not spend as much time learning debugging tools and associated utilities to help get us out of trouble? Part of the answer is that debugging is often not taught as a subject — but this workshop is here to fix that!
In this workshop you will learn how to use a debugger (GDB) and associated tools (valgrind, sanitizers, code coverage tools, objdump, dwarfdump, etc.) to help debug and understand what your software is doing. In the age of AI generated code, legacy code, and massive code bases, understanding how to use tools is of critical importance.
In this workshop we’ll do interactive exercises to help ramp you up, and get you ready to tackle any project with tools in hand to help you understand how to write correct code, read code, and develop software with confidence.
Tags: debugging, tooling
[Onsite] How Hardware Gets Hacked: Breaking and Defending Embedded Systems
Instructor: Nathan Jones
Duration: Two Day
Abstract: In this two-day hands-on workshop, participants will attack and defend a paired car-and-key-fob embedded system implemented in C++ based on the 2023 MITRE Embedded Capture-the-Flag (eCTF) competition. Using a host-based simulation of competition firmware, attendees will progressively exploit vulnerabilities including:
- Simulated secret extraction over JTAG/SWD
- Replay attacks and broken rolling-code implementations
- Message authentication failures
- Timing side channels in PIN validation
- Buffer overflows and memory corruption
- Simulated fault injection attacks that subvert control flow
For each exploit, participants will analyze why it works at the firmware level and then work with the provided firmware, attack scripts, and automated test harnesses to test and implement practical defenses. These may include secure key handling, message authentication codes (MACs), constant-time comparisons, hardened buffer management, and defensive design patterns resilient to fault attacks.
Tags: embedded security, secure design, threat modeling
[Onsite] Performance and Efficiency in C++ for Experts, Future Experts, and Everyone Else
Instructor: Fedor Pikus
Duration: Two Day
Abstract: Your compiler is smart, but it is not a magician. It cannot fix a design that fights the hardware, nor can it optimize code that hides its intent. To achieve the peak performance C++ is capable of, you must master the deep interplay between the language, the compiler, and the physical machine. Most C++ developers know how to write code that is correct. Fewer know the actual cost of the abstractions they use. And only a small fraction understand how the compiler translates those abstractions into physical execution.
This class reveals the “secret life” of your application. We move beyond standard optimization advice to explore the mechanical sympathy required to squeeze every cycle out of modern systems. We will examine code from three perspectives: the hardware that executes it, the compiler that generates it, and the language rules that constrain it. We will demonstrate that performance is not an afterthought but a fundamental part of the design specification. You will learn how to validate that specification early—running “estimation benchmarks” on mock-ups to predict performance before writing a single line of production code.
Tags: performance, hardware, efficiency, caches, memory, optimizations
[Onsite] Secure Engineering in Modern C++: Preventing Catastrophic Failures
Instructor: Tanya Janca
Duration: Two Day
Abstract: C++ powers infrastructure, financial systems, robotics, game engines, and safety-critical software. Its performance and control come with risk: small engineering mistakes can become catastrophic security failures.
This intensive two-day, hands-on training teaches professional C++ developers how to build resilient systems that remain secure under real-world pressure.
Participants will analyze insecure native code, exploit failure paths, and implement safer modern C++ patterns. Through guided code reviews, bug-fixing exercises, live threat modeling, and fuzz testing, attendees will learn how C++ systems are actually compromised and how to prevent those failures in their own software.
Topics include memory safety, dangerous language features, modern safer C++ patterns, parsing untrusted data, injection risks, authentication and authorization design, secret management, encryption, least-privilege architecture, supply chain risk, logging for detection, and incident readiness.
Tags: Modern C++, secure coding, software security, secure software design, memory safety, defensive programming, threat M]modeling, fuzz testing, secure engineering, supply chain security, authentication and authorization, secrets management, least privilege
[Onsite] Talk Tech and Keep Your Audience Awake
Instructors: Andrei Alexandrescu, Laura Savino, and Sherry Sontag
Duration: Two Days
Abstract: A good technical talk is as much about storytelling as it is about presenting information. At best, it is a shared experience between speaker and audience. Even the most complex topics can be presented simply and clearly, sparking questions, conversation, and perhaps even some debate. When this is done well, a good talk becomes a great one and leaves everyone, including the speakers, with more: more understanding, more curiosity, more interest.
We will help you learn how to build a compelling narrative and to discover how even small tweaks to your presentation can make a huge difference. Learn how to add context and clarity to your talks; how much detail is enough; how to craft simple and effective slides; how to be truly comfortable on stage and engage your audience; and how to cope with the unexpected.
Should you choose, you will be able to present some of your own work, learning from both other participants as well as your instructors. Andrei, Laura, and Sherry will give you valuable feedback and will share their insights and experiences, including the hiccups and disasters that have made them better speakers. This talk is geared for presenters at CppCon, and if there is space available, anyone aspiring to be one.
Sherry will also hold “office hours” on Zoom a couple of hours a week during the four weeks leading up to CppCon for anyone interested in early direction.
Tags: Presentation
Post-Conference Classes
[Onsite] AI++ 201: Building HFT Infrastructure with AI
Instructor: Jody Hagins
Duration: Two Days
Abstract: In a previous conference talk, I demonstrated building a complete OPRA feed handler without writing a single line of code by hand. Over the two days of this workshop, you’re going to do something even more difficult.
We’re building a matching engine. Not a toy, one that conforms to IEX specifications, with the kind of IPC infrastructure you’d actually deploy: lock-free queues, seqlock arrays, a sequencer pattern. The works. And you won’t write a single line of code yourself.
Every line comes from Claude Code. You prompt, you guide, you review, you course-correct, but your fingers don’t type C++. By the end, you’ll have a working matching engine and a visceral understanding of what AI can and can’t do with a serious C++ project.
We will first cover the foundations: how agentic loops work (condensed review), and why C++ is uniquely challenging for AI assistants. Compilation latency breaks the fast-iteration feedback loop. Header/source splits multiply context requirements. Templates generate error novels. The agent can write code that compiles but has undefined behavior. We’ll develop strategies for each problem, then begin building.
Tags: AI, LLM, agentic programming, tool calling, code generation, C++, HFT, matching engine
[Onsite] Function and Class Design with C++2x
Instructor: Jeff Garland
Duration: One Day
Abstract: C++20 to C++26 brings a massive number of new language and library features – which can feel overwhelming to developers coming from older standards. This tutorial focuses on introducing those tools and how to use them in construction of functions and classes — which are the foundation of C++ programs. The tutorial is based, first and foremost, on the presenters experience building production large non-stop distributed systems with C++2 and also his work on C++ libraries, including work on the C++ standard library. We’ll focus on features with wide deployment which can be utilized in production systems today.
Participants will leave with a base knowledge of applying C++2x features to their designs and projects. In particular, concepts, ranges and range algorithms, aggregate types, advanced error handling, and other features.
Tags: concepts, function design, class design, C++20, C++23, C++26
[Onsite] High-performance Concurrency in C++
Instructor: Fedor Pikus
Duration: Two Days
Abstract: This course is designed to empower participants with the knowledge and skills required to unlock the full potential of high-performance concurrency in C++. By delving into fundamental principles and advanced techniques, attendees will gain a profound understanding of how to design, implement, and optimize concurrent programs effectively.
The class begins by addressing the essentials of performance and guiding participants on how to evaluate and measure the efficiency of concurrent programs. Emphasis is placed on the significance of performance measurement, providing insights into practical methodologies for assessing program efficiency. The exploration of threads and memory management goes beyond the basics, offering a nuanced understanding of threads in C++, multi-threaded memory access, and the critical aspects of avoiding data races.
Participants will learn effective strategies for synchronizing memory accesses and gain insights into memory models, equipping them to navigate complex memory-related challenges in concurrent programming. The attendees will learn the tools offered by the C++ language, including C++20 and coroutines. We will learn about thread schedulers, thread pools, and pipelines, as well as thread-safe data structures. This class equips participants with a comprehensive skill set to harness the full potential of C++ for high-performance concurrency, covering everything from fundamental principles to advanced tools and techniques.
Tags: concurrency, performance, HPC, threads, multi-threading, lock-free, coroutines
[Online] C++23 in Practice: A Complete Introduction
Instructor: Nicolai Josuttis
Duration: Three Days
Abstract: C++23 is now fully available by major C++ compilers so that more and more projects and companies are using it. Therefore, it is time to look at the contents of C++23 (new features and significant extensions in both the language and the standard library).This three-days training introduces and discusses all major language and library features of C++23. The goal is to be ready to use them in practice and benefit from their purpose and design in your day-to-day work.
Many features extend C++20 features and make them (more) usable in practice. For example, std::generator is the first interface class to deal easily with coroutines, so that C++23 introdcues a new paradigm to implement generators and state machines. For these topics, the basics of C++20 will be part of this training.
As usual for his trainings and books, Nicolai Josuttis will focus on both the design and the practical usability of the new features. Attendees will understand why we have them and how to use them right. As a long-term active member of the C++ Standard Commitee and well-known educator, the quality of this training will give you the best revenue for understanding, use, and avoiding the traps of C++23.
[Online] Programming with C++20
Instructor: Andreas Fertig
Duration: Three Days
Abstract: After the seminar, you will clearly understand what C++20 adds to the plate. You can consciously select features from the new language standard for a project and use them safely.You will start learning how easy comparisons can be in C++20 and how much less code you have to write to create a simple class that supports all six comparisons. You will then learn about one of C++20’s biggest revolutions, Concepts. Your next stop is coroutines. You will now learn about the improvements in the STL: ranges. Besides the new things you can do in constexpr-context, you will also learn about two new elements of the constexpr-family: consteval and constinit.
All attendees get a complimentary copy of the book Programming with C++20.
[Online] Using C++ for Low-Latency Systems
Instructor: Patrice Roy
Duration: Two Days
Abstract: This course will focus on techniques programmers can use to get better, more predictable or more stable performance from systems with low-latency constraints. It is subdivided in sections that cover subsets of the subject matter; each section discusses C++ features that help achieving the section’s objectives, with emphasis on contemporary (C++20 and C++23) features wherever that makes sense.This training emphasizes portable C++ code. We might on occasion examine platform-specific aspects of programming, but the intent is that participants will be able to use the ideas and techniques covered in this class regardless of their chosen platform.
Tags: Low-Latency, Performance, Portability, Optimization
