Loading…
Venue: Colorado A clear filter
Monday, September 14
 

08:30 MDT

Profiles for simplicity and guarantees
Monday September 14, 2026 08:30 - 10:15 MDT
The C++ community is growing fast. C++ is being used in critical applications. C++ can be used in ways that ensures correctness, simplicity, performance, and maintainability. How can we ensure that it is used is such desirable ways? How can we teach new and old C++ developers to do so?
The general strategy is called “subset of superset” and is based on the idea that by extending (“supersetting”) by adding libraries, we can simplify static analysis to where we can remove undesirable uses (“subsetting”) without damaging expressiveness or efficiency. Where run-time checks are necessary, such as to catch out-of-range accesses in hardened libraries, static analysis can be used to minimize the number of checks.
The strategy is supported by the “Profiles” framework, that allows us to require or suppress specific sets of guarantees, called profiles.
As examples, I show how to eliminate uninitialized-object errors and container-invalidation errors (a kind of dangling pointer errors) using the profiles framework and implementations of the “Initialization” and “invalidation” profiles. Both with zero run-time cost.

Presenters
avatar for Bjarne Stroustrup

Bjarne Stroustrup

Professor, Columbia University

Monday September 14, 2026 08:30 - 10:15 MDT
Colorado A

10:15 MDT

Conference Group Photo
Monday September 14, 2026 10:15 - 10:30 MDT
Follow the crowd immediately after the opening keynote to be in the conference photo. Be part of conference history!

Photo will be taken by CppCon's official conference photographer, Jonathan Phillips.
Monday September 14, 2026 10:15 - 10:30 MDT
Colorado A

11:00 MDT

C++26: A Curated Tour of What's New
Monday September 14, 2026 11:00 - 12:00 MDT
The next evolution of C++ has officially arrived, bringing a massive wave of enhancements to both the core language and the Standard Library. But with hundreds of committee proposals officially baked into the standard, where do you start? Continuing the tradition from previous releases, this fast-paced session delivers a comprehensive look at the new and updated features that define C++26.

We won’t get bogged down in the minutiae of every single ISO proposal—covering everything in detail is impossible in just one hour. Instead, you'll get a high-level, curated overview of the most impactful changes, from the major game-changers down to the small quality-of-life gems. If you want to get up to speed with the new standard and see how it will shape your codebase, this session is for you.

The session will touch on the following core language and Standard Library topics.

C++26 core language changes include - Reflection - Contracts - Unnamed placeholder variables - = delete("reason"); - Pack indexing - #embed - constexpr exceptions, constexpr placement new - Variadic friends - ...

C++26 Standard Library changes include - Execution control library - New libraries such as , , , , , and more - std::inplace vector: dynamically-resizable vector with fixed capacity - std::philox engine: counter-based random number engine - std::text_encoding: text encodings identification - More constexpr for containers and container adaptors - Saturation arithmetic - New SI prefixes - Printing Blank Lines with std::println() - ...

Where applicable, I’ll point you toward other specialized CppCon sessions for those ready to dive even deeper into specific topics.

Presenters
avatar for Marc Gregoire

Marc Gregoire

Software Project Manager, Nikon Metrology
MARC GREGOIRE is a software project manager and software architect from Belgium. He graduated from the University of Leuven, Belgium, with a degree in "Burgerlijk ingenieur in de computer wetenschappen" (equivalent to a master of science in engineering in computer science). The... Read More →
Monday September 14, 2026 11:00 - 12:00 MDT
Colorado A

14:00 MDT

Familiar C++ Patterns That Fail at Scale and the Design Shifts That Prevent Them
Monday September 14, 2026 14:00 - 15:00 MDT
Some of the most expensive C++ bugs are not caused by obscure language features. Instead, they emerge from code that looks reasonable: shared ownership that quietly extends lifetimes, singletons that become invisible dependencies, and performance-driven decisions that harden into architecture.

This talk examines these common design-level failure patterns in large-scale C++ systems. We cover three concrete design shifts:

Lifetimes: Shifting from shared ownership to explicit lifetime boundaries. Coupling: Shifting from implicit global coupling to injected dependencies. Interfaces: Replacing permissive APIs with constrained interfaces using std::span, std::optional, std::variant, and strong types.

Each shift is presented with the failure pattern it addresses, the solution, and the design rule it yields. Attendees will leave with practical heuristics for designing systems that are easier to reason about, test, and evolve: all grounded in real-world failures and the redesigns that fixed them.

Presenters
avatar for Divya Chandrasekar

Divya Chandrasekar

Software Engineering Team Lead, Bloomberg
Divya Chandrasekar is an Engineering Leader at Bloomberg, where she leads FXGO Orders, a trading platform within FXGO. She holds a master’s degree in Computer Engineering from the University of Florida and has held multiple engineering roles at Bloomberg. With a strong technical... Read More →
avatar for Devpriya Dave

Devpriya Dave

Devpriya Dave is a software engineer on the FX Options team at Bloomberg. While at Georgia Tech obtaining her master's degree, she helped design and build the system behind Georgia Tech's Machine Learning for Trading online course. She is passionate about STEM mentorship and is always... Read More →
Monday September 14, 2026 14:00 - 15:00 MDT
Colorado A

15:15 MDT

The Latency Slippage: Understanding the Hidden Costs of Caching for Low Latency C++
Monday September 14, 2026 15:15 - 16:15 MDT
Choosing cache-friendly data structures is a well-known optimization, but it's rarely the whole story. This talk goes deeper, exploring the hardware mechanics that dictate real-world performance and showing where significant gains are still left on the table.

We'll start from the ground up: what actually happens inside the cache hierarchy when your code issues a memory read or a software prefetch? Understanding the hardware lets us answer, when you should prefetch manually, and when you should trust the hardware prefetcher.

