Speaker: Victor Ciura

Audience level: 3

What is it like to come to Rust from C++? What are the gaps, the needs, the gems and the tools you should know about? Where is my favorite C++ feature in Rust? What are the idiomatic parallels between various successful strategies and features in both these languages? What are their respective strengths?

Speaker: Ivan Čukić

Audience level: 6

Coroutines were touted as one of the most important features of C++20, and we had many talks to watch and blog posts to read about how they work internally and how to customize them and implement our own coroutine types for writing structured conurrent code. Since then, the Standard got no asynchronous coroutines, and most effort in the area of 'structured concurrency' went to senders and receivers.

While...

Speaker: Ivan Čukić

Audience level: 6

Coroutines were touted as one of the most important features of C++20, and we had many talks to watch and blog posts to read about how they work internally and how to customize them and implement our own coroutine types for writing structured conurrent code. Since then, the Standard got no asynchronous coroutines, and most effort in the area of 'structured concurrency' went to senders and receivers.

While...

Speaker: Andreas Fertig

Audience level: 6

C++ is used in many different fields. One that sticks out is the embedded domain, you're often working with tight constraints. Writing software is challenging and fun at the same time.

Speaker: Quasar Chunawala

Audience level: 3

I would like to present a short "back-to-the-basics" talk on designing a lock-free SPSC queue. I would like to briefly touch upon, why mutual exclusion and what race conditions are, mutex types and mutex managers in the C++ standard library. We look at the producer-consumer problem (its a different type of race-condition). Then, we code up a simple lock-based SPSC queue using condition variables. I also walk-through few examples of std::binary_semaphore, std::counting_semaphore, barriers and latches.

After...

Speaker: Evgenii Seliverstov

Audience level: 6

Even with the best C++ practices, memory errors and concurrency issues remain a challenge. The modern tooling available in GCC and LLVM can help to catch these problems at runtime. This talk provides a deep dive into address and memory sanitizers with a practical case study of instrumenting an application.

Speaker: Alex Dathskovsky

Audience level: 2

With C++23 already making headlines and C++26 on the horizon, it’s tempting to focus on the bleeding edge. But in practice, many companies are still navigating the shift to C++20 — not beyond it. This talk is designed to help developers make the most of this pivotal transition.

While the "big four" features of C++20 — concepts, coroutines, ranges, and modules — often steal the spotlight, there’s a rich set of lesser-known but immensely useful additions that can dramatically improve the way we write modern C++.

In this session, we’ll go beyond the headlines and dive into the real-world power of C++20. Using practical examples, we’ll explore improvements to constexpr, enhanced lambdas, the spaceship operator, consteval, templated lambdas, and more — all the features that silently unlock better performance, maintainability, and expressiveness.

Whether you’re still on C++17 or already experimenting with C++20, this talk will bridge the gap between potential and practice — and get you ready for what’s next.

Speaker: Alex Dathskovsky

Audience level: 2

With C++23 already making headlines and C++26 on the horizon, it’s tempting to focus on the bleeding edge. But in practice, many companies are still navigating the shift to C++20 — not beyond it. This talk is designed to help developers make the most of this pivotal transition.

While the "big four" features of C++20 — concepts, coroutines, ranges, and modules — often steal the spotlight, there’s a rich set of lesser-known but immensely useful additions that can dramatically improve the way we write modern C++.

In this session, we’ll go beyond the headlines and dive into the real-world power of C++20. Using practical examples, we’ll explore improvements to constexpr, enhanced lambdas, the spaceship operator, consteval, templated lambdas, and more — all the features that silently unlock better performance, maintainability, and expressiveness.

Whether you’re still on C++17 or already experimenting with C++20, this talk will bridge the gap between potential and practice — and get you ready for what’s next.

Speaker: Andrew Drakeford

Audience level: 6

Data-oriented design (DOD) has gained traction for its practical approach to solving real-world problems. Refactoring data into an Entity-Component format sets the stage for cleaner, more efficient implementations—where lambdas process ranges and SIMD operations exploit the power of contiguous data layouts. DOD is widely recognized for addressing hardware-related performance challenges, but where do these challenges originate?

The...

Speaker: Mikhail Svetkin

Audience level: 2

In the ongoing debate about the safety of C++, undefined behavior (UB), bounds checking, and memory leaks often dominate the conversation. While some argue that these pitfalls are inherent to the language’s power and flexibility, modern C++ standards have introduced mechanisms to mitigate these risks.

Speaker: Jonathan Müller

Audience level: 6

Iterators and ranges have been essential parts of the C++ standard library since its inception. With C++20, they were brought to the next level in the form of `std::ranges`: We now have formalized requirements on the algorithms, lazy views to enable pipelines, and much more powerful iterators. Since then, more and more views and algorithms have been added in C++23.

Speaker: Jonathan Müller

Audience level: 3

When you need a container, pick `std::vector` by default. This is because `std::vector` is cache-friendly.

Speaker: Sebastian Theophil

Audience level: 7

Every program may encounter errors, some originating from internal bugs in the program, others coming from the environment the program is operating in. Ignoring all errors will make the program utterly unreliable, while treating every conceivable one introduces lots of extra complexity with little benefit. So which errors should you handle? And how should you handle them? This talk describes our proven approach to error handling so that you can write more reliable software with less effort.

C++23...

Speaker: Jan Baart

Audience level: 3

Modernizing a large C++ codebase can seem like a daunting task, but it doesn’t have to be. In this session, we’ll explore a variety of modern C++ techniques and practical refactorings you can apply to improve your codebase. Discover modernization approaches that enhance readability, maintainability, and adaptability:

Speaker: Olivia Quinet

Audience level: 1

The type-erasure design pattern was used to create an efficient expression evaluator.  It is applied to large datasets with complex user-defined expressions involving several columns.