JetBrains C++ team at CppCon 2018: trip report
Our C++ team is on its way back home from Bellevue, Washington, where CppCon was held during the last week of September. While our memories are still fresh, we’d like to share our impressions of this year’s installment of CppCon.
As the biggest and most global C++ event, CppCon gathers attendees from all over the world and unites C++ developers of all levels of knowledge across many areas. Classes, sessions, panels, podcast recordings, lightning talks, open-content sessions, exhibition tables, posters – all these different formats help participants share their knowledge of all aspects of C++ development.
This year was unique for many reasons. First, the conference finally outgrew the maximum space available in Bellevue, and that’s why next year’s CppCon will move to a new place in Aurora, Colorado, a city near Denver. We all felt a little sad about leaving the Seattle area and spent the week trying to capture all the good memories of this place.
Second, several new formats entered the program including Lightning Challenges and Tools Time.
Third, the organizers opened the first floor to companies who’d like to communicate more closely with the C++ developers at the event.
There were many more points that made us think this CppCon was a huge success. Let’s talk about some.
This year’s keynotes were exceptional and highly technical. Bjarne Stroustrup talked about Concepts, which in his opinion simplify designs by being a better specification of the interface, give precise error messages as early as possible, and scale well. He also discussed the typical question that bothers C++ developers: accidental false matches. From his point of view, this can only happen if two entities only differ in semantics (like backward vs forward iterator). But generally, concepts rarely produce a false match. So while concepts don’t catch all type errors, they are still a powerful language feature to make C++ simpler and safer.
Kudos to Bash Films who did the official video recording at the conference. Many talks are on YouTube already, and Bjarne’s keynote session was online on Tuesday, the next day after the actual talk!
Another keynote had a surprising and exciting title – Patterns and Techniques Used in the Houdini 3D Graphics Application – and lived up to it! How amazing was it to see C++ developers on stage accepting an Academy Award?! Having the C++ committee receive such recognition, on that stage, was an incredible feeling! Mark Elendt shared the story of SideFX and the Houdini application, as well as the language-level solutions and patterns they used. Since Houdini has been around for a while, it’s interesting to see the evolution of the ideas and compare custom solutions at every point in time with those available in the standard library and the language in general.
Next up was Herb Sutter with Thoughts on a more powerful and simple C++, a self-reflection on the evolution of the language. Herb discussed how modern C++ language abstractions make user code simpler, let developers deprecate problem features, and remove unnecessary special cases. Still, these language abstractions need to follow the 3 main principles of C++: zero-overhead abstractions, determinism and control, and link compatibility. This philosophic part was followed later by an update on two areas Herb is currently working on: bringing metaclasses to C++, and introducing lifetime update checks. The goal of the former is to give a name to a subset of types with common characteristics. Since the first announcement at ACCU 2017, the proposal has evolved. In his keynote, Herb showed the updated syntax and a couple of new real-world samples where metaclasses seems to be very useful indeed, like properties in C++ and a synchronization sample. Last but not least, how good it would it be if we got rid of macros and switched to modules, constexpr, and metaclasses instead?
The second part of Herb’s update was dedicated to the Lifetime proposal. This was later complemented by a talk from Matthias Gehre and Gabor Horvath exposing the details of Clang implementation (which you can already try in Compiler Explorer on a special clang branch – pass the
-Wlifetime flag to the compiler). The idea is to have lifetime checks running fast enough to perform in the IDE and during compilation. It’s reported that Clang implementation has ~5% compile-time overhead on large LLVM files. I assume these checks will soon land in clang and maybe other compilers, so keep an eye on it and check out the proposal for more details.
The last big session was run by Chandler Carruth and dedicated to Spectre and the famous meltdown issues. This presented a perfect opportunity to deeply understand the problem by digging into the assembly code on various samples. Finally, possible solutions and actions were discussed. This talk was followed by a dedicated Spectre panel, which allowed the audience to discuss the topic, share their concerns and fears, and ask for practical advice from experts representing Google, Microsoft, and Red Hat.
I’m afraid I can’t cover all of the amazing talks we had the pleasure of listening to, but a few deserve a special mention:
- In his talk on initializers, Nicolai Josuttis discussed the Almost Always Auto principle, issues with types consisting of several words, narrowing conversion, and issues with initializing an
- Compile time regular expressions, by Hana Dusíková. Many attendees I’ve talked to called it one of this year’s best talks. Even though the language features required by the CTRE library were accepted as a draft to C++20, they still don’t work in any of the modern compilers. But the
_ctrelanguage extension does for GCC and Clang. Hana showed the implementation for the latter, as well as many interesting samples and of course the benchmarks.
- What could possibly go wrong?, by Simon Brand and Phil Nash. This should be of interest for anyone wondering why Herb Sutter started this whole exception handling movement. In their talk, Simon and Phil tried to demonstrate and evaluate all the options for error handling available in the language today, giving scores and validating various improvements.
- Best practices in C++, by Jason Turner, based on his GitHub-based materials at http://cppbestpractices.com/. This is a treasure trove of great advice that every C++ developer should check out to make sure they are aware of possible issues that may creep in and ways to resolve them. The topics discussed included proper getter accessors, trailing return types, and constexpr downsides, among others.
- In his talk Compile-time programming and reflection in C++20, Louis Dionne discussed new features like guaranteed compile-time execution, reflection, code generation, compile-time memory allocation, strings, and containers, and how they all fit together into one vision of a new kind of modern compile-time programming. This is a true gamechanger. It will let us do amazing new things and profoundly change the way we think about C++ metaprogramming.
- Finally I’d like to mention the talk of our friend Matt Godbolt, Bit between the bits, which can come in very handy for those who want to dive into the details of the compiler/linker job, for example, to learn how global constructors work.
We are also happy and proud of our team members who managed to get 5 talks into the program!
Over to Phil Nash
Once again, I only managed to attend a handful of talks owing to my own commitments (two full talks, a lightning challenge, Tool Time, a panel, two full live podcast recordings, a lightning podcast appearance, and a two-day class – phew!). What I did see was very much in keeping with the sentiment that I have heard from many attendees: this was the best CppCon yet! It was also the biggest – I heard (so maybe official figures will differ) that over 1,300 attended the conference in total! There are much bigger tech conferences out there, but in the C++ world that’s about double the next biggest that I know about. What’s amazing is that, even at this scale, there is still a friendly community feel to the event. It’s not as intimate as some of the smaller conferences, but has its own unique quality that you can only really experience by being there in person.
Of the talks I saw, Andrei Alexandrescu’s coverage of the proposed
std::expected was the first. Andrei always gives a great talk and, dare I say it, this was no “exception”! But I had a particular interest in this topic as I would be covering much the same material in my joint session with Simon Brand the following day. As “expected” (sorry, it’s a rich seam here), there was a large overlap between the two talks – and Andrei even used a similar approach of weighing up the pros and cons using a number of dimensions. However, the presentation style, ultimate direction and conclusions were also different enough that I think people who saw both talks got something out of each. In fact I asked at the start of mine how many had attended Andrei’s and a substantial number raised their hands. I think that’s an indication of the interest in the topic. By the way, the main difference was that Andrei stopped at
std::expected, whereas Simon and I went on – first to show how adding a set of monadic operations can help improve things further, and then to show how the Static Exceptions proposal takes the whole thing to its ultimate conclusion.
My other main talk was on Catch2 and was a bit of an update and refresh of one I have given at some other conferences last year. There were two big additions to Catch2 since the last ones that I covered: generators and support for
This year we saw the introduction of a new evening session on Tuesday, Tool Time. This was a “tech labs” style event where anyone who wanted to represent a tool (an application, framework or library) could do so on a level playing field. We were there with CLion and ReSharper C++, of course, but it was also nice to see tables with one-person open-source projects alongside us. I wasn’t able to join the JetBrains tables myself, because I was running the session! I think it was a success and we’ll be doing it again – although it was unfortunate that it coincided with the first evening of the Lightning Challenge talks, which were very popular.
Talking of Lightning Challenges (more on them later), I did one on Thursday entitled You’re Not As Smart As You Think You Are, which dug into the science of cognitive limits, how it relates to our code, and what we can do about it. However, that particular lightning talk session was memorable for two other entrants: Simon Brand using a glass of water as a metaphor for monads, then proceeding to illustrate what using an optional without a monadic interface was like by emptying the water over his head! On the more serious end of the spectrum – yet with artful lighthearted flourishes – the inimitable Walter Brown took us on a tour of his mentors over the years, and concluding that he now realizes it is too late to thank them and tell them how much they have shaped him, because they are no longer with us. The implication is that, if we have the chance, we should not wait so long. Who are your mentors? In your career, in technology, in life? Do you appreciate what you have gained from them? Have you told them and thanked them? Don’t wait too long.
Back to Anastasia…
Booths, tables, and Tools time
The CppCon exhibition grows year by year. In 2018, it added the first floor giving attendees a wider variety of companies to talk to. We thank everyone who visited the JetBrains booth on Monday, Wednesday, and Thursday – it was a pleasure talking with you! Some attendees even tried our C++ quiz and won T-shirts right on the spot, while others participated in the license raffle. Meanwhile, the raffle survey gave us an overview of the C++ standards and compilers mostly used by the attendees. The distribution of C++ standards correlates with what we previously saw in the JetBrains Developer Ecosystem survey and the C++ Developer Survey that the C++ Foundation ran earlier this year:
It’s also worth mentioning that C++17 has increased its share compared to last year, if we go by the survey we run at CppCon on a regular basis.
In terms of C++ compilers, GCC dominates even though it’s lost some points over the year, while MSVC and Clang are approaching fast:
Making its debut, the Tools Time format gave all tools and library developers an opportunity present their work and talk to end-users on an equal footing. Even though the lightning talks, open-content session, and Tools Time all competed for attendees, we think the format was successful and we’d like to thank those who participated and especially those who came to the CLion and ReSharper C++ tables.
Lightning talks and Lightning Challenge
This year was the first time to run the brand-new Lightning Challenge format. The rules are tough – a speaker only gets 3 minutes guaranteed, then 3 more minutes can be added if 50% of the audience vote yes, and finally 2 more minutes are added if 70% vote yes. Sounds challenging, doesn’t it? Phil Nash, Timur Doumler, and yours truly decided to participate as we love a challenge. Since the format was experimental, only 6 topics were accepted to the challenge, and surprisingly all 6 speakers got their full 8 minutes. Believe me, when you get on that stage and the clock and voting counter are ticking, you feel the adrenaline! The energy and excitement in the room went through the roof.
We would like to invite every C++ developer to participate in CppCon next year in Colorado. The conference is scheduled already for the week of September 15-20, 2019, so mark the dates in your calendars today!
The JetBrains C++ Team
The Drive to Develop