From there, we'll examine the invisible cost of multi-core C++. Cache coherency protocols (MESI/MOESI) can silently degrade performance through false sharing, RFO stalls, and coherency storms. We'll walk through how to diagnose these issues using hardware performance counters and how to eliminate them.

Additionally, we will contrast these behaviors across the data cache (DCache) and instruction cache (ICache), and analyze how Translation Lookaside Buffers (TLBs) impact overall memory read latency.

Finally, we'll tie it all together by combining hardware insight with application profiling data to arrive at practical strategies for low latency C++, packaged as an application-aware memory allocator.

Presenters
avatar for Sanchit Gupta

Sanchit Gupta

Low Latency C++ Developer, Graviton Research Capital
Sanchit Gupta graduated from Indian Institute of Technology, Madras with Honours in Bachelors of Technology in Computer Science and Engineering. Since graduating, Sanchit has worked for Graviton as a Low latency Software Developer
Monday September 14, 2026 15:15 - 16:15 MDT
Colorado A

16:45 MDT

Back to Basics: const, constexpr, consteval
Monday September 14, 2026 16:45 - 17:45 MDT
const is one of the oldest and most widely used features in C++, yet many developers still struggle with the subtle differences between const , constant expressions, constexpr , and consteval .

In this talk, you will learn how compile-time constants evolved in modern C++, starting with const and continuing through the features introduced since C++11. You will see what constant evaluation really means, what the compiler is allowed to execute during compilation, and where the limits still are today.

Using practical examples, we will explore when const is enough, when constexpr is needed, and how compile-time and runtime execution interact in modern C++. We will also look at common pitfalls, surprising behavior, and cases where compile-time programming can either improve code or make it harder to understand.

Finally, you will see how features such as consteval and std::is_constant_evaluated influence correctness, testing, and maintainability.

By the end of this talk, you will have a deeper understanding of constant evaluation and know how to use modern compile-time features more effectively in your code.

Presenters
avatar for Andreas Fertig

Andreas Fertig

C++ Trainer & Consultant
Andreas Fertig is an expert C++ trainer and consultant who delivers engaging and impactful training sessions, both on-site and remotely, to teams around the globe. As an active member of the C++ standardization committee, Andreas contributes directly to shaping the future of the language... Read More →
Monday September 14, 2026 16:45 - 17:45 MDT
Colorado A

20:30 MDT

Committee Fireside Chat
Monday September 14, 2026 20:30 - 22:00 MDT

Moderators
avatar for Guy Davidson

Guy Davidson

Head of Engineering, Six Impossible Things Before Breakfast

Presenters
avatar for Andrei Alexandrescu

Andrei Alexandrescu

Principal Research Scientist, NVIDIA
Andrei Alexandrescu is a Principal Research Scientist at NVIDIA. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design to... Read More →
avatar for Bjarne Stroustrup

Bjarne Stroustrup

Professor, Columbia University

avatar for Braden Ganetsky

Braden Ganetsky

Braden Ganetsky graduated from the University of Manitoba with a degree in mechanical engineering, fueled by his passion for mechanical puzzles. During his final year of school, when all classes and activities were remote, he discovered C++ and has been hooked ever since. He interned... Read More →
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Principal Software Engineer, Microsoft
Dr. Gabriel Dos Reis is an Architect for Visual Studio at Microsoft, working in the area of large scale software construction, neurosymbolic tools and techniques.  His contributions to C++ include scalable generic programming, pioneering compile-time computation, language support... Read More →
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
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... Read More →
avatar for Nina Ranns

Nina Ranns

The Standard C++ Foundation
Nina Dinka Ranns is a C++ consultant and a long-time member of the ISO C++ standardization committee, where she has contributed since 2013. She currently serves as ISO C++ committee vice convener and as a director of the Standard C++ Foundation.

Throughout her career, she has worked on systems ranging from telecommunications infrastructure to cloud-based security products. As a consultant, she has collaborated with Edison Design Group, Qt Group, Bloomberg, and the C++ Alliance on compiler technology, library design, and the... Read More →
avatar for Ruslan Arutyunyan

Ruslan Arutyunyan

Senior Middleware Development Engineer, Intel
Ruslan is a Senior Middleware Development Engineer specializing in parallel and threading runtimes. He joined Intel in 2017 and has experience in the autonomous driving domain, where he led the development of two libraries. Currently, Ruslan is the lead developer of oneAPI DPC++ library... Read More →
avatar for Timur Doumler

Timur Doumler

Senior Software Engineer, Citadel Securities
Timur Doumler is a software engineer specialising in low-latency and real-time C++. He works at Citadel Securities and is an active member of the ISO C++ standard committee, where he has (co-)authored many successful proposals including [[assume]], std::inplace_vector, and contract... Read More →
Monday September 14, 2026 20:30 - 22:00 MDT
Colorado A
 
Tuesday, September 15
 

09:00 MDT

Interesting Upcoming Low-Latency, Networking, Concurrency, and Parallelism Features from Kona 2025, Croydon 2026, and Brno 2026
Tuesday September 15, 2026 09:00 - 10:00 MDT
This talk is the 2026 edition of our series that highlights low-latency, networking, parallelism, and concurrency proposals to the C++ Standards Committee, especially those discussed in the Kona 2025, Croydon 2026, and Brno 2026 meetings. This talk from the Concurrency TS2 Editors, DG and SG14/19 chair will describe the following features and show how they can be used. It will also give their motivation, background, and their place within the overall framework of C++ low latency, networking, parallelism and concurrency:

