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 it’s 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).

2 Days

Accelerated TDD: For More Productive C++

C++/Embedded

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

Security

Technique


- Get introduced to Embedded Linux and Yocto,
- See how Yocto helps to create custom Linux distribution,
- Discuss practical considerations for cross-development,
- Cover the Yocto build-system in more depth,
- Learn about Yocto layers and recipes,
- Create a cross-development toolchain with Yocto (SDK)
- Configure and build the Linux kernel and user space applications.
- Tools and techniques for debugging kernel/user space applications.




- Have a map to navigate Yocto projects,
- Understand how to configure, build, and debug embedded Linux components.
- Be ready to embark on your Embedded Linux & Yocto journey!




This is a practical hands-on workshop. Along with the PDF course material, you will get a virtual machine to practice. To fully benefit from these hands-on exercises during the course, bring a laptop VirtualBox or VMware installed. Your laptop should have hardware virtualization enabled, at least 8Gb of RAM, and plenty of disk space (at least 45Gb). The download and installation instructions will be provided in advance.

You will also be able to redo the exercises at your own pace after the course.




Some experience of working with an embedded environment (RTOS or bare machine) and the C programming language is assumed. Familiarity with the Linux shell commands is beneficial, but not mandatory.


Jump-starting your Embedded Linux & Yocto Journey

Embedded

Product

UNDERSTANDING EXPLOITATION AND FINDING VULNERABILITIES

Gain essential knowledge, and hands-on experience, in effective vulnerability detection tools and techniques, and how these vulnerabilities are wielded in exploitation of C++ and C applications. By deepening your understanding of exploitation, the motivations driving mitigations, and the identification of high-risk constructs, you will be able to design software that better meets your security needs.

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

The training will provide its students with:

knowledge on how to use tools to find vulnerabilities in native applications

give a hands-on experience in some exploitation techniques

 - Slack: 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 security professionals with some programming experience in C or C++.

: How to use tools like Address Sanitizer and fuzzers like AFL/libFuzzer to find and fix security vulnerabilities. Here you will use fuzzing to find the Heartbleed vulnerability in OpenSSL. You will also be tasked with fixing Heartbleed, and then reviewing the fix that was shipped at the time, to get a realistic impression of how difficult it can be to analyze and fix vulnerabilities in real life scenarios.

Exploiting Buffer Overflows with Custom Exploit Shellcode

: How to exploit buffer overflows and execute arbitrary code, and the mitigations that can help prevent it from happening. Here you will exploit a program with your own custom shellcode.

Return Oriented Programming (ROP) and Format Strings

: How to bypass stack protection mechanisms using ROP and generated ROP chains. And we’ll use format string vulnerabilities as an example of a completely different way of exploiting applications.

DAY 1 - FINDING VULNERABILITIES USING FUZZING

Introduction to exploitation, vulnerabilities and specifications

Mitigations and Tooling: Static and Dynamic Analysis

Undefined Behaviour and Compiler Optimizations

DAY 2 - EXPLOITATION AND WRITING SHELLCODE

Exploitation: Writing and Testing Custom Shellcode

Exploitation: Return Oriented Programming (ROP)

(In)Secure C++: Sec Edition

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


The world runs on code written in the C programming language, yet most schools begin the curriculum with Python or Java. 

 bridges this gap and brings C into the modern era—covering the modern C17 Standard as well as potential C2x features. With the aid of this instant classic, you’ll soon be writing professional, portable, and secure C programs to power robust systems and solve real-world problems.

 introduces C and the C Standard Library while addressing best practices, common errors, and open debates in the C community. Developed together with other C Standards committee experts, Effective C will teach you how to debug, test, and analyze C programs. You’ll benefit from Seacord’s concise explanations of C language constructs and behaviors, and from his 40 years of coding experience.

How to identify and handle undefined behavior in a C program

The range and representations of integers and floating-point values

How dynamic memory allocation works and how to use nonstandard functions

How to perform I/O with terminals and file systems using C Standard streams and POSIX file descriptors

How to understand the C compiler’s translation phases and the role of the preprocessor

