Explore the Doom C Codebase in VS Code | Learn to Navigate Complex C and C++ Code on Linux

by Greg Law

From the description:

Using the classic Doom C program on Linux as our real-world example, we trace the exact moment a zombie is killed and backtrack through the codebase to understand how it happened [..] using Undo’s Time Travel Debugging technology.

C++ in Embedded Systems Interview with Author Amar Mahmutbegović

by Jens Weller

Watch the video

Lightning Talk: The UB Detector: constexpr

by Andreas Fertig

Summary of the talk:

A constexpr function evaluated at compile time is free of any undefined behaviour they say. Do you think that statement is true as well?

Modern C++ Error Handling

by Phil Nash

Summary of the talk:

We’ve had exceptions in C++ since before the first standard. C++17 introduced std::optional and C++23 std::expected (along with the so-called Monadic Operations for both types).

What should we use and when?

Meanwhile we still have older approaches, such as boolean or error code returns, as well as global or thread local error status or pointer or reference arguments.

Do these still have a place?

And where does assert fit in? And the (hopefully) upcoming contracts?

Perhaps more importantly, once we’ve examined all the trade-offs, can we defer any of those decisions to when we are best positioned to commit to them?

Erroneous conditions can have a big impact on your code’s safety and security, so error handling shouldn’t just be left to the “exercise left for the reader” in the books we used to read. Let’s get this all straight.

Lightning Talk: How Far Should You Indent Your Code? - The Number Of The Counting

by Dave Steffen

Summary of the talk:

Coding Standards have to say something about how we indent our code.  Is there a definitive answer?

Guide to Linear Algebra With the Eigen C++ Library

by Daniel Hanson

Summary of the talk:

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.

Lightning Talk: Amortized O(1) Complexity in C++

by Andreas Weis

Summary of the talk:

We will take a quick look at how amortized analysis for algorithms works. We will use two examples from the standard library to demonstrate this and show how in one place, the standard's interpretation of amortized constant complexity is at odds with the usual use of the term.

Lightning Talk: Using PMR in C++ Embedded Systems for Functional Safety

by Scott Dixon

Summary of the talk:

Dynamic memory is often disallowed in high-assurance, c++ embedded systems but, when examining the reasons why, C++17 Polymorphic Memory Resources emerge as an unexpected solution to enable the use of C++ standard library constructs for such projects. My talk will explore how PMR can be used to meet functional safety requirements and to build embedded systems that are robust, performant, and testable.

Back to Basics: Unit Testing in C++

by Dave Steffen

Summary of the talk:

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.

Lightning Talk: The Main Points in C++ - Dots in C++

by Miodrag Misha Djukic

Summary of the talk:

A simple element of punctuation marks -- a point (dot) -- but used for so much. What are the all the ways a point is used in C++? Can you list them all? One point (dot), two points (colon), three points (ellipsis), four points (double colon). Let’s quickly go over all the usages: a well known ones, but also some that are encountered not so often.

Cost of C++ Abstractions in C++ Embedded Systems

by Marcell Juhasz

Summary of the talk:

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.

Lightning Talk: Rust Programming in 5 Minutes

by Tyler Weaver

Summary of the talk:

I'm now working in Rust and now I have time for all sorts of frivolous learning. It is glorious. I'm going to try in 5min to teach a bit of Rust to a C++ audience.

Introduction to Wait-free Algorithms in C++ Programming

by Daniel Anderson

Summary of the talk:

If you've attended any talks about concurrency, you've no doubt heard the term "lock-free programming" or "lock-free algorithms". Usually these talks will give you a slide that explains vaguely what this means, but you accept that is is approximately (but not quite exactly) equal to "just don't use locks". More formally, lock-freedom is about guaranteeing how much progress your algorithm will make in a given time. Specifically, a lock-free algorithm will always make some progress on at least one operation/thread. It does not guarantee however that all threads make progress. In a lock-free algorithm, a particular operation can still be blocked for an arbitrary long time because of the actions of other contending threads. What can we do in situations where this is unacceptable, such as when we want to guarantee low latency for every operation on our data structure rather than just low average latency?

