CppCon 2024

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++.

Small embedded devices might only have one processing core but hardware accelerators, peripherals, and external events abound. Asynchronous event handling is the bread and butter of these systems; however, the lack of robust libraries in the bare-metal arena often result in a concurrency nightmare.

After a short sender/receiver primer, we will explore some patterns and idioms that have proven useful when employing the design in a high availability, complex embedded device. We will use [Intel's open source bare-metal senders and receivers library](https://github.com/intel/cpp-baremetal-senders-and-receivers) as well as other open source packages to build elegant, declarative solutions around interrupt handling, schedulers, devices drivers, and communication protocols. The patterns will be demonstrated on an STM32 target controlling a simple robot.

While this talk is focused on bare-metal implementations and embedded concerns, the shape of a solution is applicable to many domains and environments. Join me as we wrangle concurrency using the sender and receiver design.

For many years, members of the C++ working group, WG21, have tried to add support for contract assertions — preconditions, postconditions, and assertion statements within a function body — to the C++ language. It’s been a long and difficult road, but we now have a proposal (P2900, “Contracts for C++”) to add significant contract support in, we hope, C++26, with more complete support to follow in C++29.

Looking back, the contracts feature has been unusually difficult and contentious. I contend that the difficulty is inherent in the feature: a contracts facility, by its nature,  cannot be understood from any single point of view.

In this lecture, I will explain why understanding contracts requires seeing the feature from a panoply of perspectives, and show how shifting between these perspectives allows one to make effective use of the facility.

This lecture is derived from presentations made to the Language Evolution subgroup of WG21 at the St. Louis meeting in June 2024.

In this talk, we will delve into the limitations and challenges associated with using std::function, std::packaged_task, std::apply, and similar constructs in modern C++ development. Despite their utility, these constructs often introduce performance overheads by invoking copies and moves of captured member variables, leading to increased complexity and unexpected behavior. I will share practical examples and common pitfalls encountered in real-world applications. Finally, I will present an alternative approach I have developed to mitigate these issues, offering a more efficient and reliable solution for developers.

When your code base is growing, the time it takes to compile is also growing. But why, where is the compiler spending time? Lots of focus in C++ is on the performance of compiled code, but when you're compiling millions of lines of code, its important to pay attention to the build times. Neglecting this aspect can lead to significant losses in developer productivity.

In this talk, I will explore some capabilities built into Clang and Ninja that C++ developers can use to identify, understand, and mitigate long build times.

Localization in mobile robotics, critical for autonomous navigation, is a challenging problem often addressed through particle filter algorithms, also known as Monte-Carlo Localization (MCL) estimation. The integration of the ranges library in C++20 introduced powerful new tools to enhance the implementation of these algorithms, further extended in C++23. This talk explores the use of these modern C++ features to develop efficient, composable particle filter algorithms that are well-suited for both 2D and 3D localization tasks.

Attendees can expect an introduction to the basics of particle filters, providing a foundation for understanding their application in robotics. They will then be taken through the design and implementation of a series of essential functions for a particle filter library. These examples will demonstrate how C++23 ranges can be used to refactor traditional MCL approaches into more flexible and efficient solutions.

Writing an emulator is truly transformative for any aspiring developer. In this session, we will be building parts of a lightning-fast Nintendo GameBoy (DMG-001) emulator library, complete with a webAssembly frontend.

We will introduce the concept of a 'fast' emulator, highlighting its significance beyond mere gaming authenticity. After setting clear limits as to what we aim to achieve within the allotted time, we will delve into some foundational aspects of modern computing by implementing the core components of a GameBoy emulator. Along the way, the need for various programming patterns will emerge naturally, showcasing their relevance in real-world development scenarios.

Additionally, we will demonstrate how integrating modern high-level C++ constructs streamlines our codebase, enhancing both readability and performance. You will witness firsthand how these constructs simplify development and yield significant speed enhancements (even when applied to emulating low-level systems).

This session aims not only to provide practical insights into modern emulator construction but also to invite collaboration on future enhancements and optimizations.

In our daily work, we often use integral data types to perform arithmetic calculations, but we may not always consider how the selection of the data type can affect performance and compiler optimizations. This talk will delve into the importance of choosing the correct data type for the job and how it impacts compiler optimizations. We will also examine the overall performance implications for the application. We will explore specific algorithms where using unsigned data types is more beneficial and other situations where signed data types are the best choice. Furthermore this talk will dive into the differences between signed and unsigned integers, how the processor handles certain operations and explain many of the surprising pitfalls of using integral types.
Attendees will come away with a deeper understanding of how data type selection can impact their code and how to make better choices for optimal performance.

This session will follow the guidelines from my short article on LinkedIn but it will go into higher details and contain more examples and explanations.

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.

Get ready to dive into the latest C++ developments in Visual Studio Code (VS Code) developed in the last year. Our focus has been on faster extension performance, from optimizing the time to colorization to faster symbol searching in your workspace. Also, discover how VS Code has been supercharged to boost your productivity through new features such as extracting to a function and an easier CMake integration process for your projects. Throughout this session, we will deep dive into how you can leverage GitHub Copilot, your AI-powered pair programmer, to create, maintain, and optimize your C++ projects. Whether you are a VS Code veteran or just getting started, join us to learn more about the newest features in VS Code.

Motion planning algorithms play a crucial role in enabling robot arm to navigate complex environments efficiently. They are required to determine a robot's trajectory and optimize its motion to minimize cycle time and maximize throughput. In this talk, we delve into optimizing a robotic arm motion planner using the CHOMP algorithm, highlighting the significance of employing good coding practices and design patterns.

Beginning with an overview of motion planning techniques and the rationale behind selecting the CHOMP algorithm for robotic arm manipulation, we scrutinize the initial naive code implementation. Transitioning to modern C++ implementation, we introduce key concepts utilized in the refactor and present code snippets illustrating the transformation from legacy to modern paradigms.

Attendees will glean insights into identifying and addressing challenges in legacy code, mastering essential modern C++ concepts for motion planning optimization, and quantifying the tangible benefits through performance metric comparisons. It will further encourage them to integrate design patterns into robotics programs.

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!

It is common knowledge that online mulltiplayer games are some of the hardest kinds of software to develop. Game developers have to deal with data packets coming with a substancial delay, in fact working with data from the past. The rollback technique allows to give the illusion of real-time by extrapolating input with a game simulation from the confirm frame to the current one. However, for the implemention to work there are several key factors that need to be taken into account. The game simulation update needs to be deterministic, the game state should be easily copyable, and the game state should be clearly separated from the graphics side of the game.

C++23 introduced std::mdspan, a multi-dimensional view type that expanded on the capabilities of its predecessors, std::span and std::string_view, by eliminating the restriction to view into contiguous blocks of memory. Multidimensional array-type data structures are commonly used in robotics applications such as RGB and depth images, as well as occupancy grids for navigation. While these alone present a compelling alternative to hand-rolled data structures, this talk will illustrate the flexibility of the layout and accessor policy customization points included in std::mdspan, demonstrating its potential through various examples, including helping a robot arm inventory beer bottles.

This talk will review conventional use cases of std::mdspan in robotics, such as occupancy grids and submaps for determining obstacles and collision checking with polygonal footprints, as well as handling camera images retrieved after deep learning inference. Additionally, we will discuss commanding single and dual robot arms for inventory inspection using synchronous and asynchronous strategies via the std::mdspan accessor policy and std::future.

While these toy examples may have speculative applications, they highlight the flexibility and extensibility of this new data structure for novel use cases.

Linear algebra is an essential part of scientific programming, particularly in domains such as quantitative finance, data science, physics, and medical research.  It is also relevant to imaging in game development.   As C++ did not have all the convenient built-in multidimensional array capabilities and supporting libraries that came with typical Fortran platforms, scientific programmers making the transition to C++ back in the late 1990’s and early 2000's often found themselves in an inconvenient situation with limited options.  These included building up this functionality mostly from scratch, wrestling with interfaces to numerical Fortran libraries such as BLAS and LAPACK, or somehow convincing management to invest in a third-party commercial C++ linear algebra library.

The situation has improved substantially over the years with the development of several well-regarded open-source linear algebra libraries for C++.  One in particular that has become popular, first released in 2006, is the Eigen library.  It has been adopted for use within both the TensorFlow machine learning library and the Stan Math Library, as well as at CERN, and it can also be found in the implementation of high-performance quantitative trading strategies in C++.

In this talk, we will examine the setup and basics of the Eigen library, followed by a discussion of some of its more advanced features, including applications of matrix decompositions frequently used in quantitative work, as well as its compatibility with STL algorithms.  It will conclude with an overview of how it can be used within the context of the C++26 BLAS interface proposal (P1673), via an interface with std::mdspan now available in C++23.

In C++23 we have std::optional and std::expected along with the "monadic" operations that can be used on the objects of these types. By chaining the computations, these abstractions allow you to manipulate the underlying values using less boilerplate code. In addition, we have a range library for processing collections of elements in a similar manner.
These topics have been quite popular in the C++ community for the last five years or so. However, many of them are focused on theoretical parts, have only small non-related examples, or even use other programming languages to illustrate the ideas.
This talk is prepared based on more than one year of using functional programming approaches for developing one of the commercial internal libraries our team is working on. I’m going to share this experience with the audience. We’ll talk about API design in general, spitting between pure and impure context, and the pros and cons of using “optional” and “expected”. There will be real code examples and some useful tips.

The Meet the Presenters Banquet is open to all attendees. Ticket required. Invitation is included with "Regular" and "Full" conference registration and is also available as a separate, stand-alone registration.

This is your opportunity to meet and discuss with the presenters (main program, poster, instructors) in a relaxed, informal environment.

Lightning talks are your five minutes of stardom. The format encourages a focused and often high-energy presentation about nearly anything (subject to approval by the conference) that might be interesting to the C++ community, including proprietary technologies. They can be of a lighter or humorous nature, but they need not be.

https://cppcon.org/lightning-talk-submissions/