We’ll consider simplicity from a number of viewpoints, including essential versus accidental complexity, value demand versus failure demand, simple versus simplistic.

We’ll also look at typical sources of complexity in our coding habits, along with code examples in various languages.

We'll see that many practices and approaches can be used both to simplify and to complicate. It's all in knowing how and when versus how not to and when not to use them. For example, we can encourage reuse through code libraries, platforms and services, but we can also make an architecture needlessly complex and draw in unnecessary dependencies, with implications for maintainability and security. Similarly, AI assistance can be employed to make code simpler and easier to work with but, without attention and guidance, it can make things more complicated and harder in the long run, becoming a new source of legacy.

We’ll explore verbose and convoluted code, the effect of programming paradigm and how we can turn down the imperative noise of many languages and styles with declarative techniques.

We'll talk about what we might (or might not) mean by clean code, and whether that's a helpful approach.

We'll learn it’s not just in our programming and languages where we find complexity: our development processes, tools, architectures and organisational cultures can often encourage unnecessary complexity, costing us time, effort and opportunity where simplicity would have had the opposite effect. Suffering from heavy Agile™ ceremony? Too much certification and not enough action? That.

We’ll look at how we can work with incomplete knowledge without adding speculative complexity of so-called future proofing.

We’ll acknowledge technical debt and neglect for what they are and understand why legacy is so often the opposite of simple, no matter what its backstory or business value. We want to make sure that as well as recognising unnecessary complexity in the small and the large, that we also have an idea of the practices that can help with simplification.


As well as presenting concepts, examining themes and considering code, this masterclass will also offer plenty of opportunity for questions and discussion, plus some hands-on refactoring exercises (options will be available in different programming languages).

What kinds of complexity do we find in software systems?

What are the costs of accidental complexity in code and architecture?

Where does complexity appear in our organisations and processes?

The technical debt consequences of long-term technical neglect

Refactoring as an act of simplification, discovery and evolution

The role of testing in keeping code, architecture, delivery and life simple

How to be the human in the loop when working with AI code generation

Programming paradigms and their effect on complexity

Declarative programming versus imperative programming

Keeping code, architecture and development process lean

2 Days

5-6 May

Keeping It Simple

.NET

Agile

Architecture

Functional Programming

JavaScript

Testing

Work skills

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

The Rust programming language promises to be safe, fast and productive. Created by Mozilla, Rust provides high level features while maintaining control and safety for low level code if required. Rust plays in the same playing field as C/C++ but is fit for any kind of software, from low-level system code to servers, clients and anything in between.

This course introduces the fundamentals of Rust, from the basics up to using types, modules, generics, pattern matching, error handling and more. Lab exercises are used to help sink in the theoretical concepts.


- Understand the Rust language fundamentals
- Write idiomatic Rust code with structs, functions, traits, enums, and other fundamental Rust pieces
- Understand Rust ownership
- Use modules to organize code

Good knowledge and experience with at least one programming language such as C++, C#, Java, Python, JavaScript, Kotlin, Visual Basic, …

This workshop requires you to bring your own laptop with the following installed:

- Windows, Linux, or MacOS
- VS Code or RustRover installed
- Some PDF viewer



Module 11: Threads and Concurrency (if time permits)

Module 14: Advanced Topics (if time permits)

Rust Programming Crash Course

Rust

Programming Languages

To be fair, the people who abuse this term are also the people who probably fall under this category. I prefer “Agentic Programming” instead. I have pushed thousands of lines of code in production using agentic programming. Code that would have taken me months to write myself now takes merely days.

In this workshop, we’ll explore agentic programming as a disciplined engineering practice, not a toy.
Using Claude Code, I’ll show how to collaborate with AI agents to produce maintainable, reviewable, and production-ready code, without surrendering architectural control, correctness, or performance.

What Claude Code, Codex and Cursor are, how they work, and how you should use them

Designing clear agent boundaries and responsibilities.

How to turn vague intent into explicit, testable instructions.

Create plans that can run for hours on end, generating and testing code as they go.

Much more (workshop contents are constantly updated as new models and tools are released)

This is not a “let the AI take the wheel” session. It’s about teaching the AI to work like a senior engineer, while you stay firmly in charge. If you believe AI coding tools are dangerous, flaky, or fundamentally incompatible with serious software engineering, then this workshop is for you.



A laptop with your favourite IDE installed

Vibe Coding for Production

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;

... know about the importance of value semantics;

... comprehend the advantages of non-intrusive design.

Attendees will need to bring a laptop to this workshop. 
Either have a working C++20/23 environment on your machine (any OS, any IDE/editor and compiler work) or use an online compiler (

C++ Software Design

This course proposes an exploration of generic programming through many lenses. From relatively simple use cases, we will move to expressing one's own generic types, writing efficient and safe generic containers and algorithms, writing and using type traits, solving real problems through template metaprogramming (the reputedly scary part; we'll make it fun), variadic templates, programming with constexpr, fold expressions, and getting acquainted with the beauty of concepts. In the end, we will write less code to get better results.


The target audience is intermediate-level developers who:

Are familiar with modern C++, meaning C++11 and more in this case, without necessarily being experts 

Seek to develop an understanding, or a deeper understanding, of generic programming mechanisms made available to them in C++

Want the programs they write to be faster, safer and more correct

Junior developers can benefit from this course if they are willing to explore this part of the C++ language. Developers coming to C++ from another language might find the course surprisingly instructive, as they might gain a better understanding of the workings of other languages too – generic programming in C++ is quite different from generic programming in Java or C# programmers. More advanced developers might also enjoy this course if looking for a greater familiarity with modern C++ and its usefulness in their daily tasks. Please examine the Selected Approach and Expected contents sections below to ensure you make the right choice for your needs.