Atomic Compare and Hazard Pointers Reclamation Control

  • We discuss a proposal for atomic compare operations that clarify programmer intent and simplify static analysis by avoiding the unnecessary leakage of atomic values. We also explore how these operations complement recent proposals to enhance the expressiveness of atomics, such as the use of tagged pointers.
  • We examine techniques for controlling C++26 hazard pointer reclamation, demonstrating how to offload retirement overhead to asynchronous executors to ensure predictable thread latency. We show how this capability can prevent specific deadlock scenarios and assess whether such controllers should be standardized or remain user-space patterns.
Twenty-One Years Without Sockets, The History of Networking in C++ and What We Learned Along the Way

  • Go has standard networking. Rust has standard networking. C++ has been trying since 2005. This talk tells the twenty-one-year story in seventeen minutes: the library that shipped but never standardized, the dependency that blocked it, the coroutine revolution that changed the assumptions, the technical discovery that explains why I/O doesn‚Äôt fit the three-channel model cleanly, and the bridge that lets both models win. Three decision points, three lessons, one live question: how should coroutines and senders coexist for C++29? No villains. Just the story and the engineering. Networking is now finally a C++29 priority, so said the Direction Group‚Äôs P5000.
Out-of-Thin-Air (OOTA) Values.

  • The memory models for high-level languages, including C++, C, Rust, and even Java, have been prone to out-of-thin-air values. For example, given two atomic integers X and Y, both initially zero, if one thread does a relaxed assignment from X to Y and the other does a relaxed assignment from Y to X, the mathematical C++ memory model does not rule out the outcome where both X and Y have the value 42. However, both communication and computation take time, and so we have proven that OOTA values cannot happen on real-world production-quality computer systems. This result makes compiler-writers‚Äô lives easier, and also eases the jobs of those brave individuals pursuing the full mathematical OOTA problem by relieving them of the need to live within CPU and memory constraints of production-quality compilers.
Discussion

There are other features under discussion, but the features we will present seem close to approval, are particularly interesting, and/or are relatively non-controversial. We will show use cases for each and prognosticate their journeys to C++26 and beyond. This will help programmers in concurrency, lock-free programming, and low-latency applications understand how best to take advantage of each of these important facilities.

Presenters
avatar for Paul E. McKenney

Paul E. McKenney

Software Engineer, Facebook
Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present... Read More →
avatar for Maged Michael

Maged Michael

Staff Software Engineer, Category Labs
Maged Michael is the inventor of several concurrent algorithms including hazard pointers, lock-free allocation, and multiple concurrent data structure algorithms. His code and algorithms are widely-used in standard libraries and production. His 2002 paper on hazard pointers received... Read More →
avatar for Michael Wong

Michael Wong

CTO, Distinguished Engineer, YetiWare
Michael Wong is the CTO of YetiWare an AI company, and was a Distinguished Engineer/VP of R&D at Codeplay/Intel. He is a current Director and VP of ISOCPP, Chair of the C++ Direction Group, and a 25 year senior member of the C++ Standards Committee with more than 15 years of experience... Read More →
Tuesday September 15, 2026 09:00 - 10:00 MDT
Colorado A

10:30 MDT

Language Designers Panel
Tuesday September 15, 2026 10:30 - 12:00 MDT
This Language Designers Panel features three of the people who decide what the languages you use every day actually become:
  • Bjarne Stroustrup, the creator of C++ (who will have just given his own Monday conference kickoff keynote the day before)
  • Guido van Rossum, the creator of Python
  • Mads Torgersen, the lead designer of C# and Anders Hejlsberg’s successor in that role
  • Moderator: Emma Tracey, founder of CultRepo and producer of its new feature film C++: The Documentary and Python: The Documentary
Three living and growing languages used by millions of developers, three design philosophies, one stage, one conversation.
Bjarne and Guido have never been on stage together anywhere and may never be again; add Mads to the stage, and we expect this special moment to be watched, cited, and argued over for years. You can be in the room when it happens.
Why should a C++ audience care about a panel that is two-thirds “other languages”? The answer is that these languages are two of C++’s closest neighbors and are used together all the time.
  • Python is, by the numbers, C++’s truest sister language. In the Standard C++ Foundation’s annual C++ developer survey, when we ask which other languages C++ programmers use, Python always comes first, consistently around 70 percent — ahead even of C, which you might expect to win and is consistently around 45 percent. If you write C++, the odds are very good that you also write Python; the two have grown up side by side, gluing and being glued, and the relationship only deepens each year.
  • C# and C++ are the two dominant languages on Windows, and the two are constantly used together — native performance underneath, managed productivity on top — so the person designing C# is designing part of the world that a great many C++ developers ship into.
So this is a conversation among the architects of the three languages most of us actually live in. What do they envy in one another’s designs? Where do they think they got it right, and where would they start over? How do you steer a language with millions of users and decades of existing code without breaking the people who depend on you? And the lessons to learn from their shared experience reach well beyond language design — the same instincts that shape a language will sharpen how you design your own libraries and products. Bring your own questions, too — you will not get a chance like this often.
Moderators Presenters
avatar for Bjarne Stroustrup

Bjarne Stroustrup

Professor, Columbia University

avatar for Mads Torgersen

Mads Torgersen

Speaker, Microsoft
Tuesday September 15, 2026 10:30 - 12:00 MDT
Colorado A

14:00 MDT

Running Compiler Explorer in 2026: Sandboxes, Storage, and Strangers' Code
Tuesday September 15, 2026 14:00 - 15:00 MDT
Compiler Explorer looks simple: type code, get assembly. Underneath: a fleet of sandboxed machines running hundreds of compilers across dozens of languages, terabytes of binaries to keep current, and the ongoing problem of executing arbitrary code from internet strangers.

