(Virtual) Trip Report: C++ Online 2025

I virtually attended C++ Online 2025, which was my first experience of the conference. The conference ran from the 26th to the 28th February, with workshops scheduled afterwards.

I’ve had a lot of (very positive!) life happenings over the last few months which have taken me away from programming, so it was time to dust off the cobwebs with one of the first C++ conferences of the year. It’s also the reason this post is nearly two weeks late!

Front Matter

C++ Online is (as you might have guessed) an online-only conference. It is a relatively new conference, and appears to be a kind of sibling conference to C++ on Sea. In fact, attendees of either C++ on Sea 2024 or C++ Now 2024 were offered free entry to C++ Online.

Tickets are priced at £99 + VAT for standard entry, which I paid for out of pocket. Discounts are available for students and members of supporting meetups or community sponsor organisations.

The event lobby was hosted on the conference website. It looked a lot like the ACCU online conference portal, but re-skinned with the C++ Online black and green retro-synthwave inspired design.

The schedule was comprised of two tracks of concurrent material. This was useful for avoiding choice overload, especially given that a few of these talks have been given at other conferences. Talks were organised into the following categories:

• Algorithms
• Asynchronous
• Design
• Generic / Metaprogramming
• Safety
• Social
• Standard Library
• Testing
• Tooling/Utilities

Talks ran from roughly midday until 10PM UK time. I live in the UK and definitely enjoyed not having to bend my day around the conference schedule! One small quality of life feature I noticed was that the top of the schedule page started at the current time, so the next sessions were always immediately visible. Talk recordings were available promptly the next day and with talks starting at midday, there was plenty of opportunity to catch up on the previous day’s sessions.

There were also open content sessions, described by the conference as ‘a way of presenting at C++Online that is open to anyone in the C++ community’. These sessions were hosted in the gather town virtual venue. They were part of the official conference schedule, but not recorded. I don’t recall seeing this concept before, but it seemed like a great way to increase live engagement in an online-only event.

Day 1

The conference schedule started with an opening address for Phil Nash, one of the conference organisers. Whilst this was largely standard conference front matter, there was one particularly interesting set of comments made about C++ as a language. Phil said that we will see throughout the conference that C++ “is not a dead language” and that there was “still some fight in us yet”. The state of online programming language discourse seems particularly volatile at the moment so I wasn’t sure how much to read into these comments, but it was an unexpected way to open the conference for sure!

Keynote: Six Impossible Things

The opening keynote was Kevlin Henney’s ‘Six Impossible Things’. The name is a reference to a quote from the book Through the Looking-Glass: “Sometimes I’ve believed as many as six impossible things before breakfast”. I had already seen this talk on YouTube a few years back, so most of the content was familiar to me.

The first impossible thing was that representations can be infinite. Floating point numbers are the canonical example of an infinite space that we represent with finite precision. The crux of the argument is that nothing is really infinite as far as we know. Although this reminds me of the idea that all algorithms are O(1) in practice if we set the constant factor to the lifetime of the universe…

The second impossible thing was that every question has an answer. One example of this is in practice is the C standard time function which returns the time ins seconds since the UNIX epoch. However, if your system has no calendar or clock, then it will return (time_t)-1. The lesson to learn is that things like time are resources to be passed around and treated as fallible, rather than tautological.

The third impossible thing is that every truth can be established where it applies. An immediate counterexample given by the speaker is Principia Mathematica, which aimed to lay down a solid foundation for all of mathematics. Of course, Gödel put paid to that with the Incompleteness Theorem. Code is another example of an axiomatic system, so this applies to our code. A C programming example of this can be found in strlen, where we assume that a \0 will exist in the input string. This is an assumption that can easily cause a lot of damage, but we certainly cannot write a check for this in standard C.

The fourth impossible thing is future is knowable before it happens. A good point was made about roadmaps, a common feature of medium-term software planning, which tend to be one dimensional. However, geographic road maps are a network of many roads that allow different paths to be taken. The shortcoming of phrasing roadmaps in such a one dimensional way is that the real world is inherently fraught with uncertainty, so the visualization of the future must accommodate multiple routes or factor in the uncertainty.

The fifth impossible thing is to consider that a distributed system is knowable. If another part of a distributed system fails, we might fail ourselve with no warning whatsoever. The speaker goes on to describe CAP theorem, which stands for: consistency, availability, and partition tolerance. The theorem states that any distributed system may only provide two of these guarantees.

The sixth and final impossible thing is that technical debt is quantifiable as financial debt. Technical debt is often phrased as a challenge of legacy codebases that have got, but (hopefully) our real world financial debts are structured and well risk-managed. Usually, real world technical debt is unmanaged technical debt, or technical neglect. If we are consistently paying off a known amount of technical debt, then it could be argued that a team is working really well!

