There are many cases of performance, correctness, design and security, however, where foundational concepts taken for granted by those with a more formal background would benefit software developers who might otherwise not have had the opportunity to learn about them.

Three broad topic areas will be covered during the day: low-level representation; data structures and algorithms; distribution and concurrency.

• Welcome to the Machine: Modern programming languages, libraries and operating systems hide a lot of the lower-level machine detail. A developer can easily ignore much of what happens beneath the virtualisation of their runtime or the abstractions of their high-level programming language. Much of... but not all of. To understand a number of edge cases, failures cases and surprising cases, developers should be familiar with the various ways in which numbers are represented. It also helps to understand how memory is addressed, both physically and virtually, and how to perform bit manipulation when needed. And when we talk about memory, we also need to talk about processor caching, instruction pipelines, speculative execution and, of course, that virtual machines are still machines. All of these considerations have an impact on the mechanical sympathy and, therefore, the performance of code, as well as its correctness and security.

• Everything in its Right Place: Most of the time, the data structures we need can be found commodified in a programming language's standard library, along with a number of useful algorithms. But, as many codebases witness, most developers rarely venture beyond array-like collections, often with unintended performance consequences or verbose code. And for those who do, there is often not a full appreciation of how hashing- and ordering-based collections work and the trade-offs they involves. In this module, common concrete and abstract data types will be examined in terms of their structure and performance characteristics, as well as some common and esoteric algorithms understood in terms of their time and cache behaviour, with a proper appreciation of what big O notation does and does not entail.

• Go with the Flow: Although many developers find themselves working in software architectures reliant on networks and in languages that freely offer support for multithreading, they often lack a more formal understanding of the principles, theorems and guidelines that govern these domains. In this module, we will introduce happens-before semantics, TOCTOU errors, how deadlocks and livelocks occur, the fallacies of distributed computing, CAP theorem and PACELC theorem, along with how to work within these constraints and avoid common pitfalls.

This full-day session is suitable for anyone in software development with a past, present and future programming role, whether as an introduction or as a refresher.

1 Day

26 Jan

The Hitchhiker's Guide to Computer Science

Work skills

Architecture

Concurrency

Database

Embedded

Programming Languages

Microservices

Security

Join me in this full day discovery of where Dapr and Aspire compliment each other, fight each other or when to choose which flavor.

By the end of this workshop you will have the tools you need to successfully setup a microservices architecture, and you'll know how to choose between Dapr or Aspire on its own, or how to use them together

.NET Aspire and Dapr: a microservices match made in heaven

.NET

Cloud

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 unit test good? It's 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#, JavaScript and TypeScript.




• 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

27 Jan

Program with GUTs

Testing

Agile

JavaScript

In this one day class, you'll learn about the challenges of distributed systems, and what you can do to create software that is much more likely to work when users need it to.

Whether you're building a fine-grained microservice architecture, or a more monolithic distributed system, you'll learn concrete practices to help make your software more robust.

This is not a coding matserclass, but it is interactive. This is a class about concrete practice, but presented in a technology agnostic way.

Resilient Distributed Systems

How can we steer our customers toward a modern future? How do we transition business-critical applications to new technologies without sacrificing the features that users truly value? There is no simple answer to this question.

I’ve spent years navigating these modernization journeys, encountering many of the same challenges you face today. Over time, I’ve refined a way of working that not only allows me to grasp the details of how these legacy systems work but also helps me pinpoint the elements that matter most to end users. With these insights, I am well on my way to designing a new system that can get accepted by end-users and prove its worth.

In this hands-on workshop, we’ll simulate a real modernization scenario. I’ll take on multiple perspectives—from CFO to end user—and together we’ll craft several modern architectures for the use case at hand. We will end up with different architectures, because there is no “one size fits all”.

By the end of our interactive workshop, you’ll walk away with a new set of strategies and tools to convert old, reliable applications into innovative, efficient systems that not only meet today’s demands but also delight their users.

User-Driven Transformation of Legacy Systems

This hands-on workshop will equip you with practical skills to implement your own MCP servers, clients and MCP-enabled knowledge bases, connecting your organizational knowledge to advanced AI models in a controlled, secure manner.

Introduction to Model Context Protocol and its business applications

Core MCP concepts: Server/client architecture, agents, resources, and tool calling

RAG fundamentals and architecture patterns

Hands-on exercises: Building a local MCP server and RAG pipeline

Implementing solutions in AWS Bedrock Knowledge Bases

Preparing for production: Security considerations and optimization strategies

Final exercise: Exposing your Knowledge Bases through your MCP server

Basic Python or JavaScript programming knowledge

Familiarity with AI/ML concepts (helpful but not required)

Laptop with necessary development environment

This training is targeted at developers and people with a medium+ technical skill level and interest for AI.

2 Days

26-27 Jan

Context Is King: Two Days to AI Mastery with MCP & RAG

