ACCU 2017 trip report


We’ve just returned from ACCU 2017 in Bristol, UK. Being amazed by the event I decided to share some notes here, and hope Phil will also jump in and share his impression. There are also reports by Vittorio Romeo, Simon Brand and Samathy Barratt which you might find interesting.

JetBrains booth and my talk

We’ve decided not to break the good tradition started in 2015 and as usual had a booth for Wed-Fri. We’d like to thank everyone who came for a chat or just to say hello:

My general impression was so much different from the one in 2015 (I skipped 2016 for family reasons). Back in 2015 it was just one week after the CLion 1.0 release, so not that many were familiar with JetBrains as a whole or any of our C++ products (CLion, ReSharper C++, AppCode). We mostly gave intro demos and explained who we were and what we did.

This time was totally different! Most of the attendees had heard about our tools (that felt great!) and many of them had tried them. So our conversations revolved around particular use cases, new features and plans. And of course we shared our new Clang-Tidy integration.

One thing that I noticed in particular was that relatively few people are aware of our free trial program. If you simply go to our site, you’ll find CLion’s build (stable release or EAP, depending on your preferences) to download and use free for 30 days. If your company requires longer evaluation, simply drop us an email to and we’ll process it quickly.

Attendees were also interested in refactorings our tools provide, and we really have a lot. Get a free trial to try them all on your project!

Luckily I had my talk on the first day, which then helped me relax for the rest of the event. I talked about the C++ language and how we see it as tool developers. The topic seemed to resonate with many, and attendees found this new view interesting and useful. At least they liked my samples with similar lines which mean different things depending on the context:

The video is already available, and you can find the slides here.

Conference in general

Because of the booth and my own talk, I unfortunately was not able to listen to many. However, I made some good choices and caught a few very interesting topics. Considering that most of the talks were recorded, I feel good about how it all went in the end.

Mongrel Monads, Dirty, Dirty, Dirty

How do you usually handle errors in C++? Niall Douglas was talking about various options here: from enums to optional and expected and much more. The sample he built his talk around was a frequently used open-file-by-name case. So Niall iterated, showing various solutions to the task. What I found most valuable was the performance measurements that showed how badly the solution with exceptions fails. His own outcomes solution was also quickly introduced. The video is already available, so find more details there.

Lightning: LLVM C/C++ compiler frontend in Java

As you might guess, this one was extremely interesting to us as a C++ IDE creators. We already had some discussions about it with Vladimir Voskresensky at the Saint Petersburg user group that I currently run. The full version of the talk was presented at LLVM Europe 2017 and the recording is already available. At ACCU Petr Kudriavtsev made a short presentation. However, you could still get the idea.

Treating clang as the powerful tool it is, but considering the potential issues when using it from inside a Java-based IDE (Java-C++ bridging overhead, safety, etc.), the NetBeans team decided to try another way and ported clang into clank, a Java version of clang. An interesting fact is that they’ve got a tool that is capable of translating clang’s patches into clank code with minimal manual work required. While there is some performance degradation and the adoption is not wide inside NetBeans (only in preprocessor for now), this is still an interesting solution. We are currently also playing with several options on how to generally improve our C++ parser and we’ll definitely follow NetBeans team work at least out of curiosity.

5 years creating FOSS dev tools for C and C++: the untold

The talk was presented by Diego Rodriguez-Losada, a person who we should thank for Biicode in the past and Conan now. Despite the fact it was not that technical, but rather a set of advice from personal experience, I still found it interesting. I was definitely glad to see CLion on many slides. We indeed try to keep the tool lock-in to a minimum, so that you can rely on well-known toolchains instead of learning and sticking to another new one created by another tool vendor.

C++ Core Guidelines – Modernize your C++ Code Base