Kevlin’s talks are famous, and I love the dry sense of humour that he brings to them. Even if it was rehash for me, there were enough humorous examples for it to be well worth a second watch.

C++26: An Overview

For my second talk of the conference, I chose to attend Rainer Grimm’s ‘C++26: An Overview’. It was great to see Rainer giving a talk live with some assistance. He has raised both awareness and money for ALS through his blog and book sales respectively.

The talk was hampered slightly by a few technical issues, but overall it was a useful summary of the new features coming to C++26. I am cautiously optimistic for the reflection proposal. The syntax looks immensely arcane, but it is a feature that C++ needs in my opinion. This is somewhat evidenced by people are already emulating it by using destructuring assignments from aggregate types into tuples (which is perhaps equally arcane). std::inplace_vector<T>, a static capacity std::vector-like container is a great win too - it feels like we’ve all hand-rolled an equivalent container at some point! Lastly, I am very excited for the executors proposal. C++ has been lacking high quality asynchronicity features for a long time, so it will be interesting to see if this proposal can finally get us there.

How to Parse C++

My next talk was ‘How to Parse C++’ by Yuri Minaev. Aside from staring at some of the baffling uses of syntax it is possible to create in C++, my first realisations of just how crazy writing a C++ frontend must be came from paper P2621 ‘UB? In My Lexer?’. Whilst if you read the paper it’s easy to see how bugs like that could occur, it does make for a great headline and say that further work will be needed to remove all UB from lexing.

In this talk the author shared tales of parsing C++ code, drawing on their experience from working on PVS Studio. The talk started with classic compiler theory and morphed into parsing gnarly C++ code samples with direct references to the standard grammar.

Overall, an enjoyable talk on an interesting subject.

Data Oriented Design - One Million Times Faster

Next up was Andrew Drakeford’s talk ‘Data Oriented Design - One Million Times Faster’. I was particularly excited to dig deeper into this topic after seeing a few compilers start to use data-oriented design for parsing text faster than traditional AST designs. The speaker outlined the goals of the talk as focussing on transformations of data and yielding massive speedups.

The talk started with a recap of hardware considerations for performance-oriented software such as cache latencies, out of order execution, etc. Benchmarks of matrix storage formats against access patterns were presented, with no real surprises to be had at the results. SoA and AoS design patterns were also outlined. I hadn’t heard of partitioning with SoA, where one uses different algorithms to deal with the arrays depending on a size threshold.

The topic of matrix chain multiplication came up, which I hadn’t thought about since university! Godbolt links were provided for solving matrix chains with constexpr functions were provided, which seemed like an interesting idea for increasing performance. No indication of compile time costs for this were given though.

External Polymorphism and Type Erasure

For the penultimate slot of day one, I chose to attend ‘External Polymorphism and Type Erasure’ by Eduardo Madrid. The talk explored runtime polymorphism without using virtual polymorphism. Eduardo has given a lot of in-depth technical talks, so I was excited to be able to catch one live for the first time.

The talk opened with an explanation of substitutability and Liskov Substitution principle, with relevant examples in C++ STL types. These substitutability properties can be used to translate compile time techniques to runtime with external polymorphism.

The pains of sub-classing were discussed and Sean Parent’s famous talk inheritance is the base class of evil was referenced. I agree with these sentiments. Type hierarchies tend to pollute code with all-or-nothing language features, reference sematics hell, memory layout concerns, performance overhead, and overly complicated lifetimes (and that’s just what I could think about in 10 seconds for the sake of making this point!). Eduardo discussed these points in great detail in the talk.

External polymorphism was described as hand-crafting an external vtable for a type. This allows us to separate the implementation of the polymorphism outside the class and adapt the polymorphic interface against the vtable. I had never heard of this pattern before, so this talk was enlightening for me! Although, if it is fairly uncommon, I wonder how much practical usage it will be for me in my day-to-day programming. It would have been ideal to see some real world benchmarks of this method against inheritance-based polymorphism, because I would imagine that compilers have pretty good internal models of inheritance hierarchies. It was cool to see the vtable implementation clearly in assembly though!

Compiler Construction in C++

‘Compiler Construction in C++’ by Abhilekh Gautam was my first open content session, so I had to head to the Gather Town venue rather than using the usual Zoom link.

For the second time today, I was treated to some compiler theory classics with C++ code examples showing the implementation of each step. I liked the code-oriented approach the talk took because it has been a while since I have written a compiler frontend from scratch, so it was useful to see some implementation details in modern C++. The IR representation chosen was LLVM, which lends itself well to the speaker’s goal of using the material for teaching people about compilers.

