Speaker: David Sankel

Audience level: [ Beginner | Intermediate | Advanced ]

This talk introduces the Beman Project, a new community initiative to improve the quality of C++ standard library enhancements. The project provides a) a simple way for engineers to evaluate standard library proposal implementations, b) a high quality template for standard library authors to share their implementations, and c) a modern platform for the wider C++ community to discuss standard proposals.

We'll...

Speaker: Mike Crowe

Audience level: [ Intermediate ]

Modernising your codebase sounds fun to start with, but quickly gets tedious. Can we use tools to help us speed through the tedious bit?

Speaker: Greg Law

Audience level: [ Intermediate | Advanced ]

Race conditions and other issues with multi-threaded code can be fiendishly difficult to debug. Too often we rely on printf, coffee and swearing -- we can do better!

Speaker: Nico Heidtke

Audience level: [ Beginner | Intermediate ]

I'll talk about the lessons one can learn from observing C++ codebases and development teams grow and mature over time - meaning the typical problems that arise as more code, more developers and dependencies are added.

We'll look at some common yet avoidable mistakes and how to prevent unnecessary technical debt.

The goal is to provide developers with the knowledge to be able to avoid some of the most critical mistakes early on in a codebases life-cycle. Each piece of advice will come with a field report.

...

Speaker: Louis Dionne

Audience level: [ Beginner | Intermediate | Advanced ]

This talk will go over two security mitigation techniques we implemented as extensions in the Clang and libc++ toolchain: Standard Library hardening and typed memory allocation. Standard Library hardening allows catching common cases of undefined behavior such as out-of-bounds memory accesses and turning them into guaranteed traps. Typed memory allocation allows passing compiler-inferred type information to the system allocator, which can then isolate memory allocations based on types so as to make it more difficult to put together a type confusion attack by exploiting a temporal memory safety issue.

Speaker: Ignas Bagdonas

Audience level: [ Advanced ]

Practical software does not run in an abstract vacuum, it runs on underlying hardware platforms. Practical software engineering does not exist in an abstract vacuum either. The software layer sits in between the domain specific requirements on top and the underlying runtime platforms below. Many interesting developments have happened on all three of those layers over the years, and while contemporary hardware has gone a long way forward, it often suffers from the attention deficit caused by an overshadowing flood of advancements and “advancements” in the software part of the universe. This new shiny programming language is safe, performant, and solves a backlog of problems that have been dragging for long. While that new shiny programming paradigm automagically relieves from dealing with low level details and the toolchain is plain amazing. The hardware side brings into this fistfight a set of new architectures, ISAs, and hardware abstractions – just to stay on par with the software side. Looks perfect? What else would an engineer dream about, no?

Not really. Let’s take a look at the contemporary commodity hardware platforms of today, and also at the trendy software engineering waves of today, and try to sense how and why it could (and frequently does) cross out the potential benefits of hardware advancements – and what could be done to actually be friendly to your underlying hardware, and at what cost.  

This is a set of somewhat separate topics, bound together into a common logical set of performance engineering.

How do language constructs such as references, lambdas, inheritance, object representation, runtime checks, and selected STL examples map to the actual runnable platform level code, and at what cost.  

The notion of out-of-order execution, claims on whether OoO is superior and there is no need to look at the level of instruction selection. What specifically is out of order in the context of contemporary x86 platforms (surprisingly, it is not instructions), and what impact does it have to the overall performance. A brief look into where the complexity lies inside the contemporary high performance execution cores and sockets, and why aspects such as variable length instruction encoding are trivial to resolve.

Memory hierarchy operation, logical, physical, and geometrical address spaces, their relationship and translations, memory performance in virtual address spaces, and clever ways to hide capacitor array’s latency.

Vectorization and why it is still not there yet universally everywhere, and why it won’t be?

Data dependencies and what could be done about it.

How could one help the compiler to do the right thing, and yet more important – how could one stay away from making things more complex for the compiler to do the right thing.

Branching control.

ABI aspects, parameter passing, compilation unit scope and its impact.

