Meeting C++ 2015 Trip Report (Day 1)

22 January 2016
| |
Reading time: 4 minutes

From December 4th to December 5th 2015, I attended the Meeting C++ 2015 conference in Berlin. The conference had about 450 attendees and featured two keynotes, 26 talks and two slots for lightning talks in four tracks. Attendees were mostly from Europe (about 55% German), but there were also attendees and speakers from overseas.

The conference is also a great social event, so I arrived Thursday evening to hit the hotel bar with a handful of people I know from Twitter and the Hamburg C++ user group. Among them were the creators of the Biicode and conan.io package managers. That lead to interesting discussions about the lack of established portable C and C++ package management tools.

Meeting C++ Team

Das Meeting C++ Team – Fotograf: Detlef Wilkening, Copyright: Meeting C++

Friday started with a welcome message to the conference attendees from its creator Jens Weller, where he also held a little restrospect on the history of the conference. Meeting C++ is meant as a hub for the C++ community in Europe and worldwide. The website started by listing, creating and sharing information about C++ user groups and encourages everyone interested to join or create one of those groups. The yearly conference started in 2012 with 150 attendees and has been growing ever since.

The welcome message was directly followed by an amazing Keynote “Understanding Compiler Optimization” from Chandler Carruth who works with the Clang/LLVM team at Google. Chandler demonstrated how the LLVM optimizer works on the intermediate representation, which is the general, assembler-like output of the compiler frontend. He talked about inlining, analysis of data flow and control flow and showed examples of optimizations of memory use and loops. My main takeaway of the keynote was that we should not try to help the optimizer, especially that we should not battle it but work with it. This is best achieved if you understand what the optimizer can do and what not, and by not doing manual optimizations like loop unrolling, as they can even prevent the optimizer from doing its job.

The first regular talk I attended was “Functional C++” by Nicola Gigante. C++ is not (only) an object oriented language, it is a multiparadigm language. We can choose from the paradigms available to find the best solution to a given problem, especially for problems that object oriented programming has no answer to, like concurrency. With thread safe pure functions, functional programming is a hot topic these days not only because it allows for a safer programming in the multicore age, but it also facilitates reasoning about programs by separating computations from side effects. With generic lambdas and function return type deduction, C++14 adds the functional paradigm to our toolbox. Libraries like Boost.Hana and Boost.Fusion support currying, function composition and other techniques that are known from functional languages like Haskell. Together with the concept of ranges proposed for C++17 classic algorithms become composable and pure functions allow the implementation of lazy ranges aka. generators.

In the second slot I attended a talk of the “embedded” B Track called “Deeply Embedded C++” by John Hinke. It was basically an experience report on how C++ can be used in embedded projects, although they usually don’t allow the use of core features like exceptions and heap allocation. John showed how his team had introduced a safe handling of correlated flags by using template metaprogramming and special types for flags that brought the needed compile time safety without making any difference in the generated assembler. The second part of the talk was about “ESTL”, an adaption of standard library containers designed for environments where containers must have a stack allocated maximum size and error handling through exceptions can be used only in emulations. At the end of the talk there was a short discussion with Michael Wong, member of the C++ standard committee and head of the SG14 subgroup for low latency and game development topics. The good news for embedded C++ programmers is, that SG14 is going to address many embedded problems, so stay tuned for upcoming technical specifications (TS) and the C++17 standard!

For the last slot of that day it was difficult for me to decide which talk to attend. There was a talk by Michael Wong about parallel programming models and two other interesting topics, but in the end I decided to learn something about the upcoming C++17 standard: “An Introduction to Resumable Functions Coroutines” by James McNellis, which gave an overview over the current state of the proposal for stackless coroutines in C++17 that can be suspended via the new keyword co_await and resumed later on. C++ coroutines are a powerful tool for concurrent programming that can for example replace tedious “future.then()” chains and complicated state management with Boost.Asio’s completion handlers.

James McNellis talking about coroutines

James McNellis – Copyright: Meeting C++

After that last talk on Friday there was a speakers` dinner for invited guests only and a social event for all conference attendees labeled “Drinks & C++” where I got to meet and chat with lots of different C++ developers from all over Europe until long after midnight.

That first day already was a great experience. It featured very interesting talks, but also lived up to its name: “Meeting C++” is a great opportunity to meet lots of interesting people from the C++ community. Stay tuned for the second part of the trip report!



Comments (0)


Sign up for our Updates

Sign up now for our updates.

This field is required
This field is required
This field is required

I'm interested in:

Select at least one category
You were signed up successfully.

Receive regular updates from our blog


Or would you like to discuss a potential project with us? Contact us »