Speaker: Bryce Adelstein Lelbach

Audience level: [ Intermediate | Advanced ]

In the next decade, three major new C++ features will reshape how we write C++ code - reflection/injection, pattern matching, and senders:

Speaker: Michael Shah

Audience level: [ Beginner ]

The C++ Standard Library provides a common set of data structures (known as containers) for inserting, updating, and removing data. Since the most recent standardization of C++ 23, additional container and container adaptors have been added. In this talk, I will discuss how C++ organizes these containers (sequence, associative, unordered associative, and adaptors) targeted at a beginner who wants to understand how to navigate the STL. ALong this journey trade-offs with each data structure will be discussed. Listeners to this talk will leave with a cheat-sheet of data structures, so they know immediately which data structures to use when starting a project. C++ examples will be shown for how to use each container, the time complexity of the operations, the common implementation of each container. Some other common 'gotchas' regarding thread-safety and iterator invalidation will be displayed in these examples. Finally, time will be spent at the end of this talk highlighting the new C++ 23 flat container containers. 

Speaker: Frances Buontempo

Audience level: [ Intermediate ]

How can a deterministic function possibly give random results? We will find out and learn how to use various random number distributions.

Speaker: Tina Ulbrich

Audience level: [ Intermediate ]

When talking about ranges I always get the same questions "but how about compile time? how about runtime?" because usually abstractions give us the impression that they might slow down either compile time or run time or both. The advantages of ranges lie in the ease of use, composability, and readability but many people cannot sacrifice run time performance for it. So that sparked the idea of using different tools to do a deep dive into the ranges code and answer these questions as objectively as possible. In this talk I will talk about the tools I used on both Windows and Linux and the insights they give into ranges code compared to non-ranges code. I will concentrate on runtime performance and memory usage. The analysis features one example written in: C-style C++, C++17 and C++23/ranges. The comparison of these styles will give you an impression which effects modernization of your code has on performance.

Speaker: Denis Yaroshevskiy

Audience level: [ Beginner | Intermediate | Advanced ]

Consider the difference between explaining the gist of quick-sort and actually writing a production implementation. The first is very quick and can be done in 5 minutes while the second can easily take you months. We will firmly plant ourselves in the first category and look at the basic ideas behind some non-trivial SIMD (i.e. vectorized) algorithms. The plan is to at least cover strcmp, set_intersect and sort but I hope to squize in a few more. The talk does not expect you to know anything but some CS101 algorithms. After the talk, hopefully, SIMD will not seem such a mysterious art.

Speaker: Arno Schödl

Audience level: [ Intermediate | Advanced ]

Ranges have been in the C++ standard for while now, and find their way into modern codebases. At think-cell, we have been developing and using our own range library for 20 years, which is built on top of the standard and is compatible with it, but goes beyond it in many aspects. Range adaptors are often stacked, a filter on top of a transform on top of etc. To make such a stack efficient, iterators are not good enough. We use a new concept that is more efficient and at the same time compatible with iterators so library users can keep using iterators as they did before. The standard library is very strict about the distinction between containers and views, and range adaptors are views which must maintain a reference to the data being adapted. Instead, we allow range adaptors to hold data themselves to make them self-contained and lazily evaluated at the same time. The standard iterator model only allows external iteration. However, internal iteration is often much easier to implement than external iteration. For many applications, internal iteration is completely adequate and more efficient than external iteration. Therefore, we bring internal iteration into the range family, to the point that the library user may not know or care which kind of iteration is being used. Standard algorithms return iterations and use the end iterator to signal some singleton state. By customizing return values, we can make our code more terse and expressive, for example eliminating these dreaded iterator end checks. These features combined make ranges an excellent tool for text formatting. We can use these ranges to represent the values to be formatted, conceptually turning them into lazily evaluated strings. These can be used just like regular strings are used today: in function returns; as standard algorithm input; embedded into other, equally lazily evaluated strings; and so on, before they are finally expanded for display. By choosing the right interfaces, we can optimize this expansion at compile-time, allowing both nice syntax and a performance which is very close to manually optimized code.