The claims on the imminent obsolescence of x86 and how the new wave of ARM and RISC-V upstarts will overtake it once again after previous not so successful attempts.

...

Speaker: Nicolai Josuttis

Audience level: [ Beginner | Intermediate | Advanced ]

Concepts are a pretty new key feature of C++. Introduced with C++20, they provide a way to deal with requirements and specify constraints on generic code. This can be used to improve overload resolution, avoid invalid use of generic code, improve error handling, and improve documentation of generic code.

Speaker: Goran Arandjelovic

Audience level: [ Intermediate | Advanced ]

Asynchronous programming in C++ is a challenging task. Various async models and corresponding libraries facilitate these tasks, and it seems that it's becoming easier. With C++20 coroutines, we have new possibilities, but standard library support for coroutines is virtually nonexistent. Also, having only C++ coroutines in a toolbox is like having only raw pointers or std::thread, i.e., low-level primitives, which cannot be enough for highly composable and scalable APIs. There are a lot of libraries for async tasks implemented on top of coroutines, but there's still an open question - which one to use?

Aside...

Speaker: Andreas Fertig

Audience level: [ Intermediate | Advanced ]

C++ is well known to be used, especially when efficiency matters and you want complete control of the resulting binary.

Speaker: Roth Michaels

Audience level: [ Intermediate | Advanced ]

C++ templates are a powerful tool for compile-time programming, generic programming, and metaprogramming. Historically many of these techniques have been considered advanced techniques or even arcane-magic by many C++ developers. Complex error messages and concepts like SFINAE being hard to teach can leave use of C++ templates out of reach—if you don’t know what SFINAE, come to this talk and find out what it is and why you might not need to use it anymore.

Speaker: Nevin Liber

Audience level: [ Intermediate | Advanced ]

There was (and still is) much controversy around the discriminated union variant type included in C++17. This talk is a first hand account of the process as well as the details of the various design deliberations and tradeoffs that were made to achieve consensus. It will get into both the performance and usability considerations that were debated, as well as some speculation as to where the C++ committee might like to take it in the future, including pattern matching to address useability concerns and a proposal to add it as a first class language feature.

...

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: Michael Shah

Audience level: [ Beginner ]

The C++ Standard Library does not yet have an '#include graphics library', so instead we rely on vendors to provide APIs for hardware accelerated graphics. When it comes to graphics programming, there exist many low level APIs available including: DirectX, OpenGL, Vulkan, Metal (and even webGPU). However, getting started with these new graphics APIs can be difficult. Vulkan which has been around for several years now, provides a low-level C-based API for native targets in order to maximize performance. In this talk, I will provide an introduction to using the Vulkan API and the C++ abstractions to manage some of Vulkans complexity. In this talk we'll provide some background so that you can understand the graphics programming basics, and then we'll show you how to render a simple 3D triangle on native targets using Vulkan. Audience memberse will leave this talk understanding how to leverage C++ to build your own mini-graphics framework in Vulkan and with resources to continue their journey.

...

Speaker: Fernando Iglesias

Audience level: [ Beginner | Intermediate ]

This talk is about recreational programming of terminal visualizations in C++, using a Python library based on asyncio. The topic originated while spending (probably too much) time solving Advent of Code puzzles in C++, finding a terminal-graphics library written with Python's async/await tasks, and not being able to resist the temptation of going down the rabbit hole of trying to use it in C++.

With...

Speaker: Titus Winters

Audience level: [ Beginner | Intermediate | Advanced ]

Let’s face it, working in our industry is terrifying. Unlike most professions, software engineers are regularly asked to automate away major parts of their own jobs. Common practices and critical technologies change every five years or so, threatening to obviate our existing skills and mastery. Even more scary, most of the interesting development work in our field are things that we can just barely accomplish, since the easier tasks are already automated and everything harder is impossible. In this talk I’ll shine a light on fear, uncertainty, and doubt in tech, before suggesting practices and tools to change the mood. We will revisit research on the importance of teamwork, culture, and communication, highlighting why basic tools for culture and understanding are powerful weapons in our fight against fear in tech.  

...