(Virtual) Trip Report: Meeting C++ 2024

I virtually attended Meeting C++ 2024, which was my first experience of Meeting C++ in any format.

Much like with ACCU earlier this year it was awesome to see another conference with online access. Whilst, in my opinion, the experience from online conferences pales in comparison to in-person attendance, it is great for accessibility. This year I have had more going on than usual, so the cheaper and easier to access online conferences have been useful. I managed to get early bird pricing for the online ticket, which was less than 55 GBP - pretty reasonable compared to the standard prices.

Front Matter

The online conference portal was hosted on Hubilo. It was my first time using this platform and overall I’d say the experience was pretty good. The talks were hosted on four livestreamed tracks that lasted for the entire duration of the day, as opposed to having an individual Zoom meeting per talk. There were 4 talk tracks in total (with track D being online only).

The user interface for each stream was intuitive. It was nice to see separate sections for asking questions and chatting with other online attendees. Credit to the conference staff who asked every single question that had been submitted online (at least at the talks I went to), it really does help make the online experience feel a little closer to the room.

Day 1

Day 1’s keynote was “Fear in Tech” by Titus Winters. As could be inferred, it was a culture-oriented talk about where fear comes from in tech teams and practical steps to alleviate it. There were too many nuanced pearls of wisdom to hope to cover comprehensively here, but I’ll try to summarise some of my key takeaways:

• We often experience an internalised “exam mentality” from university. Our work is only checked when it is examined, and this mentality can transfer to PRs.
• Psychological safety is the number one predictor of team success, according to Google’s Project Aristotle.
• Westrum’s Organisational Cultures were something I have definitely experienced, but never heard formalised. I feel like I have some experience with aspects of each archetype.
• We should write team culture documentation, covering how we work.
• Tools that let us experiment (VCS, CI, monitoring etc.) are useful for alleviating fear, especially in more junior team members.
• Code that we are afraid to change is an existential risk.
• We must be capable of reacting to any valuable technical changes, even if we don’t choose to take them.
• When deciding on new tools or technology we should ask: How will it work over time? How will it affect the team? What are the pros and cons?

The first talk of Meeting C++ 2024 saw the mention of Rust and C++’s bad defaults - that certainly didn’t take long! An awesome opening keynote overall that left me with some new mental tools and direction.

The second talk I attended on day one was Klaus Iglberger’s “Design Patterns - The Most Common Misconceptions (2 of N)”. Klaus had a really infectious energy and sense of humour, which was great because design patterns are not exactly the most hair-raising talk topic. Static interfaces were the focus of the first part of the talk. It was suggested that concepts aren’t really a good model of static interfaces unless you add something like a type tag to derive from in order to mimic the explicit grouping of a type hierarchy. There was also a discussion of std::variant vs classic OOP type hierarchies and the architectural pitfalls associated with this. Benchmarks showed some performance benefit to using std::variant however.

Props to Philipp Dominik Schubert for an early contender for best talk title: “The Notorious B.U.G. - The Most Popular Bugs and Code Smells in C and C++”. Philipp works for Sonar, a tool that I currently only use for C# because the C++ analysis is not free.

The talk covered some techniques for analysing source code (such as symbolic execution) and the top 10 analyzed issues for C++. There were no surprises here: the usual suspects use-after-free like null pointer dereferences all made an expected appearance. Anyone that has been following the recent safety conversations would probably be able to guess the rest of the line up. The remedial advice was a reiteration of the importance of tooling yourself properly and communicating your intent effectively with the compiler. All the classic advice was there: sanitizers, warnings as errors, etc. One particularly interesting tidbit that I hadn’t heard before (as someone who does not work in a security centric domain) was to not rely on memset to zero buffers that previously contained sensitive data. If the buffer is about to be destroyed then some optimizers might believe that they would be pointlessly overwriting the memory before destroying it anyway and consequently may omit the memset call altogether.

The talk finished up with some musings about the state of C++. Given the number of these bugprone issues that we face as C++ developers, are we failing to teach C++? Are the defaults of the language wrong? The speaker seemed to think so (and I agree!), but it was noted that we can use modern C++ to address many of these issues. Realistically though, uptake of more modern techniques can be slow in the real world due to toolchain support.

