CppCon 2024

Talk Tech and Keep Your Audience Awake is a one-day onsite training course with presenting practice, taught by Andrei Alexandrescu and Sherry Sontag. It is offered at the Gaylord Rockies from 09:00 to 17:00 Aurora time (MDT) on Sunday, September 15th, 2024 (immediately prior to the conference). Lunch is included.



Course and instructor details are available here.

This course requires separate registration which is currently closed.

Using the volatile keyword correctly is vital when accessing hardware devices in C++. Unfortunately, the volatile keyword is among the most misunderstood aspects of the language. If you don’t use volatile appropriately, you may find the compiler generating code that’s very different from what you intended.

This session will help you write more robust device drivers that avoid common mistakes surrounding volatile. Step by step, it explains:

 
• Why volatile is necessary

 
• How volatile affects the code that the compiler generates

 
• How you should place volatile in object declarations

 
• Which statements the compiler is and isn’t allowed to reorder around accesses to volatile objects

 
• How to avoid misusing volatile

 
• How to avoid introducing inefficiencies when using volatile objects

Perhaps you've heard that you should reduce variable scope. But have you ever really stopped to think about why? In this session we'll run through a manufactured example that illustrates the difference reducing variable scope can make, and we'll do some examination as to what difference it made with the compiler.

Message reception and dispatch is something common to many codebases. And deep down, we know that Boolean algebra underlies everything we do. But we seldom give it a second thought, or if we do, we probably dismiss it as trivial; something we learned in college and quickly outgrew.

This talk shows the unreasonable effectiveness of going back to basics and really understanding and unlocking the power of Boolean algebra in the design of a message handling library for embedded systems. We’ll talk about separating message layout and semantics, how to match against messages for dispatch, and particularly how to compose and simplify constraints at compile time, in order to do the least at runtime. We’ll also introduce Boolean implication and see a non-obvious application which is key to a generic approach. Finally we’ll see how message matchers can be generically transformed using compile-time information, allowing complete flexibility of expression and maximum runtime performance.

Our game programmers and game engines involve fights between heroes and their foes. There are «classical», traditional ways to express heroes and monsters fighting each other, but contemporary C++ is particularly expressive and versatile language and with out language there are many ways for heroes and monsters to hit at each other. These techniques are what this talk will explore

Functions are the fundamental unit of interoperability in software design: users write applications by composing functions provided by various libraries. However, naive function composition can result in poor performance due to memory overheads that exist at function boundaries. Operator fusion --- combining the execution of several operators into one operator --- is a well-known technique to combat this overhead. Previous solutions to add fusion rely on complex, monolithic compilers and languages that force performance engineers to rediscover old solutions in new ecosystems, leading to decades of performance engineering work going underutilized. In this work, I attempt to identify the minimal ingredients required to enable fusion on top of existing library interfaces. In doing so, I propose a lightweight enrichment of function interfaces that exposes data production and consumption patterns of functions. I show how to implement these ideas in C++ and demonstrate the benefits of my system by showing that it is competitive with state-of-the-art high-performance libraries, and that it can fuse across library boundaries for unforeseen workloads.

When it comes to security, using "good" randomness is key - at least so we are told. But unlike using an insecure protocol or a weak cryptographic key, it may not be intuitive why "bad" randomness may be a problem. What even makes randomness "good" or "bad"?

In this session we will explore several real-world exploits based on bad randomness including online poker, cryptocurrencies, cars, web-traffic encryption, and video games.
Don't worry, no security background knowledge needed.

In the end, you will have entertaining stories to share and a better and more intuitive understanding of the dangers of "bad" randomness.

When a C++ compiler encounters an expression like f(x, y), it must consider several language mechanisms to decide which function f the program will call. These mechanisms include name lookup, overload resolution, default function arguments, and template processing. Having a firm understanding of these mechanisms and how they interact will help you write user-friendly interfaces for you and your team.

This session begins by reviewing each of these mechanisms individually. It then examines how those mechanisms interact, focusing on situations that are most likely to occur in practice. Some of the questions that we’ll consider are:

 
• How does the compiler resolve calls on overloaded functions with implicit conversions on multiple arguments?

 
• Why does the compiler apply implicit conversions when resolving calls to overloaded functions, but not when making calls to function templates?>/li>
  

After this session, you’ll have a clearer understanding of how the compiler makes sense out of your code. With this knowledge, you’ll find it easier to craft interfaces that are easy to use correctly and hard to use incorrectly. You’ll also be better able to steer the compiler in your intended direction when necessary.

In this session we will look at what it means to be moved-from, what impact being moved-from can have on code correctness, and we'll consider if some types should simply just be non-moveable for the sake of safe, correct code!

