Speaker: Mateusz Pusz

Audience level: Beginner | Intermediate | Advanced

The most of the Concepts TS and Ranges TS is merged into the C++20 standard draft document. The talk will present a current design of those features and will provide suggestions on how to use them in our source code. That presentation is meant to inspire discussion on how should we use those long-awaited features while building tools and the C++ Standard Library.

Speaker: Boris Schäling

Audience level: Beginner | Intermediate | Advanced

Too lazy to look up high performance data structures in Boost? This talk is for you! This is a quick introduction to data structures in Boost that have been built explicitly with high performance in mind. Some of the data structures introduced in this talk you can use right away without having to rewrite lots of code. These data structures provide easy gains if you are looking for a quick way to improve the performance of your programs.

...

Speaker: Odin Holmes

Audience level: Intermediate | Advanced

Working in the embedded domain where 'special cases' are the norm I often find myself fighting with customization capabilities and 'canned' (non-customizable) abstractions. std::string often has a small buffer for small string optimization, std::function has something similar, why can't I set the size of that buffer, or more radically why can't I just stick that same buffer in a std::vector for a 'small vector optimization'. While we're at it why can't I take .at() out of std::vectors public interface and call some user-defined function on out of memory, maybe I turned off exceptions but still want to handle errors properly. Maybe I want a std::deque interface but have a fixed sized ring buffer under the hood. Those following the SG14 will notice I am ticking off proposals, the problem with these proposals is that the mostly follow a common pattern: "I need X without Y" or "I need X to have Y" and there are many many combinations of X and Y. Why do I have to pay for atomic ref counting in a shared_pointer in a single threaded use case? We could go on all day. In this talk we will explore the feasibility of building classes from composable pieces, some concrete proof of concepts as well as the library infrastructure needed for this task

...

Speaker: Timur Doumler

Audience level: Intermediate | Advanced

Initialization semantics is widely regarded as one of the most difficult aspects of the C++ language. We have many different kinds of initialization and many different syntaxes for it, and they interact in complex and often surprising ways. C++11 introduced the concept of "uniform initialization". But instead of unifying, this feature introduced even more complex rules, which were subsequently amended in C++14, C++17, and will be changed again for C++20.

In...

Speaker: Denis Blank

Audience level: Intermediate | Advanced

Today asynchronous programming is in great demand,
especially after it has become a huge success in the Node.js ecosystem.

Speaker: Tony Wasserka

Audience level: Intermediate | Advanced

Recent compiler versions enable us to leverage new C++17 features such as structured bindings and fold expressions to great effect on the expressiveness and type safety of our software - but what if we're stuck on an old compiler that barely supports C++11? Is patience for a toolchain update our only hope of new features?

Speaker: Daniela Engert

Audience level: Beginner | Intermediate

Experiences from introducing the {fmt} string formatting library into an existing application code base.

Speaker: Miro Knejp, Jakob Schweißhelm

Audience level: Intermediate | Advanced

std::vector is the most popular container in the Standard Library, and for good reasons. It has the best performance characteristics for iteration-heavy workloads and is commonly understood as the recommended go-to container. However users have to be careful about the iterator-invalidating side-effects many of its operations have. In general this means it cannot be used for algorithms that require stable pointers to a vector's elements, as those pointers can be invalidated even by a simple push_back. Consequently, many containers have been invented to circumvent this issue. These usually involve the allocation of individual blocks of memory (like std::deque) or extra levels of indirection (like boost::stable_vector). But in doing so, they sacrifice vector's most cherished property: contiguous storage.

This...

Speaker: Goran Arandjelovic

Audience level: Intermediate | Advanced

Popularized for the first time in the year 2001 by Andrei Alexandrescu's book "Modern C++ design", Policy-based design emerged as a great tool for library authors to provide more flexibility when it comes to solving difficult design problems.

Speaker: Jonathan O'Connor

Audience level: Intermediate

How do you go from just using templates to writing libraries that rely on template meta-programming magic?

Speaker: James McNellis

Audience level: Beginner | Intermediate | Advanced

We’ve all heard horror stories about bugs that were near-impossible to root-cause, and many of us have at least a few stories of our own. Corrupted or uninitialized memory. Resource leaks. API misuse and race conditions. Occasional and inconsistent crashes where all you have to go on are a series of unhelpful crash dumps. These kinds of problems are often time-consuming and tedious to debug, and can be both draining and infuriating.

Time Travel Debugging (TTD) is a reverse debugging toolkit for Windows that makes debugging these kinds of problems far easier, in both small programs and commercial-scale software like Windows and Office.  It enables you to record bugs as they happen, then replay the recording in the debugger afterwards, and use most of the debugger features that are available when debugging a live process.  TTD has been an invaluable tool for software developers and escalation engineers within Microsoft for many years and we were excited to release the first public preview of TTD last year at CppCon 2017.

In this interactive and hands-on session, I’ll introduce what Time Travel Debugging is and demonstrate the basics of how to use it.  We’ll walk through the root cause analysis of some typically difficult-to-solve bugs like memory corruption and API misuse.  Finally, we'll look at TTD’s advanced querying capabilities, which let you query information about memory accesses and function calls, enabling you to quickly answer questions such as “where were all of the places where the value 1 was written to this variable?” and “where are all of the places that this function was called where it returned an error?”

We’ll look at all of these things from the perspective of a C++ developer.  All of the example programs that we’ll be debugging will be C++ programs, and the larger examples will be based on real-world bugs.  As we walk through the examples, I’ll also introduce other, related debugger features that make debugging easier in general, even when not using Time Travel Debugging.

Speaker: Manuel Sánchez

Audience level: Intermediate

Qml is a declarative UI description language part of the Qt C++ framework for applications. Part of its QtQuick module, Qml brings reactive model-view-model UIs focused on cross-platform application development and touch-friendly mobile-like applications in particular.
In this talk I will present how my team ported our old web based touch UI for our video ip solution "WM&IP" to a full C++ Qt stack using QML for the frontend. Also I will present how we used our own C+ +14 static reflection library "tinyrefl" to automate the creation and export of models to the Qml UI.

...

Speaker: Christian Hofmann

Audience level: Beginner | Intermediate

Lambdas are a very powerful tool which was introduced with C++11. They are handsome, inline function definitions, extremely useful to be used as callbacks. These neat little things make programming a lot easier, and are much nicer to read than std::binds. But…

Speaker: Lars Knoll

Audience level: Beginner | Intermediate | Advanced

Qt 5.12 is the next long term supported version of Qt and is planned to be released by end of November. The talk will give an overview over the new features and improvements in Qt 5.12.

Speaker: Odin Holmes

Audience level:

Over the past two years I presented new ways to write algorithms in template metaprogramming with the kvasir::mpl library at various conferences. In this talk, after a brief review of some of those advances, I would like to show how my latest creation: the boost.tmp library (not yet submitted to boost) offers a relatively feature complete DSL with which one can meet the vast majority of metaprogramming needs with no disambiguators and odd keywords. We can even benefit from the added clarity of a DSL without increasing compilation time.
We will also explore other strategies of SFINAE use, more efficient use of type_traits as well as a teaser of my vision of what fusion style metaprogramming should look like.

...