Peter Sommerlad dedicated his talk to the C++ Core Guidelines, overviewing the sections and talking about the most important ones. If you haven’t read the Guidelines document at GitHub yet, take this talk as a good introduction to the topic. Learn about the general ideas behind the Guidelines and see some sample of when they are important. We of course also waited impatiently for the demo, as Cevelop is now capable of performing some checks from the Guidelines on the code. While we currently support them mostly via Clang-Tidy (and some checks are available in our own implementation for some time already), Cevelop has taken another approach and implemented them in its own parser engine. I’ve got some good ideas like introducing const to the code that we might have in CLion as well.

Grill the C++ committee

The session with the committee was great. We learned how the committee feels about C++17 and things not coming into it (seems that, while they are satisfied with many additions to the standard, Modules, Concepts and Ranges are still the biggest demand for C++20 or however it will be called). Again it was explained how to start with a proposal, and Herb Sutter encouraged everyone to try. Moreover, the session recording is already up on the ACCU YouTube channel.

Over to Phil

I also only had a chance to attend a few of the talks. Unlike Anastasia’s, my talk was on the final day, so I spent more of my time preparing for that. Nonetheless I still thoroughly enjoyed the conference – both in the sessions, and in the after-session socialising. I’ve been an active member of the ACCU since around 2000, and have been to all but one of the last 15 years of conferences, speaking at most of them. Catching up with old friends has always been an enjoyable part of the conference, but it’s easy to fall into the trap of inadvertently excluding others who are not already part of your group. Usually I consciously try to break away from that at times and meet new people. This year the JetBrains booth gave me another great way to do that – but one of the emergent sub-themes of the conference was that of going even further to be inclusive and, for most of us, our blindness toward the very real problems in this area. These thoughts are captured far better than I could ever put them in Samathy’s blog post that Anastasia linked to at the start, as well as a lightning talk that Andy Balaam gave, and also blogged about here.

On a more technical note I caught some of the same talks as Anastasia, but also a few different ones. First up was Nico Josuttis’ talk on “The nightmare of Move Semantics for Simple Classes” which showed just how challenging it can be to take advantage of perfect forwarding in a relatively simple case. Fortunately he finished with a few helpful rules of thumb that will give you reasonable defaults for most cases.

I also learnt about “Functional Programming for the Web with Elm”, by Austin Bingham, which was a great introduction to a language that is at once both far removed from the C++ center of gravity of the conference, but also familiar as we adopt more and more functional idioms (just see my talk). It certainly beats JavaScript!

Admittedly the first talk I was able to give my full attention to (without fiddling with my slides, or at least thinking about my own talk) was the first one after mine – the last of the conference before the closing keynote: Odin Holmes’ “Modern C++ Design reloaded”, wherein he took us through the main topics from Andrei Alexandrescu’s famous book and revisited in the context of what we think of as “Modern C++” today. Some things are no longer relevant or are much easier to do (e.g. variadic templates instead of typelists), some have fallen out of favour (singletons, policy-based smart pointers) and some just have newer, generally nicer, ways of doing things. One big shift has been away from TMP (Template Meta-Programming) towards metaprogramming being supported as a first class (as opposed to “accidental”) feature of the language. But Odin also argued that there is still a place for some of the older techniques – especially in the embedded domain.

Back to Anastasia

Closing keynote by Herb Sutter: Thoughts on Metaclasses

I managed to listen to only one keynote session, but it was so incredible that it really was worth it! I’m not sure if Herb really wants us to talk about it widely for now. The recording will be made public only after the proposals are presented to the committee (which definitely makes sense), but let me share the main idea here.

If the proposals are accepted, we might get metaclasses, we might avoid boilerplate code via talking to the compiler in code, we might get DSLs out of C++ without vendor-specific compilers, and much more. Moreover, clang is already catching up with these proposals!
Intrigued? You should be! But keep calm and wait for the committee to react (fingers crossed!).

There were more, but I’ll stop here and let you wait for the recordings available. Find them at YouTube: Day 1, Day 2, Day 3, and Day 4. And I certainly recommend that you join the ACCU 2018. The dates are known (2018-04-11 to 2018-04-14) so you can already save them in your calendar.

Your CLion Team
The Drive to Develop

This entry was posted in Conference & Events and tagged , . Bookmark the permalink.

Leave a Reply

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