I’ve enjoyed CppCon’s backlog of content on YouTube for quite some time, but I never got the chance to attend the conference in person. So this year I decided to take advantage of the virtual format of the conference and check it out first hand. I’m so glad I did! It was a lot of fun experiencing everything in realtime despite the awkwardness of the first-time online venue. As an aside, I meant to post this a lot sooner, but it seems despite the virtual format it still came with con crud, and I’ve been sick since the conference ended.
I was a little worried that I might not be able to appreciate all the discussion, that it would be very high level and academic considering the vast amount of C++ experience attending the conference as a whole, but to my surprise the conference is very welcoming to people of all skill levels. Through the Q&As, I also heard a lot of questions from people having issues that were very relatable to my own day-to-day at work, so that was refreshing. Overall, I think one of the most entertaining and informative sessions was the AMA with Herb Sutter. I’ve always loved his talks and just participating in a long, agendaless Q&A session with him was really enlightening. Honestly overall I think the Q&As worked a lot better than with the live format conference from what I’ve seen, because here the technology made it easier to push some of the best questions to the top (through a voting mechanism) rather than the floor going to whomever happened to be brave enough to walk up to the microphone. I do wish that the conference organizers allocated more time for questions, because a recurring problem with every talk was that there would only be 3 or 4 minutes (if that) to answer questions at the end of each session.
On the other hand, networking was very awkward (for me, at least). They created a virtual hallway that was meant to give people a place to congregate, as well as virtual tables prior to the start of each talk, but I noticed probably 80-90% of attendees didn’t have a microphone setup, so it was very quiet. It was definitely a lot harder to get involved in organic conversations. It probably also doesn’t help that I didn’t have any existing connections at this particular conference to help with introductions, so I ended up not doing any networking to speak of.
With the general impressions out of the way, let’s talk about specific sessions that I liked.
I was inspired right from day one! The opening keynote was called The Beauty and Power of “Primitive” C++ by Bjarne Stroustrup. He presented some interesting concepts using low level C++ to create a system for rapidly transporting data structures without serialization. Later that same day, Phil Nash presented Test Driven C++ and showed off how to use Catch2 to do test-driven development. Between those two talks, they inspired me to create my own version of both as part of a programming “kata” (as Nash called it) just for practicing the things I heard that day. The result is SeriStruct, which is slowly evolving. I made a lot of progress in between conference talks, and I hope to get back to it once I’m fully recovered from being sick. I’ve written lots of unit tests in my time, but switching things around to write the tests first is way more enjoyable than I thought it would be.
One of my favorite talks of the conference was No Touchy! A Case Study of Software Architecture with Immutable Objects by Borislav Stanimirov. My attitude toward concurrent programming and mutable data structures has evolved greatly over the years, so I appreciated this talk that tracked directly with my preferred solve for the problem, which is if at all possible to avoid mutability. Stanimirov deep dived on the system he wrote for copy-on-write objects to power medical imaging software, so it showed a real, practical usage of this design concept. It was also refreshing to have the presenter respond to really low level concerns from the audience like “What about CPU cache misses?” with a very practical “Look that’s not really important here.” Sometimes it can be stifling when every C++ discussion is dominated by those who need to squeeze the most out of every last CPU cycle. It’s nice to know there are others out there writing higher level applications code in C++.
The Surprising Costs of void() (and Other Not-Quite-Innocuous Evils) with Patrice Roy opened my eyes to a lot of little pitfalls in the language, all mined from real world code that Roy had encountered. There was so much information in this one that I really want to rewatch it once it’s available on YouTube.
Lastly, it should be no surprise that I want to talk about Herb Sutter’s closing talk, Empirically Measuring, and Reducing, C++’s Accidental Complexity (also no YouTube link yet). In his presentation, Sutter showed the difficulty of understanding the arcane soup of ampersands in C++ function signatures and how confusing it can be to decipher the intent. He goes on to present some pretty radical changes to the language specification to simplify things. Personally I’m all for anything that makes C++ more accessible and easier to maintain, but I wonder how the larger world of C++ programmers will take this proposition. Sometimes I think longtime C++ developers actually like the arcaneness (arcanity? arcanicity?) of their chosen language. At any rate, I wouldn’t expect we’d have to worry about it any time before C++26.