A lot has changed in the 14 years that the site has been around: The sandboxing layers that let it run other people's code without losing sleep. The storage situation that very nearly broke it, and the content-addressable filesystem that quietly rescued everything. The operational war stories, the migration sagas, and the bits that are far more boring than they look from the outside. Along the way you'll see some of CE's recent features in their natural habitat, and get a peek at what's coming next.

You'll come away with a working mental model of how to run untrusted compilation at scale - and why the parts that look easy are almost always the hard ones.

Presenters
avatar for Matt Godbolt

Matt Godbolt

Programmer and sometime verb, Hudson River Trading
Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He works for Hudson River Trading on cool and interesting performance things. He's previously hacked on mobile apps at Google, run his own C++ tools company and spent more... Read More →
Tuesday September 15, 2026 14:00 - 15:00 MDT
Colorado A

15:15 MDT

Lock-Free Timer Scheduling With C++ Atomics
Tuesday September 15, 2026 15:15 - 16:15 MDT
Applications that present rapidly changing market data to human users face a practical challenge: updates may arrive thousands of times per second, but humans only benefit from periodic refreshes. Efficiently coalescing and scheduling that work without overwhelming CPU resources becomes a concurrency problem rather than simply a rendering problem.

This talk demonstrates how modern C++ atomics can be used to build a lock-free timer scheduler optimized for extremely high update rates. The scheduler follows a single-producer, multiple-consumer design in which work items represent recurring tasks that must execute periodically. Consumers process scheduled work and re-schedule it for future execution without relying on traditional locks or centralized coordination.

The most unusual aspect of the design is its “reverse work stealing” behavior: consumers can proactively give away work to other consumers and become idle themselves. Rather than distributing work evenly across all threads, the scheduler attempts to pack work onto as few cores as possible, reducing idle spinning, lowering CPU utilization, and improving cache locality. Because tasks may have highly variable execution times, the scheduler must also prevent pathological cases where work is endlessly redistributed between consumers.

Attendees will learn how atomics, lock-free forward lists, and memory ordering can be combined to implement high-throughput schedulers with predictable latency characteristics. The talk also discusses practical tradeoffs, implementation challenges, and performance measurements from production-inspired workloads, including producer throughput of approximately 50 million scheduled tasks per second and consumer processing throughput approaching 700 million tasks per second, while keeping migrated work items below 1% in typical workloads.

Presenters
avatar for Maxim Gurschi

Maxim Gurschi

Maxim Gurschi is a senior software engineer on the FXGO team at Bloomberg, where he is focused on building scalable, high-performance trading systems for electronic foreign exchange trading. In this role, he explores practical applications of modern C++ (20 and above) in latency-sensitive... Read More →
Tuesday September 15, 2026 15:15 - 16:15 MDT
Colorado A

16:45 MDT

Ensuring Code Quality in the Age of AI : More Code, Less Engineering!
Tuesday September 15, 2026 16:45 - 17:45 MDT
Was generating lines of code / upping the commit count the major impediment to delivering stable production ready software?

AI-assisted development has lowered the barrier to churn out code, helped engineers move faster in unfamiliar codebases, and made legacy systems easier to approach. however increased code output does not automatically mean better delivery of more reliable code.

In this talk, we will look at some of the emerging problems that are now becoming evident with AI ***amplifying existing weaknesses** such as code duplication, larger pull requests and the temptation to accept plausible generated changes without sufficient scrutiny . AI does not remove the need for engineering judgment. It removes the friction that used to slow down code creation

We will explore practical lines of defense to effectively reinforce long-term codebase health including stronger pull request descriptions, shared reviewer responsibility, review checklists, and metrics

The goal is not to reject AI. The goal is to ensure that AI improves engineering delivery rather than accelerating technical debt.

Presenters
avatar for Peter Muldoon

Peter Muldoon

Engineering Lead, Bloomberg
Pete Muldoon has been using C++ since 1991. Pete has worked in Ireland, England and the USA and is currently employed by Bloomberg. A consultant for over 20 years prior to joining Bloomberg, Peter has worked on a broad range of projects and code bases in a large number of companies... Read More →
Tuesday September 15, 2026 16:45 - 17:45 MDT
Colorado A

20:30 MDT

C++: The Documentary
Tuesday September 15, 2026 20:30 - 22:00 MDT

Tuesday September 15, 2026 20:30 - 22:00 MDT
Colorado A
 
Wednesday, September 16
 

09:00 MDT

Awaiters and Awaitables
Wednesday September 16, 2026 09:00 - 10:00 MDT
C++20 coroutines come with a reputation for complexity — and writing your own coroutine return type deserves that reputation. But here is the good news: you probably don't have to. With std::generator in C++23, high-quality libraries like Asio and cppcoro today, and std::task on its way in C++26, most developers can simply write co_await and move on.

There is one gap, however. Sooner or later, every developer using coroutines needs to bridge an existing asynchronous interface — a timer, an I/O operation, a thread pool callback, a legacy future — into the coroutine world. That bridge is built with awaiters and awaitables, and that is exactly what this session teaches.

We will start from first principles: what does co await actually do? We will demystify the three functions that form the awaiter protocol — await ready, await suspend, and await resume — and build a clear mental model for each. We will implement a real awaiter from scratch, then explore how symmetric control transfer keeps the call stack flat across deeply chained async operations. Next, we will learn how to make any existing type co await-able without modifying it, using operator co await, and how await transform lets you restrict or adapt awaitable behavior to a specific coroutine context. Finally, we will look at how to write cancellation-aware awaiters using std::stop token, so your coroutines respond promptly when work is no longer needed.

No prior coroutines experience is assumed. If you know what co await looks like on the surface but not what happens underneath it, this session is for you. You will leave with both the knowledge and the code to wrap any asynchronous operation into a first-class co await expression.

Presenters
avatar for Mateusz Pusz