How to test, debug, and analyze C programs

 will teach you how to write professional, secure, and portable C code that will stand the test of time.

Editors and Integrated Development Environments


Locale-Specific Behavior and Common Extensions

Unsequenced and Indeterminately Sequenced Evaluations

Effective C (and C++)

We start immediately with working programs so that abstract concepts can be made concrete. Testing is integral to our approach and many of the exercises are 'test driven'. Students will be able to work on Windows, Linux or Mac OS X.



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:

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

Programming Languages

In addition to that, the so-called source inclusion model and independent compilation of separate pieces of code are potentially inefficient, brittle, and error-prone. Sometimes, people aren't aware of these problems and compilers can't help to avoid them because of the fundamental limitations of the way we are used to build programs. With the advent of modules in C++20, there is now an answer to all those problems within the language itself. Despite modules reusing existing concepts that have existed since the inception of C++, their application at this level is new and probably unfamiliar. This might hinder programmers from taking advantage of the benefits that C++ modules bring. The goal of the course is to instill confidence in the adoption of modules.




- introduce you to the motivation for the addition of modules to the language
- explore the shortcomings of libraries and library interface design in the traditional world, and how to overcome them and improve
- teach the foundational concepts of modules
- give the full picture of all the options available to you to compose modular libraries
- teach how to write modules from scratch
- give guidelines on how to use existing libraries as modules
- explore the potential pitfalls and how to avoid them
- show the performance benefits of modules
- look at the current state of the development ecosystem with regard to modules
- and give you the opportunity to ask me anything about C++

About a 3rd of the time is spent on interactive material presentations, the bigger part is individual hands-on coding on your computer where you
- create clean sheet modules
- do library to module conversions
- analyze a concrete code example




- can create simple and composed modules
- can use modules in applications
- identify and handle problems related to modules

--------




Daniela is a member of the ISO C++ committee and mainly participates in the study groups dealing with the development of the language and tools. She has been researching the area of C++ modules since before the introduction of C++20 and has become one of the world's leading experts in this field. She has a degree in electrical engineering and has worked in small innovative companies in the field of software and hardware development for more than 30 years. Among other things, she spent her youth researching the first microprocessors of the late 70s and has been developing software professionally for 40 years. After a long period of using many different programming languages, C++ has become her sole workhorse for the last two decades. Most of her career has been in applied digital signal processing (medical, metrology, reconnaissance, etc.), but in the last decade the focus has shifted to specialised engineering in the field of industrial non-destructive testing of semi-finished and finished steel products using ultrasound.

Using C++ Modules with Confidence

This practical course will demystify some very useful operations with git, give you some good habits that set you up for success, and prepare you for solving complex problems.

With the power of examples, stories, and exercises you will learn about and get experience with topics and features like:

* The art of good commits
* Effective git log: search, queries, diffs
* Making use of the staging area
* Mastering merges: conflict resolution and octopuses
* Composition with cherry-picks, fixups, and rebase
* Frequent snapshots and rollbacks
* Bisecting for bugs: time travel for the cause
* Recovering not-yet-lost changes
* Transports, patches, and emails

After the course you will have a renewed appreciation for what git can do for you, and a stronger foundation to build on when maintaining your programs.




Your favourite git client and programming environment.

There is no substitute for real world examples; you can bring your own code base, or a favourite open-source one, to play with. This is fun, but optional; plenty of good examples will be provided.




Some basic exposure to git, or at least some of version control system, is necessary as some core concepts will not necessarily be carefully explored.

NDC { TechTown }

Workshops

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

Using C++ Modules with Confidence

Daniela Engert

Git Beyond Push & Pull

Jørgen Kvalsvik

C++ Best Practices

Jason Turner

C++ Software Design

Klaus Iglberger

(In)Secure C++: Sec Edition

Patricia Aas

Accelerated TDD: For More Productive C++

Phil Nash

Jump-starting your Embedded Linux & Yocto Journey

Simon Goda

Python Properly

Austin Bingham

Effective C (and C++)

Robert Seacord