Contemporary C++ for Low-Latency Systems a training course with programming examples taught by Patice Roy, is offered twice. Once as a two-day onsite class at the Gaylord Rockies from 09:00 to 17:00 Aurora time (MDT) on Saturday and Sunday, September 13th and 14th, 2025 (immediately prior to the conference). Lunch is included.

It is also offered as a three-day class online from 09:00 to 15:00 Aurora time (MDT), 11:00 to 17:00 EDT,  17:00 to 23:00 CEST,  on Monday through Wednesday, September 22rd – 24th, 2025 (following the conference).

◈ Register Here ◈ See Other Offerings ◈

Course Description

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.

Prerequisites

Participants are expected to be intermediate-level programmers with an interest in programming systems with low-latency constraints, Programmers that work on such systems but would like to leverage today’s C++ in their work might also find this class of interest.

Course Topics

The topics covered in this class are as follows. Most of these topics could be the subject of an entire class (and indeed, some have been the topic of an entire class in the past!); for that reason, we will focus on aspects that pertain to low-latency systems.

• C++ for Low-Latency Systems

In which we will define what we mean by “low-latency”; discuss the similarities and differences with real-time systems; introduce worst-case execution time concepts and discuss measurement utilities and techniques. Resilience-oriented aspects of C++ programming will be discussed in this section but will also be a recurring theme throughout the entire course.

• Key Low/No Overhead C++ Features

Some C++ features have strong upsides and little-to-no downsides for low-latency system development. In this section of the course, we will explore and use some of the most relevant ones. This includes compile-time programming through various means.

• C++ Features to Use with Care in Low-Latency Systems

There are C++ features that can be used for low-latency systems but with particular care only, as they have costs that could be higher than their benefits. We will take a reasoned, measurement-based approach to build an informed judgement.

• Leveraging the standard library in Low-Latency Systems

Some companies rewrite some or all of the standard C++ containers due to a belief that their needs cannot be satisfied by the tools this library offers. We will explore ways to get the most out of the containers and the algorithms provided by the standard library and examine ways to enhance it when appropriate. We will also examine latency-related risks associated with some key containers.

• Concurrency and Parallel Programming

Low-latency systems concerns overlap those of parallel and concurrent systems in different ways: reducing reliance on blocking operations and synchronization facilities, for example, is a strong trend in these two areas.

• Memory Management

C++ lets programmers manage memory allocation manually in various and interesting ways. We will explore ways to use these mechanisms to our advantage when building low-latency systems.

• Efficient Cache Usage

Contemporary C++ offers many features that help one get the most out of one’s hardware and take into account both the meliorative and punitive aspects of data and instruction caches. We will explore this question with examples and nuances.

Course Instructor