CppCon 2024

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.

• Related: The CppCon 2024 Friday keynote will be all about reflection… more about that will be announced soon!

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.

• Related: The CppCon 2024 Monday evening panel and Wednesday keynote will be all about safety… more about those will be announced soon!

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.

Since our first popular Safety and Security panel at CppCon 2023, there has been a lot of development in ISO C++ in this space and in this panel we aim to give everyone a chance to ask the key authors questions on this development. There has been development in:

1. Profiles P2687r0 , P2816R0 , and P3038R0,: what is the main idea?

2. C++ Core Guidelines Concurrency and Parallelism sections: how will this improve C++ safety

3. MISRA C++ 2023 published based on C++ 17: what does it contain?

4. Contracts: how close are we? Will it be in 26?

5. SG23 Safety and Security and SG21 contracts

6. Safety/Security Blog post by Herb Sutter

Recent US government reports and media follow-ups have been numerous:

https://www.whitehouse.gov/oncd/briefing-room/2024/02/26/press-release-technical-report/

https://www.whitehouse.gov/wp-content/uploads/2024/02/Final-ONCD-Technical-Report.pdf

https://www.infoworld.com/article/3713203/white-house-urges-developers-to-dump-c-and-c.html

Its not all bad news as the following shows:

A 2024 Discussion Whether To Convert The Linux Kernel From C To Modern C++

https://www.phoronix.com/news/CPP-Linux-Kernel-2024-Discuss

This panel, the second at CppCon, is back by popular demand where previously we had a Tuesday night session attended by 70% of attendees, continues a series of panel at every future CppCon where we will have the opportunity to discuss the progress of Safe and Secure C++ in that year, to enable the improved use of C++ in the Automotive, Embedded, Space, Medical or any domain that requires safety and security.

Since 2023, there has been new edicts by the US government, new development in C++ Profiles, Contracts, and new blog posts to respond to the government requirement for memory-safe languages and we want to hear from all the interested parties. As such I aim to have the key players each of these members had significant developments. The C++ community also wants to hear from each of them their ideas and ask them direct questions as to why they think what they are developing will help to make C++ safe and secure.

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.

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.

Meta-programming is one of the most significant C++ superpowers. It enables seemingly impossible feats, but there is a considerable cost associated with it as well. Therefore, its applications have been limited to experts and cases where the benefits greatly outweigh the maintenance burden.

But what if that doesn't have to be the case? In this talk, we will explore an alternative approach to template meta-programming that does not require an understanding of the traditional 'angle bracket' technique.

We will also make the case that anyone who can write C++ can become a meta-programming guru! But what about compilation times and/or testing/debugging, you may ask? Well, we will cover those as well, and it might be surprising what modern C++ is actually capable of!

Additionally, we will cover how the static reflection proposal and C++20 ranges can further improve the ability to write meta-functions and how C++ compares to other languages such as circle. However, we will also show how to apply the technique with C++17 on all major compilers with a ready-to-go solution.

Finally, we will benchmark compilation times of different approaches, showcasing their strengths and weaknesses.

If you are interested in meta-programming or have always wanted to understand its practical use cases but never really grasped them, this talk is for you!

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.

In less than a year since its original publication, the WG21 proposal “Reflection for C++26” (P2996) has made good progress towards its titular goal.  From its inception, we intended that design to offer a modest-but-useful set of features with a solid foundation on top of which we will be able to incrementally grow an easy-to-use, rich, and extensible C++ meta-programming framework.  This keynote will review some of the fundamental tools proposed in P2996 and follow up with a vision for some additional capabilities that we’re working on.