CppCon 2024

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.