Rust is a language originally made by Mozilla for use in browsers. It features both a powerful type system which makes writing abstractions easy and the borrow checker which gives the compiler the ability to guarantee memory safety. When you have an error in your code, the Rust compiler will typically pinpoint its exact location with a helpful diagnostic.

Rust is becoming extremely popular among programmers and was voted the most loved programming language in the 2020 StackOverflow survey. It is quickly gaining recognition as a preferred language across industries, with Amazon, Microsoft, and Google as notable examples. However, Rust is also known for its steep learning curve. This workshop will provide you with a path to understanding Rust and obtaining intermediate proficiency, designed for people familiar with C++.

Project structure and the Cargo package manager

Data types (Algebraic data types, Struct, Enum)

Pattern matching, functional programming aspects

Exercises, including Rust for embedded systems


Familiarity with C++ or another equivalent systems programming language is strongly recommended.




C++ programmers who are interested in getting started with the Rust programming language. People who are looking into the advantages of integrating Rust in their C++ project, or who want to stay up-to-date with the latest developments in the industry.




We recommend installing rust on your system ahead of the workshop: 

2 Days

Rust for the C++ Developer

C++/Embedded

Programming Languages

This training class explores modern C++ design and the modern forms of classic design patterns. It provides guidelines, idioms and best practices for sustainable and maintainable design, which enables programmers to create professional, high-quality code. Amongst others it will answer the following questions:

 How does good C++ design with a minimum of dependencies look like?

What are the most important rules for robust, maintainable, and sustainable design

What are the most common pitfalls in C++ software design?

Why does classical C++ design based on inheritance hierarchies fail so often?

How are the classic design patterns implemented in modern C++?

What are alternatives to the classic design patterns?

After this course, participants will ...
... have a detailed understanding of the essential design principles;
... understand the benefits of separation of concerns;
... be able to design code with minimum dependencies;
... have an impression of the modern alternatives of classic design patterns;
... have gained knowledge about modern design techniques;
... understand how std::function, std::any, and ranges work;
... favor composition over inheritance;
... avoid the usual pitfalls in the context of inheritance;
... know about the importance of value semantics;
... comprehend the advantages of non-intrusive design.


at least two to three years of C++ experience

 The course expects that all participants are familiar with the syntax of the language and have used inheritance and templates before.


You will need a laptop with an IDE/editor of your choice and any compiler capable of at least C++14 (GCC, Clang, MSVC, ...) 

Please note that some programming tasks will require C++20 to compile.

Modern C++ Design Patterns

Design

Software Design

This class will go through all major and important minor features of C++20 (covering both language and library), introduce them conceptually, provide compelling examples, and give key insights and hints about how to use them in practice.

As a member of the C++ standards committee, Nicolai will also give useful background information about purpose and design decisions.

We will cover all new language features with real examples that work and provide insights about the power of C++ but also its flaws and traps.


Details of concepts (using concepts, semantics constraints, concepts versus type traits, standard concepts)

Details of ranges and views (dealing with const, iterator categories, projections, pipelines, sentinels)

Barriers, latches, semaphores, extensions for atomics, and output sync streams

Chrono extensions (calendar and time zone support)

Formatted output (standard and user-defined formatting)

consteval, constinit, and compile-time vectors/strings

New NTTP types (floats, lambdas, objects, ...)

Several small new language and library features (bits handling, source location, typename, string extensions, char8_t, ...)

Programmers who want to get a well understanding of the new features of C++20

Attendees should be familiar with Modern C++

C++20 in Practice - A Complete Introduction

We start immediately with working programs.

Packaging and distribution of Python packages

Callable objects, lambdas, and extended argument syntax

Properties, class methods, and static methods

Multiple inheritance, method resolution order, and super()

Collection protocols and implementing collections

This workshop requires that you bring a laptop with the following software installed:

Python 3.3 or greater installed. Python 3.5.1 would be ideal. 

An editor for Python code. Attendees can use whatever editor they prefer, but we recommend PyCharm which is a full-featured Python IDE : 

The ability to either connect to the Internet or accept USB flash drives so we can distribute course materials on the day.

Python Properly

Python

 is ideal for people who have little to no experience in C++, but are proficient in an Object Oriented Programming language, like Java or C#.

Introduction to C++ and presentation of the project

Using variables, functions and parameters effectively

An introduction to the compilation model of C++. Build systems, compilation, linkage, headers, translation units and libraries

Introduction to unit testing using Catch2

Classes, structs, namespaces and enum class