Mateusz Pusz

C++ Trainer, Train IT
Mateusz Pusz is a C++ architect and voting member of the ISO C++ Committee (WG21), with 100% meeting attendance since 2017. As an active contributor to Library Evolution, he originated variable template template parameters (P2008, now part of C++26), co-authored heterogeneous lookup... Read More →
Wednesday September 16, 2026 09:00 - 10:00 MDT
Colorado A

10:30 MDT

How C++26 changes the way we write code
Wednesday September 16, 2026 10:30 - 12:00 MDT
The upcoming C++26 Standard is a major update of the language and one of the most impactful releases in the history of C++.

std::simd transforms high-performance C++ by raising vectorisation to a portable standard abstraction. The new sender/receiver execution library provides a powerful generic framework that redefines asynchronous programming in C++. Contract assertions introduce scalable and configurable correctness checks for identifying program defects and making C++ code safer. Finally, reflection – the most eagerly anticipated feature of C++26 – profoundly reshapes how we reason about C++ and what we can accomplish with it.

This talk is the third installment in a popular series exploring how each new C++ Standard changes the way we write code – from everyday idioms to advanced patterns – with a practical focus on what matters most to real-world developers. This is not a firehose talk that tries to cram as many additions to the latest Standard as possible into one hour. Instead, we focus deliberately on just a handful of particularly impactful features and highlight the essential ideas every C++ developer needs to understand.


Presenters
avatar for Timur Doumler

Timur Doumler

Senior Software Engineer, Citadel Securities
Timur Doumler is a software engineer specialising in low-latency and real-time C++. He works at Citadel Securities and is an active member of the ISO C++ standard committee, where he has (co-)authored many successful proposals including [[assume]], std::inplace_vector, and contract... Read More →
Wednesday September 16, 2026 10:30 - 12:00 MDT
Colorado A

14:00 MDT

Rule of 0,1,2,5,6,7,8,9,10?
Wednesday September 16, 2026 14:00 - 15:00 MDT
As of C++11 there are 6 special member functions that the compiler will generate for us if we don't do anything to get in the way.

But there are many other member functions, in the form of comparison operators, that we can =default explicitly

Which of these should we =default? How do we help the compiler, or stay out of its way?

How many do we need to implement? When can you trust the compiler or not?A

Presenters
avatar for Jason Turner

Jason Turner

Sole Proprietor, Jason Turner
Jason is host of the YouTube channel C++Weekly, co-host emeritus of the podcast CppCast, author of C++ Best Practices, and author of the first casual puzzle books designed to teach C++ fundamentals while having fun!
Wednesday September 16, 2026 14:00 - 15:00 MDT
Colorado A

15:15 MDT

Queue Discipline: A Deep Dive into Lock-Free SPSC, MPSC, SPMC, and MPMC Queues in Modern C++
Wednesday September 16, 2026 15:15 - 16:15 MDT
Queues are the backbone of concurrent systems — yet most C++ developers treat them as a black box. Pick the wrong queue topology, misplace an alignas, or use the wrong memory order, and you pay for it in microseconds of latency, invisible cache thrashing, or subtle correctness bugs that only manifest under load. This talk is a rigorous, bottom-up treatment of the four canonical concurrent queue topologies: SPSC, MPSC, SPMC, and MPMC. We start with the hardware reality — how cache coherence protocols turn innocent struct layout into a performance disaster through false sharing — and build upward through the C++ memory model, atomic operations, and queue algorithm design. For each topology, we derive the minimal set of memory ordering guarantees required for correctness, show how to exploit producer/consumer asymmetry to eliminate unnecessary synchronization, and demonstrate how alignas(std::hardware destructive interference size) and deliberate padding can be the difference between 100ns and 10ns throughput. We dissect Dmitry Vyukov's MPMC ring buffer, the intrusive MPSC queue, and Michael-Scott's linked-list queue — not just their interfaces, but the why behind every memory order acquire and every phantom cache line. We then go beyond correctness into the practical engineering tradeoffs: bounded vs unbounded, throughput vs latency, contention vs coordination overhead. Real benchmark data shows how these decisions interact non-obviously — an MPMC queue can outperform MPSC under certain producer counts, and seq cst where you don't need it can quietly halve your throughput. Attendees will leave with a clear mental model for choosing and implementing the right queue for their threading topology, a checklist for false sharing audits, and battle-tested code patterns suitable for low-latency production systems.

Presenters
avatar for Anmol Singhal

Anmol Singhal

Gardening, My garden
Anmol has spent 5 years working as a quantitative developer at Goldman Sachs and IMC trading. Previously he completed his education from NYU and BITS Pilani. Most recently he developed multi threaded applications for trading application and improved software performance. He errs on... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
Colorado A

16:45 MDT

Modern C++ Techniques to Reduce Boilerplate Without Sacrificing Performance
Wednesday September 16, 2026 16:45 - 17:45 MDT
Modern C++ gives developers powerful tools to write cleaner, safer, and more expressive code — but many production codebases still suffer from excessive boilerplate, repetitive patterns, and verbose implementations inherited from older C++ styles.

This talk explores practical modern C++ techniques that significantly reduce lines of code while preserving readability, maintainability, and runtime performance.

Through real-world examples, we will refactor traditional C++ implementations using features such as ranges, structured bindings, constexpr, concepts, CTAD, lambdas, std::optional, std::variant, and std::expected. We will examine where these features genuinely improve code quality — and where they can accidentally hurt clarity or performance if misused.

The session also goes beyond syntax improvements by analyzing generated assembly, compiler optimizations, allocations, and benchmark results to validate whether “shorter” code truly remains zero-cost.

Attendees will leave with practical patterns they can immediately apply to modernize existing codebases, reduce unnecessary complexity, and write more expressive C++ without sacrificing performance.

