Contrary to some others C++ conferences, I don’t have a great attendance record at Meeting C++. The last (and only other) time I was there was in 2017, which incidentally was also the year I started to speak publicly at tech conferences. I had tried to come back in 2018, but that year most of my proposals didn’t make it (CppCon was the only one to accept any of the new ideas I came up with that year). The year after that, I travelled so much for events that I would probably not have made it to Berlin even if I was invited. And then the pandemic happened.

All that to say, it had been a while and my memories of the conference were a bit fuzzy and I wasn’t sure what to expect.

Venue & city

Since its inception 10 years ago, Meeting C++ has been held in the Vienna House Hotel in East Berlin. Speakers are lodged on site, and attendees are encouraged to do the same. That makes it convenient to freely go from your room to the conference in a flash in case you forgot something, or want to grab your coat before heading out with a dinner group.

Despite that suggestion, I found the post conference evenings at the hotel bar/lobby pretty quiet. I could only meet a handful of people there each night, mostly other speakers. Either folks got tired early, or they decided to head into town and went back directly to their room afterwards. I’m told the hotel also has a fancy sky bar, sadly it was either closed or booked for private events during our stay.

The reason I mention all this is because as good as the talks can get, I believe the hallway track and the evening tracks are usually the real reason I urge people to attend conferences. I’ve got some inspiration from live talks in the past, but not nearly as much as from a break or evening conversation with other attendees. To me this is the one thing that online conferences have failed to replicate (not for a lack of trying, mind you).

Flights to Stockholm being rare, I arrived early a day in advance and had another almost full day after the conference due to a late flight back. Given the conference hotel location, it was quite easy to head into town and see the city. Berlin doesn’t lack in sights, museum, restaurants, concerts and the like. If you find yourself going to the conference in the future with some spare time, you should easily be able to find something of interest to do.

Keynotes

Thursday

The conference opened with Nicolai Josuttis’ Belle Views on C++ Ranges, the Details, and the Devil. In a large tour of C++ std::views, Nico shared his concerns about the potential pitfalls and traps that lie and await the unwary programmer. In particular, the fact that views of non-const containers allow mutability of elements (similar to std::span), but also offer no simple way to build a view to const, nor a simple way to write a generic function that will constrain the view to const elements and ensure any confusion between = and == will be stopped on its tracks by the compiler.

Worse, he also demonstrated several dangerous edge cases stemming from views possibly caching data to guarantee amortized constant time on begin(), making some view filters behave differently depending on the underlying container. I’m told some of those points were already mentioned in Nico’s book on C++20, and lead him to recommend staying away from std::views until the issues are addressed (std::ranges are fine though).

Finally, he briefly demonstrated an alternative implementation he made named Belle Views, which diverges from the standard to avoid all those potential pitfalls (at the other cost of different tradeoffs). Sadly the repository had to be taken offline the following day as it turns out some code was lifted from GPL-licensed STL implementations which were incompatible with the project’s license. I’m sure the repo will come back up later once those issues are sorted out.

There has been some discussion online since that talk came out, and so far it looks like there’s no big consensus on the topic. Some countered that those examples can be convoluted (especially reusing views or using views taken before a container is mutated), and that views are explicitly made to be similar to span and that no one should expect a different const propagation model.

Friday

The second day continued with Contemporary C++ in Action from Daniela Engert. In about an hour and half, she walked us through the entire code of one of her recent projects written with C++23. The whole thing was a client/server app for Windows able to stream animated GIFs from a server to a client that would display them as video.

While it did of course make use of 3rd party libraries (such ffmpeg, SDL and Boost.ASIO) for rendering, video decoding and networking, it was impressive to able to read through entire thing in the time of one talk. One might have expected the code to be quite verbose, but the point was that through the use of contemporary C++ features it was possible to fit the whole application in about 1000 LOCs.

Still while impressive, it was a lot of code to go through and I felt like a few more high level slides would have helped digest the whole thing. I guess the issue was to be able to fit all that under an hour and half, which is difficult for most “real” projects.

Saturday

The closing keynote was Breaking Dependencies: The Path to High-Quality Software by Klaus Iglberger. In it, he made an interesting observation that C++ conferences focus a lot on language features and other “implementation details”, and not so much on software architecture. A given conference will probably have a bunch of talks about the latest new thing coming up with C++23, but barely one mentioning design patterns or how to build good C++ software from a higher level point of view.

Sadly, it felt like the discussion lost its track halfway through the talk, spending in my opinion too much time talking about the nitty gritty details of how to implement a design pattern like the Singleton or the Factory in Modern C++ and the talk ran out of steam for me.

Still, I believe there is an argument to be made that we should talk more about software architecture in C++ compared to the amount of time we spend on NRVO, SFINAE and other random letter combinations.

Talks

As usual in my trip reports, I will not go over each talk I attended but rather mention the ones that especially caught my attention, one way or the other.

• Lambdas—how to capture everything and stay sane from Dawid Zalewski gave a good recap of all the lambda capture rules, reminding us of the caveats and best practices to keep in mind.
• Foundations of GPU programming by Filipe Mulonde showed that there is a lot to explore in GPU programming, but sadly an hour was not enough to cover all he wanted to talk about and I’d recommend splitting that talk into two, or maybe three parts.
• Hana Dusíková’s Lightning Updates demonstrated an interesting way to implement real-time update and hot reload of program data (in her case an antivirus database) with a rather elegant model.
• After attending and (re)watching a few talks about the topic, I finally managed to make sense of Deciphering Coroutines - A Visual Approach from Andreas Weis. I think he did his best to make them palatable, I just find the topic quite hard to follow due to the amount of glue code that needs to be shown when using C++20 coroutines (partially due to lack of library support).
• C++ MythBusters by Victor Ciura was a nice and refreshing experience after some of the more “heavy” talks, exploring the most common myths and legends about C++ and whether or not they still make sense today (if they ever did).

Final thoughts

This might be a controversial opinion, but I really do feel like the return to in-person conferences is a blessing. Some folks might be confortable with the online experience, but I have to admit my attention span during the last three years of CppCon (online each time) has plummeted to almost nothing, to the point that I feel like I would only attend online if the program is in need of content as a speaker. There is just something that doesn’t work for me with sitting in Zoom calls and barely getting any interaction with the speakers or the attendees. Between Meeting C++ and ACCU this year, I was really happy to be able to reconnect with friends and peers, discuss ideas and get some inspiration.

Do I recommend attending Meeting C++ if you can? Absolutely! Will I try to be there next year? Maybe. As more and more conferences reopen in-person, I’ll have to make some choice as to which ones I can reasonably go to. But it’s high on my list.