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

Maybe we’ve even tried TDD, and felt that it was just adding even more ceremony to the problem with no real advantages.

But the advantages are definitely there! We just need a good grounding in what TDD _actually_ is (and isn’t) and how to do it properly – especially in the context of C++, which brings its own idiosyncrasies and bottlenecks to the matter.

That’s what this workshop aims to be. Whether you’ve never written a test before, or you’ve had some mileage with TDD already, be prepared to ratchet up your productivity by thinking about things in new ways and gaining more approaches to breaking down problems in sustainable ways.


This workshop is intended for anyone who wants to improve the quality, readability, flexibility and suitability of their code. Whether you've tried TDD before and want to brush up and learn some new perspectives, or you're completely new and want to see what the fuss is about.


You should have at least a basic grasp of C++ fundamentals and be comfortable creating new projects, building and running them. No prior TDD or unit testing experience is required - but if you have some you should still get something out of this course.


A compiler and IDE (or other editing environment you are comfortable with).

Accelerated TDD - For More Productive C++

This workshop explores modern C++ design and the modern forms of the classical design patterns. It will provide a deeper understanding of software design in general and design patterns in particular. It will give advice on how to decouple software systems and teach guidelines, idioms and best practices for sustainable and maintainable design. 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 classical design patterns realised in modern C++?

What are alternatives to the classical design patterns?

Which tools are available to support good C++ 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

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 a two day training course. It is ideal for new hires that have little to no experience in C++, but are proficient in an Object Oriented Programming language, like Java or C#.

 should ideally be taken before Mod(C++) Intermediate, another two day course which expands on the topics in Mod(C++) Fundamentals. Taken together these two courses will give a good foundation for a modern C++ programmer.


The Fundamentals course gives the students an 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 PacMan. Topics covered in the course include:

Variable and function use, including auto, const, overloading and function templates

Namespaces, classes and structs, when and how to use them

Standard library containers and algorithms usage

How to efficiently use values and references

Memory theory, including understanding allocation on the heap and stack

RAII and lifetime management, including Rule of Zero

Lambda functions and using them with standard algorithms

An introduction to the C++ compilation model and advice to make the best use of compilers and build systems

Students are assumed to be proficient in anObject 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 Jetbrains CLion, QtCreator or Visual Studio. A GitHub account will be useful.

Mod(C++) Fundamentals

This course concentrates on security issues intrinsic to the C and C++ programming languages and associated libraries. You will learn to identify common security flaws including:

For each of these security flaws, we demonstrate specific remediation techniques as well as general secure coding practices that help prevent the introduction of vulnerabilities.

Material in this presentation was derived from the Addison-Wesley books Secure Coding in C and C++ and The CERT C Secure Coding Standard.

Exercise: Reviewing Code for Integer Defects

Secure Coding in C and C++ should be useful to anyone involved in the development or maintenance of software in C and C++.

If you are a C or C++ programmer, this book will teach you how to identify common programming errors that result in software vulnerabilities, understand how these errors are exploited, and implement a solution in a secure fashion.

If you are a software project manager, this book identifies the risks and consequences of software vulnerabilities to guide investments in developing secure software.

If you are a computer science student, this book will teach you programming practices that will help you to avoid developing bad habits and enable you to develop secure programs during your professional career.

If you are a security analyst, this book provides a detailed description of common vulnerabilities, identifies ways to detect these vulnerabilities, and offers practical avoidance strategies.

The course assumes basic C and C++ programming skills, but does not assume an in-depth knowledge of software security. The ideas presented apply to various development environments, but the examples are specific to Microsoft Visual Studio and Linux/GCC and the Intel Architecture.

Students are also encouraged to bring their own C and C++ programming language development environments (compiler, editor, etc.), such as Microsoft Visual Studio, Xcode, GCC, or Clang.

Secure Coding in C and C++

Security