Allocation on the stack vs heap, std::unique_ptr, Rule of Zero and RAII

Introduction to tooling like Clang Tidy, Clang Format, CMake, GDB

Introduction to sanitizers like AddressSanitizer, Undefined Behavior Sanitizer and Memory Sanitizer

Students are assumed to be proficient in an Object Oriented Programming language like Java or C#. They should be working in (or looking to work in) a C++ project.

The exercises will be done in a CMake based project. The students will need a development environment, a rich IDE is recommended, for example Visual Studio Code and Jetbrains CLion. A GitHub account will be useful.

Mod(C++) Fundamentals

The Intermediate course gives the students a deeper understanding of how one should think and program in “Modern C++” ( C++11/14/17/20). The exercises will all be based around a 2D graphics game inspired by Ms. Pac-Man. 

DAY 1 - GENERIC PROGRAMMING “THINKING”

Introduction to the training Presentation of the project

Class templates, function templates, non-type parameters

Variadic templates, fold expressions and parameter packs

Special member functions (Rule of Five/Zero)

Pragmatic introduction to move semantics and return value optimizations

Safety: Riskier constructs in C++ and how to minimize their impact

Students are assumed to have some C++ experience or should have taken Mod(C++) Fundamentals. They should be working in ( or looking to work in) a C++ project.

Mod(C++) Intermediate



(+) Topics marked with a plus sign will be covered as time permits.

2. Fundamental Concepts
* System calls and library functions
* Error handling
* System data types
* Notes on code examples

3. File I/O and Files
* File I/O overview
* open(), read(), write(), and close()
* The file offset and lseek()
* Relationship between file descriptors and open files
* Duplicating file descriptors
* File status flags (and fcntl())
* Retrieving file information: stat()

4. Processes
* Process IDs
* Process memory layout
* Command-line arguments
* The environment list
* The /proc filesystem

5. Signals
* Overview of signals
* Signal dispositions
* Useful signal-related functions
* Signal handlers
* Signal sets, the signal mask, and pending signals
* Designing signal handlers

6. Signals: Signal Handlers
* Async-signal-safe functions
* Interrupted system calls
* SA_SIGINFO signal handlers
* The signal trampoline (+)

7. Process Lifecycle
* Creating a new process: fork()
* Process termination
* Monitoring child processes
* Orphans and zombies
* The SIGCHLD signal
* Executing programs: execve()

8. System Call Tracing with strace (+)
* Getting started
* Tracing child processes
* Filtering strace output
* System call tampering
* Further strace options

9. Pipes and FIFOs
* Creating and using pipes
* Connecting filters with pipes
* FIFOs (+)

10. Alternative I/O Models
* Nonblocking I/O
* Signal-driven I/O
* I/O multiplexing: poll()
* Problems with poll() and select()
* The epoll API
* epoll events
* epoll: edge-triggered notification
* epoll: API quirks
* Event-loop programming


The following people are likely to find the workshop of particular benefit:

Programmers developing system-level applications for Linux systems, or programmers porting such applications from other operating systems (e.g., Windows) to Linux.

Embedded programmers developing applications for Linux, or porting embedded applications from systems such as VxWorks or QNX to Linux.

DevOps engineers and sytem administrators who want to gain a greater insight into the oepration of Linux applications.



The workshop consists of a mixture of detailed presentations coupled with many coding exercises that allow participants to apply the knowledge learned in the presentations.



You should have a good reading knowledge of C or C++. For the practical sessions, templates will be provided to relieve you of the need to type in tedious boilerplate code. The templates are in C, but if you wish, it is also possible to complete the exercises in another suitable language such as D, Rust, or of course C++.

You should have a basic familiarity with the Linux/UNIX command line to do tasks such as listing directories, editing files, and compiling programs.

No previous system programming experience is assumed.


You'll need a laptop with Linux installed--either as a native install or inside a virtual machine (VM). In the latter case, you should ensure that the VM has working Internet access. The system should have a C compiler (e.g., gcc) and "make" installed. (It's likely that both of these are provided as part of the default install, if you are setting up a new system.)

Linux System Programming Fundamentals

Linux

Talk (60 min)

Keynote: Kate Gregory

In the course of the talk I will focus on major problematic points of the previous design of the library and will demonstrate how to replace them with mostly constexpr code.

Leaving Template Meta-Programming Behind

The Boeing 737 MAX: When Humans and Technology Don't Mix

Product

Technique

