Tests help to make long-term product development cost effective rather than a cost centre, they underpin the effective flow of CI/CD and reduce failure demand on a team. But the discussion of unit testing goes further than simply doing it: what makes a good unit test? It is not enough to have tests; poor quality tests can hold back development just as good tests can streamline it.

This session looks at good unit tests (GUTs) and different testing workflows, from test-driven development (TDD) to refactoring-driven development, whether the code you are testing comes from the past, from a prompt or direct from your fingertips. Examples will be in C++, C and Python.




• Kinds of tests
• Test-writing workflow: POUT, ITL, DDT, TDD and more
• What makes a unit test good?
• Common test smells and failure modes
• Tests as documentation and specification
• Given/When/Then and Arrange/Act/Assert test structure
• Aligning tests with domain concepts
• Data-driven tests
• Choices and checklists for test data
• Understanding (and misunderstanding) code coverage
• Structuring tests according to state models
• Grouping and nesting tests according to Given/When/Then
• Addressing brittle tests and long-term skipped tests
• Test strength: overfitting and underfitting tests
• Improving the design of your code by listening to your tests
• Dependency management and mocking
• Alternatives to mocking

1 Day

23 Sept

Program with GUTs

Testing

Python

Technique

The workshop primarily focuses on tooling for application development on the Linux desktop. It will be discussed how to apply the same tools to development on embedded Linux.

The course is valuable to any C++ developer that wants to get an overview of the tooling landscape on Linux. Some advanced C++ topics will be touched on that impact performance but otherwise only a solid basic understanding of C++ and Linux is required to attend.

2 Days

Debugging and Profiling C++ applications on Linux

Linux

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

This course covers specific remediation techniques for each category of
security flaws 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

Day 2: Dangerous Optimizations & Dynamic Memory


Secure Coding in C and C++ is 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.

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

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.

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.

22-23 Sept

Secure Coding in C and C++

Security

Programming Languages

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 web browser that can access 

C++ Best Practices

Good Software Design -- the proper management of dependencies -- is the foundation for the success of a project. The basic building blocks for software design are design patterns. Design patterns have proven themselves invaluable over several decades and thus knowledge about them is essential to design robust, decoupled systems. Modern C++, however, has profoundly changed the way we use C++, how we think about design and implement solutions. This also affects how we implement design patterns.

This training class explores modern C++ software 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;
* ... know about the importance of value semantics;
* ... comprehend the advantages of non-intrusive design.

C++ Software Design

- Linux kernel and initial root filesystem (initrd/initramfs)

- Downloading and unpacking the kernel source

- Testing the kernel without a root filesystem

- Introduction to Buildroot (and busybox)

- Downloading and unpacking the Buildroot source

- Creating the root filesystem with Buildroot

- Testing the root filesystem without the kernel

5. Using the custom distribution (Linux kernel + root filesystem)

- Booting the custom distribution on a virtual machine with QEMU

22 Sept

Building a Linux Distribution From Scratch

Starting with an existing embedded C application, we'll convert the build system to cargo. We'll then see how to call C from Rust and vice versa. We'll look at several strategies for how to do the migration, including starting from main and working down, and starting from the drivers and working up. In addition, we will look into how to setup testing for embedded projects using Rust's built-in test framework.

At the end of this workshop you'll have a good overview over the steps required to perform a migration, as well as hands-on experience.

This workshops expects participants to have experience with embedded C, as well as some exposure to Rust.

Migrating a an embedded C application to Rust

Rust

Guix supports features such as development environments (think python virtualenv but for all languages), a better container builder than docker, time travel, and handles cross-language dependencies. Users and operators should not care about cargo, pip, npm, go, cpan, or maven, etc., but they should, and do, care about the integrity of the supply chain and ease of getting programs to run. All powered by simple package recipes in Scheme (Guile), all easily version controlled.