In these situations, there is a stronger progress guarantee that we can aim for called wait-freedom. An algorithm is wait free if every operation is guaranteed to make progress in a bounded amount of time, i.e., no thread can ever be blocked for an arbitrarily long time. This helps to guarantee low tail latency for all operations, rather than low average latency in which some operations are left behind. In this talk, we will give an introduction to designing and implementing wait-free algorithms.

Without assuming too much background of the audience, we will review the core ideas of lock-free programming and understand the classic techniques for transforming a blocking algorithm into a lock-free one. The main bread-and-butter technique for lock-free algorithms is the compare-exchange loop or "CAS loop", in which an operation reads the current state of the data structure, creates some sort of updated version, and then attempts to install the update via a compare-exchange, looping until it succeeds. compare-exchange loops suffer under high contention since the success of one operation will often cause another to have to repeat work until they succeed. The bread-and-butter technique of wait-free programming that overcomes this issue is helping. When operations contend, instead of racing to see who wins, an operation that encounters another already-in-progress operation attempts to help it complete first, then proceeds with its own operation. This results in the initial operation succeeding instead of being clobbered and forced to try again.

Lightning Talk: Strategies for Developing Safety-Critical Software in C++

by Emily Durie-Johnson

Summary of the talk:

This talk delves into the importance of a safety-first mindset in software development within the medical device domain. It explores the intersection of C++ and industry standards that ensure safety-critical software. Attendees will learn to ask guiding questions during code development that emphasize the importance of coding as if the technology will be used on their loved ones. With real-world examples and best practices, this session highlights the personal and professional responsibilities of engineers in safety-critical fields to create reliable software.

C++ Under the Hood: Internal Class Mechanisms

by Chris Ryan

Summary of the talk:

My talk will examine the internal C++ mechanisms around the topics of:

• The C++ onion as it relates to construction, destruction and polymorphism,
• Order of Object construction & destruction, and pre- & post-main() processing.
• Member Function Pointers (not your father’s C function pointer),
• Member Data Pointers (not raw pointers) (data-morphic functionality),
• Understanding the Call Stack, Stack Frames and Base Pointer mechanisms.

Peering Forward - C++’s Next Decade

by Herb Sutter

Summary of the talk:

This is an exciting year for ISO C++: In just the past few months, it has started to become clear that C++ is approaching three major positive turning points that are starting to materialize together in a blossoming of usability we haven’t seen since C++11.

First, compile-time reflection, including source generation, will dominate the next decade of C++ as arguably the most powerful feature that we’ve ever standardized, and (fingers crossed!) it’s on track for being included in C++26 in the coming months. I expect reflection’s impact on library building to be comparable to that of all the other library-building improvements combined that we’ve added since C++98.

Second, memory safety is being taken seriously in WG21. After a decade or two of gradual smaller improvements, the committee is actively working toward taking the major step of enabling well-known proven-effective safety checks at compile time by default, without compromising performance.

Third, simplifying C++ is being taken seriously. I’m not the only person actively proposing simplifications to C++, and I expect the rate of simplification proposal papers to increase again in the coming year as the fruits of in-the-field experiments turn into evidence that the experimental improvements are working and are ready to be considered for ISO C++ itself to benefit all programmers.

Most of all, the above overlap and reinforce each other. For example, reflection will enable writing more new facilities as compile-time libraries instead of as language features that have to be baked into a compiler, which helps simplify future language evolution. Reflection will also enable compile-time libraries that let developers express their intent directly and leave it to the library code to accurately generate correct implementations, which helps reduce errors and makes our code both simpler and safer.

ISO C++ has long been solidly in the top 5 programming languages and is going strong. This talk presents reasons to expect that C++’s future is bright, and that perhaps its most important decade is just ahead.

Lightning Talk: From Macro to Micro in C++

by Conor Spilsbury

Summary of the talk:

Our continuous real-time monitoring led us to investigate an anomaly in the data about our system's performance. This led us to investigate and identify the culprit: a specific data structure used in our code and the way that structure was being initialized.

To Int or to Uint, This is the Question

by Alex Dathskovsky

Summary of the talk:

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.

When Nanoseconds Matter: Ultrafast Trading Systems in C++

by David Gross

Summary of the talk:

Achieving low latency in a trading system cannot be an afterthought; it must be an integral part of the design from the very beginning. While low latency programming is sometimes seen under the umbrella of "code optimization", the truth is that most of the work needed to achieve such latency is done upfront, at the design phase. How to translate our knowledge about the CPU and hardware into C++? How to use multiple CPU cores, handle concurrency issues and cost, and stay fast?