The C++ compiler developers are working hard to make their product conforming to the new specification and lots of features are already available to play with. During the training, a particular emphasis will be put on learning and practicing the most prominent C++20 features like Concepts, Ranges, and Coroutines, but also we will try many other smaller features of the new language.

Two days are not enough to cover everything of this massive release. We will do our best to cover as much as possible but probably we will scope mainly on the new language features and will cover only the most essential library facilities.


During the workshop we will work with the latest version of the compiler thanks to the Compiler Explorer, so no special environment preparation is needed.

Introduction to C++20



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

1. Fundamental concepts
* System calls and library functions
* Error handling
* System data types

2. File I/O
* File descriptors
* I/O system calls: open(), close(), read(), write()
* Seeking to a file offset: lseek(); file holes
* Relationship between file descriptors and open files
* Duplicating file descriptors
* Open file status flags
* I/O buffering in stdio and the kernel

3. File attributes
* Retrieving file information: stat()
* File ownership and permissions
* Changing file attributes

4. Directories and links (+)
* Hard and soft (symbolic) links
* Directories
* Current working directory
* System calls and library functions for working with directories and links

5. Processes
* Process ID and parent process ID
* Memory layout of a process
* Command-line arguments
* Environment list

6. Process Credentials
* Password and group file
* User and group IDs
* Process credentails: real and effective IDs; supplementary group IDs
* Retrieving process credentials

7. Signals
* Signal types and default actions
* Setting signal dispositions
* Signal handlers
* Blocking signals (the signal mask); pending signals
* Designing signal handler functions
* Reentrant and async-signal-safe functions

8. Process lifecycle
* Process creation: fork()
* File descriptors and fork()
* Process termination: exit(3) and _exit(2)
* Monitoring child processes: wait(), waitpid()
* Orphans and zombies
* The SIGCHLD signal

9. Executing programs
* Executing a program: execve()
* The exec() library functions
* File descriptors and exec()

10. Privileged programs (+)
* Set-user-ID and set-group-ID programs
* Changing process credentials

11. Using pipes and FIFOs for interprocess communication (+)
* Creating and using pipes
* Using pipes to connect filters
* FIFOs
* Semantics of I/O on pipes and FIFOs




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

Marit and Christian introduce the concept of binary exploitation with code examples. They demonstrate how to exploit a recent vulnerability in Sudo by explaining the vulnerability and the exploit, and running it live! Then they will demonstrate ways to detect and prevent memory corruption vulnerabilities in your software.

Talk (60 min)

Demonstrating binary exploitation with a recent vulnerability

Tools

What has writing about the Core Guidelines shown me?

Technique

Things to remember when you build your robot army – how (not) to fail miserably in IoT projects

Designing a modern build system and dependency manager, how hard can it be?

Asynchronous I/O and coroutines for smooth data streaming

An Introduction to Android Automotive OS

Embedded

Architecture

Platform

SOLID Revisited : The State of the Matter

Agile embedded development under regulatory constraints

Testing

Product

Software Engineering Is About Tradeoffs

How to start using coroutines

A (short) Tour of C++ Modules

From Program to Process - What Happens After the Compiler

Keynote: Garbage In, Pearls Out?

In this presentation I will start with some background on Yocto Project meta layers and then I will show step-by-step how to build in the support for your board. Along the way, I will highlight some of the common pitfalls, and how to avail them.

If you want a single sentence that summarizes the whole presentation it is “keep it simple”.

How to write a really good board support package for Yocto Project

Half-Day

NDC Party (Food, Drinks Quiz)

In this presentation, we will look at how cgroups work, from the perspective of the future. That is to say, I will ignore cgroups v1, and explore how cgroups work starting fresh from a version 2 perspective. Topics we’ll cover include creating and destroying cgroups, moving processes into cgroups, setting resource limits on cgroups, enabling and disabling controllers, and managing different resources to different levels of granularity. No previous knowledge of cgroups will be assumed.

 An introduction to control groups (cgroups) version 2

Diving deeper into control groups (cgroups) v2

