CppNow 2016 Trip Report

As you may have seen on our blog, we like to go to tech conferences all over the world. The C++-Now is especially loved. Last year two of my colleagues were at this event – this year it was my turn.

The conference

C++Now is a conference with its own particular charm and atmosphere and is now in its tenth year. Located at a high altitude in Aspen, Colorado it is surrounded by the beautiful landscape of the Rocky Mountains. Most people tend to connect Aspen with skiing or high society, but every year after the skiing season ends a group of C++ enthusiasts gather there for a whole week to discuss the latest developments in the C++ world.

Starting originally as BoostCon, the organizers later opened the conference up to a wider range of topics. But since the beginning it has been limited to 150 attendees giving it its special character and making it easy to get to know the other participants. If you look at other events like CPPcon which typically have about 700 attendees, you won’t probably get that kind of familiar atmosphere.


My trip started with a long but pleasant flight from Munich to Denver and ended with an exhausting 4-hour drive to Aspen through darkness and rain. But after a good night’s sleep I was already meeting fellow participants in the hotel lobby for breakfast. One big advantage of a small town like Aspen. The mix of attendees was quite interesting with almost every country represented. I personally made contact with some guys from Canada, Sweden, Romania and of course the US. Even more astonishing was the variety of business sectors that people came from. Some were from the embedded domain (like me). But there were also guys working in gaming, CAD calculations and even one developer from a content delivery network (CDN) that uses C++ for its webservers.

The social highlight of the week was the BBQ dinner at the Aspen Center of Physics. Sitting outside in the sun beer in hand and enjoying a delicious American self-made burger was just the right setting to chat to a lot of different people. My personal favorites were the discussions with the firmware development lead at Apple and the LLVM Compiler lead at Google.

Interesting talks and projects

Library in a week Library in a week is a nice idea born some years ago at this conference. Imagine a lot of C++ enthusiasts gathering every morning before the actual conference and working together on a certain project. This year’s project was about kickstarting a new way of documenting boost in the style of cppreference.com. We decided to try to get the current docu into some kind of wiki to offer a nice place for editing content. Unfortunately this turned out to be much more difficult than we thought! Especially since there are lot of different documentation styles available in boost. The work was far from complete at the end of the week but people are still working on it after the conference. So let’s hope for the best.

Boost.Hana Louie Donnie attended the conference last year when he presented his work on the metaprogramming library Boost.Hana. He has continued his work on the library and this year showed how some day-to-day coding problems could be solved with the help of metaprogramming.

Variants and Tupels Two reoccurring topics were Variants, which will be partially introduced into the C++17 standard as part of the standard library, and Tupels which are the base for many metaprogramming patterns. Variants are basically the safe version of a union. You can store different types of data inside the same variable, but with the advantages of C++ type-safety. Variants are being heavily discussed in the standard meetings at the moment. The current state is that there will be a library-based variant in C++17 and probably a language-based version in C++20. Tupels have been part of the standard since C++11. They are the more universal version of std::pair. Tupels become really interesting when you start combining them with metaprogramming. You can basically pass any pair of types around in your code and evaluate them during compile-time.

Dependency Injection for C++ Dependency Injection (or DI) is probably something you’re familiar with from modern, mostly managed programming languages which are based on some kind of virtual machine (like Java or C#). DI is a clever technique where the order dependency passing is reversed. You simply specify which class depends on which other class and the framework takes care of the initialization and its order. The problem is, DI normally makes heavy usage of reflection which is not (yet) available in C++. However, a library was presented which makes use of metaprogramming to generate a compile-time only variant of DI which outperforms common implementation in different languages.

CopperSpice A small team of two people calling itself CopperSpice was pretty active at the conference. They started with a fork of the old QT4 (the current version is Qt5.7) and tried to create a fully CPP++11-compatible version of it. Along the way they removed the dependency on the MOC compiler and reworked the whole signal framework. But they didn’t stop at QT. During the documentation phase they recognized the need for a better C++ documentation framework – so they forked doxygen and created DoxyPress with better C++ language parsing. They also had a challenging talk with the title “Multithreading is the answer – what was the question?”.

Cpp++14 on ARM / Ciere Consulting creating MQTT client Of personal interest to me was a talk from Ciere Consulting about implementing an MQTT client based on the new design patterns of C++14. As an embedded developer it was particularly interesting that the whole implementation was running on an ARM Cortex-M0 core with very limited resources. They were even using standard STL containers with dynamic memory allocations. The implementation should appear on their website soon.

Further Information

If you like to have a look on some of the good presentations, you can find the collection of the whole week on Github.

ShareTweet about this on TwitterShare on Google+