In this session, I want to broaden our horizon on having this holistic perspective on our responsibility for sustainability that comes with software development. I will share both ideas about possibilities and examples from companies who make already an effort in implementing this holistic perspective because sustainability becomes more and more a success factor for every company: For finding and keeping both clients as well as talent. Thus, this session is about raising awareness of our contribution to sustainability and understanding the (first) steps we can take to make a difference.


The Planet sends an S.O.S. – Taking Responsibility for our Carbon Footprint

Testing

Architecture

Product Design

C++20 - My Favourite Code Examples

Properties of Unit Tests

Typical C++, but why?

Containers as an Illusion - Part I

Security

How to start a program

Platform

Theory makes beautiful programs; or MC/DC in gcc

Embedded

Signed Integers Considered Harmful

Language

Making sense of "volatile"

Auto-testing for situational awareness

In the meantime, it has been largely clarified what we can expect with the upcoming standard. Major deviations from it are unlikely to happen, but minor things that are already in the pipeline may still be added in the coming months.

I will present the following main points:

1) what was the Bold Plan that guided us through three years of development?
2) what is already included in the draft and what is likely to be included?
3) what could unfortunately not be finished in time?
4) which changes also affect C++20?
5) where do the implementations of the major compilers stand in terms of implementation?
6) show a few highlights from C++23 in code examples


A Preview of C++23

Zephyr RTOS: Software power tools for constraint devices

Tools

An Introduction To Floating Point Math

C++ Lambda Idioms

Reprogramming Binary Programs

Error handling in C++: as easy as "use exceptions"?

TBA - Phil Nash

TBA - Olve Maudal

TBA - Patricia Aas

Containers as an Illusion - Part II

Based on over 20 years of experience I will give you some pointers about what embedded means and the way that we develop in this environment.

I will talk about the underlying hardware: the System on Chip (SoC) and how that is packaged as a System on Module (SoM), or a Single Board Computer (SBC), or into a custom designed board. For each target, we need the four basic components of an embedded Linux system: the toolchain, the bootloader, the kernel and the root filesystem. Then, on top of that you need the applications that are going to turn it into a world-beating gadget. That may include graphics drivers to control a touch screen, network interfaces to connect to a cloud backend and databases to store structured data. There may even be real-time control tasks. Finally, I will consider how you combine the open source base operating system with your own proprietary code

Fundamentals of Embedded Linux

In this talk I will show you how to get started with Yocto, first using QEMU to create an emulated target board, and then using a Raspberry Pi. I will describe the basics of Yocto: Distro, Machine, Image. I will talk about Bitbake and bitbake recipes and I will show how recipes can be gathered together into layers. If you want to get a head start with Yocto Project and embedded Linux, this is the talk for you.

NDC { TechTown }

Agenda

09:00 - 10:00 (UTC+02)

Keynote: Kate Gregory

Kate Gregory

10:15 - 11:15 (UTC+02)

C++20 - My Favourite Code Examples

Nicolai Josuttis

How to start a program

Anders Schau Knatten

TBA - Phil Nash

Phil Nash

Zephyr RTOS: Software power tools for constraint devices

Eirik Midttun

Balaji Srinivasan

11:30 - 12:30 (UTC+02)

A Preview of C++23

Daniela Engert

Containers as an Illusion - Part I

Michael Kerrisk

Auto-testing for situational awareness

James Westfall

Theory makes beautiful programs; or MC/DC in gcc

Jørgen Kvalsvik

13:15 - 14:15 (UTC+02)

Error handling in C++: as easy as "use exceptions"?

Vitaly Fanaskov

Containers as an Illusion - Part II

Michael Kerrisk

Properties of Unit Tests

Arne Mertz

Reprogramming Binary Programs

Ole André Vadla Ravnås

14:30 - 15:30 (UTC+02)

Typical C++, but why?

Björn Fahller

Making sense of "volatile"

Inge Fredriksen

Fundamentals of Embedded Linux

Chris Simmonds

TBA - Olve Maudal

Olve Maudal

15:45 - 16:45 (UTC+02)

C++ Lambda Idioms

Timur Doumler

An Introduction To Floating Point Math

Martin Hořeňovský

The Boeing 737 MAX: When Humans and Technology Don't Mix

Kyle Kotowick

TBA - Patricia Aas

Patricia Aas

17:00 - 18:00 (UTC+02)

Leaving Template Meta-Programming Behind

Hana Dusíková

Signed Integers Considered Harmful

Robert Seacord

The Planet sends an S.O.S. – Taking Responsibility for our Carbon Footprint

Jutta Eckstein