Now testing is much more prevalent, and the companies going the fastest and with the highest quality are also the ones doing the most automated testing. But even in these companies testing is 'subservient' to coding.
In this talk I will present the idea of testing and coding as being
__equal__ first-class citizens in a co-evolving system. I will elaborate on what I mean by that. I will also present some practical tips and techniques based on this idea, some of which I am confident you will never have come across before, but which might just change the way you think about development.

Keynote: Testing as an equal 1st class citizen (to coding).

Introducing a matrix class to the C++ standard library

Delivering code with GitHub Actions

Inside a static analyser: type system

Language

Real Programming

Sandboxing a Linux application

A Physical Units Library For C++

Catching up with Catch2: Changes recent and future

Implementing C++ Semantics in Python

TypeScript for C++ programmers

We will look at what makes RISC-V so different and what it means to the future of the industry as well as software developers.

This will be an intro to how modern CPUs work with an emphasis on RISC-V design choices compared to x86 and ARM processors. We will cover concepts such as compressed instruction sets, macro-fusion and micro-operations.

Then we will talk about why the RISC-V design makes it favored by startups trying to revolutionize machine learning, high performance computing and embedded systems.

The Genius of the RISC-V Microprocessor

In this talk I will take you on a journey through the meadows of computer
science, the dark woods of C++ rules, the sharp teeth of optimisation,
the red cloak of templates, and the gift basket of class layout.

We will discuss the various problems that show up when designing general data
structures, and ways of addressing them. Who knows, maybe even a hunter shows up?

Little Red Riding Hood & the k-d tree forest

Dependency Management in C++

Volatility Ahead 

TestOps at scale

Virtual Reality with Qt Quick 3D

Instrumenting machine code over WebRTC

* This is a 3-part workshop. Please bring your own laptop.

In this workshop we want to re-discover the practice of TDD as originally envisaged by Kent Beck. We will seek to understand:

Why tests are about behavior not structure.

Why adhering to Red-Green-Refactor makes tests cheap to write in comparison to the code they cover.

Why tests should be easy to read, and how we achieve that.

Why 'driving in gears’ is a concept that is not practiced enough.

How design patterns can be used for good, as part of our TDD practice.

We will also understand why you might not value TDD as many subsequent interpreters have communicated it, and how you can grow to love it in its intended form.

But most of all we hope to show that the original practice of TDD was not the onerous make-work it has become at the hands of considerable misunderstandings, but ‘greases the wheels’ of software development.

We will use Python for demos during this presentation, but the focus of this course will be on basics that can be applied in any language.

NDC { TechTown }

Agenda

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

Keynote: Testing as an equal 1st class citizen (to coding).

Jon Jagger

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

A (short) Tour of C++ Modules

Daniela Engert

Things to remember when you build your robot army – how (not) to fail miserably in IoT projects

Nir Dobovizki

From Program to Process - What Happens After the Compiler

Anders Schau Knatten

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

An Introduction to Android Automotive OS

Chris Simmonds

Designing a modern build system and dependency manager, how hard can it be?

Jussi Pakkanen

Agile embedded development under regulatory constraints

Espen Albrektsen

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

An introduction to control groups (cgroups) version 2

Michael Kerrisk

What has writing about the Core Guidelines shown me?

Guy Davidson

Software Engineering Is About Tradeoffs

Mateusz Pusz

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

Diving deeper into control groups (cgroups) v2

Michael Kerrisk

How to start using coroutines

Mikhail Svetkin

How to write a really good board support package for Yocto Project

Chris Simmonds

16:20 - 17:20 (UTC+02)

SOLID Revisited : The State of the Matter

Phil Nash

Asynchronous I/O and coroutines for smooth data streaming

Björn Fahller

Demonstrating binary exploitation with a recent vulnerability

Marit Iren Rognli Tokle

Christian Resell

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

Keynote: Garbage In, Pearls Out?

Jason Turner

18:40 - 21:00 (UTC+02)

NDC Party (Food, Drinks Quiz)

Anders Schau Knatten