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

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

JavaScript

Agile

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#

.NET

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.


You will need to bring a laptop with .NET 10 SDK installed and an up-to-date Visual Studio or Rider. Visual Studio Code also works.

OAuth, OpenID Connect & .NET – the Good Parts

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 & Azure AI Search

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.


Bring your laptop with your preferred IDE and either Python or Node installed. We recommend an AI-coding agent like Claude Code, Cursor or GitHub Copilot, but not required!

Bring your favorite sauce! You need access to an LLM provider with an embedding model like OpenAI or Azure Foundry, but you can also use Ollama if you would like to 

2 Days

26-27 Jan

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

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

Cloud

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

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

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)

Become an Expert with Async/Await in C#

Brandon Minnick

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

Pinal Dave

OAuth, OpenID Connect & .NET – the Good Parts

Roland Guijt

User-Driven Transformation of Legacy Systems

Nico Vermeir

Modern Front End Fundamentals

Amy Kapernick

Wait... CSS Can Do That?

Dylan Beattie

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

Aleksander Stensby

The Hitchhiker's Guide to Computer Science

Kevlin Henney

Program with GUTs

Kevlin Henney