Presenters
avatar for VISHNU G NATH

VISHNU G NATH

Software Technical Lead, Applied Materials
Seasoned software developer with over 8 years of experience specializing in modern C++ development across industrial automation, semiconductor manufacturing, and enterprise systems. He currently works as a Technical Lead Software at Applied Materials, where he architects and implements... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
Colorado A

18:15 MDT

Boost.Documentary (Audience Preview Screening)
Wednesday September 16, 2026 18:15 - 21:00 MDT
Boost has always been run by its community. Nothing got in without review, nobody's library was above being argued. The Boost.Documentary filmmakers want their film held to the same standard. Join the test screening and ensure your thoughts are reflected in the general release cut!

The True Stories team will be on site during this Audience Preview Screening.

True Stories is the two-time Image Award-nominated production company of Collier Landry and Ray Nowosielski. They met on the production of A Murder in Mansfield, bringing to life Landry’s personal story for Warner Discovery, and have since together and solo led the productions of Emmy- and awards-nominated documentaries, including 1946: The Mistranslation that Shifted Culture, Desert One (HISTORY), Gumbo Coalition (HBO Max), Reservation Redemption, The Super Models (AppleTV), and Tricky Dick and the Man in Black (Netflix), and podcasts, including After the Uprising (iHeartMedia), The Collier Landry Show (YouTube), Finding Mom’s Killer (Sony/The Binge) and Moving Past Murder (YouTube).



Wednesday September 16, 2026 18:15 - 21:00 MDT
Colorado A
 
Thursday, September 17
 

09:00 MDT

Writing Low-Latency C++: Predictability, Cache, and the Architectures Underneath
Thursday September 17, 2026 09:00 - 10:00 MDT
In low-latency C++, correctness is table stakes. What separates good systems from great ones is predictability — the ability to hit your deadline not just on average, but at the 99th and 99.9th percentile, where real workloads live. Latency is a feature, and if you don't design for it explicitly, you lose it accidentally.

This talk is a practitioner's guide to writing C++ that behaves predictably under load, drawn from experience building and tuning low-latency systems on Microsoft's Azure Core platform. We start from the mental models that matter most — CPU-centric thinking, the latency stack from L1 to DRAM, and why minimizing work, unpredictability, and memory movement is the foundation of everything else — and then work through the layers of the stack where latency is won or lost in practice.

Through live demos and benchmark data on both x86 and ARM, we'll cover:

STL containers as latency contracts — why most latency bugs start with the wrong container, the real cost of dynamic reallocation, and the measurable wins from reserve() and custom allocators.

Memory layout and cache behavior — struct layout and alignment (and how it differs on x86-64 vs. ARM64), AoS vs. SoA trade-offs, hot/cold data separation, false sharing, NUMA, and TLB pressure.

Atomics vs. mutexes — when atomics actually lose to mutexes, why architecture and memory model dictate the answer, and how to choose between them in real code.

Threading and scheduling — fixed vs. dynamic thread pools, context-switch and migration costs, and why understanding the OS is half the battle.

Benchmarking and observability — why microbenchmarks lie, how to avoid measurement bias and jitter, why latency histograms beat averages, and why "absolute benchmark" is a myth.

You'll leave with a practical playbook for designing and measuring low-latency C++ systems, an honest understanding of why benchmarks from one machine rarely generalize to another, and a sharper instinct for the silent killers — allocations, branches, cache misses, and synchronization primitives — that don't show up in code review but do show up in production.

Presenters
avatar for Sampad Acharya

Sampad Acharya

Senior Quant Developer, Fixed Income Trading, Bloomberg
Sampad Acharya is a senior software engineer at Bloomberg, where he specializes in low‑latency, cache‑optimized C++ systems for trading and real‑time environments. He has worked in software development for six years. Sampad is deeply interested in how algorithms behave in the... Read More →
Thursday September 17, 2026 09:00 - 10:00 MDT
Colorado A

10:30 MDT

The Address is Not The Place: Object Residency in C++26
Thursday September 17, 2026 10:30 - 12:00 MDT
Random Access Memory is what you buy when you don’t know what your program will do next.
 
Until recently, alternative tiers of memory with vastly different latency characteristics were largely speculative. Then DRAM got expensive. CXL memory pools, far memory, even high bandwidth flash moved from blips to serious contenders. C++ has grown its vocabulary for ownership (smart pointers) and lifetimes (RAII); but intelligent memory tiering, specifically object residency, is a word we don’t natively have.
 
Attempts have been made to solve this issue at an OS-level (Meta’s TPP), or even a compiler/runtime level (OBASE) but they approach the problem transparently by design. And thus…blind by design. You can improve tiered object locality with clever placement within pages, but all these methods are structurally incapable of predicting intent. What if the power was in the developer’s hands?
 
With reflection (P2996) and annotations (P3394), C++26 finally lets us extend the vocabulary ourselves. Game developers have deeply understood smart data grouping for decades, but much of the work is locked behind game engines; not suitable for general application development. [[likely]] and [[unlikely]] hint hot and cold paths, but the future of high-performance development hints at general purpose object residency to tier-aware allocators.
 
This talk introduces an open-source C++26 residency library, demonstrating capabilities against current, and even (simulated) future hardware. The pieces are in place for C++ to create durable abstractions for object residency; with the flexibility to accommodate memory tiers that have not been invented yet!

Presenters
avatar for Laurie Kirk

Laurie Kirk

Researcher, Google
Laurie Kirk is a researcher at Google specializing in C++, reverse engineering, and deobfuscation. She runs a YouTube channel (@LaurieWired) that covers all sorts of in-depth research topics on reverse engineering, programming, and software optimizations. She has spoken at multiple... Read More →
Thursday September 17, 2026 10:30 - 12:00 MDT
Colorado A