In this talk, I will be sharing with you some industry insights on how to design from scratch a low latency trading system. I will be presenting building blocks that application developers can directly re-use when in their trading systems (or some other high performance, highly concurrent applications).

Additionally, we will delve into several algorithms and data structures commonly used in trading systems, and discuss how to optimize them using the latest features available in C++. This session aims to equip you with practical knowledge and techniques to enhance the performance of your systems and make informed decisions about the tools and technologies you choose to employ.

Vibe Coding C++ - Jens Weller

by Jens Weller

Asynchronous Programming with C++ - interview with the authors

by Jens Weller

Video: Towards safety & security in C++ -- by Daniela Engert -- using std::cpp 2025

C++ Memory Management - an interview with Patrice Roy

C++ Insights Episode 57: More performance thanks to more implicit moves in C++20 - Andreas Fertig

C++20 and Two's Complement

by Barbara Geller and Ansel Sermersheim

About the video:

Someone mentioned C++20 is unusable because the standard now requires 2' Complement. Is is possible that he has a point and if so, on what basis did he make this claim?

We encourage everyone to watch our video to discover the history of Binary Representation.

Take a look and remember to subscribe.

Think Parallel - Bryce Adelstein Lelbach

From C to Modern C++: Transforming the classroom and beyond - Gabriel Valenzuela - Meeting C++ 2024

C++ for C Developers - Migration from C to C++ - Slobodan Dmitrovic - Meeting C++ 2024

std::launder

by Barbara Geller and Ansel Sermersheim

About the video:

Our recent C++ video started a lively conversation. We showed a use case for std::launder which caught several developers off guard. A new compiler setting was enabled which exposed a problem in our existing code. Please watch the full video to find out what we learned.

Take a look and remember to subscribe.

C++26: an overview - Rainer Grimm @ Meeting C++ 2024

by Rainer Grimm

Watch the video:

Interview with Titus Winters for Meeting C++ 2024

by Jens Weller & Titus Winters

Watch the video:

AMA with Herb Sutter - Meeting C++ live

by Jens Weller & Herb Sutter

Video:

IoT Development with POCO C++ libraries and macchinaio

by Günter Obiltschnig

Chapter Videos:

POCO C++ Libraries overview

Macchina.io overview

Projects using POCO C++ Libaries and macchina.io in the real world

Q&A with Günter Obiltschnig after the talk

Template Design With Policy Classes

by Barbara Geller and Ansel Sermersheim

About the video:

We have a new C++ video which discusses Policy Based Design and compares it to other styles of programming. Do you know which design pattern policy based programming solves? Have you considered the benefits of a design which provides a solution at compile time versus run time? Are you using policies and maybe you had no idea they had a name?

Please take a look and remember to subscribe.

Undefined Behavior in C++: What Every Programmer Should Know and Fear

by Fedor Pikus

Summary of the talk:

This talk is about You-Know-What, the thing in our programs we don’t mention by name.

What is this undefined behavior every C++ programmer has grown to fear? Just as importantly, what it isn’t? If it’s so scary, why is it allowed to exist in the language?
The aim of this talk is to approach undefined behavior rationally: without fear but with due caution. We will learn why the standard allows undefined behavior in the first place, what actually happens when a program does something the standard calls “undefined,” and why it must be taken seriously even when the program “works as-is.” As this is a practical talk, we will have live demos of programs with undefined behavior and sometimes unexpected outcomes (if you are very lucky, you might see demons fly out of the speaker’s nose). Also, as this is a practical talk, we will learn how to detect undefined behavior in one’s programs, and how to take advantage of the undefined behavior to gain better performance.

Lightning Talk: Thread Safety With synchronized_value in C++

by Jørgen Fogh

Summary of the talk:

Adding thread safety to existing code is hard. The proposed type synchronized_value makes it less hard.
I will show you why.

Lightning Talk: The Responsibility of C++ 

by Neil Henderson

Summary of the talk:

Hopefully an amusing and light-hearted look at C++ and its strengths and responsibilities in the software world from a recent life-changing experience.

CppCon 2023 std::linalg: Linear Algebra Coming to Standard C++

by Mark Hoemmen

Summary of the talk:

Many fields depend on linear algebra computations, which include matrix-matrix and matrix-vector multiplies, triangular solves, dot products, and norms. It's hard to implement these fast and accurately for all kinds of number types and data layouts. Wouldn't it be nice if C++ had a built-in library for doing that? Wouldn't it be even nicer if this library used C++ idioms instead of what developers have to do now, which is write nonportable, unsafe, verbose code for calling into an optimized Fortran or C library?

The std::linalg library does just that. It uses the new C++23 feature mdspan to represent matrices and vectors. The library builds on the long history and solid theoretical foundation of the BLAS (Basic Linear Algebra Subroutines), a standard C and Fortran interface with many optimized implementations. The C++ Standard Committee is currently reviewing std::linalg for C++26. The library already has two implementations that work with C++17 or newer compilers, and can take advantage of vendor-specific optimizations. Developers will see how std::linalg can make their C++ safer and more concise without sacrificing performance for use cases that existing BLAS libraries already optimize, while opening up new use cases and potential optimizations.

Lightning Talk: Spanny: Abusing C++ mdspan Is Within Arm’s Reach

by Griswald Brooks

Summary of the talk:

mdspan introduced in C++23 gave us a standard multidimensional way to view into a container of data. While the canonical use case is to refer to a stack or heap allocated data, the accessor policy allows you to inject any side effect allowing the data to come from anywhere... like a robot arm inspecting bins.

Robots Are After Your Job: Exploring Generative AI for C++

by Andrei Alexandrescu

Summary of the talk:

Almost a year since the launch of ChatGPT – considered by many as the first truly compelling code generator that translates free-form human language into code – the C++ community continues to grapple with the implications. Reactions range from indifference or skepticism to genuine concern about the future of human programmers.

Although some advanced C++ techniques are already accessible to tools like ChatGPT, certain fundamental aspects remain outside the reach of current and possibly next-generation generative AI tools. This disparity raises pivotal questions: Which parts of the intricate C++ ecosystem can we confidently delegate to generative AI? What uniquely human skills must we retain and refine?

We'll probe the potential and limits of contemporary AI, taking a novel look at the age-old binary search algorithm. Although this algorithm has long been held up as a paragon of efficiency, we challenge that notion. What would ChatGPT have to say about it, and how might it partner with us to refine this cornerstone of algorithmic logic? The conversation opens a window into a future where developers become the "one percenters" of programming—focusing solely on the most cerebral and high-level challenges, while AI takes care of the everyday tasks. Join us to explore this fascinating paradigm shift and reflect on what it means for your own work in and with C++.

Plenary: Coping With Other People's C++ Code

by Laura Savino

Summary of the talk:

Sometimes we're fortunate enough to work with a small group of devs who share our coding values, and when we see their PRs come in, we nod along and say, "Yup, that's what I would have done. Oh, nice, that one's even better than my usual approach, I'd better tuck that idea away for next time."

This perfect alignment is precious... and particularly elusive in C++. Most of us are living in codebases that are profitable, complex, and updated in ways with which we have legitimate beef. How can we keep a sense of curiosity, progress, and satisfaction amidst patterns we would never have chosen?

This presentation explores the often-overlooked social aspects of C++ development, offering both practical tools and light-hearted commiseration. We'll draw from the field of behavior science to build strategies that address conflicting design patterns and the strong opinions that come with them.

Lightning Talk: Writing a Better std::move

by Jonathan Müller

Summary of the talk:

std::move allows the creation of const rvalue references, which is almost always wrong. It also allows moving out of lvalue references, which can be dangerous since you don't have real ownership over them and a caller might not expect the object to disappear. Let's fix those problems using macros, reflection, and more macros.

Linkers, Loaders and Shared Libraries in Windows, Linux, and C++

by Ofek Shilon

Summary of the talk:

This talk would give a crash-intro to linkers, loaders and the layout of program binaries, and explore just enough internals to understand some observable differences in C++ builds between Linux and Windows.

We will discuss the GOT, the PLT, symbol visibility, interposition, lazy binding and more. There will be a lot of details, but also a lot of 'why's and opinions.

We will also touch/rant on what the C++ standard has to say on adjacent matters. There's a good chance you've heard before "shared libraries are outside the scope of the standard", but it doesn't mean what you think it does.