Unless you’re working in the front end on a daily basis, it’s hard to keep up to date and ensure that your front end is still modern. This hands on workshop covers modern front end fundamentals, enabling you to create a layout and components without the need for any third party code. You learn core accessibility concepts to make your project more accessible without having to write complex code, take shortcuts or deal with browser specific implementations.

Once that is done, we then move on to testing our application, making sure that our accessibility improvements are there, watching for any unintended changes and making sure that the application works as it’s supposed to. Through automated tools that can be implemented as part of a deployment pipeline, to manual tools to check on the fly, there are plenty of options to ensure the front end is being tested as thoroughly as the back end.

After the tests are written, we’ll then integrate them as part of an approval and deployment pipeline. Automating the tests for pull requests, running through GitHub actions and ensuring that code is fully tested before it reaches the production branch of your repo.

Modern Front End Fundamentals

This workshop will teach you everything you need to know to start building distributed systems in .NET and ASP.NET Core and how to combine multiple services to choose the right tool for each use case you might encounter. We will define clear requirements for a system and proceed to build the entire system using all the services and tools you will use to build your own systems later at your company.

Defining the system we need to build with clear requirements

Understanding Monoliths and Microservices

Understanding what “cloud native” means

Implementing observability with OpenTelemetry

Using .NET Aspire to run our system locally

This workshop is for backend developers with some experience writing web applications using C# and ASP.NET Core. You must be able to read, write, and debug C# at a decent level and have some experience with ASP.NET Core.

Visual Studio 2022 or JetBrains Rider or Visual Studio Code with the C# Dev Kit installed

Building scalable, cloud native, distributed systems in .NET

No two classes are the same, with the attendees driving the exact agenda, but expect to cover the nature of synchronous and asynchronous communication, request-response vs event-driven collaboration, and why friends don’t let friends use distributed transactions. Along the way we can talk about the merits of different types of message brokers, why Sam now thinks schemas are cool again, and how event sourcing can be incredibly confusing.

Please note, this is not a coding class, but it is highly interactive. There will be lots of discussion - computing is all about trade offs, and this is especially true in the space of microservice communication. There is no one perfect solution, but by the end of the class you’ll better understand what trade offs might be important to you.

Microservice communication

Introducing the modular monolith; all the benefits of a monolith such as reduced complexity, ease of deployment, easier debugging, and so on - but ready to be easily decomposed into services as required.

Join us as we explore the principles, patterns, and practices that empower developers to build robust, flexible, and extensible applications without prematurely involving the complexities of microservices and distributed systems.

In this workshop, we will use the fictional case study of a thriving business aspiring to expand, exploring key topics, utilising .NET 8 and .NET Aspire..

We'll cover aspects of event-driven architecture, messaging, and various supporting design patterns.

PREREQUISITES: Attendees should be familiar with ASP.NET and C#. Other required concepts will be covered.

NOTE: This is NOT a hands-on workshop. You're welcome to bring laptops and try some of the labs provided or take notes, but it is not required.

If attendees wish to code along, the following will need to be installed on your machine (assistance with setup will be very limited):

- Laptop (Windows PC or macOS)
- Visual Studio 2022 or JetBrains Rider
- VS Code
- Azure Data Studio
- .NET 8 or higher
- Docker Desktop
- Azurite
- .NET Aspire Workload installed

Completed code and documentation will be available at the end of the workshop.

Building future-proof apps with the modular monolith


Some developers know CSS "quite well": grids and flexbox, z-indexes, transitions and filters.

Let's take it to the next level. It's 2026. CSS has functions and variables. We've got first-class support for interactive visual effects using keyframe animations, geometric transformations and view transitions - all offloaded to the GPU so it's lightning-fast and won't interfere with your JavaScript. We've got responsive typography using parameterised fonts, and more composition options and blending modes than Photoshop. We can restyle form inputs, create rich user experiences using focus anchors and validation pseudo-classes - we can even tell if the user's device has one of those little Apple camera island screen things on it.

Dylan Beattie's been building web applications since before CSS was invented, and he's been using CSS in production for nearly thirty years. In this hands-on, interactive workshop, Dylan will show you everything you need to know to make cutting-edge modern CSS a trusted part of your engineering toolkit. We'll spend the day working through fun interactive exercises and demos, you'll go away with working code and demos on your laptop, and then you can go into work next week and replace thousands of lines of pointless JavaScript with lightweight, minimal, elegant CSS.

Wait... CSS Can Do That?

Big Data

Well, it turns out that making all those messages and events work together in meaningful ways is the real challenge, especially considering the continuous changes our system undergoes. We pay a massive amount of effort considering how to design our services, considering where exactly the boundaries of each individual service lie, but what we often see is that as our systems change, interconnections surface where we didn't expect them, contracts change, receivers break, and messages end up in a dead-letter queue nobody looks at. However, if you're in for the long run, what we want to prepare our systems for is to gracefully undergo change, without undoing all the hard work previously done and turning it into a big ball of mud.

If you've moved beyond the basic building blocks of messaging and want to transition your designs from meaningless and often tightly coupled service-to-service calls to carefully designed services that are well prepared to endure change, this workshop is for you.