Low level interactions are a core part of embedded implementations. All too often, C++ developers rely on C constructs and interactions due to prior biases around language support.  Herein we present effective leveraging of C++20 and C++23 constructs in an embedded driver code base. From using an existing C driver more effectively with modern C++ smart pointers to leveraging constexprs for bit and byte manipulation in the standard library, we will go over how you can stay on the cutting edge of the C++ language evolution in the embedded space.

The jump from a theoretical algorithm to a high-performant real-world implementation is non-trivial. Factors that impact performance not reflected in an academic paper must be resolved in practice, including and not limited to cache misses, machine word size limits, parallelism overheads, and differing instruction speeds.

The Ontario Research Centre for Computer Algebra (ORCCA) performs fundamental research and development in computer algebra. Part of our work involves researching and implementing high-performance, parallel algorithms in C++. In this talk, we discuss a state-of-the-art algorithm for polynomial multiplication that beats leading computer algebra systems, such as Maple (our own library) and FLINT. We focus on our experience implementing the algorithm in CUDA C++, the challenges we faced, and our solutions.

Cancer research involves simulating "pseudo tumors" by sampling stochastic processes. Beginning with C++11, there were new features introduced in both the language and Standard Library that proved to be highly beneficial for simulating stochastic processes and analyzing the results. In addition, the linear algebra library Eigen, comprised of template code, makes it simple to perform matrix and vector operations in C++. Using an application in colorectal cancer research, the presentation will feature three topics in C++, namely random number generation, parallel computing, and leveraging the Eigen library.

One of the main attractions of Eigen is that it simplifies the code implementation for people who think mathematically, as the + and * operators are clearly defined in the mathematical sense of matrix addition and row-by-column matrix multiplication.  This talk highlights this aspect by demonstrating how to express the simulation of a stochastic cancer modeling process in C++, a problem that is well formulated in terms of matrix operations.

Simulating these stochastic processes also requires drawing random numbers. Before the new <random> capabilities in C++11, users typically needed to patch together their own uniform random number generators, as well as transformations to their desired distributions such as the Poisson and exponential distributions, which required a large amount of time for implementation and testing. This talk will show that by using methods such as std::discrete_distribution and std::exponential_distribution in <random>, constructing a random process simulator is technically simple in C++.

Cancers with seemingly similar initial conditions may develop into drastically different conditions. Much attention has been paid to events with high variability. To test a theoretical model, a huge number of simulations needs to be done to capture this variability. Therefore, concurrency is in reality a requirement rather than an option. In this application, parallel versions of certain STL algorithms introduced in C++17 are used to obtain descriptive statistics on the simulated data. In addition, an application of task-based concurrency will be used for replacing multithreaded computing formerly based on the pthread library.

In sum, this talk provides an example of using modern C++ in computational biology, with a goal of showing the C++ community that computational biology is a growing domain for applying modern C++ to general science.

Computational Fluid Dynamics (CFD) codes are ubiquitous in high performance computing. Their computational demands require the use of all levels of parallelism provided by the hardware. This includes the SIMD units of today's processors, which provide one level of data parallelism. With `std::simd`, it becomes possible to address these units directly from C++.

The talk reports on our work on the vectorization of a CFD code. The focus will be primarily on the way we have expressed vectorization using `std::experimental::simd` and less on the achieved performance gains. In this context, we have developed a library that complements `std::simd`. The goal of this library is to make loading and saving `std::simd` variables syntactically equivalent
to loading and saving their scalar counterparts. Loop bodies written for scalar variables can then be used for `std::simd` variables without modification. The talk also discusses some possible improvements to C++, since this goal can currently only be achieved by using a macro.

This is a session for those interested in visiting the "Deciphering Coroutines" on Thursday. That talk will assume prior familiarity with the C++20 coroutines feature and build heavily on the first "Deciphering Coroutines" talk from CppCon 2022.

If you have not seen the 2022 talk and are not yet familiar with C++20 coroutines, come to this session for a quick recap of the basics. We will do a detailed introduction to coroutines and get you up to speed with everything that you need to know to follow the presentation on Thursday.

Cppcheck has been evolving for 17 years, guided by a clear philosophy: minimal false positives and ease of use. This presentation will share the insights we've gained during its development. Our approach to easy configuration is a double-edged sword, providing user-friendly setup while occasionally leading to lower recall. We maintain a strict definition of false positives, ensuring the tool does not warn about well-written, functional code. This principle, while challenging, drives us to fix rather than suppress false positives. A core philosophy of Cppcheck is to learn from mistakes. When an issue is identified, we strive to implement checkers to prevent similar mistakes in the future.

The open-source community plays a crucial role in Cppcheck's evolution. We collaborate to enhance the tool, scanning large codebases like Debian's source code to identify inconsistent or dangerous code and measure false positives. We also explore how abstractions, compiler annotations, and contracts can improve SCA tools' precision and performance. This talk will provide a comprehensive look at the lessons learned and the continuous improvement of Cppcheck.