14:00 MDT

When Zero-Cost Abstractions Aren’t Zero-Cost
Thursday September 17, 2026 14:00 - 15:00 MDT
Zero-cost abstractions are a foundational idea in C++, promising expressive, high-level code without sacrificing performance. However, developers often encounter unexpected costs when using modern abstractions in practice, even when the code appears idiomatic and well-designed.

This talk explores the assumptions behind zero-cost abstractions and examines what happens when those assumptions no longer hold. Through concrete examples drawn from modern C++ — including ranges and views, type erasure, allocators, and other common abstractions — we will examine how factors such as optimizer visibility, inlining boundaries, allocation behavior, and runtime flexibility influence performance.

This talk treats abstraction as a powerful engineering tool, examining the limits of its zero-cost guarantees in real-world systems. We will look at how seemingly small design choices can introduce hidden costs, why those costs are often difficult to spot through inspection alone, and how to recover performance without abandoning good design or readability.

Attendees will leave with a clearer understanding of when abstractions are truly zero-cost, how to recognize situations where they are not, and how to make informed tradeoffs between expressiveness, flexibility, and performance in modern C++.

Presenters
avatar for Steve Sorkin

Steve Sorkin

Senior Software Engineer, Bloomberg
Steve Sorkin has been at Bloomberg since 2019, where he is a senior software engineer. He is enthusiastic about writing clean, scalable, and maintainable code for use in low latency and high throughput applications. Prior to joining Bloomberg, Steve worked as a securities/derivatives... Read More →
Thursday September 17, 2026 14:00 - 15:00 MDT
Colorado A

15:15 MDT

Modernizing Legacy Codebases without Stopping the World
Thursday September 17, 2026 15:15 - 16:15 MDT
Every mature codebase carries history and technical debt. The challenge is modernizing without stopping the world or introducing big re-write failure risks.

In this talk, we’ll explore how to modernize legacy C++ codebases incrementally using a mix of deterministic code transformations and AI-assisted refactoring .

After delving into some of the common problems with legacy modernization, we'll start tackling the simple "boring" stuff that deliver huge leverage of changes via clang tooling . These represent repeatable, deterministic reviewable upgrades that can be automated and applied at scale.

Then we can look at more difficult transformations that can be AI assisted with more aggressive transformations including API improvements and how to prevent it going off the rails. This will be backed by Compiler diagnostics, static analysis and testing to keep changes maintainable and correct .

The goal is not to replace engineering judgment, but to accelerate it: turning modernization into a continuous, low-risk workflow instead of a disruptive project.

Attendees will leave with a repeatable playbook for modernizing legacy codebases incrementally, safely, and at scale—using the right tool for each class of change

Tooling Track sessions are sponsored by Optiver.
Presenters
avatar for Peter Muldoon

Peter Muldoon

Engineering Lead, Bloomberg
Pete Muldoon has been using C++ since 1991. Pete has worked in Ireland, England and the USA and is currently employed by Bloomberg. A consultant for over 20 years prior to joining Bloomberg, Peter has worked on a broad range of projects and code bases in a large number of companies... Read More →
Thursday September 17, 2026 15:15 - 16:15 MDT
Colorado A

16:45 MDT

Writing High Performance Parsers Using State Machines
Thursday September 17, 2026 16:45 - 17:45 MDT
Starting from the simple objective of writing an optimized lexer we will grapple with their fundamental performance factor: branch prediction. We will investigate how lookup tables can improve (or hurt) the CPUs prediction capabilities with some unexpected results. Over time our design evolves by combining parsing and lexing into a single step in a way that is as fast as just a standalone lexer. A central aspect of the design will be a primitive parsing state machine from which the parser source code is generated.

After the talk attendees will have a better understanding of some advanced branch prediction techniques and should have some new ideas for their present or future parsing endeavors.

Presenters
avatar for Torben Thaysen

Torben Thaysen

Torben Thaysen was passionate about software from a young age with his earliest C++ experiments dating back over 10 years. After acquiring his masters degree in physics he returned to his passion and became a C++ developer currently with 2 years experience under his belt. Now Torben... Read More →
Thursday September 17, 2026 16:45 - 17:45 MDT
Colorado A
 
Friday, September 18
 

09:00 MDT

“If You Can’t Measure It, You Can’t Improve It”: From Profiling to Automatic Benchmarking
Friday September 18, 2026 09:00 - 10:00 MDT
Modern hardware is increasingly complex and difficult to reason about; effective C++ performance work therefore demands a disciplined loop - profile, benchmark, analyze. Yet profiling alone is tricky, doesn’t answer “what if” questions, and manual benchmarking is dominated by hidden biases.

This talk presents a novel automatic benchmarking approach that focuses on eliminating measurement biases. We combine symbolic execution of identified hot regions with microarchitectural state randomization to systematically explore latency and throughput behavior under diverse - cache, branch, data layout - conditions. The technique is integrated with Linux perf, so the entire process - region isolation, state variation, measurement, analysis - is fully automatic.

The talk first grounds attendees in profiling with hardware performance counters, Top‑down Microarchitecture Analysis (TMA), and processor tracing. We then demonstrate how to automatically stress specific microarchitectural features to produce statistically reliable, "bias‑free" benchmarks. Finally, we close the loop with machine‑code analysis, showing how the measured numbers connect directly to instruction‑level behavior and ultimately to C++ code.

Attendees will leave with a concrete framework they can apply immediately to better understand and improve C++ performance.

Presenters
avatar for Kris Jusiak

Kris Jusiak

Lead Software Engineer, Citadel Securities
Nanosecond count
Friday September 18, 2026 09:00 - 10:00 MDT
Colorado A

