Using them, we explore the various customization points C++ offers. We look at what the new keywords co_await, co_yield, and
co_return are for.

Sadly, we also have to talk about how to write a generator for a coroutine since there is no STL part for that in C++20.

Another distinction we make is between cooperative and preemptive multitasking, opening the door for another beauty of
Coroutines, why we don't need locks.

By the end of this talk, you've learned what coroutines are and where you can use them.

Talk (60 min)

C++ Coroutines from scratch

Initially developed in early 2001 for Windows and SGI Irix OS using C++98. This talk describes the history of its development and the efforts to modernize the application with regard to new C++ standards, as well as reengineering the application to take advantage of new libraries such as Eigen and ImGUI.

A C++ journey from old to modern - Modernising ObjectiveFrame

And how can you and your team gain knowledge on better securing your systems and service? Let us venture on a journey into the wonderful world that is software exploitation and learn how to use gamified safe environments to build skillsets to help us write better and safer software. Because once you learn how to hack, you never go back.

How hacking works

Security

Software Design

In 2023, there are many essential tools that every C++ developer should be familiar with when starting a new project from scratch.

These including popular C++ IDEs like Visual Studio, CLion, as well as code analysis tools like PVS-Studio, Clang-Tidy, and Cppcheck, which can help catch errors and improve code quality.

Build systems like CMake simplify the process of managing dependencies and building complex projects across multiple platforms.

Additionally, package managers like Conan and vcpkg can make it easier to download and install external libraries.

By understanding and using these essential tools, developers can streamline the development process and focus on writing efficient, high-quality C++ code.

Let's try to write a new c++ project from scratch together and see how these tools help us.

How to start a modern C++ project?

Testing

Tools

There is a tendency to create more obstacles to Linux kernel releases (requiring more approvals etc). But introducing all these obstacles and not treating kernel updates like any other software usually significantly increases the risk for the company and their service of being exploited.

One of the reasons SREs and engineers are too afraid of ANY kernel upgrade is that they don’t actually know the details about Linux kernel release process and policy. This talk tries to demystify Linux Kernel releases and provides a guide on how to distinguish a kernel bugfix release from a feature release. We also describe how kernel releases are implemented in our company and propose possible approaches to deploy kernel upgrades regularly with minimal risk.

An engineer's guide to Linux Kernel upgrades

We’re very fragmented on many topics, based on the breadth of the C++ ecosystem and the background/experience we each bring from our C++ niche.
From CppCoreGuidelines to opinionated best practices to established idioms, there’s a lot of good information easily available. Mixed up with all of this there are also plenty of myths. Some myths stem from obsolete information, some from bad teaching materials.
In this presentation, I will dissect a few of the most popular C++ myths to a level of detail not possible on Twitter… and without the stigma of newb/duplicate/eyeroll one might experience when asking these questions on StackOverflow.
Expect the familiar “Busted”, “Plausible”, or “Confirmed” verdicts on each myth and come prepared to chat about these.
This is Part 2 of the Mythbusters series.


C++ MythBusters Strike 2

Language

This was motivated by the cut-throat arena of High-Frequency Trading (HFT) and my own experiments. Extensive effort has been made to see just how far one can get using extensive template meta-programming to optimise the performance.

Following on from my previous talks regarding optimisations in C++, I undertook a multi-year investigation into extreme micro-optimisation of template meta-state machines. This Herculean effort eventually hit a "hard limit": due to Shannon's Information Theory... The meta-state machine described was a cut-down variant of the renown Boost.MetaStateMachine (mine lacks guards and other such flexibility). Each transition has been instantiated in a custom-container I termed "unordered_tuple", it provides extremely fast run-time access to each element. The input state has been encoded, using template meta-programming, in the enum tag-value to try to ensure that fastest possible instruction-encoding. The hashing of the state to identify the correct transition in the table uses a custom-designed, data-parallel algorithm that attempts to generate via brute-force an extremely fast, perfect (possibly minimal) hash: this might fail due to inadequate entropy. All this to generate a ... computed-`! (Forgive me Dijkstra...) So having erased all type information via the generated computed-GOTO, type-safety was restored via some further template meta-programming: the "constrained_override_type" that generates a specified override-set of functions and suitable abstract base-class. An analysis of the generated assembler that should demonstrate the efficacy of the techniques shall be given, followed by a performance comparison versus the much more simple "if-else" chain one may have used to implement the lookup of the transition in the meta state-machine.

