Talks at the Meeting C++ 2014 Conference

Multiplatform C++

C++ is a multiplatform language, yet many difficulties arise when you want the same code to compile properly and function identically on different platforms. If you put aside the obvious system programming related obstacles, and the differences you might have between compilers (especially when it comes to supporting C++11 and C++14), you come to the surprising conclusion that what is truly hard is all the “little things” you didn’t anticipate.

Testdriven C++ with Catch

C++ has been notorious for being a second class citizen when it comes to test frameworks. There are plenty of them but they tend to be fiddly to set-up and ceremonious to use. Many of them attempt to follow the xUnit template without respect for the language environment they are written for. Catch is an attempt to cut through all of that.

Pruning Error Messages From C++ Template Code

Many template libraries are regarded with ambivalent feelings by developers: On the one hand, such libraries can offer wonderful functionality. On the other hand, they are dreaded for the sheer amount of error messages spilled out by the compiler when there is even a small bug in the developer''s code.

Sqlpp11, An EDSL For Type-Safe SQL In C++ For Databases, Containers, Streams And More

Most C/C++ interfaces to SQL databases are string based. Theses strings effectively hide expression structures, names and types from the compiler. And they are vendor-specific. And they defer expression parsing and validation until the test phase or (even worse) production. This feels wrong. C++ can do better.

Designing value classes for modern C++

C++11 is now widely available, and so is C++14. Like for users of the language, C++11/14 is a new language for C++ library writers, too. In this talk, we will walk you through the new C++ features that impact class design. We will show guidelines that you can apply in your work tomorrow. The talk will focus on value classes, which are classes that act like an int, because that is what modern C++ is designed for.

Expression Templates Revisited: Separating Facts from Urban Legends

Since their invention in 1995, Expression Templates (ETs) have proven to be a valuable tool for many C++ template libraries. Especially numerics libraries quickly embraced them as salvation for the performance deficiencies of standard C++. This reputation as performance optimization quickly added to the success of ETs and lead to a general adoption of the technique.

Multithreading done right?

Multithreading with modern C++ is hard. Undefined variables, Deadlocks, Livelocks, Race Conditions, Spurious Wakeups, the Double Checked Locking Pattern ... . And at the base is the new Memory-Modell which make the life not easier. The story of things which can go wrong is very long.

In this talk I give you a tour through the things which can go wrong and show how you can avoid them.

Ranges and iterators for numerical problems

Ranges and iterators are the fundamental abstractions when one needs to generalize traversion of arbitrary collections of data. In this talk I will show how these concepts can be applied for numerical problems. Examples will range from representing arbitrary functions, to differential equations and cellular automatons.

Introducing Gpcxx - a framework for genetic programming

This talk had to be replaced with C++11 library components to make a programming scientist happy

This talk will introduce gpcxx - a modern C++ framework for genetic programming (GP). GP are specializations of genetic algorithms where the individuals are expression trees being evoled by an evolutionary algorithm.

Automatic Task-based Code Generation for High Performance Domain Specific Embedded Language

Providing high level tools for parallel programming while sustaining a high level of performance has been a challenge that techniques like Domain Specific Embedded Languages try to solve. In previous works, we investigated the design of such a DSEL – NT2 – providing a Matlab -like syntax for parallel numerical computations inside a C++ library.

Interactive Metaprogramming Shell Based on Clang