What Can C++ Learn About Thread Safety From Other Languages?

My first catch-up talk was ‘What Can C++ Learn About Thread Safety From Other Languages?’ by Dave Rowland.

The talk opened with a reference to ‘Borrowing Trouble: The Difficulties Of A C++ Borrow-Checker’, an article from the Chromium team about the difficulty of implementing a C++ borrow-checker. Of course, some years later this was proved wrong by Sean Baxter’s Circle compiler. We couldn’t talk about borrow-checkers without Rust, which is able to prevent data races with mutability XOR aliasing - there can only ever be a single mutable reference XOR one or many immutable references (or you own the object of course).

The quotes statistics from Google noted that thread safety issues were responsible for 5.6% of their CVEs. The speaker was concerned that with the increase of parallelism to gain performance and new language constructors like the executors proposal, these figures could easily rise. Whilst this figure may look small, it’s also worth considering that concurrency issues are notoriously hard to debug which might increase the time to respond to such categories of vulnerabilities, increasing the importance of addressing these issues as early as possible.

Sync and send guarantees were also discussed. These are (respectively) types that are safe to send to other threads or share between threads. A limited implementation of applying these to C++ through concepts was discussed, which was very interesting. There were some corner cases and constraints however, only thread-safe values (achieved via std::atomic) in std::shared_ptr instances were supported in the most extreme cases. An old proposal for a type to alleviate this called std::synchronized_value<T> was mentioned, but this seems to have fallen by the wayside.

Another approach was Herb Sutter’s metaclasses proposal, which I hadn’t heard of before. The paper describes the feature like so:

Metaclasses (provisional name) let programmers write a new kind of efficient abstraction: a user-defined named subset of classes that share common characteristics - including user-defined rules, defaults, and generated functions - by writing a custom transformation from normal C++ source code to a normal C++ class definition.

The implication being that these transformations could be used to automatically generated send/sync compatible types.

I also learned that it’s possible to delete operator new (and friends) to make it much harder to heap-allocate or take addresses of types.

Day 2

Unlock the Power of Asynchronous C++ Programming with Tinycoro

My first talk of day 2 was ‘Unlock the Power of Asynchronous C++ Programming with Tinycoro’ by Tamas Kovacs - a showcase of their library tinycoro which uses C++20 coroutines to implement asynchronous operations.

It started with an overview of the benefits of asynchronous programming and their implementation via C++20 coroutines. I’m sure I’m not the only person that hasn’t completely got their head around coroutines, and that is certainly still the case for me! The conference features a coroutine workshop (at extra cost) which I could have used to remedy that situation…

As a Rust and C# user, many of the examples felt fairly vanilla because I am used to having those tools at my disposal anyway. Although, the C++ code examples using tinycoro were much better than their STL counterparts. The author noted a few sharp edges with UB around lambda captures and the performance of the library was slower than using STL concurrency in some cases. Overall, it was an interesting talk.

Oddly there were no direct Zoom link for the first talks of the day. I’m not sure if this was intentional but I was hoping to catch up on the other session “Birds of a C++ Feature” by Honey Sukesan. This session was a round-table for people to share their C++ stories and unfortunately I was not in a position to be able to interact at the time.

Don’t Be Negative

Next up was Frances Buontempo’s ‘Don’t Be Negative’, a talk with a simple premise to remove negative numbers from a collection. Frances highlighted the value of choosing simple problems as a mechanism for learning as the premise of the talk.

The talk was a great overview of the considerations when writing generic functions, covering things like: container types, picking sensible default values for potentially unknowable types, and functional operators. Some humorous examples were presented such as rejection sampling, which generates subsets of a list until one is returned with no negative numbers… even if that means you lose some of the positive ones! It felt like something you might read in a malicious compliance story (perhaps our A.I. overloads will take notice when generating new code for us)!

I like Francis’ presentation style, which always seems to make the content of her talks feel approachable.

Declarative C++

Ankur Satle’s ‘Declarative C++’ was exactly what it said on the tin. Many desirable properties of software systems are reachable using declarative techniques. The power of these techniques tends to come from compact representations of desired outcomes rather than explicit control flow. The speaker pointed out some successful declarative technologies every day such as REGEX.

Some C++ features that we can use to write declarative code were discussed. User defined literals are a cool example of this, which have made STL types like string_view much more palatable to initialize. Operator overloading was discussed as well but I feel like there is a common-sense limit to this, otherwise one can easily end up implemented DSLs for C++ with operators and leaving consumers to suffer the gargantuan compile times that usually accompany this approach.

We can also extend declarative approaches to our APIs, and an attempt at a safer concurrency library for C++ called libguarded was discussed. This was of a similar vain to Dave Rowland’s send and sync implementations from the previous day, with the difference being that you wrap your data in the type of synchronization that you want rather than using concepts.

