CppCon 2024

Unit Testing is a big, complicated subject. With good advice coming in from books, conference talks, and blog posts beyond count, it's a daunting topic even for experienced developers.  Can we make the subject more approachable?

Yes we can.  If we look a little deeper, there are some fundamental principles behind the advice. Further, these principles seem to belong to a small number of "domains", each addressing a very different aspect of unit testing and software development.

For example, "Test error conditions separately", "Tests should be easy to read", and "Write the unit tests first" are all great advice, but each is aiming for a very different goal.

In this talk, we'll survey these domains of unit testing practice, identify some of the basic practices involved in each, and put the larger discussion of unit testing into a more useful context.  We will also see how some unit testing practices enhance or conflict with others, and how these controversies reveal deep philosophical questions that have real consequences for how we go about the day-to-day activity of testing our code.

Are you a fresh face in the world of C++ development, or perhaps you've got a bit of experience under your belt? Have you ever stopped to marvel at just how often std::vector pops up? It's a thing of beauty, a structure you can just keep piling data into, effortlessly sort, search, insert, and delete from. But do you know the price you pay for all this convenience? What about when you need to expand the structure? Or when you're on the hunt for something specific? Ever dabbled with custom predicates to dynamically tweak your data? With a plethora of data structures at our disposal in the standard library, it's a head-scratcher why std::vector seems to steal the show.

Join this talk to unravel the mystery behind why we almost always opt for std::vector, and learn how to wield it with maximum efficiency.

Learn what Return Value Optimization (RVO) is, and what you can do to ensure the compiler applies it on your C++ code! This talk is open to beginner, intermediate, and advanced C++ audiences, and will be especially valuable for engineers who work on large-scale and/or high performance codebases.

While this compiler optimization technique was first added into the C++ Standard way back in 1997, many of today’s engineers have forgotten to utilize it in their production-deployed code.

This talk will dive into different perspectives as to what RVO is, including how copy elision is defined in the C++ Standard, as well as an analysis of Assembly when RVO is enabled. We will cover the different types of RVO, compiler support for it, and guidelines to help programmers ensure that the compiler uses RVO on their code. These guidelines will tie into examples from real-world scenarios where engineers could have optimized their code to gain the time and space benefits that come with RVO. We will also showcase the performance improvements that come from employing this compiler optimization technique.

Debugging asynchronous code is hard; partially because the stack traces that engineers are used to seeing do not provide enough insight to easily determine what went wrong. Often, engineers debug these async bugs by receiving a hint of the issue from the stack trace, going to the source code to read the problematic code, and making educated guesses about the async behavior that could have led to the issue.

But we can do better. In this talk, we introduce async stack trace support, a benefit that becomes possible when adopting coroutines and senders for your asynchronous work. With async stack traces and coroutines, engineers will have visibility into the async call stack leading up to the issue. This was originally developed at Meta in Folly, and we’d like to share this capability so that this could be incorporated into other C++ coroutine libraries and provide a better debugging experience.

Our C++ code often contains violations of "Don't Repeat Yourself" (DRY). You write down enums, but then you also have to write their stringified version. You write down a class, but you have to expose every method / member in the class separately to be able to bind your class to a Python program (for example).

Reflection is (potentially / hopefully) showing up for C++26, having already been design approved by EWG, its chances are looking promising! This talk will discuss everything the basics of reflection, and we will lead up to three library ideas based on reflection, as a way to understand the massive impact this might have on the kind of libraries our ecosystem can provide, without relying on the core language to provide such abilities. The examples we will go through are:

Automatic python bindings
ABI hashing (hashing a type for efficient compatibility checking)
A better std::any variant type that brings duck typing to C++

Come attend this talk if you'd like to hear about cool new library possibilities that have opened up with reflection!

Play is FUNdamental. This session looks at some more odd corners of C++ where we try to do out-of-the-ordinary things just to see what's possible. Should we do these things in production code? Maybe not today, but in the future, who knows? 20-odd years of C++ has taught me that it's a hop and a skip from "ugh, that's really nasty" to "that's an established technique now".

Whatever you think of the things in this presentation, it's fun to learn. And things which we don't use in code today are still useful to know about when they crop up.

Join us as we explore the cutting-edge advancements of C++26, covering both small tweaks and large-scale additions. Despite C++23 not being officially released from ISO, the C++ committee is already two-thirds through the design phase of C++26 - with less than a year left until feature freeze. In this session, we'll dive into the new features slated for inclusion in C++26, with a focus on those already present in the working draft. And particularly those already making their way into compilers and standard libraries. For sure we'll cover contracts, reflection, format, and many smaller improvements. But given the large amount of material available, we'll customize the content based on audience requests.

We'll cover a variety of topics briefly, but with enough depth to get you started. From enhanced language capabilities to powerful library additions, this session will equip you with the knowledge to leverage these upcoming features in your projects.  The session will be up to date with the latest from the summer C++ Committee meeting.

