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.
Overview
Onsite classes
When:
- Saturday, September 13th – Sunday, September 14th from 09.00 – 17.00 MDT
- Saturday September 20th – Sunday, September 21st from 09.00 – 17.00 MDT
Where: Gaylord Rockies, Aurora, Colorado
Online classes
When:
- Wednesday, September 10th – Friday, September 12th from 09.00 – 15.00 MDT.
- Monday, September 22nd – Wednesday, September 24th from 09.00 – 15.00 MDT.
Important
Class registration and conference registration are separate. Attendees can register for either one or both. Class sizes are limited and may sell out.
Details
For individuals whose organization requires it, a certificate of completion is available for classes attended. For information, contact the conference registrar.
Onsite classes include breaks and lunch.
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.
Onsite Pre-Conference Classes
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: Language updates, Design
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: Better code
C++ Templates for Developers
Instructor: Walter E. Brown
Duration: Two Days
Abstract: As an intermediate-level C++ programmer, you already know about and have very likely used one or more kinds of C++ templates in your code. Whether you’ve applied std::vector or std::array to your work, or called upon any of the multitude of algorithms that the standard library provides, you’ve experienced some of the power that templates add to a C++ programmer’s toolkit.
Come discover how the world of C++ templates will open to you once you’ve mastered a modest handful of straightforward, key insights and principles. Whether it’s programming generically, or with variadics, SFINAE, concepts, overloading, or other coding practices, this Workshop will allow you to explore and apply template-based techniques that will help solve problems in your programming domain!
Tags: Templates, Language updates
C++ Under the Hood
Instructor: Assaf Tzur-El
Duration: One Day
Abstract: Dive deep into C++’s internal mechanisms in this full-day workshop.
While most C++ courses focus on how to write code, we’ll explore what happens after you write it. You’ll learn how your source code transforms into machine code, how the compiler makes decisions, and how your data is actually stored and manipulated in memory.
Through a combination of theory and hands-on exercises, you’ll examine the compilation pipeline, memory layout, object internals, and runtime mechanisms. You’ll use professional tools to inspect generated assembly code, investigate memory layouts, and understand how high-level C++ features are implemented under the hood. By the end of the day, you’ll have a solid understanding of how C++ really works, enabling you to write more efficient code and debug complex issues more effectively.
Tags: Code generation
Contemporary 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: Performance, Optimization
Safe and Efficient C++ for Embedded Environments
Instructor: Andreas Fertig
Duration: Two Days
Abstract: As a developer working with embedded systems, you need tools that help you build smarter, more efficient software. And that’s exactly what the latest C++ updates deliver. With these advancements, tackling the challenges of embedded environments—like those that follow MISRA, Autosar, or SIL—becomes easier. You can meet the strictest standards without sacrificing performance or reliability.
This course will enhance your embedded systems skills using modern C++. By practical examples, you will learn how to write code that is safer, more robust, and more efficient. You will see patterns to replace the POSIX length value API.
We’ll start with the basics and gradually move on to more advanced topics, all designed to make your code stronger and more efficient.
The course is a hands-on course. Theory is interspersed with demos and exercises.
Tags: Embedded Development
Performance and Efficiency in C++ for Experts, Future Experts, and Everyone Else
Instructor: Fedor Piku
Duration: Two Days
Abstract: This class is about performance and efficiency, spanning the entire range from the fundamentals of the hardware to the peculiarities of compiler optimizations. You will learn, on practical examples extracted from real-life programs, how to measure, analyze, and improve the performance of your programs. But most importantly, you will learn how to understand why your programs, compilers, and hardware behave the way they do. Some of the material will be basic and fundamental, some cutting-edge and esoteric, and the rest somewhere in between. All explanations will be reinforced with hands-on exercises, which you get to do in the classroom and can explore later in detail if you want to learn more.
Tags: Performance, Optimization, Concurrency
Structured Concurrency in C++: A Hands-On Workshop
Instructor: Mateusz Pusz
Duration: Two Days
Abstract: Today, C++ software is increasingly asynchronous and parallel, a trend that is likely only to continue going forward. While the C++ Standard Library has a rich set of concurrency primitives and lower-level building blocks, we lack a standard framework for asynchrony and parallelism that C++ programmers desperately need.
This training shows that concurrency is not only about the C++ Standard Library threading and synchronization low-level tools. During the workshop, you will learn how to write efficient, asynchronous, and highly concurrent code without the need for any manual synchronization between threads, leading to simpler code and faster runtimes. During the hands-on exercises, you will implement coroutine tools from scratch and create parallel processing pipelines with a new framework called Senders/Receivers proposed for standardization as a part of C++26. The Senders/Receivers framework is publicly available on GitHub so that it can be used in production immediately without the need to wait for the next C++ release.
Tags: Language updates, Concurrency, Parallelism
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
Onsite Post-Conference Classes
AVX Vectorization Workshop
Instructor: Ivica Bogosavljevic
Duration: Two Days
Abstract: This workshop is for software developers who wish to learn how to write fast software!
AVX vectorization workshop teaches you how accelerate your programs program using AVX (Advanced Vector Extensions) available in most modern Intel and AMD CPUs. We introduce vectorization from the most basic concept up to very advanced vectorization topics.
Tags: Performance, Hardware
Building a Task-parallel Programming System Using Modern C++
Instructor: Tsung-Wei Huang
Duration: One Day
Abstract: Task-parallel programming (TPP) systems are increasingly adopted by the computing community to accelerate complex scientific problems. They offer more efficient handling of irregular patterns (e.g., graph algorithms, recursion) compared to traditional loop-parallel models. However, building a scalable, flexible, and easy-to-use task-parallel programming system is a daunting challenge, as developers often confront tricky details such as concurrency controls, load balancing, and scheduling efficiency.
Tags: Language updates, Design
High-Performance Concurrency in C++
Instructor: Fedor Pikus
Duration: Two Days
Abstract: Unlock the power of high-performance concurrency in C++ with this comprehensive, hands-on two-day course. Designed for developers looking to push their C++ applications to the next level, this class covers everything from fundamental principles to cutting-edge concurrency tools introduced in C++20, with a strong focus on practical implementation and real-world challenges.
We begin by addressing the core question of performance: What makes a concurrent program efficient, and how can we measure it? Participants will explore key performance metrics and learn profiling and benchmarking techniques to ensure their code runs optimally in multi-threaded environments.
The class delves into the complexities of multi-threaded programming in modern C++, offering a deep dive into thread management, memory synchronization, and avoiding data races. Attendees will learn how to navigate C++’s memory model and apply best practices for thread-safe programming, ensuring robustness and correctness even in highly concurrent systems.
We will explore practical solutions for real-world concurrency problems using modern C++ features, including thread pools, pipelines, and coroutines, and dive into thread-safe data structures and lock-free algorithms. Through hands-on exercises, participants will build and optimize scalable systems that can handle high workloads efficiently.
By the end of this course, attendees will walk away with a comprehensive toolkit to write high-performance, concurrent C++ applications that are both fast and safe. Whether you’re building server-side systems, real-time applications, or tackling parallel processing challenges, this class will give you the skills to harness modern C++ concurrency like a pro.
Tags: Performance, Hardware, Concurrency
Online Classes
Pre-Conference: 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: Design, Architecture, Analysis
C++ Fundamentals You Wish You Had Known Earlier
Instructor: Mateusz Pusz
Duration: Three Days
Abstract: C++ is a complex programming language. When used correctly, it delivers the best possible performance. Unfortunately, it is often misused, which causes many problems.
However, it turns out that consciously using selected language features can make it relatively easy to produce high-quality software that delivers excellent runtime performance and is error-proof. This coding style is called Modern C++.
The material of this workshop is the first chapter of the trainer’s most successful and popular training called “Advanced Modern C++”. During the class, we will go through all the key features of the C++ language, discuss potential issues and pitfalls, and provide guidelines on how to use them correctly. This training discusses various topics ranging from identifiers that do not result in undefined behavior through vital language features like name lookup, overload resolution, one definition rule, and move semantics up to the design recommendations like Rule of Zero. Among others, we will see how we can provide a custom dynamic allocation strategy for our programs and how we should design and implement customization points for our engine.
Tags: Language features, design
Post-Conference: C++23 in Practice: A Complete Introduction
Instructor: Nicolai Josuttis
Duration: Three Days
Abstract: C++23 is the latest C++ release, which major C++ compilers start to support now more and more. Therefore, it is time to look at the contents of C++23 (to both new features and relevant extensions/modifications).
This two-days training introduces and discusses all major language and library features of C++23 that are available in at least one major compiler (GCC, Clang, Visual C++) . The goal is to get a first impression of how to use C++23 in practice and benefit from the purpose and design of the new C++23 features in your day-to-day work.
As usual for his trainings and books, Nico Josuttis will focus on both the design and the practical usability of the new features for ordinary application programmers knowing Modern C++. so that attendees understand why we have them and how to use them right. As a long-term trainer and educator, Nico will concentrate on the essence for best usability. As Nico being an active member of the C++ Standards Committee, the training will be spiced with inside stories.
Tags: Language updates
Post-Conference: Contemporary C++ for Low-Latency Systems
Instructor: Patrice Roy
Duration: Three 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: Performance, Optimization
Register for classes here.
