BeCpp2026 - Themes of the Symposium
Safety
Perhaps the strongest theme of the symposium was around “Safety”, or at least “preventing bugs”.
Herb’s keynote talked quite a lot about security and how we as an industry need to be focussing more on hardening our software. He noted that we have been making large improvements in this regard since 2020. Memory-related bugs and exploits have become much less of an issue compared with other kinds of vulnerabilities like SQL injection and Cross-site scripting. C++26 has many new additions that make the language safer:
Looking further into the future, Gabriel Dos Reis gave a fantastic talk on C++ Profiles. Profiles aim to continue the efforts of making C++ safer by giving developers the ability to provide guarantees for how safe, or unsafe, their code is.
In much the same way as you might write a library and tell people that it will compile cleanly with -Wall -Wextra, profiles will allow you to mark translation units, or C++20 modules, with annotations to promise a certain level of quality. They seem to work really nicely with C++20 modules.
This makes sense as C++20 modules are essentially an abstraction for compiled source files, so they are a natural vehicle to use to propagate information about the quality of code that they contain. Profiles seem to be an effort to standardize compiler warnings and static-analysis in a really powerful way.
I am quite looking forward to seeing profiles in the language!
My talk, which followed Gabriel’s, could also be seen as a talk about safety. It is all about warnings, and increasing the warning level on a fairly mature and massive code base. I focus a lot more on software quality, and code reviewing as the motivations for my talk, but you could just as easily add safety to the list of motivations. I talk about some of the more interesting bugs and code oddities that I found while increasing the warning level of Sea of Thieves, and I also talk about the decision making that went into deciding what warnings were worth it and which ones were not.
Phil Nash gave a talk on automated testing. Testing is something that we should all be doing to ensure that our software does what it should be doing, and making sure it is not doing something that it should not be doing. I really enjoyed this talk. A lot of it was a live demo… Something that I am nowhere near brave enough to do yet! Testing is key component to writing safe software, and it is something that I am quite passionate about.
Abstraction
Two of the talks had a decent emphasis on abstraction.
Bryce’s talk on the CUDA C++ Toolbox was a great practical guide in how people should be writing code that takes advantage of the GPU for general tasks. The main element of the talk was that the idiomatic way to write CUDA code was to not write CUDA code… directly. There are so many libraries that abstract away the complexities of writing fast GPU code, that you are probably much better off using a library to solve your issues. He gave some great examples of how to solve problems by using libraries like Thrust, which abstracts a lot of the complexities of GPU programming away by providing a user-friendly algorithms to use.
Guy Davidson’s closing keynote was all about abstraction, and how C++ provides a lot of great abstractions which make it a powerful language. You can watch the version of the same talk that he gave at CppOnSea here. It’s a great talk that gives a whistle stop tour of some of C++s best features, while also diving deeper into what is an abstraction, and why they are useful for all kinds of software engineering.