Plenary: Libraries - A First Step Toward Standard C++ Dependency Management

by Bret Brown & Bill Hoffman

Summary of the talk:

Prebuilt libraries have existed for decades… they even predate C++! After all these years, techniques to use prebuilt libraries are still ad hoc and difficult to maintain. A root cause of this variety of techniques is the variety of things that are C++ libraries: header-only libraries, statically-linked archives, dynamically-linked binaries, and so on. The consuming projects need to build against these libraries in consistent ways or risk unproductive workflows – and potentially, even catastrophic failure in production environments. This lack of convergence creates enormous interoperability problems across broad portions of the worldwide programming ecosystem, not just the C++ parts of it.

This talk will explore the complexities of defining what is a “C++ library.” It will then present the joint work of Kitware, Bloomberg, and others toward a preliminary design for creating initial standards for dependency management in C++ – metadata files to describe prebuilt libraries. A roadmap for maturing the design will also be shared, including proposing a standard definition for C++ libraries, building on previous proposals such as P1313: Package Specification (https://wg21.link/P1313).

This talk is intended for anyone who produces, maintains, or consumes C++ libraries. Special knowledge of C++ tooling, build systems, or package managers is not required.

Safe C++
Sean Baxter

From the talk:

Does a subset of a superset of C++ exists that achieves similar safety guarantees to rust, is useful and expressive enough, and is compatible with today's C++? If so, is anyone mad enough to do it? There is an answer to that

Lightning Talk: Let's Fix Sparse Linear Algebra with C++. It'll Be Fun and Easy!

by Benjamin Brock

Summary of the talk:

Sparse linear algebra is hard.  There are a large variety of different sparse linear algebra formats, and they all require obtuse index arithmetic in order to use.  But what if we could fix this?  In this talk, I'll present an idea for "fixing sparse linear algebra" using customization points, the ranges library, and high-level multi-dimensional iteration.

Lightning Talk: Implementing Coroutines Using C++17

by Alon Wolf 

Summary of the talk:

In this lightning talk, we will explore the journey of implementing coroutines in C++17 before they were added to the language in C++20.

The implementation uses macros, template metaprogramming, assembly functions, and more that resulting in working coroutines despite somewhat "horrible" code.

Discover how local variables within the coroutine body were leveraged to calculate frame sizes and ensure correct variable lifetimes during suspension, resumption, and destruction.

C++ Memory Model: from C++11 to C++23

by Alex Dathskovsky

Summary of the talk:

In the realm of C++ development, threading and memory management play a crucial role in crafting highly parallel and optimized programs. However, the absence of a memory model in C++98 posed challenges. Thankfully, with the advent of C++11, significant changes were introduced, including the introduction of a memory model, which brought forth a plethora of new and exciting tools for developers to leverage. This talk aims to delve into the realm of the C++ memory model, showcasing the arsenal of tools at our disposal. Attendees will gain insights into how CPUs and compilers optimize code and understand the criticality of adhering to the memory model correctly. Practical guidelines on utilizing these tools effectively will also be explored.

Throughout the talk, we will illustrate practical examples and share best practices for utilizing the diverse set of tools now available to us. From atomic operations to memory barriers, we will explore the range of techniques that allow us to develop robust and thread-safe code.

This talk will also illustrate the newer tools from newer C++ standards like JThread and so this talk will show how memory model is used and how it advanced since C++11.

Lightning Talk: Help! My Expression Template Type Names Are Too Long!

by Braden Ganetsky 

Summary of the talk:

Even the name of this talk is too long! If we're ever working with expression templates, we can easily make type names long enough to slow down compilation time. Suddenly our "zero-overhead" expression templates start giving a large compile time overhead. I'll show off a C++20 trick to fix this problem.

Lightning Talk: Filling the Bucket: Reading Code, C++ Code Interviews & Exams

by Amir Kirsh 

Summary of the talk:

We are going to review and practice a reading code challenge. Reading code skills are quite important, maybe even more than writing code. So let's dive together into filling the bucket code reading challenge!

Back to Basics: The Rule of Five in C++

by Andre Kostur

Summary of the talk:

Designing a class to behave correctly when copied and moved takes a lot of thought. The Core Guidelines provide guidance to streamline that work. In this talk we are going to look at the Core Guideline known as "the Rule of Five", how it came about, and is there anything better.