- Have a foundational understanding of messaging as an architectural style and the benefits it offers.
- Understand the basic message-based communication patterns, including request-reply and publish-subscribe.
- Understand concepts like idempotency, eventual consistency and Outbox.
- Have experience using message brokers such as Azure Service Bus, RabbitMQ, Amazon SQS or other queuing or broker technologies.
Due to the limited time in this workshop, we won't spend any time filling those gaps.

Throughout this workshop, you’ll learn:


- Coupling and how it affects the system we build
- Techniques to help identify the right service boundaries that endure change
- Design techniques to help you protect those boundaries (public vs private)
- Serialization, schemas, and why they matter
- Using CloudEvents to standardize message envelopes
- Using xRegistry to manage your endpoints, messages and schemas



Throughout this workshop, we'll divide into smaller groups for design exercises that require nothing more than your imagination and something to write with. Later, we'll switch gears and get more hands-on with some coding exercises to bring those ideas to life using C#.

Join me and unlock the secrets of messaging's real-world superpowers!

This is a Bring Your Own Device (BYOD) workshop. Therefore, attendees are required to bring their own device with the necessary software already installed:

- .NET 8 or higher
- Visual Studio/Rider/VS Code
- Docker
- Pen and paper

Future-proofing event-driven systems

With the upcoming OAuth 2.1 protocol revision, the protocol has been streamlined and simplified and the specification has been updated to meet modern application and security requirements.

This full day workshop teaches you all the OAuth you need utilizing the most common and practical techniques and libraries in the .NET ecosystem. Besides looking at built-in features of (ASP).NET, we will use popular frameworks like IdentityModel and IdentityServer, and we will learn how to use them to secure native/desktop and web applications as well as SPAs, Blazor WASM applications, APIs and daemons.

OAuth, OpenID Connect & .NET – the Good Parts

In this workshop, we will design APIs with respect to the non-functional requirements that are paramount to any serious application running in production.

This is a hands-on workshop, so be prepared to write code!

We will start by designing an API with all the production-ready quality attributes. Then, we expand the feature set so that, in the end, we have an overview of the steps we have to take to have robust APIs that are reliable and capable of effortlessly managing heavy loads without breaking a sweat.

We delve into the intricacies of REST-based APIs, exploring the client/server nature and the decision-making process behind choosing REST, endpoint naming, and capabilities. This offers a detailed guide to the API design process, documentation, and the most common usage scenarios.

Media-type selection, design & custom media types

In this section, we will address some non-functional requirements that should be mandatory for any serious API running in production

This is a Bring Your Own Device (BYOD) workshop. Therefore, attendees are required to bring their own device with the necessary software already installed:

Need to have Visual Studio, or an IDE you are familiar with

.NET Software developers who want to have a more architecture-focused approach

C# developers who want to understand the patterns and the best practices

At the end of this workshop you will be able to:

understand which APIs are best suited for which scenarios

understand are the non-functional requirements needed for a production-ready APIs

APIs in Practice : the road to production-ready

In this workshop, we will dive deep into how .NET implements asynchronous programming under the hood to become experts using async/await!

Join me as we uncover the ways that the .NET compiler modifies each of our async methods. We'll learn how to build a custom implementation of `Task` from scratch and use it with the built-in async/await keywords. Then we'll dive deep into the .NET source code to understand the importance of internal framework tools like SynchronizationContext, ExecutionContext, Principal, ThreadStatic and more!

Become an Expert with Async/Await in C#

This session aims to equip you with a personal toolbox of scripts and techniques you can rely on when dealing with performance problems. The workflow we’ll use is simple and effective:

How to solve common performance issues reactively

Dealing with resource bottlenecks (I/O, CPU, Memory)

Understanding Wait Stats and query performance

Making sense of statistics and execution plans

Proactively addressing performance issues

Best practices for database file deployments

Using Columnstore Indexes for Large Datasets

At the end of this workshop, you’ll walk away with all the demo scripts, complete with explanations, as well as an actionable checklist to help you diagnose and resolve SQL Server performance issues confidently.

NDC { London }

Workshops

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

Context Is King: Two Days to AI Mastery with MCP & RAG

Aleksander Stensby

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

0 (Zero) to Hero: Essential SQL Server Performance Tuning

Pinal Dave

User-Driven Transformation of Legacy Systems

Nico Vermeir

Become an Expert with Async/Await in C#

Brandon Minnick

Resilient Distributed Systems

Sam Newman

Microservice communication

Sam Newman

The Hitchhiker's Guide to Computer Science

Kevlin Henney

Program with GUTs

Kevlin Henney

Building future-proof apps with the modular monolith

Layla Porter

OAuth, OpenID Connect & .NET – the Good Parts

Roland Guijt

Modern Front End Fundamentals

Amy Kapernick

Wait... CSS Can Do That?

Dylan Beattie

.NET Aspire and Dapr: a microservices match made in heaven

Nico Vermeir

APIs in Practice : the road to production-ready

Irina Dominte

Future-proofing event-driven systems

Laila Bougria