Tools from the C++ eco-system to save a leg

Speaker: Anastasia Kazakova

Audience level: Intermediate

Category

C++ gives you enough rope to shoot your leg off. Readable (and thus easy to maintain, easy to support) and error-free code in C++ is often hard to achieve. And while modern C++ standards bring lots of fantastic opportunities and improvements to the language, sometimes they make the task of writing high quality code even harder. Or can’t we just cook them right? Can the tools help?

Threads and Locks must Go

Speaker: Rainer Grimm

Audience level: Intermediate

Category

What do threads, atomic variables, mutexes, and conditional variables have in common? They are the basic building blocks of any concurrent application in C++, which are even for the experienced C++ programmers a big challenge.
Therefore, it's good that we get with C++17 and C++20 to new standards.

Free Your Functions!

Speaker: Klaus Iglberger

Audience level: Beginner | Intermediate

Category

You are devoted to minimize coupling and duplication? You are taking care to maximize cohesion, flexibility, extensibility, encapsulation, testability, and even performance in order to achieve the high goals of (object-oriented) programming? Awesome! But wait: You still you favor member functions? Seriously? You have been deceived! You have been praying at the altar of false promises! Shed the shackles of Java philosophy! Free your functions!

In...

How C++ Debuggers Work

Speaker: Simon Brand

Audience level: Beginner | Intermediate

Category

Debuggers are one of the most important tools in the belt of any developer, but they are often seen as a magic black box. This is compounded by the lack of available literature, especially when compared to other toolchain components like compilers. This talk aims to demystify debuggers by showing how the utilities you use every day actually work.

Beyond the Compiler: Advanced Tools for Better Productivity

Speaker: Gábor Horváth

Audience level: Intermediate | Advanced

Category

Modern compilers provide us with advanced functionality to make us more productive and help us find bugs easily. In this talk, I will do a whirlwind tour of these tools including: formatting, static analysis, dynamic analysis, hardening (for security), coverage, fuzz testing, automated refactoring, and profile guided optimization. The talk will be full of demos. I will also talk about the big picture, how these tools fit into the development process and when they are the most useful and important.

...

Introduction to proposed std::expected

Speaker: Niall Douglas

Audience level: Intermediate

Category

Following on from the very successful ACCU 2017 talk "Mongrel Monads", this talk introduces the very latest post-Toronto edition of the proposed std::expected<T, E> which may make it out of the WG21 Library Evolution Working Group (LEWG) next year in time for the C++ 20 standard.

Expected...

Deep Learning with C++

Speaker: Peter Goldsborough

Audience level: Beginner | Intermediate | Advanced

Category

Deep Learning is a subfield of artificial intelligence that employs deep neural network architectures and novel learning algorithms to achieve state of the art results in image classification, speech recognition, motion planning and other domains. While all machine learning algorithms are initially formulated in mathematical equations (the only programming language where single lettervariable names are encouraged), they must eventually be translated into a computer program. Moreover, because deep neural networks can often be composed of many hundreds of millions of trainable parameters and operate on gigabytes of data, these computer programs have to be fast, lean, often distributed and squeeze every last ounce of performance out of modern CPUs, GPUs and even specialized hardware.

This...

Strong types for strong interfaces

Speaker: Jonathan Boccara

Audience level: Intermediate

Category

Abstract

Functional Data Structures

Speaker: Ivan Cukic

Audience level: Intermediate | Advanced

Category

Today, most software systems have the need for some sort of concurrency. This poses problems regarding the software design. In the past few years, Meeting C++ had more than a few talks related to software design in the concurrent environment. From higher-level topics like Functional Reactive Programming to lower level stuff like Coroutines TS.

Is std::function really the best we can do?

Speaker: Lukas Bergdoll

Audience level: Advanced

Category

There seems to be this complacent status quo concerning function delegates. If you know the type, store a lambda, otherwise you'll have to live with the associated overhead of using std::function.
Join us exploring the topic of function delegates whilst using conventional as well as unconventional approaches in our search for better solutions.

Practical constexpr

Speaker: Jason Turner

Audience level: Beginner | Intermediate | Advanced

Category

constexpr has come a long way since C++11. And we know that it is now possible to implement entire constexpr parsers allowing for compile-time parsing of things like JSON values. But what does this mean for every day code? Is it practical to apply constexpr throughout your code base? What cost does this incur or advantage does it provide? We will look at specific examples of applying constexpr throughout the ChaiScript codebase and what impact it had on compile time, runtime and compile size.

...

Modern C++ Testing with Catch2

Speaker: Phil Nash

Audience level: Beginner | Intermediate | Advanced

Category

Catch has gained popularity over the last six years as a modern, C++-native, test framework. Simple to use, easy to get started with, yet still powerful.
Until recently, though, it has been constrained by pre-C++11 compatibility.
Catch2 rebases on C++11 and takes advantage of this to simplify further, as well as offer new capabilities.
This talk takes a look at what's new in Catch and Catch2 and how to effectively test-drive modern C++ codebases.

Familiarity...

Local ("Arena") Memory Allocators

Speaker: John Lakos

Audience level: Intermediate | Advanced

Category

 Are memory allocators really worth the trouble? What situations merit their use? How are they applied effectively? What’s the performance impact? This practical talk by large-scale C++ expert John Lakos demonstrates that having local memory allocators in your tool box may lead to as much as order-of-magnitude speed improvements.

The runtime implications of the physical location of allocated memory are sometimes overlooked—even in the most performance-critical code. In this talk, we will examine how the performance of long-running systems can degrade when using just one global allocator (e.g., via new/delete). We will contrast the use of global allocators with various kinds of local allocators—allocators that allocate memory for a well-defined subset of objects in the system. We will also demonstrate how local allocators can reduce, if not entirely prevent, degradation seen in systems that rely solely on the global allocator. Six dimensions—fragmentability, allocation density, variation, utilization, locality, and contention—will be introduced to help characterize a given subsystem, assess the potential for accelerating its runtime performance, and—where appropriate—aid in determining the best local allocator to do so. Empirical evidence will be presented to demonstrate that introducing an appropriate local allocator can often result in substantial reductions in run times (compared with a similar system relying solely on just a single, global allocator).

...

Concepts driven design

Speaker: Kris Jusiak

Audience level: Intermediate | Advanced

Category

Concepts are finally coming! In this talk, we will go above and beyond to explore the full potential of this haunted by history feature. We will discuss how concepts may revolutionize the way the modern C++ code is written, including how concepts may provide better diagnostics and simplify the SFINAE altogether. We will also take a look at how to emulate concepts in the current standard and discuss the benefits of the design by introspection. Additionally, it will be presented how to write a loosely coupled, well-performing code by default and how to opt out to a dynamic dispatch using type erasure when necessary. Its final focus will be on increasing your testing productivity when applying the concepts driven design.

...

Reflection in C++Next

Speaker: Anton Bikineev

Audience level: Intermediate | Advanced

Category

Reflection in C++ has always been and remains a hot topic for the whole time C++ has been around, but unfortunately there is no a standard solution to retrieve and manipulate compile-time information. There have been several approaches implemented to tackle the lack of reflection, be it macros, pragmas or independent preprocessors. At the talk we will cover 2 similar proposals on reflection in C++, will look at some examples and live code a bit.

...

More talk entries