Keynote: Code & Culture

The day two keynote was ‘Code & Culture’ by Sejal Guptil. The speaker discussed matters relating to inclusion, which they described as a world in which barriers to full participation don’t exist and people can fully engage.

One case study that highlighted the importance of inclusion as a business imperative rather than moral obligation was Netflix’s approach of hiring a diverse team to write content for Netflix originals. This yielded a huge increase in new subscribers and extra profit in the billions for the two years after the initiative. As a consumer, I can say it definitely produced some great shows too! The Xbox adaptive controller is another example of commercial accessability success story.

Some counterexamples were issued as warnings to consider when making assumptions, like YouTube marking deaf videos as ‘no content’ due to the the lack of sound. Other considerations such as cultural norms (e.g. for date formats), pronouns, language, and visibility issues were highlighted as potential areas for mistakes. These were interactively presented through a deliberately problematic form. Audience feedback was solicited live to share the problems experienced whilst navigating the form, which was a great idea to practically simulate the talk content. One resource that may help readers avoid such mistakes is the W3C web accessibility initiative, which published resources make the Web more accessible to people with disabilities.

This talk was comprehensively researched and referenced, providing accessible further reading on an important subject matter for programmers.

An Intro to the Neglected Majority of x86 - SIMD

My open content session of choice on day 2 was ‘An Intro to the Neglected Majority of x86 - SIMD’ by Hugo Contreras. The talk opened with some history, peering all the way back to x87 and MMX through to the present. AVX-10 seems to be the future of SIMD on x86, which was first released with Intel’s Granite Rapids CPIs and that the speaker believes will be available on consumer chips in the next couple of years. This adds most of the AVX512 feature set to either 256 or 512 bit wide vectors. Intel have been using heterogenous cores for a while now with p-cores for performance and e-cores for efficiency. Some issues arose when only p-cores had AVX-512 support and e-cores did not support this so Intel is backtracking on AVX512 for consumer CPUs, creating the need for width variance on this new instruction set. It’s always fun to play with these types of intrinsics, so hopefully I’ll get some time to have a go in the near future.

It was interesting to learn that, depending on which threshold of counting a ‘vector’ instruction that you use, SIMD instructions make up somewhere between ~70-~85% of of x86 instructions. Having spent some time digging in to these ISAs that did not surprise me, but it does back up the talk title at least!

The speaker gave a handy list useful tools for working with SIMD code, e.g., the Intel Intrinsics guide. They also reminded me of Intel SDE, which is an emulator for Intel ISAs that can be utilized when you don’t have access to hardware support for certain instructions.

The talk rounded-off with some technical deep dives on the capabilities of modern CPUs and SIMD programming patterns. I had known of zeroing idioms (where compilers emit something like a xor eax eax in order to zero eax), but I didn’t know that the CPU detects these idioms in the instruction stream and performs the operation without using any execution units.

This talk was great. The speaker was very knowledgeable and made the information very easy to understand - a real highlight of the conference so far. Seeing as these user content talks are not recorded, this was well worth attending!

Command Line C++ Development

Matthew Benson’s talk ‘ Command Line C++ Development’ was an overview of how we used command line tools to write C++. This topic probably would have been revision for most, but one new consideration that was raised was the power requirements of IDEs. For rural communities that may have less or infrequent access to power, efficient command line applications can provide better accessibility to computing and help reduce battery anxiety. I can only think of the odd occasion where I have felt this way coding on a train, so considering this may be some people’s everyday experience was certainly jarring for me.

Day 3

Unfortunately, I was fairly busy on the last day of the conference and didn’t have time to meaningfully engage with any of the day three content!

Thankfully there were a few talks on this day that had already been given before and had recordings available on YouTube. Those aside, I’d definitely like to catch up on:

• Type Traits Without Compiler Intrinsics
• SIMD Substring in a String

Conclusion

My first experience of C++ was a positive one. I often mention the importance of low-cost, virtual conferences for the sake of accessibility and this was no exception. The content was enjoyable and I left with a few new ideas and areas for further research, which is usually a good sign.

Kudos to the organisers and volunteers for the excellent event that they produced!

I couldn’t help but (virtually) leave with the opening remarks regarding C++ “not being a dead language” lingering in my head. Whilst I certainly think that C++ is here to stay (and is indeed a language that will always have a fond place in my heart), I think we are certainly witnessing a shift away from the language by most of the mainstream software industry, and for good reason too. I have been moving most of my personal projects towards Rust, perhaps soon I will find some time to write my thoughts on this subject at greater length. For now, I will be watching developments in the C++ community with interest to see how we collectively navigate this interesting period of programming language discourse!