Trip Report: C++ on Sea 2023

Last week, I was lucky enough to attend my first programming conference - C++ on Sea 2023.

In this post, I’ll share my experiences of the conference. We’ll look at what was on offer throughout the week and some interesting points from the talks.

As an aside, recreating my personal site is something that I became motivated to do after attending C++ on Sea, so I think it is only fitting that this should be the first post!

Workshops

There were three pre-conference workshops available as an add-on to the ticket: Modern C++ Idioms, Introduction to C++ Coroutines, and Concurrency in Modern C++.

I chose Modern C++ Idioms because I am fairly recent convert to C++ (since around 2019) and wanted to make sure I really understood the most common modern C++ idioms.

Overall, it was an informative workshop with some exercises that were generally well placed in terms of difficulty and application to the source material. I was pleased to find out I had a fair amount of knowledge correctly understood beforehand. I found that this workshop built nicely on this by filling in some gaps in my knowledge and teaching me some new ideas. From my perspective, it was a useful day and put me in a good headspace for the rest of the week.

Throughout the remainder of the conference, I heard good things about the other concurrency related workshops. Hopefully, I can get some time for self-study on concurrency in modern C++ soon!

Talks

One of the main attractions of a conference is the talks and C++ on Sea did not disappoint. Three days of talks were on the agenda, often with 3 options to choose from at a time. There were a good few time slots where it was difficult to decide which to choose!

The talks will be available on the C++ on Sea YouTube channel at some point in the future. I’d definitely recommend catching up with them if you can.

I’ll briefly summarise some interesting points from the conference below:

Safety

Safety is an ever-present topic in software for good reason – the code we write can have serious real world impact.

This is especially focal in C++ at the time of writing, after the US Government named C and C++ specifically in reference to preferring memory safe languages. The conference saw a range of safety talks including an excellent opening keynote from Sean Parent and an interesting talk from Timur Doumler. A surprising takeaway was that lumping C and C++ together as being in the same class of unsafe-ness is slightly misleading, as it turns out C was responsible for 46.9% and C++ 5.23% of open-source vulnerabilities in 2019. This speaks to the power of the (sometimes very cheap) abstractions in the STL and the importance of continuing to be vigilant in developing and refining them.

Andreas Weis’ “Building Interfaces That Are Hard to Use Incorrectly” was another great safety themed talk, which contained lessons on interface design for all to learn from regardless of the safety criticality of their domain.

Ranges and Algorithms

The ranges library is a hot topic in modern C++ and C++ on Sea did not lack for content here.

I attended a great talk by Conor Hoekstra on C++23’s additional algorithms to the ranges library. It was interesting to hear some of the opinions on how we can improve the composition of range algorithms through the language itself and see some comparisons to other languages. I had little exposure to array languages prior to this talk and found it to be an interesting paradigm. I would wholeheartedly recommend catching up on this one!

Tristan Brindle’s talk titled “Iteration Revisited” largely talked about an open-source library he wrote named Flux (docs can be found here). This is based on making iteration safer through the classic index style approach (called “cursors” in the library). A killer feature of this library (which sounds like it is on the radar of the standards committee) is internal iteration. The idea is that sequence adaptors can perform internal iteration more efficiently than by a standard check then advance loop. At present, this allows the compiler to generate more performant code than the std::ranges equivalents although hopefully this will change if this feature becomes subject to standardisation.

I was made to immediately regret the fact that I did not attend Tina Ulbricht’s talk “Throwing Tools at Ranges”, as it got rave reviews from those who did attend. This talk is top of my catch-up list as a result!

Other Talk Highlights

There were several great talks that don’t really fit into groups, so I’ll list them here:

• Ofek Shilon’s “Everything I wish they told me about linkers” was a really informative talk that gave some deeper understanding to the behaviour we all witness as consumers of linkers.
• Daniela Engert’s “So, you want to use C++ Modules … cross-platform?” convinced me that it might nearly to be time to attempt to use start using modules in my personal projects and that we stay have a little way to go on tooling integrations for modules.
• Jonathan Müller’s “C++ Features You Might Not Know” was an entertaining tour of occasionally mind-boggling code snippets, highlighting just how crazy C++ can be if you try.
• Bryce Adelstein Lelbach’s “Endnote: AI-Assisted Software Engineering” was a very interesting presentation of the current power and limitations of A.I. for our everyday software engineering tasks. It also set some appropriate expectations for A.I. systems and presented ideas on how me might improve their performance in future.
• JF Bastien’s “*(char*)0 = 0;” was a thought-provoking talk about what really lies behind seemingly simple (in this case baffling) code and how we as human beings perceive this. This one is definitely recommended if you want to have your assumptions tested whilst diving down to a low level of abstraction.

This list and the aforementioned talks in the previous sections are certainly not an exhaustive list of the good talks and only represent the ones I was able to attend.

Sponsored

Each day, over the lunch break, a short sponsored talk was presented on the main stage. We heard about Intel oneAPI’s SYCL implementation, a compiler-as-a-service tool called Tipi build and how to simulate a low latency exchange.

As someone who has been using Intel oneAPI since 2019 (when it was Parallel Studio), I was very interested to hear about the included SYCL implementation and I hope to get the chance to experiment with it soon!

People

One of the key advantages to in-person meetups is the amount of, and access to, like-minded members of the community. With just over 200 attendees and 40 speakers there was always immediate access to highly knowledgeable people. Everyone that I met was friendly and welcoming, which eased my first-time nerves considerably.

Throughout the week, I was privileged to have the chance to speak to lots of interesting people who shared lots of good advice (about both programming and life in general) with me.

There was an especially good opportunity to mingle at Dinner on Sea, which was a another optional ticket add-on. The dinner seating plan interspersed speakers with attendees in a gala dinner format. The food was delicious and I had a few interesting conversations overlooking the beach as the sun set.

It was also a pleasant surprise to meet another member of the F1 grid! We were both equally surprised to find out that we were not alone in representing our industry.

Exhibitors

Most of the conference sponsors were exhibiting in the main() room of the conference.

Any event with recruitment stalls means free stash, and this year the theme was clearly coffee! All attendees were given coffee tokens to redeem from the venue and one stall had a barista armed with a wide array of pastries!

Given the applications of C++, it was no surprise to see strong representation from the finance industry amongst the exhibitors. Phil Nash joked in the opening slot of day 3 that we were witnessing a rare moment of cooperation between the trading firms: it was possible to visit 3 different companies to get a cup, a coffee, and a stroopwafel!

There were also a few tooling companies exhibiting. I hadn’t heard of Tipi build (compiler as a service) or Undo (time-travel debugger) and these tools seemed like they had some pretty cool capabilities.

As an avid ReSharper user (both C# and C++), I naturally had to visit the JetBrains stand. I was given an explanation of the editor product line-up and some tips on how to improve in CLion. I’ve always found myself gravitating back towards ReSharper but perhaps now I can give CLion a better go. They were even kind enough to offer me a second fidget cube to give to my son - which was thoughtful!

Conclusions

C++ on Sea 2023 was an incredible experience and I’m thankful to have had the opportunity to attend. I was definitely nervous ahead of my first time attending, but the friendly people, beautiful location and quality content soon put that to rest. One of the most notable trends was that there were many other first time attendees who were also having a wonderful time!

Thank you to the organisers, speakers and other attendees for a wonderful week. Hopefully I’ll be back again next year!