Speaker: Dawid Zalewski

Audience level: 6

Static reflection that shipped with C++26 is primarily a compile-time introspection powerhouse. Luckily, next to inspection, we also got two features that together allow us to use reflection for compile-time code injection. The first is the ability to define arbitrary aggregates with std::meta::define_aggregate. The second is annotations, an amazingly flexible tool for attaching metadata to our code. When combined, they finally make it possible to bring user-friendly features like Rust's #[derive(Debug)] to C++.

In...

Speaker: Rahel Natalie Engel

Audience level: 3

C++26 reflection opens up new ways to remove boilerplate and reduce duplication in complex software systems. Using examples from Catpie, an educational programming language, this talk demonstrates how reflection can simplify language implementation, improve extensibility and reduce repetitive code. We'll introduce the relevant reflection features and discuss problems encountered.
Attendees will leave with a practical understanding of C++26 reflection and with ideas for applying it to their own projects.

...

Speaker: Dušan Jovanović

Audience level: 6

std::chrono is widely called a masterpiece of API design, but why? The secret isn’t constexpr or templates. It’s mathematics.

Speaker: Anders Schau Knatten

Audience level: 1

Sanitizers like AddressSanitizer and ThreadSanitizer can find issues in your code that your compiler and tests won't otherwise find. Some important examples include uses-after-free and data races. But how exactly are they able to do this?

Speaker: Raymi Klingers

Audience level: 6

The Age of Empires series that started all the way back in 1997 famously tackled online multiplayer using a synchronous lockstep networking model as described in the paper: 1500 Archers on a 28.8: Network Programming in Age of Empires and Beyond.
This architecture relies on an entirely deterministic simulation as all players must run an identical simulation given the same input commands and parameters.

The...

Speaker: Jan Wilczek

Audience level: 6

Application developers sometimes hit a limitation of a 3rd-party library or framework. The Type Erasure design pattern can help us overcome such limitations without the need to change the 3rd-party API.

Speaker: Giuseppe D'Angelo

Audience level: 7

Trivial relocation is, informally, the ability to move an object from one place in memory to another by just copying its bytes, skipping the move constructor and destructor call that C++ normally requires. It is not a new idea: major C++ libraries (Qt, folly, BSL, EA-STL, and others) have relied on this pattern for more than twenty years to speed up container operations, and it has long been considered a natural candidate for standardization.

And...

Speaker: Hannah Lenk

Audience level: 7

Rumors of software engineerings demise have been greatly exaggerated.
Nonetheless, I am concerned when it is regularly proclaimed to be 6 month away and saddened when we are cynically thanked for our difficult-to-remember effort of having written software character-by-character.

Speaker: Boguslaw Cyganek

Audience level: 7

In the context of AI, we increasingly hear the term "tensor." Yet many developers still perceive tensors as mysterious mathematical objects hidden behind Python APIs and GPU frameworks.

Speaker: Tanweer Ali

Audience level: 2

Over the years, CPU architectures have evolved to include SIMD instructions such as SSE, AVX, and AVX-512 on x86 platforms, and NEON and SVE on ARM platforms. Compilers like GCC and Clang exploit these capabilities automatically through auto-vectorization, enabled by default at `-O2` and above. In theory, this gives us portable performance without resorting to architecture-specific intrinsics. In practice, however, auto-vectorization is often highly sensitive to how loops are expressed.

This...

Speaker: Ivan Čukić

Audience level: 3

Contracts are in. Finally!

Speaker: Roth Michaels

Audience level: 7

(full proposed title if not too long): "The Skeptic, the Staff Engineer, the PM, and the UX Designer: What changes when everyone gets an AI coding agent"

Speaker: Kerstin Keller

Audience level: 3

The program crashes in places where it has never crashed before. Only in some environments. Inside well-tested functions. And nobody knows why.

Often, these crashes are not caused by local bugs. Instead, they arise from the way our program is composed. The root cause is usually an ABI incompatibility or an ODR violation.

In this talk, we’ll look at a practical example of how ODR violations can creep into our software systems. We will revisit fundamentals such as static and dynamic libraries, linkage, and symbol visibility, and discuss how to design our components and compose our systems to make them more robust against this class of bug.

...

Speaker: Ivan Khodar

Audience level: 3

(N)RVO is a cool optimization which is not well understood. This talk will explore some examples of how that optimization works, as well as dig into the Clang compiler to demonstrate that optimization from the compiler side in order to help attendees better understand it.

Speaker: Lieven Cock

Audience level: 1

Static reflection in C++26 is major feature, it is consired a game changer. We will have a look on some basic things we can do with it, only scratching the surface of what is possible, wet your appetite, and start dreaming. We will be creating a Universal printer (which can also print enumerations), parsing command line arguments in a scalable way. Next we will determine if there is padding in our types and we might also generate some new types if time permits.
All nice little things which are now possible, thanks to reflection.

...