A few days ago, I attended the Meeting C++ conference in Berlin, the third year in a row. As usual, I had a lot of fun and interesting conversations with lots of people I had or had not met before.
Conferences are as much about socializing and networking as they are about listening to interesting talks. Therefore, when Carlos van Rooijen proposed to have a pre-conference meetup on Wednesday, I decided to travel to Berlin a few hours earlier.
We spent the afternoon walking through Berlin and climbing to the top of the Victory Column. In the evening, the place to be was the Sky Bar of the conference hotel where dozens of conference attendees had a beer or two with a 14th-floor sight of Berlin at night and a chat about C++ or other topics.
I got up a little early as most days, so I had time to work on my slides for an hour before breakfast. The usual thing with slides is that no matter how much time you spent preparing them, they’re never quite finished.
The conference started off with a welcome message by Jens, followed by the first of three keynotes: Better Code: Human Interface by Sean Parent. Sean is a gifted speaker, and if you ever have the chance to attend one of his talks, you definitely should. The main topic of his talk was the difficulty of mapping the complexity of program logic to the UI which leads to the need for declarative approaches for the UI logic. He said that it would be hard to teach declarative languages and declarative thinking to programmers who only know imperative paradigms, but I disagree. Learning new stuff is at the core of being a developer, and declarative approaches are on the rise again. Since Sean is a strong proponent of using standard algorithms instead of raw loops, he also presented a few tricks and insights regarding those.
The second talk I attended was Practical C++17 by Jason Turner. Besides Jason being a brilliant speaker, the topic also sounded interesting to me, so this decision was a no-brainer for me. Jason presented the impact the use of several C++17 features had on the code base of ChaiScript, regarding performance, readability, and more. It definitely was refreshing to see a C++17 talk that did not present the theoretical use of features with artificial small-scale examples but had a connection to real-world code.
After Jason’s talk, I watched Strong types for strong interfaces by Jonathan Boccara. Jonathan presented the general concept of strong types and why we should use them. He then showed us his take on a library for strong typedefs. His implementation includes the very interesting option of Skills, which are optional small features that can seamlessly be added to any strong typedef.
The next talk I attended was How C++ Debuggers Work by Simon Brand. It was a very well-presented talk about the principles that debuggers use to help us find those pesky errors we write and that the compiler so willingly hides in the executable for us. I had read about and toyed around with compilers and interpreters and how they work. Getting the overview and a basic understanding of what Debuggers do under the hood was a very nice addition to that knowledge.
I did not attend the last slot that day but instead had some chats and finished the slides for my talk. I also came late to the hilariously presented Conan C++ Quiz, so I only watched it from the sidelines. Trying to figure out some of the answers without pen and paper proved to be quite a challenge. The day ended with a sponsored party, and as usual, when there are great people and interesting chats, I ended up in my hotel room later than planned.
The day started with a brilliant keynote, It’s complicated by Kate Gregory. We want to write readable programs and simple code, but we also want the power that makes C++ so complex. The key point in Kate’s talk was that you can’t have simple rules for a complex system. For example, “Don’t use exceptions” is such a simple rule, but it’s not the whole truth. For that reason, the core guidelines are not as simple as we maybe would like them to be. The talk resonated with the message I try to convey with my blog: Simplifying the code we write without being able to simply write “Do this, don’t do that.” It’s complicated.
The second talk I attended on Friday was Practical constexpr by Jason Turner, again about the impact on a real-world application, this time of using
constexpr. It did show that Kate was right: A simple “constexpr all the things!” does not quite cut it. Jason showed that, in the right circumstances, applying
constexpr can improve run-time performance, but it also may be that it does not improve or even deteriorate performance in places where we would not expect it. As always when we deal with performance improvement, there is only one thing that really helps: measure, measure, and measure again.
For the third slot that day, I was hijacked by Jens to sit on a Panel about “Beginning with C++”, together with Kate Gregory, Wouter van Ooijen, Jason Turner and Rainer Grimm. We had some good discussions including the small, but engaged audience. Topics included sources to learn C++ from, and whether C++ is a good language to start learning to program with. The opinions on the latter differed, but we all agreed that it should not be the only language you learn. For example, include a functional or declarative language to add paradigms to your understanding that are not traditionally covered by C++.
Declarative Thinking, Declarative Practice by Kevlin Henney was a must-watch again, simply because he is such a great speaker. If you ever come to a conference where Kevlin is speaking, make sure you attend his talk. In the talk, Kevlin touched a mix of topics, from ways to calculate roman numerals that are very different to our imperative mindset to well-named tests. Some of it I had seen, e.g. in his ACCU 2017 talk, and a video of his talk about good unit tests. Nevertheless, it was a very entertaining talk (who else can claim to mix Shakespeare with programming topics?), and for me, that’s one of the reasons I go to conferences for.
The last day of the conference started off with a talk Code Reviews – Why, What, and How by yours truly. Of course, there was a last minute panic editing of the slides, and of course, I left one error in, but that’s how it goes in my experience. I honestly don’t know how the other speakers can be so perfect all the time. I initially had submitted a different talk proposal, about my journey from financial enterprise C++ to an embedded project and the differences. However, Jens had contacted me, that there was another proposal quite similar to mine, and if I’d like to talk about code reviews, that kind of topics was not covered enough yet. The talk went better than I would have imagined, and the audience was larger than I had thought it would be.
In the break and talk slot after my talk, I listened to the embedded meeting going on in the Lounge Track. The Lounge Track is a great thing for the conference attendees who think that having breaks is a waste of time, so, during the breaks, you can attend discussion rounds in the lounge.
The last talk I attended on Saturday was The hidden rules of world-class C++ code by Boris Schäling. Boris showed different ways to implement factory methods. Since C++ is not a purely object-oriented language, it should not be a big surprise that we have other options than the classic inheritance-based implementations.
Before the closing Keynote, there was an update about Meeting C++, followed by a number of “secret” (i.e. not announced) lightning talks. The most inspiring ones were by Kate Gregory and Guy Davidson. In a very personal talk, Kate shared five things she learned when she was diagnosed with cancer. Guy spread the word about the #include initiative for diversity. Diversity in tech is known to be an issue, and looking at the C++ community, especially conference attendees, it seems to be even more so.
Sadly, I could not stay for the closing keynote, but what I saw about it on Twitter makes me eager to see the recording as soon as it is available. According to Jens, the first videos should be available in the next days. I’ll add links to the videos of the talks I mention here as soon as they are available.
As always, Meeting C++ was a great event. My main goal at conferences is not learning new stuff – I can do that at home – but experiencing good speakers, and especially meeting people from the community. That I did, thanks to the get-togethers in the restaurant and bar on Wednesday, the well-organized party on Thursday (thanks, Conan/JFrog), the speakers’ dinner on Friday (thanks, Jens) and all the breaks between the talks. I also have to thank my employer, Zühlke, for sending me to conferences like Meeting C++. (By the way, we’re hiring!)