Speaker: Jana Machutová

Audience level: 2

Once upon a time, a developer spawned a thread… and everything seemed fine. But inside that tidy code lived data races, deadlocks, and memory gremlins waiting to escape. In this 60-minute story-driven adventure, we’ll meet the most common (and mischievous) concurrency bugs in modern C++. We’ll explore how they sneak into everyday code and why they’re so good at hiding. Expect playful examples. No silver bullets — just a friendly map of the concurrency monster zoo. You’ll walk away a little braver… and your threads a lot better behaved.

Speaker: Sandor Dargo

Audience level: 1

Time handling in C++ looks simple — but it has some caveats. Between system_clock, steady_clock, high_resolution_clock, and a few new friends from C++20, it’s easy to pick the wrong one and end up with flaky tests, wrong timestamps, or confusing results.

Speaker: Sandor Dargo

Audience level: 2

AI is rapidly changing how we write software. We type less, prompt more, and spend increasing amounts of time reviewing code instead of creating it. Productivity may be up — but something else feels off.

Many of us, developers, are sadly experiencing it: the loss of flow, reduced sense of ownership, and the unsettling numb feeling that the craft we fell in love with is slipping away.

But what if we're looking for joy in the wrong place?

In this talk, we'll explore how AI is reshaping the day-to-day experience of programming — not just what we build, but how it feels to build it. We'll revisit what made programming fulfilling in the first place: solving problems, reducing complexity, and exercising judgment.

From there, we'll develop a new mental model of programming in the AI era — one where typing matters less, but clarity, taste, and decision-making matter more than ever.

You'll walk away with:

• A deeper understanding of why modern development can feel more tiring despite higher productivity
• A reframing of programming as a craft that goes beyond code generation
• Practical techniques to regain flow, strengthen your judgment, and find joy again in your work

AI hasn't taken away the craft of programming — but it clearly it changed its shape. The opportunity for mastery is still there. The question is: are we willing to adapt how we pursue it?

Speaker: Daniela Engert

Audience level: 6

Compilation speed is one of the major pain points for developers, cited in many surveys.

Speaker: Denis Yaroshevskiy

Audience level: 6

C++26 introduces two new low level concurrency primitives: rcu and hazard pointers.
Both can serve as fast, practical alternatives to locking - if you know how to use them.

Speaker: Frances Buontempo

Audience level: 1

How do you remove negative numbers from a container? remove_if doesn't actually remove elements. More modern C++ gives us better approaches which are less confusing. This talk will show old and new ways to remove negatives, helping you think about what is going on under the hood and why.

Speaker: Amlal El Mahrouss

Audience level: 4

In this talk we're going to layout techniques and decisions to take in order to successfully develop a low-level system in modern C++ (C++17 and more)

Speaker: Guy Davidson

Audience level: 7

The three-year train model continues to deliver as the next version of C++ heaves into view. In Croydon earlier this year the committee waved off the working draft to ISO to publish it as C++26. It will take a while to work its way through the process, but we're ready to start looking at what it delivers for you, the C++ user.

Speaker: Robert Schimkowitsch

Audience level: 3

A std::variant can store a value of one type at a time, out of a user-defined set of types. Those types can be completely unrelated to one another, but we can design them to have similarities. Templates allow us to process unrelated types, if there is a common way to interact with them. Bring those two observations together, and wonderful things become possible.

In this talk, we explore combining template techniques with std::variant. The result? Extensible code with less boilerplate.

We cover the basics of the subject area, then introduce an example inspired by my own work experience. As we dive into some key code snippets essential to the overall design, we identify problems, then figure out how to solve them. On this journey, we learn about breaking dependencies, ergonomic use of distinct data types and replacing duplicate code with a single implementation. We look at template instantiations to visualize and understand both the compile-time and run-time aspects of our code. Finally, we evaluate the code design impact of our changes, and what benefits they gave us.

After this talk, you will have a firm grasp on techniques that make std::variant even more useful in practice. This will unlock more options for your next application subsystem design. You do not need prior knowledge of either std::variant or writing template code.

Speaker: Klaus Iglberger

Audience level: 6

Design patterns are everywhere, as they are the key to managing dependencies between software entities. Thus knowledge about these is an essential part of every programmers toolbox. But despite their fundamental importance, there are some common misconceptions about them, in particular about several of the most often used design patterns.

Speaker: Mikhail Matrosov

Audience level: 6

High frequency trading is one of the fields where there is no real alternative to C++. When every nanosecond matters, you absolutely need a tool which can squeeze everything from your hardware.

Speaker: Guy Davidson

Audience level: 7

"Profiles" are a framework designed to improve software safety and security by allowing developers to opt into specific sets of rules and guarantees. Championed by C++ creator Bjarne Stroustrup, they provide a way to transition existing codebases toward modern safety standards (like memory and type safety) without fragmenting the language into incompatible dialects.

Speaker: Tina Ulbrich

Audience level: 1

Ready to start your first larger C++ project but unsure where to begin? The modern C++ ecosystem offers an overwhelming number of tools, libraries, IDEs, compilers, and learning resources, making it difficult to know which choices are worth your time.

This talk provides a practical introduction to building a modern C++ project from the ground up. We will explore the most common and widely recommended tools in the ecosystem, compare their strengths and trade-offs, and discuss how to choose the right setup for your specific needs.

By the end, you will have a clearer understanding of the available options and the confidence to make informed decisions when starting your next C++ project.

Speaker: Mathieu Ropert

Audience level: 6

Software performance doesn't happen on accident, nor can it be an afterthought. Through my career I have found that with the right combination of factors most non-trivial codebases can achieve significant performance improvements.

Speaker: Antoine MORRIER

Audience level: 6

Writing correct multithreaded C++ is hard, and the type system does little to help.