This course will concentrate on standard C++ and avoid most compiler-specific and operating system-specific techniques and tools.



Since the class will involve problem-solving exercises, participants must bring their laptops (or equivalent development tool) and at least one recent C++ compiler of their choice; compilers that support at least C++20 (ideally C++23 or even C++26 as some examples will use the latest version of the standard) are obviously preferable given the subject matter.

As mentioned previously, we will strive to constrain ourselves to standard C++ only, and will be avoiding non-portable or platform-specific code as much as possible.

The format for this course will be a combination of lecture-style presentation of features and tricks and exercise solving. We will typically start with a concrete problem to solve, and a minimal objective to achieve, and work towards reaching that objective for some short time. A presentation of potential solutions will follow, accompanied by a discussion where participants' input is encouraged.



Topics covered in this course include :



Humble beginnings
- Simple examples
- Templates are not macros
- Anatomy of a template
- Templates and implicit contracts
- Traditional template parameters: types and integral constants

Type deduction
- Words of power: auto, decltype, decltype(auto)
- Types of references
- Forwarding
- Value categories

Generic classes
- Writing a non-generic class (simple example)
- Transforming a non-generic class into a generic class
- Making a generic class safe: rethinking its public interface
- Template specialization

Generic algorithms
- From loops to algorithms, with care
- Iterators
- Function objects
- From generic type to generic member function
- Lambdas
- The Law of Useful Returns
- Numeric algorithms

Type traits
- Evolution of type traits, from inception to standardization
- Writing traits yourself
- Standard traits
- Documenting containers
- Documenting iterators
- When to use typename
- When to use template
- Traits aliases for types

Template metaprogramming
- From constants to types
- Non-type template parameters
- A non-existing yet useful function named declval
- Generic variables
- Traits aliases for values

Using traits in practice
- Implementing an average function
- The close_enough case
- Tag dispatching
- enable_if and SFINAE
- if constexpr
- Introduction to concepts
- The difference case
- The distance case
- Traits for optimization and safety: the copy case
- Traits for optimization and convenience: the lexical_cast case

Concepts
- Improving generic code through concepts
- Turning generic programming into normal programming
- Benefiting from common_type
- Writing concepts
- Using requires clauses
- Why requires requires?

Variadic templates
- Why and how they are useful
- The reason for perfect forwarding
- Classes with variadic bases
- Composing lambdas
- Novel ways to use packs

Fold expressions
- What they are, how they work
- Interesting applications

The C++ detection idiom
- Detecting the validity of a specific type
- Detecting the validity of a specific function
- Detecting the validity of arbitrary expressions
- Comparing with enable_if
- Comparing with concepts

More on constant template parameters (previously named non-type Template parameters)
- Interesting use cases
- Floating point parameters
- Literal type parameters
- Compile-time strings

Putting it all together
- Combining the various aspects of generic programming seen throughout the course to solve concrete problems in cool and efficient ways



Metaprogramming for fun and profit
- Type lists
- Computing on constants
- Benefiting from template template parameters

Introduction to ranges
- A small overview of ranges for people familiar with algorithms


Generic Programming: from Strange to Normal

This course goes beyond traditional security testing to incorporate novel adversarial machine learning, Responsible AI (RAI) violations, and emerging threats to AI agents. Participants will gain hands-on experience with the latest attack vectors while learning defensive strategies.


The course emphasizes practical application through a custom-built red teaming platform that simulates real-world AI deployments. Participants will work with live AI systems—not mockups or demonstrations—to experience the unpredictable nature of AI vulnerabilities firsthand. Our lab environment includes vulnerable LLM applications, multi-agent systems, and multimodal AI tools that mirror enterprise deployments.

Each module combines theoretical understanding with immediate practical application. When we cover prompt injection techniques, participants immediately test them against live systems. When we discuss automated red teaming, participants build and deploy their own attack workflows using open source tools. This learn-by-doing approach ensures that participants leave with both conceptual knowledge and muscle memory for executing these techniques.

The competitive lab environment includes CTF-style challenges with scoring and leaderboards, making the learning process engaging while building the adversarial mindset essential for effective red teaming.

By the end of this training, participants will be able to:


- Systematically assess LLM applications for prompt injection, data extraction, and jailbreak vulnerabilities
- Execute advanced attacks including Crescendo, Greedy Coordinate Gradient (GCG), Prompt Automatic Iterative Refinement (PAIR), and Tree of Attacks with Pruning (TAP).
- Identify RAI violations across bias, privacy, misinformation, and harmful content categories.
- Leverage automation tools for offensive AI security, benchmarking, and agent building.

- Lab environment: Access to a custom-built platform to AI red teaming.
- Code samples: Complete setup with all tools and target applications .
- Digital Workbook: 400+ slides covered in the course for future reference.


- Laptop with access to the internet.
- Familiarity with the Python programming language and being able to write simple scripts.
- Background in machine learning is not required.


- Module 1: AI Security Landscape
- Module 2: LLM Attack Fundamentals
- Module 3: Automation and Scale
- Module 4: Introduction to Agents and Agentic Systems
- Module 5: Open Source Tooling for AI Red Teaming

- Module 6: Advanced Attack Techniques
- Module 7: Multimodal Models
- Module 8: Building Defenses and Mitigations
- Module 9: Responsible AI Red Teaming

NDC { Toronto }

Workshops

09:00 - 17:00 (UTC-05)

C++ Software Design

Klaus Iglberger

C++ Best Practices

Jason Turner

AI Red Teaming: Attacks on LLMs, Agents, and Multimodal Systems

Gary Lopez

Generic Programming: from Strange to Normal

Patrice Roy

Rust Programming Crash Course

Pavel Yosifovich

Vibe Coding for Production

Nick Chapsas

Keeping It Simple

Kevlin Henney