Developing metaprograms is hard and painful. Templight ( supports the development and debugging of template metaprograms, but the code has to be recompiled after every minor change and tricks are needed to retrieve useful information about the result.

A number of languages (Python, Haskell, Erlang, etc) provide an interactive shell for trying code out and displaying the results immediately.

Generating OpenCL/CUDA source code from C++ expressions in VexCL.

VexCL is an opensource C++ vector expression template library for OpenCL/CUDA. It has been created for ease of GPGPU development with C++ and provides convenient and intuitive notation for linear algebra operations, vector arithmetic and various parallel primitives. This talk discusses C++ techniques that VexCL uses to effectively generate OpenCL/CUDA compute kernels from user expressions.

Objects? No Thanks!

Micro-controller programming can benefit from compile-time polymorphism without paying a run-time price by using static class templates.

For small micro-controllers (kilobytes of memory) C++ run-time polymorphism (using objects and virtual methods) is often deemed too expensive in ROM, RAM, and run-time overhead.

The C++ Memory Model

The C++ memory model defines how multiple threads interact with memory and shared data, enabling developers to reason about concurrent code in a platform independent way. The talk will explain multi-threaded executions and data races in C++, how concurrent code is affected by compiler and hardware optimizations, and how to avoid undefined behavior by using locks and atomic operations.

Generic parallel programming for scientific and technical applications

Technical and scientific applications dealing with a high computational load today face the challenge to match the increasingly parallel nature of current and future hardware. The talk shows how the increased complexity of software can be controlled by using generic programming technologies. The process and its advantages are introduced using many concrete examples, starting from simple operations on sequences (like sum/reduce or local filters), then moving into higher-dimensional applications like image processing and finally to particle methods based on dynamic neighborhood graphs.

C++ Executors

Executors (or schedulers) will be a base building block in C++ for asynchronous and parallel work. Executors for asynchronisity are somehow similar to allocators for containers: They are a very important implementation aspect, but for most people they are hidden behind the scene. Developers concerned with performance however want to have a closer look to executors, to understand what different design dimensions exist for executors and what implications they have on performance and programming model.

Asynchronous programming infrastructure: the Asynchronous library

During the last Meeting C++, we studied a CD Player built upon the Boost Meta State Machine library and using Qt's event loop for the asynchronous infrastructure. This however has a few drawbacks: we don't always want to run as a Qt application and Qt is limited on the parallelization front. We of course have std::async, but well, it's not that asynchronous.

Writing robust code

Error handling is a fundamental part of any API. The error handling strategy of a code base determines how costly errors are at run time, how much code is spent on error handling, whether const can be used for classes, and whether functions are composable. This talk will cover all popular error handling and reporting strategies, including global variables (errno), return codes, exceptions, and assertions.

C++ SIMD parallelism with Intel Cilk Plus and OpenMP 4.0

Performance is one of the most important aspects that comes to mind if deciding for a programming language. Utilizing performance of modern processors is not as straight forward as it has been decades ago. Modern processors only rarely improve serial execution of applications by increasing their frequency or adding more execution units.

When dependency hell freezes over: Managing C/C++ project dependencies

Try to complete the following sentence: Python has Pip, Ruby has Gem, Dart has Pub, C++ ... Unfortunately, there is no possibility to continue the sentence with the word has": There is no standard solution for resolving and keeping track of dependencies and version compatibilities for C/C++ projects.

Monads in Chains

Monads are scary, and monads are evil. But they are still useful.

In the recent years, the abuse of multi-threading has become apparent and more and more systems started being developed in the reactive, or event-processing style. It allows lowering the number of threads to match the system cores instead of items that are being processed by using non-blocking asynchronous APIs.

Keynote: The Evolving Search for Effective C++

Scott Meyers has been searching for guidelines that summarize effective C++ programming for nearly 25 years. During that time, the language has seen considerable change, as has the background of C++ software developers and the means by which programmers acquire and exchange information. With the experience of researching, writing, and publishing the latest of his “effective” books (“Effective Modern C++”) fresh in his mind, Scott steps back to consider the process of identifying and promulgating useful guidelines for effective C++ software development.

Coding Dojo

What is a Coding Dojo?

A Coding Dojo is a meeting where a bunch of coders get together, code, learn, and have fun.
(Emily Bache, The Codig Dojo Handbook)

The coding dojo will be in the Track B Room during the first Lunchbreak!

C++11 library components to make a programming scientist happy

This talk presents a survey over components of the C++11
standard library which facilitate the life of a programming scientist.
It will provide a gentle introduction to the random number generator
and evolve this to a complete application: the stochastic simulation
of share price development.

Keynote: Plain threads are the 'GOTO' of today's computing

When in 1968 Edsger Dijkstra published his famous paper 'GOTO considered harmful', he instigated a wide discussion in the community leading to the now commonplace knowledge that structured programming - while somewhat higher level than GOTO - is superior. It raises abstraction levels and makes code more approachable to humans.