C++ is often criticized for its lack of inherent memory safety, but the spectrum of potential program validations extends far beyond just memory concerns. This talk delves into the necessity of early validation, emphasizing the benefits of compile-time checks in C++. By leveraging compile-time validation, developers can catch errors and enforce constraints before the code is even executed, enhancing both safety and correctness.

A functional programming approach to compile-time validation will be discussed, highlighting its benefits and demonstrating its application in ensuring code correctness.

Moreover, the talk will delve into the realm of compile-time unit tests, showcasing how they enable developers to validate code behavior at compile time, paving the way for more efficient debugging and maintenance.

Exploring advanced features, we'll discuss existing compile-time techniques to implement lifetimes, borrow checker, and other validation rules by leveraging template metaprogramming for memory safety and how they can be improved with the upcoming C++26 reflection proposal.

Additionally, we will review language extensions and compiler-specific features that augment compile-time validation capabilities. Finally, the talk will cover the role of static analysis tools in detecting potential issues early in the development process, thus complementing compile-time techniques. Attendees will gain a comprehensive understanding of the various strategies available for enhancing program reliability through compile-time validation in C++.

C++20 introduced "views" as easy-to-use building blocks for processing the elements and values of containers and ranges.
The filter view is one of the key views, because filtering collections of data to process only elements that satisfy a specific constraint or requirement is one of the most important use cases of dealing with ranges and views.

Unfortunately, the filter view is also one of the most surprising C++ standard views. Even for simple use cases, you can easily get:
- Unexpected functional behavior
- Surprising compile-time errors with cryptic error messages
- Fatal runtime errors (without even noticing them)

There are reasons for the design of the filter view. For a successful filtering of elements you should know and understand the design and all of its consequences.

The talk will demonstrate all the issues with simple real-work examples and explain both the motivation and consequences if this design in practice. Listen and learn aspects you would not expect but have to know when using the filter views and views in general.

Generic programming, better known in C++ as templates, can feel daunting and overwhelming to those unfamiliar with the paradigm.  This Back to Basics talk will explain the foundations of C++ templates, covering the language rules that must be understood in order to work with template code effectively.  I will provide some guidelines for how to use templates and how to write templates.

While you won't come away from this being an expert in template metaprogramming--that's an impossible task for any hour-long presentation--you should have a strong enough foundation that you can correctly maintain template code while you develop your expertise in generic programming over time.

This talk is designed for those who are learning C++ and want an introduction to templates and generic programming.  It will also be useful for experienced C++ developers who haven't mastered templates yet and want to brush up on their understanding of how templates work.

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.

In this talk we introduce the basics of concepts. You will get an overview of
- the difference between requirements, concepts, and constraints
- where you can apply concepts
- how to formulate concepts
- what the standard library gives you as and for concepts
- how to design concepts right

DRY -- don't repeat yourself -- is an important software engineering principle. Repetitive code is error-prone code. Inevitably, and sooner rather than later, we will forget to change one of these repetitive code locations. C++ offers many different tools to share code and data and I often see novice and intermediate programmers struggle with choosing the best one in each situation. We have template functions, template classes, std::variant, virtual classes and std::any. We have some common associated programming patterns like CRTP, templated base classes, template functions taking function arguments. All of these have their uses and in my talk, I want to develop some intuitions on when to use which.

The C++ community has long been interested in reflection, and we have made significant progress in adding core reflection capabilities to the language. While there is emerging clarity on the querying side of reflection—inspecting existing code artifacts programmatically—there is considerably less consensus on the generative aspect: using reflection insights to emit new code. As a result, current proposals showcase a stark contrast between well-polished reflection query capabilities and limited code generation capabilities.

Reifying only the reflection of preexisting code in an Ouroboros manner leads to a curious circularity that hinders the synthesis of new artifacts. This talk provides examples that demonstrate the necessity of generative capabilities in reflection and discusses current and upcoming proposals for generative extensions in C++ reflection.

Functional programming is a declarative way of writing programs by composing functions.
In many situations, this can lead to code that is easier to write and understand and less error-prone.
However, it requires a shift to a more functional mindset.
This talk gives an introduction to functional programming in C++ using the modern standard library.
We will cover algorithms using `std::ranges`, composable error handling with `std::optional` and `std::expected`, algebraic data types, and separating IO from computation.
In the end, we'll even cover the M-word.

Lifetime management in C++ is flexible and powerful. But this comes with complexity and lots of ways to shoot your leg off. That has only gotten worse as the language has evolved.

This talk introduces or recaps the so-called Rule of 0 and Rule of 5, which suggest that you should aim to need no Special Member Functions (customs constructors, destructors assignment operators) for most of your types. But if you do need them, you probably need all 5.

But if we do need to implement them it can still be hard to know what to do. It helps to know what sort of type you are dealing with, so we’ll break down the common categories.

Along the way we’ll look at vocabulary types we already have in the C++ standard library that can help us move more of our code into the realm of the Rule of 0.

Come with us on a journey through these rules, type categories and behaviours and start to make sense of lifetimes in modern C++.