Template Meta-State Machines, Madness and Shannon.

Design

In application areas where human live or capital is at risk, safe and secure code is a must, but even in other domains the internal quality of C++ programs is an important factor for programmers' effectiveness. Adhering to MISRA-C++ can help to achieve better internal quality, reducing the risk of undefined behavior and portability issues through implementation-defined behavior.

Since the original MISRA-C++ 2008 guidelines that addressed C++03, five new C++ standards were released. While inherently conservative, an update to the MISRA-C++ guidelines was prepared and is (about to be) released in 2023 adressing C++17.

This talk will give an overview of why and what MISRA-C++ attempts to achieve as well as demonstrate some example MISRA-C++ rules and how modern C++ design already fulfils them.
Some seemingly surprising guidelines are shown and explained, why such "unachievalbe" guidelines exist and the rationale behind those guidelines that one seemingly must violate.
For example, an advisory guideline forbids to write your own loops, except for a few cases, which sounds ridiculous on first sight. The talk will show a few cases how to work around but also tells you not to sweat it to hard, but reminds you that getting loop statements correct is really hard.

Safer C++ with MISRA-C++ 2023

Embedded

Writing secure C++ code is hard. We will try to take a lesson from other industries where security is important and see what measures we can put in place to make our C++ code more secure.
We will talk about practical tools and techniques, language features to use and to avoid, fuzzers and sanitizers, hardening using compiler options, methodology, some UB to be aware of, and the general feasibility of using C++ where security is important.

Secure development with C++ - Lessons and techniques

Data Distribution Service (DDS) is one of many publish-subscribe systems in existence. It differs from most in that it is a standard (so there are many implementations) and in that it is broker-less (so there is no server). The lack of a central message broker is of particular interest, because it means that it works on infrastructure with no servers.

This talk will give a short introduction to DDS and CRDT technologies and then look at how they can be combined to create truly distributed applications. CRDTs allow for complex distributed state, while DDS provides near real-time updates. Having both at the same time makes it possible to build a wide range of applications. The presentation will also touch upon some of the broader ideas underlying such systems, and aims to be of interest to developers that are merely offline-curious.

Offline first computing in an online world

Architecture

But somebody has to set up that build in the first place. This talk is directed at those (soon to be) experts. In a case study I will show some tips and tricks to use a library and tools for which there is no support in CMake yet.

In the case study, we will look at a C++-application that uses embedded SQL to talk to an Oracle SQL-database. To build the application, it needs to link against Oracle’s client library, and the files with embedded SQL need to be converted to pure C++ before they can be compiled. How can we find that library when there is no CMake module for it yet? (We write our own!) How can we execute Oracle’s preprocessor to convert files with embedded SQL in a structured way when there are tens, or hundreds, of those files, possibly spread over different CMake targets? Come to my talk and I will tell you.

Tips and Tricks for Becoming a CMake Master

This talk will go over what it means to play video games with the assistance of tools and show a few examples of how this can be done using C++.

From games that support creating tools to injecting your own code into a game.

This is an introductory talk on this topic but it will cover a few lower level systems interactions. No video game knowledge is needed.

Playing Video Games One Frame at a Time

Gaming

The talk covers Linux and its ELF symbols in particular, but Windows has some similar concepts. It applies to both C and C++.

In this talk, I'll go over

What symbols are, and why do we need them

Why your program has three different symbol tables

The difference between binding and visibility and how C/C++ linkage relates to the two

Where symbols are stored and how to view them

Allowing users to override your functions/globals

How the linker handles C++ templates and inline variables

Which entities need symbols and which don't

Symbol tables used in static and dynamic linking

Default vs hidden visibility and a useful idiom to work with these

How symbols work and why we need them

Reintroduction to C

C++ is about to turn 40. Though the ecosystem was very diverse and incomplete for many years, it is getting better! In this talk, I will discuss:

The typical “project model - compiler - debugger” triad, and how it still depends on the area of usage (Embedded or Game Development).

How the build systems and dependency managers are now more standard.

How Clang affected the standard toolset in all areas, forming not only a baseline for compilers, but also formatters, code analyzers, and IDEs.

How many code analyzers exist for C++ and why there is still room for improvement.

How unit testing and code coverage solutions can be used effectively.

And finally, how the language committee is learning to listen to and help standard toolset contributors.

You’ll get a better understanding of the tools available to help you develop complex solutions in C++ without struggling with toolsets.

Standard C++ Toolset

But despite their fundamental importance, there are some common misconceptions about them, in particular about several of the most often used design patterns:

Factory functions are frequently mistaken for the Factory Method design pattern

The Builder design pattern is often associated with the implementation of constructors

The Bridge and Strategy design patterns are regularly mixed-up

The modern form of the Visitor design pattern, std::variant, is often considered a replacement of virtual functions

(Bonus) The Decorator design pattern is sometimes mistaken as the Chain of Responsibility design pattern

In this talk I'll shed some light on these misconceptions and explain why they obstruct the proper communication about software design and architecture. Additionally, I’ll address the biggest misconception of all: design patterns are a tool for object-oriented programming.

Design Patterns - The Most Common Misconceptions (1 of N)

The first challenge is the hardware: embedded devices are often designed for a price, which means slow CPU, not much RAM, not much storage: hardware that is definitely not powerful enough to compile the programs that it will run. In consequence, Embedded Linux almost always involves cross compilation utilising build tools such as Yocto Project


Next, consider the type of workload. Typically, it involves reading from sensors (buttons, dials, cameras) and using the information to create some kind of output, from example an alert. This is real-time computing. Fortunately, modern Linux is pretty good at soft real-time and quite good at hard real-time – these are terms that I will discuss in the talk
Thirdly, bear in mind that there is no admin to come along and apply a patch or reboot when things go wrong. We need robust methods of pushing updates to the target, of rebooting when things go wrong and of remote logging of critical errors.


These are just three examples of what makes Embedded different; there are others. So, please come along to this talk if you have ever wondered about the devices that surround you and how the Linux that many of then contain is put together

The Challenges of Embedded Linux

Return Oriented Programming, an introduction

This keynote discussed the requirements for developing C and C++ software for safety-critical and security-critical software, approaches to meeting these requirements, and the future of C and C++ in these domains.

Keynote: Safety and Security: The Future of C and C++

Regardless of reason, PMR, Polymorphic Memory Resource, is available since C++17, and makes your life much easier.

* Tools and techniques for analysing the memory usage of your program.

* How PMR makes memory management easier.

* How to use PMR with the standard library types.

* Advice, and pitfalls to avoid, on your quest to improving the memory usage of your program.

Most Malleable Memory Management Method

Was the charter not good enough to fulfill its ideals? Why did so many changes occur for C23? What is missing, and how are those things missing?

We will explore past, present, and future features for the C programming language. We will discuss the balance of power between users, librarians, implementers, and the standard committee. And, ultimately, we may yet find out what it really means to steer a 40+ year old programming language towards a better, brighter future.

C is So Back: Unbreaking the Charter

Complimentary food and drinks will be served. 

 - Keynote: Steps to Wisdom - Kate Gregory 
Do you have to be old to be wise? You do not. You can learn and discover wisdom over a lifetime, but you can also learn small lessons that open the doors to a wiser way of living – at any age.

This talk presents a selection of lessons that can make a real difference in how you write code, architect systems, participate in meetings, manage your career, and generally live. Some of it you already know, but aren’t relying on. Some of it will be new to you. I want to give you the confidence to tackle things the way a wise person tackles them, and the benefits that can bring you.



1 Day

NDC Party

While having a robust security team is ideal, the reality is that for some organisations, it will be up to the developers to evaluate encryption tools and libraries on top of other urgent priorities and features to ship.

In this talk we’ll cover why encryption is so important, cryptography basics, the zero trust security framework, key generation and management options, and best practices around data storage.