Introducing xstd::any<N, Features...>, an extension of C++17’s std::any, designed to be a type-safe, owning container that can handle any data type with enhanced functionality. xstd::any can be configured with additional features such as comparability, hashability, and streamability, making it ready for use in std::map, std::unordered_map, and for output operations. This template-based implementation utilizes small object optimization to store types smaller than N bytes directly, avoiding heap allocation and minimizing dynamic memory overhead.
The presentation will explore the internal design and implementation of xstd::any<>, focusing on how it manages memory efficiently and maintains value semantics even when dynamically allocating larger objects. The session will showcase practical use cases, demonstrate usage with standard C++ containers, and explore the recent C++ features that enhance its functionality.
Like std::variant or std::tuple, xstd::any requires mechanisms to handle various contained object types seamlessly. We will discuss the addition of stream operators, hash functionality, and comparison operators, enhancing its usability across different programming scenarios.

Outline:
* Requirements: Understanding the needs for a versatile container like xstd::any, compared to other generic container types.
* Example Use Cases: Demonstrating practical applications and benefits.
Implementation and Memory Layout: Deep dive into technical details and optimizations.
* Testing: Approaches to ensure reliability and performance.
* Exception Safety: Handling errors and exceptions.
* Interaction with std:: Containers: Integration strategies and examples.
* Question & Answers: Open floor for audience queries and discussions.

Presentation Materials & Source Code: All resources, including detailed presentation slides and the source code, are freely available on GitHub for further exploration and testing.

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 this talk, we present the current design of the Contracts MVP targeting C++26. We discuss preconditions, postconditions, assertions, contract-violation handling and much more. We consider how the Contracts MVP provides a superior replacement for custom assertion macros and, when used correctly, can significantly improve the safety and correctness of your code.

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 discuss the problems the Beman Project is addressing, how it came about, and, most importantly, how to get involved. At the end of this talk you'll feel equipped to build and test proposed standard libraries, provide feedback, and, perhaps, contribute some implementations yourself!

The Beman Project is named in memory of Beman Dawes, the much loved co-founder of Boost.

A key programming principle that encapsulates significant aspects of Object-Oriented Programming, is to hide your implementation details. This guidance aligns with principles such as encapsulation, decoupling, and programming for interfaces rather than concrete types. Yet, keeping your implementation details hidden is no easy feat. In this talk, we'll discuss the challenges, highlight tricky situations, and share tips on how to steer clear of them. Applying the practices presented in this talk, participants will be well-equipped to navigate potential pitfalls, foster best practices, and ultimately write C++ code that is more elegant, robust and maintainable.

Unit testing is a crucial practice for ensuring software safety. However, boundary cases, particularly those involving error handling and failure-tolerant logic, can be challenging to test in real-world applications. When writing test cases, the caller side of a target function may lack the necessary information to determine why an error occurred. Additionally, existing unit testing frameworks often cannot identify which path is exercised when multiple paths can produce similar outputs. These challenges are also present during fuzzing.

This talk introduces a lightweight, header-only C++11 library designed to address these issues. By including a single header file, users gain access to an integrated framework that combines assertion, logging, unit testing, and fuzzing, offering a more cohesive solution than using separate frameworks.

Attendees will learn about the design and unique features of this library, including:

* **Integrated Assertion and Logging**: The library's assertion/logging macros allow unit tests to be aware of assertion failures and logged data, incorporating this information into the test reports.
* **Structured Logging**: Developers can log structured data and access it during unit tests, making it easier to diagnose issues when errors occur.
* **Fuzzing API**: With a simple, structure-aware fuzzing API and support for Clang and libFuzzer, users can quickly run fuzzing tests within their unit testing framework, utilizing all the aforementioned features.

By the end of the talk, the audience will leave an understanding of how this library enhances the ease of writing unit tests and improves the overall safety of C++ applications.

With an intuitive understanding of Bitcoin’s programmability we can study programming primitives such as “time” and “hash-time” lock contracts (HTLCs), which are the crucial building blocks for higher abstraction protocols such as the Lightning Network.

We will describe “Lightning” by role playing the actions of its nodes. We’ll see how they exchange value globally and nearly instantaneously. We’ll appreciate that this is a practical solution to the problem of micropayments, financial inclusion, and the starting point for even higher abstraction level protocols such as the Sphinx protocol. This protocol enables payments for streaming services without subscriptions or doxxing yourself.

Depending on audience interest, we’ll explore topics such as pay joins, coin joins, and/or how to incorporate into smart contracts real world data, using the primitive of Discrete Log Contracts (DLCs) to make so-called “Oracles.”

As we summarize these technical solutions, we’ll see that they create an ecosystem that leads to Bitcoin becoming the world’s reserve currency.

