Speaker: Daniela Engert

Audience level: [ Intermediate | Advanced ]

Languages are difficult. Foreign languages even more so. This applies not only to people, but also to computers. Nevertheless, we must always try to find the most appropriate formulations that convey our intentions as clearly and comprehensibly as possible, regardless of the language in which we express ourselves.

Speaker: Frances Buontempo

Audience level: [ Beginner | Intermediate | Advanced ]

AI is a huge topic and most people are talking about LLMs at the moment. Let's take a step back and look at something completely different: nature inspired swarm algorithms. We'll discover how to implement the "cat swarm algorithm" as an example. Each approach appears to give rise to swarm intelligence, and provides a good basis for learning how other AI algorithms work.

Speaker: Bryce Adelstein Lelbach

Audience level: [ Beginner | Intermediate ]

At the heart of the C++ programming language is the multi-threaded abstract machine and its execution model, the platform-agnostic formal model that generically describes how to run a C++ program. In this talk, you will learn the rules that govern how your C++ code is executed and see how those rules impact the C++ code you write every day.

Speaker: Miloš Anđelković

Audience level: [ Beginner ]

Disclaimer: excessive use of the word fun
Have you ever wondered how much fun() you can have using C++? What exactly is fun and how it works behind the scenes? What types of fun there are?
While this is a broad topic that would take more than one conferene talk to cover, here we will try to answer some of those questions, starting with the plain old fun and then moving into, perhaps more interesting, member fun.
We will cover some parts of overloading and overload resolution, how they are called and what pointers to member functions look like and what they are good for.
Finally we will try to answer what is a static fun but isn't static fun, and why it is the way it is.

This...

Speaker: Jonathan Müller

Audience level: [ Advanced ]

A C++ program manipulate objects, but it is undefined behavior if you attempt to manipulate them while they are not alive.

Speaker: Arne Mertz

Audience level: [ Beginner | Intermediate | Advanced ]

Books, blogs, and especially the C++ Core Guideline project usually contain useful guidelines and best practices towards writing better C++ and software in general. Quite often, these guidelines get retold countless times and are stripped of their rationale and reduced to single sentence rules that are blindly followed.

Speaker: Kevin Carpenter

Audience level: [ Beginner | Intermediate ]

Effective memory management is crucial for building efficient and reliable C++ applications. Custom memory allocators provide a powerful tool for optimizing memory usage, reducing fragmentation, and improving performance. This talk will explore the intricacies of memory allocation in C++, from the basics of dynamic memory management to the implementation of custom allocators. Attendees will gain insights into the standard allocator model, techniques for designing custom allocators, and practical examples of their use in real-world applications.

Join us to unlock the full potential of memory management in your C++ projects.

Speaker: Sandor Dargo

Audience level: [ Beginner | Intermediate ]

Clean code promises readability, maintainability, and clarity. But is it possible that the pursuit of clean code comes at a catastrophic cost to performance? Some sceptics argue that adhering to clean code practices means sacrificing years - if not decades - of hardware advancements. Is clean code really that expensive? Let’s explore the complex relationship between clean code and software performance. In this talk, we’ll delve into what makes software performant. We’ll demystify the effects of clean code on performance and discover what real bottlenecks are that you’ll encounter while working on enterprise software.

But...

Speaker: Steve Love

Audience level: [ Beginner | Intermediate ]

Unit testing in modern C++ has some great tool support, but it's easy to forget how language features play their part in testability, and how designing code to be easy to test can be harder than it sounds. This talk explores how C++ language features can be used to great effect in creating testable code that (not coincidentally) makes it great for use in application code too.

Speaker: Victor Ciura

Audience level: [ Beginner | Intermediate ]

Why should we be concerned with symmetry? Symmetry is fascinating to the human mind and everyone likes objects or patterns that are in some way symmetrical. It is an interesting fact that nature often exhibits certain kinds of symmetry in the objects and phenomena in our Universe.

Speaker: Sebastian Theophil

Audience level: [ Beginner | Intermediate | Advanced ]

Classes are maybe the most important language-feature of C++. It was originally called "C with classes" after all! Classes in C++ have constructors, destructors, base classes, template arguments, attributes etc. But that is just syntax. When we write and read code, a class should have meaning! It represents a value, a container, a resource or a state machine. Starting from these different use cases, I will show the best C++23 practices to define common types of classes. How do we define and constrain the life-cycle of an object? What special member functions should a class define or not define? What are regular types? What are standard layout types? I will cover the spaceship operator, conditionally explicit conversions, C++26 contracts, reference-qualified member functions and deducing this. By starting from common use-cases, I hope to show not only how to use these C++ features but when to use them.

Speaker: Gabriel Valenzuela

Audience level: [ Beginner | Intermediate | Advanced ]

This talk will explore my background in teaching C++ at university, focusing on the transition from traditional C programming to modern C++ in a comprehensive project-based lab environment. I will share insights on effective teaching methodologies, highlight the importance of bridging the gap between C and C++, and discuss the advantages of adopting modern C++ practices by showing the results it had on students. In addition, I will offer a perspective on the importance of lifelong learning in the rapidly evolving field of programming.

Speaker: Kerstin Keller

Audience level: [ Beginner | Intermediate | Advanced ]

If you are maintaining a C++ library, there is very little way to get around using CMake, as it's the de-facto standard (meta) build system for cross-platform development.
Writing good CMake build files for libraries makes all the differences, if a library integration goes smoothly or ends up being a huge hassle for the user of the library.
While integrating numerous (>100) open source libraries for inhouse usage, I have seen and learned alot about how (and how not) to write good CMake Code. 
In this talk, we will touch upon some fundamental concepts, that result in clean CMake code, useful for any developer using CMake.

Speaker: Andreas Weis

Audience level: [ Beginner | Intermediate ]

Modules have been one of the most highly anticipated features of C++20. Unfortunately, it was also the language feature that took the longest to become widely available for developers to use. This year for the first time we see broad support for the feature in all major compilers and mainstream build system support through CMake. The goal of this talk is to provide you with all the basic knowledge to allow you getting started with C++20 modules today.

We...

Speaker: Timur Doumler

Audience level: [ Beginner | Intermediate | Advanced ]

Design by Contract is a very effective approach for writing safer, more correct programs. It has been successfully implemented in programming languages like Eiffel and Ada. Attempts to add a Contracts facility to C++ have a long and storied history spanning two decades. Since the last attempt to standardise Contracts (for the C++20 Standard) has failed, SG21 — the Contracts Study Group on the C++ Standard Committee – has been working on a new design, the so-called Contracts MVP, which is now essentially feature-complete and on track to make it into the upcoming C++26 Standard.

In...