C++ 20 developers do not need to sacrifice high-level expressiveness and code cleanliness for high performance when writing cross-platform code. Concepts and constraints combined with build tool configuration and judicious use of the preprocessor can enable novel techniques resulting in significant improvements to cross-platform architectures. The techniques are the result of experiences in the video games and embedded software fields; however, the techniques are applicable to high performance scientific code and general applications supporting multiple platforms

This presentation discusses how various features of C++ may be used to develop high-level and high-performance code in cross-platform projects. It focuses on the design and implementation of a small family of quaternion classes. Quaternions are a small numeric type used extensively in 3D graphics and thus ideal as the focus. The discussion begins with an unoptimized implementation that will compile on all platforms. Optimized versions for multiple architectures (SSE/AVX, Neon, and WebAssembly SIMD) will be added. These optimized types are added without changing a single line of existing code. Additionally, supporting multiple revisions of a spec will be illustrated. Implementing new revisions does not result in changing any pre-existing files, and new revisions may leverage older revisions and need not ever reimplement pre-existing functions. This reduces code repetition and all its attendant liabilities.

As much as I like C++, it is certainly not free of -- let's say -- quirks.  Both the core language and the standard library exhibit idiosyncracies, sometimes even in conflict with one another.

Some of these "oops" may be historical in origin.  However, most are due to the spectrum of viewpoints held by the hundreds of contributors who have participated in C++ standardization to date.

This talk points out many of these inconsistencies and numerous other infelicities in naming, behavior, or both.  Come see whether *your* pet C++ peeve is mentioned!

C++20 modules represent a significant advancement in the language, promising to improve compile times, enhance code organization, and streamline dependency management. This talk is tailored for developers eager to harness the power of C++20 modules in their projects. We will explore the fundamentals of building both shared and static libraries using CMake, the de facto build system for C++.

Attendees will gain practical insights into setting up build files and organizing source code with modules. We will dissect real-world open-source module projects, offering a concrete understanding of how modules are being used in the wild. A key focus will be on the "import std" model, demonstrating how to create a module interface for large, existing libraries, facilitating a smoother transition to modular codebases.

Significantly, CMake released non-experimental support for C++20 modules in October 2023, marking a pivotal moment for developers. Visual Studio, Clang and GCC all have some level of support for modules. However, the adoption of this feature is still in its early stages, with relatively few projects currently leveraging it. This session will bridge that gap, providing the essential knowledge and hands-on techniques to confidently integrate C++20 modules into your development workflow.

By the end of this session, participants will be equipped with the knowledge to effectively use CMake for building projects with C++20 modules, making the most of this cutting-edge feature to enhance their codebases. Whether you're maintaining legacy code or starting a new project, this talk will provide the essential tools and techniques to master C++20 modules.

This talk will highlight the key discussions in ISO C++ parallelism and concurrency related proposals since the last CppCon discussed in the Kona 2023, Tokyo 2024, and St. Louis 2024 C++ standard meetings. We aim to update CppCon attendees every year in this area. We focus on features that are close to standardization, and/or appear to be relatively non-controversial so that you get a look ahead on what is coming for the next C++ release.

This talk, by the Concurrency TS2 Editors will describe all the features and show how they can be used as well as give their motivation, background and how they fit within the overall framework of C++ parallelism and concurrency.

1. Atomic
2. Hazard pointer extensions
3. Pointer Tagging
4. Parallel Algorithms, Parallel Range algorithms

There are other features being discussed at these meetings, but they are still in development and could still change. So we focus on those features that seem close to approval, interesting, and/or are relatively non-controversial. We will show the use cases of each and describe how some of them are already heading to C++26 or beyond. This will help programmers in concurrency, lock-free programming, low-latency applications how to take advantage of each of these important facilities.

Have you ever wanted to run a Llama 2 model in C++? In this talk, we'll dive into C++ techniques for Llama 2 model inference. We'll start with a model trained in PyTorch and explore different ways to implement the inference solution for the Llama 2 language model, focusing on keeping things simple and minimal.

Llama 2 is a cutting-edge language model that's making waves in the field of natural language processing. It can generate human-like text, understand complex language tasks, and is used in everything from chatbots to content creation. Its efficiency and accuracy are setting new industry standards, making it an invaluable tool for developers and researchers.

Inspired by the awesome llama.cpp and llama2.c projects, this talk aims to show a simple and educational approach. We'll hard-code the Llama 2 architecture and create the inference in pure C++ with no dependencies. Join us to learn how to build Llama 2 models efficiently using a streamlined and dependency-free C++ solution. If time allows, we will also explore additional C++ techniques for fast Llama 2 model inference.

By the end of the talk, you'll have an understanding of what Llama 2 is and how it works. You'll also learn practical ways to implement the Llama 2 model inference in C++ and potential optimizations.

The mandate for C++ is to deliver uncompromised performance and leave no room for a lower level language.
This presentation looks at C++’s superpower for delivering on this mandate. We explore this both to understand how to write better C++ code and to better understand how to evolve C++.
We’ll look at several examples showing how this superpower is applied in different ways, including one of the most controversial issues facing the C++ community today.