Speaker: IRAKLEIA KARYOTI

Audience level: [ Beginner ]

As code bases grow, and more and more feature requests come in, the need for componetization and decoupling is more like the only way to go.
So we are now leaving monolithic architectures (or more like we've been leaving monolithic arhictectures for quite some time now) and we're switching to service oriented designs.
Many of us are now using grpc (google's RPC framework) for interconnectivity and it all works great, when we'll building from scratch.
But what if we would like to modernize our old code bases or connect our old monolithic apps? How can we effectively do that?
How can we advance from the usage of such a modern RPC tool, without even knowing about it?
This talk will be about providing a solution to use grpc C++ in a more generic way, abstracting the details, decoupling service implementation from its definition and eliminating dependencies.

Speaker: Klaus Iglberger

Audience level: [ Intermediate ]

Creational design patterns, among them the Factory Method, the Abstract Factory, and the Builder design patterns, are among the most commonly used design patterns. However, in the almost 30 years since their formulation, many misconceptions and myths have accumulated around these design patterns.

Speaker: Greg Law

Audience level: [ Intermediate | Advanced ]

Everyone knows that debugging is twice as hard as writing the code in the first place. At some point your program, which did billions of things per second, has diverged from your expectations and you need to figure out where. Time travel debugging can be incredibly powerful: it allows you to rewind your program's execution to any line of code that executed and see any piece of program state at any time. Setting a watchpoint (aka data breakpoint) on a suspicious-looking data and winding back to the line of code that last changed that data is particularly helpful.

For...

Speaker: Nicolai Josuttis

Audience level: [ Beginner | Intermediate | Advanced ]

One of the most important but also most suprising C++ standard views is the filter view, introduced with C++20.

Speaker: Koen Poppe

Audience level: [ Beginner | Intermediate ]

As developers, adding log statements seems easy and risk-free. However, with hundreds of machines, collecting those log files can become quite a challenge, let alone making sense of the important information they contain. We set out to reduce logging to its essentials and explore optimisations not only in terms of disk space, but also runtime performance and even exposure. Leveraging ideas from well-known software related workflows, we will write a C++20 logging framework from scratch and highlight some surprises along the way.

Speaker: Daniela Engert

Audience level: [ Intermediate | Advanced ]

If you are interested in the topic of C++ Modules you are probably aware of the fact that the implementation of modules in the three major compilers is progressing at very different speeds: msvc is mature enough to be used with modules almost everywhere, but both clang and gcc are coming along at their own pace. The same is true with build systems that support C++ Modules. MSBuild handles all kinds of module types, but most people are waiting for modules support in CMake to even consider start using them. So, let's dive into the cross-platform modules world and see what you can do today, how you can create modules with CMake, and what kind of experience you can expect.

This...

Speaker: Boguslaw Cyganek

Audience level: [ Beginner | Intermediate | Advanced ]

If you are an academic teacher, a group leader, or a software engineer interested in developing methods for the robust teaching of C++, then please come to my talk so we can share ideas for better and more efficient teaching of C++.

Speaker: Miloš Anđelković

Audience level: [ Beginner | Intermediate ]

It's a regular thing to write a class that will later be used in various ways trough the application. But how often do we stop and thing about what the compiler does with it, what the compiler can do with it, and finally how the class ends up looking in memory. To novice programmers there are some rules and behaviors that might be surprising. Here we will take a stroll trough the C++ documentation and see what the compiler is allowed, by law, to do, define some terms, see what tools we can use to peek under the hood and better understand our code. All of this of course accompanied with some simple examples because seeing is believing. And finally this entire exercise would be useless unless we see what actual impact this has on performance.

This...

Speaker: Rainer Grimm

Audience level: [ Beginner | Intermediate ]

With the publishing of the C++11 standard, C++ got a multithreading library and a memory model.
This library has basic building blocks like atomic variables, threads, locks, and condition variables.
That’s the foundation on which C++ standards such as C++20 can establish higher-level abstractions. This higher-level abstraction will be the focus of this talk.