Developers will leave this talk with the confidence to decrypt confusing industry messages around data security and implement recommended practices to secure their business and customer data (preventing the next data breach headline).


Don’t Throw Away the Key: What Developers Should Know about Encryption

Why Data Access Patterns Have Always Mattered

This library has basic building blocks like atomic variables, threads, locks, and condition variables.
That’s the foundation on which C++ standards such as C++20 can establish higher-level abstractions consisting of extended atomics, semaphores, latches and barriers, cooperative interruption, an improved std::jthread, and synchronized output streams.

Concurrency Improvements in C++20: A Deep Dive

This talk might be interesting if you want to know:
- the difference between flat_* and regular containers
- when to use them
- about the performance and memory impacts

I'm also going to share some actual usage cases and talk a little bit about common mistakes.

Understanding And Mastering Flat Containers

Applications can securely store and share credentials, secrets and cryptographic keys, sign and encrypt data, negotiate a common encryption key - all this by never touching a single byte of the underlying cryptographic material.


This is especially useful in the post-heartbleed and cloud-native environments, where services authenticate and securely talk to each other using some kind of credentials. But if a network-facing service also has some secret in its process address space, it sets itself up for a security failure as any potential out-of-bounds memory access vulnerability may allow the secret to be leaked. Imagine a world where you don’t have to run an SSH agent just to protect your SSH keys.

On top of keeping your secrets secret Linux keystore nicely integrates with specialized security hardware, like TPMs and HSMs and may provide a single entry point on the system for applications to obtain their secrets. Thus Linux keystore is a very useful building block for a corporate key management system.

What is Linux kernel keystore and why you should use it in your next application

This talk will cover some obscure features you might not know. We will cover strange syntax like commutative array indexing and complicated declarators, surprising cases of undefined behavior in frequently used operators contrasted with a surprising lack of undefined behavior in operations that really shouldn't work, overlooked language facilities — some of them actually useful, and half-forgotten standard library functions — some of them for good reason.

For each feature, we will talk about the what, the why, and how you can use it to write better (or much, *much* worse) C++ programs.

C++ Features You Might Not Know

The same is true with build systems that support C++ Modules. MSBuild handles all kinds of module types, but most people are waiting for modules support in CMake to even consider start using them. So, let's dive into the cross-platform modules world and see what you can do today, how you can create modules with CMake, and what kind of experience you can expect.
This is *not* an introduction into C++ Modules, there are a couple of talks and other material available for people to learn from and familiarize themselves with the fundamental ideas. The talk will focus on the practical aspects of cross-platform support, using common tools.

The talk will
- give a short recap of what Modules are
- look at the current state of Modules in clang, gcc, and msvc
- look at the current status of CMake
- look at the upcoming Modules Technical Report, currently in development by SG15, to be issued in 2023 by the C++ standard committee
- give guidance how to create, deploy, and use C++ Modules (using CMake if possible)

Throughout the session, the material is presented along a concrete code example.

So, you want to use C++ Modules ... cross-platform?

I'll then show a practical demonstration by implementing a coroutine-based wrapper over the popular C library, libcurl. By the end, any of the fears the audience have about coroutine will be dispelled.

What we’ve been awaiting for?

I will showcase image classification in C++ on a Raspberry Pi and demonstrate how a classic game can be implemented using hand gesture recognition.
No prior knowledge of machine learning or embedded devices is required to attend this talk.


Leveraging the power of C++ for efficient machine learning on embedded devices

The ambition or dream of a perfect night's test run may in fact be harmful. Having that goal can make you consciously or unconsciously hesitate to write tests that target weaknesses in the system under test. Tests that fail regularly provide an always up to date status of the problems that still need fixing. Intermittent end-to-end test failures tracked over time provide valuable input to development teams to determine the priority for fixing known issues.

However, dealing with broken tests is a challenge. So this talk will focus on a wide range of tried and tested strategies, tools and practices that ensure the meaningful signal from your test results doesn't get lost amid the noise of test failures. This talk will also cover a variety of effective recovery strategies to ensure you still run as many tests as possible on each build--in spite of failures. It will also cover concrete strategies to reduce the number of false positives which quickly drain the value out of your end-to-end testing investment.

