Speaker: Marcell Juhasz

Audience level: 3

This session dives deep into the world of vulnerabilities from a C++ developer's perspective. Using a simple embedded device as the playground, where the memory model is stripped to the bare essentials, attendees will explore how classic attacks like buffer overflows can be used to hijack control flow, inject code, and manipulate the stack.

Speaker: Tina Ulbrich

Audience level: 1

„The compiler does not read comments, and neither do I” - Bjarne Stroustrup

Speaker: Nicolai Josuttis

Audience level: 7

C++20 introduced coroutines, which are functions that can be subspended and later resumed (in the same or a different context). As a consequence, coroutines allow programs to switch back and forth between different paths of execution. However, C++20 only provided low-level support, which is highly flexible but requires a lot of boilerplate code to implement even simple coroutine use cases.

One...

Speaker: Robert Schimkowitsch

Audience level: 3

Let's talk about monads. How do they work? Why and how would you use them?

Speaker: Sandor Dargo

Audience level: 3

Code reviews! Most consider it an indispensable element of modern software development. Yet, it's a surprisingly polarizing topic, with a significant crowd claiming that code reviews are a waste of time or even harmful. The reality is that most of us spend a non-negligable part of our workday reviewing pull requests. But how often do we pause to ask: Why are we doing this? And how can we do it better?

This...

Speaker: Sandor Dargo

Audience level: 1

In this beginner-friendly talk, we are going to explore namespaces. They are an essential tool for organizing our codebase around different concerns and across different layers. But we cannot call it a day by simply stating that.

Speaker: Mathew Benson

Audience level: 3

This talk will be a look at the current landscape of developing C++ without an IDE by taking a look at the tools, and in particular command line tools like compilers, linkers, etc. which are the backbones of the Integrated Development Environments(IDEs) that are the main way many people get to interact with the C++ language.

Speaker: Anders Schau Knatten

Audience level: 6

Programming languages like C, C++, and Rust all define a memory model, which allows you to reason about the ordering of memory operations in your program. This is crucial for the correctness and speed of your multithreaded programs, whether you're using good old mutexes or lock-free algorithms. But did you know that your CPU also has a memory model?

In the first part of this talk, we review some examples of C/C++, both single- and multithreaded, including a common lock-free algorithm. We examine the compiler-generated Assembly code and gain an intuition for how much reordering the compiler and the CPU are allowed to do. We then discuss what C++ means by a data race and how to avoid them using atomics and memory orderings like sequentially consistent, relaxed, acquire, and release. We also see how C++ reasons about memory ordering in terms of happens-before relationships.

In the second part of the talk, we examine the CPU memory models and what we mean by reordering of memory operations. There are many sources of reordering, such as the compiler, the CPU pipeline, micro-ops, memory systems with store buffers and coalescing, caches, etc. We then see how CPUs reason about memory ordering differently than languages like C++ and Rust and how the CPU memory models enable the language memory models to work. We also see how x86, ARM, and RISC-V have different approaches to this.

At the end of this talk, you will have gained a better understanding of what guarantees your programming language gives you and how the CPU works under the hood to allow your programs to (safely) go vroom! You will also have learned not to make assumptions about the correctness of your code by simply looking at the Assembly code.

Speaker: Anders Schau Knatten

Audience level: 1

Clang 20 introduced Function Effect Analysis (FEA), which enables real-time safety guarantees at compile-time. Mark your functions as non-throwing, non-allocating, or non-blocking — and have the compiler enforce it! For instance, a function marked non-allocating is not allowed to call malloc or new, and can only call other functions if they are also marked non-allocating (or if the compiler can deduce that they won't allocate).

In this talk, we will demonstrate function effect analysis and explain how it works. We will also see why it can be hard to enable FEA in the presence of third-party libraries, and what can be done about it.

At Squarehead, we've used FEA almost since its official release to refactor our soft real-time pipeline towards harder real-time. We will present our experience and lessons learned from this process, and the talk will be packed with useful real-life tips, tricks, and practices to set you up for success.

We will also demonstrate the brand-new RealtimeSanitizer, the run-time companion to FEA.

After this talk, you'll know how and why to use Function Effect Analysis and RealtimeSanitizer and be aware of real-life tips, tricks, and practices for using them in your own projects.

Speaker: Daniela Engert

Audience level: 3

There is a perceived push towards memory-safe languages in the developer community. Various administrative bodies want to see a reduction in avoidable vulnerabilities in commonly used software. These vulnerabilities may harm people, equipment, and property.

Speaker: Gabriel Valenzuela

Audience level: 3

This talk presents the engineering design and implementation journey of PetriNet Studio, a SaaS-based Petri Net simulator developed as part of my master’s thesis in Software Engineering. More than just a simulation tool, the project explores how modern C++ can be leveraged to architect a modular, extensible, and high-performance backend for a formal systems modeling platform

Speaker: Peter Sommerlad

Audience level: 3

C++ integers suffer from potential inaccuracy in arithmetic operations as well as undefined behavior.

Speaker: Arne Mertz

Audience level: 3

In projects that run over longer time, change is inevitable, and at some point the toolchain starts to look old and rusty compared to what is available elsewhere. "Let's just switch the compiler" is a phrase that is muttered quickly but can have multiple consequences. In this talk, I discuss the risks and pitfalls of switching to a new compiler as experienced in different projects, as well as the benefits beyond getting access to shiny new language features. The talk will also cover some thoughts and experiences of mitigating those risks.

Speaker: Steve Love

Audience level: 1

CMake has emerged as a leading tool for managing C++ projects. Although it's not particularly new,
there's a perception that it's complicated, arcane, or just unfamiliar. As an experienced programmer
returning to C++ after an extended absence, I certainly found CMake unfamiliar, but a little
research showed me that it's not as hard as it looks. I also discovered that it's flexible and
powerful too. In this talk I want to share some of that experience and hope that you'll embrace
CMake.

Speaker: Klaus Iglberger

Audience level: 7

It is popular today to complain about C++’s perceived safety issues: bounds, type, initialization and lifetime safety, and not to forget undefined behavior. However, when we take an honest look we will realize that today we have wonderful solutions to cope with these issues: ranges, value semantics, strong types, concepts, constexpr, … Using those makes it almost impossible to experience problems with any of these safety issues. So the question is: why do C++ developers still experience problems and why is C++ still perceived as problematic?

In...