This course will be a primer on software packaging and some history, a tour of some very neat guix features, and plenty of time to get our hands dirty by writing some packages of our own.



Basic Guix usage, such as package installation and generations, disposable shells, development environments, and building containers

Package management with Guix

Tools

Cloud

DevOps

Functional Programming

The learning happens entirely inside interactive Jupyter notebooks, where you can tweak parameters, rerun cells, and visualize results in real time. Step‑by‑step labs culminate in profile‑driven tuning sessions that capture execution traces with NVIDIA Nsight Systems, spotlight memory bottlenecks, and quantify the speed‑ups your optimizations unlock - mirroring the disciplined workflow championed in advanced CUDA C++ training. By the end, you’ll walk away with a practical toolkit for transforming everyday Python scripts into GPU‑powered engines and a systematic approach to squeezing every last flop from modern accelerators.

In this class, you'll learn to:

- Spot workloads ripe for GPU speed‑ups and explain the CUDA thread-block-grid model.
- Swap in CuPy or Numba to accelerate NumPy code with minimal changes.
- Write and coordinate custom CUDA kernels- including cuda.cooperative launches -entirely in Python.
- Maximize throughput via coalesced memory access, shared‑memory tiling, and lean host/device transfers.
- Profile, diagnose, and iterate on performance using Nsight Systems directly from Jupyter notebooks.

The course material is open source and can be found here: 

https://github.com/NVIDIA/accelerated-computing-hub/tree/main/gpu-python-tutorial

CUDA Python Fundamentals and Best Practices

Language

The course is hands-on and interactive. You'll use our web-based, zero-install platform to complete coding exercises and learn to use developer tools like our Nsight visual profiler. 

At the conclusion of the workshop, you'll have an understanding of the fundamental concepts and techniques for accelerating C++ code with CUDA and be able to: 


- Write and compile code that runs on the GPU 
- Optimize memory migration between CPU and GPU 
- Leverage powerful parallel algorithms that simplify adding GPU acceleration to your code 
- Implement your own parallel algorithms by directly programming GPUs with CUDA kernels 
- Utilize concurrent CUDA streams to overlap memory traffic with compute - Know where, when, and how to best add CUDA acceleration to existing CPU-only applications 

All of the course materials are open source, and can be found here: 

https://github.com/NVIDIA/accelerated-computing-hub/tree/main/gpu-cpp-tutorial

CUDA C++ Fundamentals and Best Practices

Languages

We introduce vectorization with NEON ground up from the most basic concept up to very advanced vectorization topics.



Basic vectorization patterns – vectorizing for loops, foor loops with early exit, while loops and convergence loops

Common vectorization patterns – vectorizing loops with conditions, conditional counting, loops with structs and matrix transposition.

Vectorization inhibitors – learn to detect and remove obstacles that hinder efficient vectorization

Vectorization types according to data access pattern – there are several ways to do vectorization, here we investigate inner-loop vectorization, outer-loop vectorization.

Advanced vectorization patterns – we talk about how to vectorize copy_if, trees and lookup tables.

Memory performance – improve the performance of your vectorized code by better using the memory subsystem.

Peak performance – reach peak software performance by breaking instruction dependencies, avoiding register spills and cleverly using everything hardware has to offer.

NDC { TechTown }

Workshops

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

C++ Software Design

Klaus Iglberger

NEON Vectorization Workshop

Ivica Bogosavljevic

Secure Coding in C and C++

Robert Seacord

C++ Best Practices

Jason Turner

Debugging and Profiling C++ applications on Linux

Milian Wolff

Program with GUTs

Kevlin Henney

Building a Linux Distribution From Scratch

Ignat Korchagin

Migrating a an embedded C application to Rust

Eivind Bergem

Package management with Guix

Jørgen Kvalsvik

CUDA Python Fundamentals and Best Practices

Bryce Adelstein Lelbach

CUDA C++ Fundamentals and Best Practices

Bryce Adelstein Lelbach