<< Previous

Lightning Updates

Speaker: Hana Dusíková

Audience level: [ Beginner | Intermediate ]

I'm going to talk about what it means to update data in your application, and about how we can use modern C++ facilities to make this task very simple.

I will build vocabular types describing basic components of the problem, and use the standard library to build a generic library. The talk is a case study of how well designed generic code can be used to many purposes.

Cool stuff about GDB you didn't know.

Speaker: Greg Law

Audience level: [ Beginner | Intermediate | Advanced ]

If you write C++ on Linux then chances are that you use GDB at least sometimes.

Breaking Enigma With the Power of Modern C++

Speaker: Mathieu Ropert

Audience level: [ Beginner | Intermediate ]

During the Second World War, Alan Turing and his team at Bletchley Park used a very primitive computer to crack the German Enigma machine encryption and allow the Allies to read the Axis secret communications. To achieve this feat they used every trick in the book to reduce the problem to something that could be achieved by an early 1940s electro-mechanical computer.
What if we were nowhere as smart, but got readily access to a 16 cores 2020s CPU and modern C++?

In this talk, we will show a brief history of Enigma's design and cryptoanalysis at the time, and then will try to see if we can break it using a modern machine and some C++20. How many combinations can we try per second using all our cores and with the help of some micro-benchmarking?


The Floor is Lava, trying to teach C++

Speaker: Patricia Aas

Audience level: [ Beginner | Intermediate | Advanced ]

Over the past year we have developed and taught a training course aimed at teaching C++ to people who already know how to program in another language. Trying to get people to a place where they are a productive junior developer in C++, and have modern C++ habits is a challenge. In this talk we explore learning C++ as a programmer, and choosing what to skip and what to teach.

Sandbox Games: Using WebAssembly and C++ to make a simple game

Speaker: Olafur Waage

Audience level: [ Intermediate ]

WebAssembly is an interesting environment, especially for C++ programmers. With tools like Emscripten becoming better and better and game development libraries starting to add support for WebAssembly it is worth taking a look into this world.

Foundations of GPU programming.

Speaker: Filipe Mulonde

Audience level: [ Intermediate | Advanced ]

Today's computers are heterogeneous systems composed of various types of processing units such as CPUs, GPUs, TPUS, etc. Graphics processing units (GPUs) can be used as general purpose parallel processors to make their excellent processing capabilities available for many workloads besides graphics. 

To move or not to move: an interactive analysis

Speaker: Amir Kirsh

Audience level: [ Beginner | Intermediate ]

Move semantics is one of the most important features added in C++11 and yet it is still considered as a complex subject by many. "Should we use std::move here or not?" is a frequently asked question, not only by novices. The consequences of a bad std::move decision could be either bad performance or a bug.

Properties of Unit Tests

Speaker: Arne Mertz

Audience level: [ Beginner | Intermediate ]

Unit tests are the foundation of the test pyramid. While there is no single precise definition of a "unit" that the name refers to, we can deduce a number of desirable properties of these tests, e.g. from how they are used in the development cycle. These properties in turn have implications on how we want to design those units under test. This talk will not try to give yet another definition of what is or isn't a unit, but it will try to narrow down our design goals for those mysterious beasts.


std::function, past, present, future

Speaker: Farid Mehrabi

Audience level: [ Intermediate ]

A short review of the path that made std::function possible, its application, requirements, downsides and alternatives. A breif eplanation of observer pattern and traditional callback systems through function pointers. And a short disscution on existing libraries and some vendor specific compiler extentions for functions.

CPU Cache Effects

Speaker: Sergey Slotin

Audience level: [ Beginner | Intermediate | Advanced ]

Modern computer architectures have many properties that can impact software performance. While the compiler is generally good enough at "in-core" optimizations such as instruction selection and various loop optimizations, most memory acceleration techniques cannot work optimally without some help from the programmer. This talk draws a picture of what every C++ developer needs to know about modern memory systems to perform these kinds of optimizations by presenting a series of small code examples and benchmarking their performance — often producing surprising results — experimentally deriving key memory characteristics and highlighting different CPU cache effects.


The expected outcome

Speaker: Ivan Čukić

Audience level:

There is a plethora of ways to do error handling in C++ and all have their pros and cons.

What's new in Conan 2.0

Speaker: Christopher McArthur

Audience level:

Conan C++ package manager from JFrog: the open source, distributed and universal way of managing your dependencies and your binaries, used by thousands of companies in the world. With the Conan 2.0 release rapidly approaching it's time to learn about the new features that can vastly improve your workflows. One of the most important changes is the new graph model which address real world use cases. Plugin and Extenstions are going to allow user to tailor Conan to their exact use case allowing for even more flexibility.


C++ for multi-accelerator, multi-vendor systems

Speaker: Guy Tamir

Audience level:

Free up your C++ code to work on multi-accelerator systems from any vendor.

Typescripten — Generating type-safe JavaScript bindings for emscripten

Speaker: Sebastian Theophil

Audience level:

WebAssembly has become a very popular target platform for C++ developers. Thanks to emscripten, porting native applications to WebAssembly is easy — as long as the application only uses the browser as a display and input device. However, emscripten does not provide type-safe wrappers to the standard JavaScript APIs such as the DOM manipulation API, let alone any other JavaScript API provided by existing web applications. Our open source tool “typescripten” has been built on top of three powerful technologies to close this gap. It uses TypeScript interface definition files and the TypeScript compiler API to create type-safe C++ wrappers based on emscripten. TypeScript already has interface definition files for over 7000 JavaScript libraries that you can now use safely from C++. We strive to design our C++ wrappers such that the C++ code using them looks similar to the equivalent TypeScript or JavaScript code. However, the peculiar semantics of prototype-based Javascript and Typescript are often difficult to translate into a type-based language such as C++. I will discuss the challenges we faced and choices we made when designing this framework.