–

Join us on Friday for a panel in which Eduardo, Jon, and Kris will answer Bitcoin questions.

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.

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.

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.

This session will feature detailed case studies that measure the overhead associated with common programming abstractions in the context of embedded systems. By examining both compile-time and run-time implications, attendees will gain valuable insights into how these abstractions impact system resources like memory usage and execution speed.

Key areas of exploration will include:

- **Encapsulation**: Assessing the cost of data hiding and interface protection depending on implementation strategies.
- **Inheritance**: Evaluating the costs and benefits of using class hierarchies in environments where memory and processing power are limited.
- **Polymorphism**: Comparing run-time polymorphism via virtual functions to compile-time alternatives like templates and concepts, analyzing their respective impacts on performance and flexibility.

Through empirical data and performance metrics, participants will observe how traditional object-oriented techniques affect resource utilization. The discussion will also cover the advantages and trade-offs of these techniques, providing a balanced view of their impact on embedded systems.

Designed for developers and system architects working within the constraints of embedded systems, this talk aims to provide valuable insights into making informed decisions about when and how to use specific programming abstractions. Attendees will leave with a clearer perspective on optimizing their code for maximum efficiency, armed with practical knowledge about the trade-offs involved in adopting various software design paradigms.

Ever wrestled with an embedded unit that had a mind of its own? That was my reality a few years ago.
This unit, built with Linux, C++, and QT, was designed to be a reliable middleman, handling RF frames from a multitude of endpoints.
But it was a bit of a wildcard - unexplained resets, occasional data loss, and all.
It was supposed to support 7500 endpoints, but once we hit 5000, it started to show signs of strain.

The software was a tough nut to crack - maintaining it was a challenge and it wasn't exactly a developer's favorite.
But here's where the plot thickens: after two years of relentless work, we transformed this underdog into a champion.
The unit now supports 10,000 endpoints, with zero resets or data loss.

Intrigued? Join me as I unravel the journey of this remarkable turnaround.
Let's dive into the world of embedded systems and explore how we turned the tide in our favor.
It's a tale of performance improvements, overcoming challenges, and making the impossible possible.
If you've ever wondered how to boost efficiency in embedded systems, or if you're just a fan of a good tech turnaround story, this talk is for you.

Come to one of my favorite talks to give! In this session we'll discuss the wide range of tools available to the modern C++ developer, why, and how to use them for the highest code quality.

Could we revisit numerical integrators in the light of C++26 and bring more genericity, performance, and expressivity to the domain? In this talk, we will explore how modern C++ techniques can add something new and relevant to one of the oldest and most basic task of scientific computing: the integration of systems of equations. We will examine, in particular, how most numerical integrators can be derived from a small set of first principles that can be easily mapped onto C++ concepts and composable algorithmic building blocks. One of the goal of the approach introduced in this presentation will be to achieve as much as possible with the simplest and smallest amount of code. C++23 and C++26 programming techniques, including reflection, will be leveraged to transfer some of the burden of implementation to the compiler while still ensuring maximum performance.

In practice, the talk will combine aspects of high-performance computing, numerical methods, and software architecture. We will start by summarizing recent discoveries made in applied mathematics on Runge-Kutta methods, linear multistep methods, and general linear methods to see how it can help design better abstractions that can be translated into C++ concepts. We will then examine how a few carefully crafted algorithmic building blocks can be combined to generate the whole diversity of numerical integrators from first principles. The automation of this approach using C++23 and C++26's reflection to make the compiler generate highly efficient code will be then discussed in great length. Next, we will dive into parallelization strategies, including distributed ones as well as heterogenous computing. Some perspectives will also be given on the possibility for the compiler to branch on the best integrator given the mathematical properties of a system of equations as well as ways to derive new integrators at compile-time.

To illustrate our approach, we will examine the behavior and performance of numerous integrators on several real-world problems including a supercomputing N-body code for cosmology that simulates the gravitational dynamics of large scale astrophysical structures in an expanding Universe. A great care will be taken to make all the code and examples as reproducible and standalone as possible so that most of the presented content can simply be copied and pasted to make it work everywhere. Finally, even if the talk will focus on the particular case of numerical integration, the methodology presented in this talk will be applicable everywhere in scientific computing and beyond to achieve better software architecture in technical contexts.

Standard C++ provides a few functions to convert a double or float value to string, namely, sprintf, stringstream::operator<<, snprintf, to_string, to_chars and format.

This talk concerns what goes on behind the scenes, i.e, the algorithms which these functions might use to do their job. Curiously, many of these algorithms have dragon-related names like Dragon, Grisu, Errol, Ryu and Dragonbox.

Here mythology meets technology and we shall introduce the new dragon that has just arrived in the den.

(Please leave your bows and arrows at home, they won't be necessary here.)