Cpp On Sea 2019 Trip Report

From February 3rd through February 6th I have been in Folkestone, UK, to visit the first C++ On Sea conference.

There must be something in the water on that island that enables them to organize fantastic conferences like ACCUConf and, since this year, C++ On Sea.
C++ On Sea is definitely the best conference I have ever been to, and here’s a little glimpse why I think so.

To put my experience in context, here is what my main reasons are for going to conferences:

I arrived in Folkestone on Sunday evening. It is in Kent, UK, directly where the channel tunnel emerges. Leas Cliff Hall, where the conference took place, is situated directly on the cliffs and has a great view that sometimes lets you see the French coast. If it’s not windy, rainy and foggy as it was most of the time during the conference.

Conferences don’t start with the opening speech or first keynote. They start on the day before, when people meet to chat and socialize. In this case, I had dinner with one of several groups of people from the #include<C++> community.

Monday, February 4th

On Monday morning, the actual conference programme started with an opening speech by the conference organizer Phil Nash.

C++ was not only in the conference name, but also in the details: The opener was titled “Hello, World”, there was a “main()” plenary hall and session rooms titled “const west”, “east const”, and “unsigned”. The latter was the smallest of the session rooms and had an overflow problem a few times, but luckily that did not lead to undefined behavior, because C++ conference attendees seem to be very nice people in general.

The list of C++ puns goes on, as you can see from the floor plan and schedule.

The first keynote of the conference was Oh, the humanity! by Kate Gregory. She showed how the cliché of the logical, unemotional programmer is wrong. We can see lots of emotions in the code we write, and we better check whether it’s the emotions we want to show towards our fellow programmers.

One of the takeaways from the talk was that single letter variable names are bad and a sign of laziness. I myself am guilty of this, and throughout the conference, lots of speakers commented on their own slides in the lines of “yeah, since Kate’s keynote I know I should fix those”.

After the keynote, normal sessions started in four tracks. The first talk I went to was Postmodern immutable data structures by Juan Pedro Bolivar Puente. Juanpe showed some great examples of very efficient, partially copy-on-write, vector-like data structures.

The next talk I visited was by Adi Shavit and is called What I Talk about When I Talk about Cross Platform Development. Adi showed how the “Salami tactic” enables us to write as little platform-specific code as possible by building thin layers of platform-independent C and C++ APIs around a pure C++ domain core.

Subsequently, I went to the main() track to see Jason Turner talk about Practical Performance Practices Revisited where he showed how seemingly innocent changes can enable the compiler to optimize our code. The talk contained a fair amount of “life-godbolting” and showed how optimizer technology is advancing: Jason himself sometimes seemed to be surprised that newer versions of Clang reduced his examples to a no-op or a constant return statement.

After that followed the most amazing talk I have ever seen at a conference. The keynote Deconstructing Privilege by Patricia Aas does not seem to have anything to do with C++, but it has to do a lot with the people who use it.

In her talk, Patricia shows how even though we might have hardship in our lives, being spared discrimination due to race, gender, sexual preferences and/or other factors can give us a head start in life. If you look again at the list in my Tweet above, this talk is a great example of #2: I have never before seen a large room filled with so many people in complete stunned silence.

After the keynote, there was a session of 11 interesting, enlightening, and entertaining lightning talks. The day concluded with a gala dinner where speakers and attendants met to eat and chat.

Tuesday, February 5th

After a short kick off, day two of the programme started with another round of sessions. The first one I visited was Programming with Contracts in C++20 by Björn Fahller. Contracts let the programmer define preconditions and postconditions for their functions that can, depending on compilation flags, be checked at run time.

While this sounds like a great thing to have, the current state of the standard draft looks rather disappointing to me. This is also due to some properties of the language that implementers cannot always work around. However, while I am writing this, a standing committee meeting takes place at Kona, where no less than seven papers regarding contracts are scheduled for discussion.

The second talk was quite something different in many regards. Hana Dusíková talked about Compile Time Regular Expressions, but not in person: Due to a canceled flight, she had to give the presentation remotely. And, of course, Murphy’s law provided some technical difficulties so she had to rely on Matt Godbolt as an avatar to handle her slides and, lacking a working camera, tell her about reactions from the audience.

This manner of talk delivery was quite an experience and had an element of fun, at least for the audience. But the talk itself was just amazing. Hana presented the intricacies of parsing regular expressions at compile time in a casual manner that makes constexpr template wizardry seem like a stroll in the park. In addition, there even was a working regex parser written in JavaScript in her slides (that Matt had to type the input for) to demonstrate the tree her library builds at compile time. Quite a few minds were blown by this talk.

Then it was time to give my own talk about Learning (and Teaching) Modern C++ – Challenges and Resources. In the presentation, I talked about how the quick evolution of our language makes it hard for teachers and authors to keep their knowledge and teaching materials up to date, and about the benefits and drawbacks of the different resources available to us.

As the next talk to watch I chose Sailing from 4 to 7 Cs: just keep swimming by John Shearer, because it mentioned one of my blog posts in the abstract and the talk: John presented how his team started out with the “4C” development environment (Clang, CMake, CLion, and Conan) and added three more “C”s and quite a few other letters to their tool stack.

The last keynote of the conference was by Matt Godbolt: What Everyone Should Know About How Amazing Compilers Are in which he showed us how good optimizers are at guessing what developers want to do. In a series of live compiler explorer examples, he presented how modern optimizers can sometimes melt multiple lines of code into a single assembly instruction.

The key takeaway from this keynote: Trust your optimizer, don’t manually optimize in “smart” ways without checking the output, because you might actually inhibit the optimizer from recognizing common patterns.


For me, the conference was a blast. I met a lot of people I had known from other conferences, quite a few that I had only met online before at #include<C++>, and made a handful of acquaintances I would not have made otherwise. Full marks for #1 of my conference checklist.

There were also quite a few talks that were fun and/or engaging to attend, for me and others. A check on #2 of the list, and also for #3, as I find it always rewarding to share thoughts and experiences with a room full of people, even though the prospect is extremely scary every time I submit a talk proposal.

If you have not been there, there are two things you should do: Try to get a ticket for the next installment (hopefully 2020) and watch the videos on Youtube. (At the time of writing, new videos are uploaded every day)

Previous Post
Next Post

Leave a Reply

Your email address will not be published. Required fields are marked *