Meeting C++ trip report

Earlier this month, KDAB attended the Meeting C++ conference in Düsseldorf as a Gold Sponsor. The conference was well attended by people from across the spectrum of C++ use, and with a wide variety of expertise. Attendees were enthusiastic and interested in getting the most out of C++11, sharing knowledge about the direction of C++, Qt, Boost and tooling. Many worked in the embedded world or on gaming platforms, and many worked mostly or exclusively on in-house applications, rather than on libraries.

KDAB had a booth at the conference where we showed some demos of what can be done with modern Qt, and talked to people about our service offerings and our Qt and C++11 trainings.

There were many great talks from technical and community leaders.

As usual at such a conference, the "hallway track" can be as interesting as the talks themselves. We had some discussions about the experience Qt has with moc, the QMetaObject, and the QMetaType system etc. I was directed at the ISO C++ Reflection Study Group, and will try to direct some feedback there.

We didn't get to attend all talks in the conference, but here is a run-down of some of the interesting talks we did attend.

The first keynote was given by Eric Niebler, known from the Boost community, and related some advice for professional growth, and how library writers can take advantage of C++11 to present better interfaces for their users.

Peter Sommerlad, a university professor from Switzerland, explained why concepts didn't make it into the C++11 standard and how the new road map for concepts in C++ looks like.

The first step will be to introduce the syntax for declaring and using concepts into the language standard. If that's done, they want to port STL to concepts in a second step. There were many questions during the talk about the usefulness of concepts and if it is possible to not only check the syntax but also the semantic constraints of a template at compile time. Concepts are one of the most-talked-about parts of C++ standard features, so this is exciting work to follow.

Marc Gregoire talked about C++ AMP, Microsoft's abstraction layer for GPGPU computing. GPGPU computing refers to running some general purpose code massively parallelized on a graphics card.

The talk started with a nice demo that showed why you want to use your GPU. It simulated the movement of 1800 stars in a galaxy (depending on their weight and gravity). By using a GPU you speeded up the simulation by several magnitudes. This was an amazing example of what can be done when GPU resources can be used.

Afterwards he described the disadvantages of the existing solutions like CUDA or OpenCL and then presented the concepts of AMP. The API is quite small and easy to use, as he showed in calculating a Mandelbrot fractal.

Unfortunately AMP is currently only supported by Microsoft Visual Studio, but Intel seems to work on a cross-platform implementation of AMP... let's see what the future will bring us there.

Another talk was about Templight, a debugger for template metaprograms based on Clang. The speaker presented the problems associated with debugging template metaprograms, and described the Clang patch they created to extract information during compilation. Their patch results in creating an xml file containing all template instantiations, and the resulting graph of dependencies and compile-time values can be viewed in a Qt-based application.

The eventual goal is that all compiler vendors would be able to create a similar xml file which third parties could consume in tooling. That way, the quality of information available to tooling does not depend on the user using a particular compiler.

A talk about containers available in Boost was mostly showing how to use the Boost Multi-index library. The talk also covered boost bimap, which uses some of multiindex internally, the boost container library, which contains implementations of some stl containers (vector, etc.), and some other containers (flat_map, which is an always-sorted vector). Finally, he showed boost intrusive, which does not take ownership of the contained types, and requires the contained type to have some methods which the container uses.

It was an interesting talk about some containers which I didn't know about. I had seen the boost implementation of std::vector and wondered why it existed: It is so that the user can rely on one implementation on all platforms, instead of the MS implementation which is different from the libstdc++ and libc++ implementation, has different bugs etc.

Next year, the Meeting C++ conference might be held in Berlin, which is a familiar location from many Qt conferences. It will be another opportunity to get out from the world of Qt, which we are comfortably familiar with, and see how the other half lives.