10:30 MDT

What can C++26 reflection do for you?: A practical experiment in using reflection with an emphasis on binary protocol support
Friday September 18, 2026 10:30 - 11:30 MDT
How far can C++26 reflection take us? What are some techniques, gotchas, limitations and workarounds? How would reflection help write code that interacts with bespoke binary data formats? Come along as we explore a practical example together.

This talk will review advice gleaned from applying C++26 reflection to binary (structs on a wire) protocol handling. This type of protocol exists all around the world from financial market data formats to custom hardware interaction. Is the proposed reflection support enough to take a protocol definition written in the native terms of C++ and create flexible components to interact with that protocol?

Presenters
avatar for Andy Webber

Andy Webber

Technologist, Susquehanna
My name is Andy Webber and I work at Susquhanna which is a financial trading company near Philadelphia, PA. I started learning C++ in high school and I’ve been hooked ever since. I especially enjoy attempting to understand the full stack from the hardware up through high-level... Read More →
Friday September 18, 2026 10:30 - 11:30 MDT
Colorado A

13:30 MDT

Thinking Low Level, Writing High Level
Friday September 18, 2026 13:30 - 14:30 MDT
An overview of contemporary hardware platforms and how software engineering and design practices and methodologies could help in building performant systems, with a particular focus on low level optimizations. Contrary to attempting direct low level software engineering for addressing performance specifics, this talk would focus on how higher level abstractions could and should be used, and how a software engineer could help the compiler to “do the right thing”. The trend of moving software engineering focus upward to constructs that have a tendency of hiding the specific of the underlying platform is quite clear – and there certainly are very good reasons for such a paradigm change.

Performance matters. Premature optimization is evil. Is there anything in between those two extremes? How feasible is it to rely on the abstraction of the platform as hidden by the compiler and the corresponding libraries and language constructs, expecting that it will be able to realize the intended lower level optimizations? How much of hints and specifics would one need to expose for the compiler to be able to get the equivalent of direct low level approach? What is the right balance between expressing application logic via higher level construct yet still being able to gain the performance benefits compared relying on the low level specifics?

Looking from the practical applicability of lambdas, iterators, ranges, coroutines, error handling, and safe(r) memory access, the talk would attempt to cover a set of use cases with a focus on analysis of what could be done for focusing on performance.

The overall goal of the talk is not to go deep into low level aspects; the goal is to explain that one needs to be aware of such low level details while operating on the higher level constructs.

Presenters
IB

Ignas Bagdonas

Principal Architect, Equinix
Ignas Bagdonas has been involved in network engineering field for over two decades, covering operations, deployment, design, architecture, development, and standardization aspects. He has worked on multiple large SP and enterprise networks worldwide, participated in many of the world's... Read More →
Friday September 18, 2026 13:30 - 14:30 MDT
Colorado A

14:45 MDT

What 25 Days of Optimisations Taught Me About Compilers
Friday September 18, 2026 14:45 - 15:45 MDT
In December I posted a short video every day about a different compiler optimisation. Some were obvious. Some surprised me. A handful caught me out completely, and some even were compiler bugs!

This talk distils the most interesting into one talk. It isn't a clip show: the order matters, the gaps matter, and together they tell a story about where modern optimisers are scarily good, where they're stubbornly bad, and where that gap has moved in the last few years. With outtakes about what didn't make the cut and what I got wrong on camera.

Presenters
avatar for Matt Godbolt

Matt Godbolt

Programmer and sometime verb, Hudson River Trading
Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He works for Hudson River Trading on cool and interesting performance things. He's previously hacked on mobile apps at Google, run his own C++ tools company and spent more... Read More →
Friday September 18, 2026 14:45 - 15:45 MDT
Colorado A

16:15 MDT

C++: Growing in a world of efficiency, safety, and AI
Friday September 18, 2026 16:15 - 18:00 MDT
C++ is adding major expressive power (e.g., reflection) and addressing weaknesses (e.g., memory safety hardening) at exactly the moment when chip supply and power budgets are raising the value of what people came to C++ for in the first place: control over memory layout (space) and deterministic performance (time). This talk is about that convergence, in two parts.
First, we cover the latest developments in ISO C++ itself, where the committee completed technical work on C++26 in March 2026, and then in June voted the first additions into the working draft for C++29:
  • Key C++26 language improvements like reflection and the initial round of memory safety hardening, and standard library performance enhancers like std::simd and std::execution.
  • A new Annex in the C++29 working draft cataloging every case of core language undefined behavior, the first step toward addressing it systematically rather than one paper at a time.
  • Draft “profiles” for stronger portable memory safety guarantees, now being prototyped and targeted at C++29.
Second, we consider how quickly both hardware and software are moving in the industry around us. This year, capital is pouring into silicon and power at a jaw-dropping rate, and agentic systems are arriving with new capabilities and new failure modes. We’ll see how both affect C++ programming in the trenches:
  • Why performance efficiency has been enduringly important, from the 1940s through to today and with no end in sight.
  • How current industry data (SlashData, IDC) documents sustained growth in demand for professional programmers, especially who know languages that can operate under real space and time constraints.
  • What AI does and doesn’t change about any of it: a pragmatic view both of where AI has shown real benefit in our programming world, and of what it’s not good at (yet, or ever).
Throughout, we might hear a little grumbling from the speaker about how he has always written his own talk titles and abstracts and prose using em-dashes, but now can’t use em-dashes anymore because of, well, you know.

Presenters
avatar for Herb Sutter

Herb Sutter

Technical fellow, Citadel Securities

Friday September 18, 2026 16:15 - 18:00 MDT
Colorado A
 
Share Modal

Share this link via

Or copy link

Filter sessions
Apply filters to sessions.