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 two day hands-on workshop will give you a chance to explore numerous types of hardware interfacing, including:

We will be looking at these from the point of view of embedded systems, including Linux based IoT devices. For the hands-on portion of the workshop we will be using Raspberry Pi boards to implement a smart door bell.

In the lectures, you will learn the theory necessary to implement such a device. Starting from power on, we will consider how Linux discovers what hardware is attached, and especially the role of the device tree in non PC systems. We will look how Linux represents hardware internally through the device driver model and the sysfs file system, and how it loads device drivers for each component of hardware. Then we will see how to interact with device drivers from user-space programs to make a working system.

We will be using the industry standard Yocto Project to build the disk images for the target. If you are not familiar with Yocto, don’t worry: we will be covering the fundamentals of Yocto as well.

The workshop is suitable for anyone working with Embedded Linux, or IoT devices, or is just curious about how things work

To get the best out of it you will need good command-line Linux skills (grep, find, bash), good C/C++ coding skills, and a basic knowledge of computer architecture (memory address spaces, interrupts, DMA)

Hardware Interfacing with Yocto Project

Embedded

Architecture

Software Design

Product Design

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.

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



For the hands-on programming tasks, you are expected to use your own machine. Any operating system (Windows, Linux, MacOS, ...), any IDE/editor (MS Visual Studio, CLion, vi, emacs, ...) and any compiler capable of at least C++14 (GCC, Clang, MSVC, ...) can be used

Modern C++ Design Patterns

Design

The training will provide its students with:

vocabulary to understand reported vulnerabilities

knowledge on how to receive vulnerability reports professionally

knowledge on how to use tools to find and fix vulnerabilities in their own code

knowledge on how to design a more secure product

knowledge on how to design a CI/CD pipeline that will improve the security of their own codebase

: Will be setup a week in advance to facilitate resolving of any technical issue

 cloud instance: guarantees same environment

This training is explicitly targeted at C++ developers, though C developers will also benefit.

Demystify exploitation, show that exploitation is a mindset, not a set of techniques

Demonstrate the motivation for mitigations in the platforms, languages and tools

Show that C++ and C are not easy to reason about

Teach the students to recognize constructs that have a higher risk of having vulnerabilities

Teach the students which tools can be used to find bugs before others find them

Teach the students about tools they can use locally while coding

Teach the students about tools they can integrate in their CI/CD pipeline

Help them think about how security fits into the team context

Help them view their application in a new ways

DAY 1 - INTRODUCTION, FUZZING AND NUMBERS

Exploitable: UB and Compiler Optimizations

DAY 2 - STACK BUFFER OVERFLOW, SHELLCODE AND GOOD PRACTICES

(In)Security in C++

Security

We look at the pros and cons of various options to find the simpler, safer, more maintainable, and better performing options that exist.

Writing clean, safe, maintainable C++ that performs well by default by gaining a deeper understanding of the language

Using tools to help ensure that your C++ is as safe as possible


A working knowledge of C++. This class is valuable for all skill levels, but the absolute beginner will get less from the class.


Students will work on small exercises in groups. Students will need a laptop with a webbrowser that can access 

C++ Best Practices

Technique

In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. 

In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.

Computer with git client to access git repository.

Refactoring Code: An Incremental and Purpose Driven Approach

 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

Python has, due to its flexible nature, firmly established itself in many domains such as web development, task automation, data analysis and visualization. Python is a leading language in engineering, finance, science, and education.

The deceptively simple syntax of Python has proven easy to pick up and learn, which is by design. However, the path to real Python proficiency is only granted to those who strive for it.

In this workshop, we cover intermediate and advanced concepts and constructs in Python, showcasing how they work “under the hood” with the aim of gaining a true understanding.

Building, testing and distributing your code as a package

Callable objects, lambdas and the underlying bytecode

Operator overloading and other common interfaces

Variadic functions and argument unpacking syntax

Multiple inheritance and method resolution order

A basic familiarity with Python is recommended, as the course with cover intermediate to advanced concepts.

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

Python 3.6 or greater installed. Python 3.7 or newer would be ideal. 

Poetry the packaging and dependency manager. 

A code editor supporting Python. Attendees may use whichever editor they prefer, but we recommend PyCharm or VSCode : 

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

NDC { TechTown }

Workshops

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

Modern C++ Design Patterns

Klaus Iglberger

Hardware Interfacing with Yocto Project

Chris Simmonds

Rust for the C++ Developer

Hans Elias B. Josephsen

Python Proficiency: Beyond the Basics

Sebastian Roll

(In)Security in C++

Patricia Aas

Mod(C++) Fundamentals

Ólafur Waage

C++ Best Practices

Jason Turner

Refactoring Code: An Incremental and Purpose Driven Approach

Venkat Subramaniam