My penultimate talk of the day was “The C++ Execution Model” from Bryce Adelstein Lelbach. Bryce’s talks always offer some in-depth insights into concurrency, and this was no exception. There was a manageable build up of the standard-ese required to grasp the rules for the execution model. The types of sequencing and forward progress guarantees were explained, which was interesting to me as someone with little knowledge of the standard in this area.

The session I attended was yet another Klaus Iglberger talk entitled “There is no Silver Bullet”. The abstract of the talk offered to compare classic OOP and FP approaches to problem solving. I found the overlap with his previous talk was quite large here, indeed the examples were more-or-less the same as in the previous session. Nonetheless, it was good revision.

It has been easier for me than usual to decide which talks to attend at Meeting C++. As we are at the back end of conference season, some of the talks have been given at other conferences and subsequently uploaded to YouTube. With that said, my catch up list from the first day is still fairly long! I am particularly looking forward to:

• How to debug Linux multi-threaded code, including race conditions
• Portable floating-point calculations
• Introduction to Sender/Receiver framework
• Writing VSCode extensions for fun and profit

Day 2

The day two keynote was Hana Dusíková - My Favorite Data Structures. It was pitched as a “things I wish I knew before hacking clang” explainer, which was intriguing for me because I have been trying to get back into programming languages and compilers in my own time. The talk covered some inner workings of data structures through clang’s AST evaluation. As someone who has started reading the clang source code fairly recently, I was not surprised to learn that clang’s constant evaluation implementation was in a single 17k LOC source file! I also learned that much more of the STL that I expected could be made constexpr and it was awesome to see the (very long) list of proposals that Hana had put together to push this capability forward. For me, constexpr semantics are one of C++’s strongest superpowers so continuing to push its capability forward will certainly be useful.

The second talk I watched live was “Pipeline architectures in C++: overloaded pipe operator |, std::expected and its monadic operations” by Boguslaw Cyganek. It covered some history of pipelining, std::optional, std::expected and pipeline operations in real world code samples. I am a big fan of these functional approaches and have used them a lot in personal projects. There wasn’t a great deal of new information, but the refresher that this talk gave was definitely welcome.

Kate Gregory’s talk “The aging programmer” was a talk I was especially looking forward to. Not just because Kate’s talks are always great, but because I filled in the survey that she sent out to the community in preparation for the talk! The survey covered questions regarding programmers’ concerns about body and mind as we age. As such, there was a tour through the health concerns raised by survey respondents with practical advice and anecdotes throughout. It was interesting to learn that, whilst COVID-19 is fairly resistant to hand washing, the sheer amount of extra hand washing people did during the pandemic eradicated an entire strain of flu! A jarring point for me was that our attitude towards older folks affects our own experience of aging - apparently even to the extent of causing medical issues. It was definitely useful for me (as a self-identifying(?) young person) to hear this hour of wisdom.

The last talk I attended on Friday was Peter Muldoon’s “Software Engineering Completeness (Part 1): Knowing when you are done and why it matters?”. Peter Muldoon’s talks are always fiercely practical, but this talk extended that practicality into the philosophy behind delivering “business value”. This could mean immediately realised value (like features) or long term values (code that is easy to modify and fix). The talk centred on the importance of good definitions of “done” and how we can bring them about. The speaker cautioned against the ever-tempting option to tentatively mark something “done” if it is code complete with tests. Rather, we should perhaps only consider things as “done” when they are fully proliferated throughout PROD. The importance of shared language was also highlighted in the context of delivering in a team - a parallel with Titus Winters’ day one keynote.

I was not able to attend a session in the last slot of the day, which leaves me with extra catch up. The talks on my watch-later list for day two are:

• Testable By Design
• Stories from a parallel universe
• Growing Pains - Lessons from Seeing Codebases Mature
• The Beman Project: Bringing Standard Libraries to the Next Level
• What is a static function, but isn’t a static function?

Day 3

Due to personal commitments, I couldn’t attend any of Saturday’s sessions in a live capacity.

Saturday’s format did not contain a keynote, but rather 3 morning sessions. Seeing as I didn’t attend any of these, my catch up list is massive (nearly everything) so there is little point in listing it here!

Conclusion

The Meeting C++ 2024 online experience was excellent and, at the early bird price, is was certainly well worth the entry fee. There were a wide range of interesting talks which, as an online attendee, is about the only thing you are qualified to judge! Kudos to the organizers for putting a solid online conference experience together!