The art of living with broken things

Technique

Our Adventure building a massively scalable mixed C++ and Rust remote compiler cloud

Image processing with Halide

They don’t execute the machine code in the order the compiler told them to. By cleverly analyzing data dependency between instructions, CPUs can dynamically change the order in which your program executes, increasing efficiency without sacrificing correctness.

In this talk you will learn how this is possible, which advantages it provides, but also what the limitations are. Additionally, you will learn concrete techniques to take advantage of out-of-order execution in your C and C++ programs. Which optimization efforts should you care about, and which are better left to the compiler and the CPU?

By the end of this talk, attendees will gain an understanding of how out-of-order processors work, enabling them to write more performant code faster.

Out-of-order execution - what can it do for me?

I'll also talk how we go about reporting compiler bugs in a way that
makes them more likely to be fixed, and about various interactions that
we've had with compiler development teams. Over the past decade or so we
have reported more than 750 bugs, and we have also produced a variety of
open-source tools that developers can use on their own.

Locknote: How Badly Do We Want Correct Compilers?

This talk has a twofold aim. Firstly, it explores the inner workings of large language models with an eye for leveraging them effectively for coding tasks. Second, it highlights a few "wet intelligence" C++ idioms that remain elusive for current AI tools.

Brace yourself for a fascinating journey that traverses from philosophical musings to complex C++ templates, and ventures into the realm of C macros that are often unspoken of in genteel circles. By the end of this talk, which aspires to become horribly outmoded due to the rapid advancement of AI, you will hopefully be better equipped for cooperating with the dynamic field of AI in your C++ development endeavors.

C++hatGPT: How AI Tools Impact Your Life as a Systems Programmer

This talk will cover some git uses beyond push & pull, with some strong opinions on how to effectively make good git-logs (and why) sprinkled in.

git beyond pull & push

In this talk, we will embark on a journey that challenges conventional wisdom. By leveraging mathematical analysis, statistics, and empirical measurements—with the aid of ChatGPT as our trusty digital companion—we will discuss a modified binary search algorithm that performs fewer comparisons on average and offers greater room for optimization..

If you're drawn to the beauty of algorithms, the craft of code optimization, and the underlying mathematics that weave the fabric of our digital universe, this talk is an invitation to see an old problem with new eyes and to embrace AI as a new ally. Come prepared to deepen your understanding and sharpen your skills with a fresh perspective on a classic algorithm, and learn how the fusion of human intuition and artificial intelligence can unlock uncharted territories in problem-solving.

NDC { TechTown }

Agenda

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

Keynote: Safety and Security: The Future of C and C++

Robert Seacord

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

How to start a modern C++ project?

Mikhail Svetkin

Reintroduction to C

Olve Maudal

C++ Coroutines from scratch

Andreas Fertig

Offline first computing in an online world

Ørnulf Staff

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

Tips and Tricks for Becoming a CMake Master

Hans Vredeveld

How symbols work and why we need them

Anders Schau Knatten

Design Patterns - The Most Common Misconceptions (1 of N)

Klaus Iglberger

Secure development with C++ - Lessons and techniques

Helge Penne

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

Standard C++ Toolset

Anastasia Kazakova

C is So Back: Unbreaking the Charter

Björkus Dorkus

Template Meta-State Machines, Madness and Shannon.

Jason McGuiness

Most Malleable Memory Management Method

Björn Fahller

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

An engineer's guide to Linux Kernel upgrades

Ignat Korchagin

Return Oriented Programming, an introduction

Patricia Aas

A C++ journey from old to modern - Modernising ObjectiveFrame

Jonas Lindemann

Playing Video Games One Frame at a Time

Ólafur Waage

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

Safer C++ with MISRA-C++ 2023

Peter Sommerlad

How hacking works

Espen Sande-Larsen

C++ MythBusters Strike 2

Victor Ciura

The Challenges of Embedded Linux

Chris Simmonds

17:30 - 22:00 (UTC+02)

NDC Party

Kate Gregory

Anders Schau Knatten