Writing code with performance in mind makes your application more responsive for users, and can lower hosting costs for cloud-based deployments.

Load testing for APIs and web applications

Patterns and framework features for writing efficient C# code

Making performance testing part of your CI/CD pipeline


Attendees will be expected to be familiar with .NET and C#.

2 Days

27-28 Jan

High Performance .NET Development

.NET

This will be a hands-on workshop designed for beginners in functional programming. We'll do lots of domain modeling exercises starting with some simple models and then enhancing them with constraints, state machines, error handling, commands and events, and so on.

The core concepts of functional programming and how they can be applied to Domain Driven Design

How to represent the nouns and verbs of a domain (e.g. the ubiquitous language) using types.

Why representing the domain model using types is better than UML or other documentation (hint: it can never get out of sync)

How to capture constraints and business rules in the domain model itself instead of being buried in the implementation

How to treat errors as a part of the domain

How to build a complete business workflow from smaller components using composition

How to design a functional architecture with bounded contexts, validation, I/O and on.

At the end of the workshop you'll know how to accurately represent a rich domain using some simple code which can then be used as the starting point for an implementation

Domain Modeling Made Functional

Functional Programming

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

This highly interactive workshop upgrades IT architects and senior developers to play a more impactful role across their organization. They will learn how to forge a crucial connection between the IT engine room and the organization’s leadership by tackling complexity, more effectively communicating with senior management, and influencing the organization's operating model.


Learning about disruption from Silicon Valley

Participants will vote, discuss, debate, draw, and present in small groups. No preparation is required except for an open mind and interest in group work.


This workshop targets senior developers, architects, technical product managers, or tech leads who are looking to build a tighter linkage between their technical work and the organization's strategy. We assume participants already have a solid technical foundation, and now it's time to help them reach the "upper floors".


The Architect Elevator: Visiting the Upper Floors

Architecture

For .NET developers, there’s a whole raft of new libraries, services, models, and concepts to get your teeth into. This workshop aims to cut through the complexity and focus on what you really need to know to get started with AI programming on .NET. It will emphasize foundational topics in .NET+AI, including the new Microsoft.Extensions.AI standards, then go onto the next level of understanding of real-world production AI systems.

, semantic search, vector databases, vector indexing

, chat, function calling, structured output, middleware pipelines

: Ingestion/chunking, retrieval-augmented-generation, evaluation

In each case we’ll have explanations/demos plus guided exercises in C#, some being open-ended for more advanced exploration. We hope what you’ll get out of it is a broad understanding of current-day AI+.NET app development, and a sense that you’ve experienced most of the main pieces


Familiarity with C# and typical .NET application patterns, such as dependency injection

You don’t need to know web programming with ASP.NET Core or Blazor in any significant detail, though one or two exercises will use them. Mostly we’ll work in console apps to preserve focus on AI.


You’ll need a Windows/Linux/macOS laptop with:

.NET 9 – whatever the latest preview is

An editor – either Visual Studio, VS Code, or Rider

 (and while you’re on a fast network at home, run “ollama pull llama3.1” because that’s a 4.7GB download)

deployment. It’s not strictly required since you can just use Ollama, but OpenAI/AzureOpenAI will be much faster – especially if your laptop doesn’t have a good GPU. And you’ll learn more if you can compare small models on Ollama with the big ones like GPT 4o.

Building AI-powered applications with .NET

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

We will cover the design process of several API types, including REST, and then we will transition towards messaging, always with an eye on the Cloud.

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 to effortlessly manage heavy loads without breaking a sweat.

By the end of the workshop, you will know how you can evolve your architecture from simple to complex that has the most sought-after quality attributes, from RESTful to messaging-based. We will deep dive into a new world that covers queues, topics, brokers, different abstractions, and patterns like outboxes or sagas specific to distributed systems.

We will see what the usual steps are to do that and what transformations we have to make in our architecture to accommodate everything.

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


In this section we delve into intricacies of REST-based APIs, the client/server nature of it and we explore the decision-making process behind choosing REST, by offering a detailed guide to the API design process, documenting and the most common usage scenarios.

Media-type selection, design & custom media types


This section we cover gRPC and we outline the RPC API design process. We start by exposing and defining operations, particularities of consuming these APIs and document them. This succinctly summarizes the key components covered in this part, providing an overview of the gRPC protocol, considerations for RPC, and the step-by-step process for designing RPC APIs.


In this section we take our previously designed API, and we start doing the necessary changes to make use of asynchronous messaging.

We deep dive into a new world that covers queues, topics, message brokers, different abstraction and patterns and we will see what changes are needed to adapt our previous architecture.

In this section we will see how we can introduce patterns like Outbox, Competing consumers, Sagas, Routing Slips and learn what we gain from using them, as well as looking at how we can monitor our system.

Versioning strategies for backwards and forward compatibility

Performance, Optimization and Scalability  


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

RabbitMq installed as standalone instance or we will install it in Docker

The workshop targets .NET Software developers that want to have a more architecture-focused approach

C# developers that want to understand what are the communication patterns, and the best practices for APIs in distributed architectures.

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

understand which APIs are best suited for which scenarios

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

evolve a ‘traditional’ architecture to a more complex one that uses asynchronous messaging

Understand what asynchronous messaging brings to the table and where it can benefit our distributed systems

Designing APIs


This workshop teaches advanced, cutting edge techniques based on ongoing research that are designed to identify and decrease risk, improve confidence in decision making and protect your architecture when the domain is characterized by uncertainty.

The workshop introduces ideas on the philosophy of architecture, forcing participants to think outside of the technology and relate decision making to markets, culture, economic and societal concerns. It teaches practical techniques in stressor analysis and the use of matrices to make component decisions and gives participants the chance to work with these techniques in labs and groups.


This workshop is suitable for senior developers who want a head start into the world of architecture, for teams embarking on large, risk filled projects, and for seasoned architects seeking new techniques. It has also been successful in unting teams around a common definition of architecture.

Concrete Complexity for Software Engineering

Modelling stress: socio-economic architecture

Contagion analysis and component decisions


Good understanding of software design. A laptop with Excel will be necessary.

Advanced Software Architecture with Residuality Theory

Microservices

Soft Skills

In this tutorial, we will look at distributed systems, such as microservices, and how we integrate them. We will understand why we would prefer to messaging, the fundamentals and key concepts of messaging and how to build an event driven architecture. If you have ever been put off moving from HTTP or RPC-based solutions to messaging because of the need to learn how to implement messaging-based solutions, this workshop will get you started. if you have been using messaging but want to gain a firmer understanding of how to build event driven architectures, this workshop will help you understand how to succeed with reactive approaches.



The material is presented in four parts: integrating distributed systems, an introduction to messaging (hands-on exercises), advanced messaging, and event driven architectures.

Hands-on exercises are offered in C#, JavaScript, Python and Go.



Messaging Architectures and Simple Patterns

Insights from Paper Offices and Flow-Based Programming

Commands or Event? Orchestration and Choreography.


We will use Rabbit MQ for examples. You need not have the latter installed on your machine, but you should have Docker installed on your machine, as exercises will use Docker Compose.

This is a Bring Your Own Device (BYOD) course. At BYOD courses delegates are required to bring their own laptop with the necessary software installed.

The exercises are self-paced and you will find it helpful to have headphones to listen to the material that accompanies each exercise (though scripts are provided for those who cannot use headphones).

Practical Messaging

DevOps

Python

First, we start with Azure Queue Storage-a basic, cost-effective, and durable message queue that enables effective decoupling of components, increases resilience, and supports scalability scenarios.

After getting our feet wet with this no-frills queuing technology, we dive deep into feature-rich Azure Service Bus. This service is replete with all the bells and whistles needed to build robust and reliable applications leveraging the publish/subscribe pattern.

We also take a peek into Azure Event Hubs, which supports streaming millions of events per second to build real-time data ingestion services.

We end the day by learning how to leverage the power of Azure Event Grid to combine various messaging services in order to take advantage of their potential without the need for polling.

After this workshop, you will be armed with a solid foundational understanding of Azure messaging service offerings and will be able to identify which one is appropriate for your needs. Furthermore, you will walk away with the benefits of practical experience coding against those services, jump-starting your career building reliable messaging solutions in Azure.

This is a Bring Your Own Device (BYOD) course. At BYOD courses, attendees are required to bring their own laptop with the necessary software already installed. To use Azure messaging services, you'll need a subscription (*). If you do not have an existing Azure account, you may sign up for a free trial (

) or use your Visual Studio Subscription (

https://visualstudio.microsoft.com/subscriptions/


(*) Some Azure resources may be created and provided to attendees with connection strings on a limited basis.

Reliable Messaging in Azure

Cloud

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.

We'll investigate the different requirements that need to be met, starting with a code kata and how we can apply various design patterns to our way of thinking.

We'll then move on to actually building out a functioning, all-be-it, contrived application in .NET 8 and C#, learning as we go.

Modular Design Principles: Learn how to break down your application into cohesive modules that encapsulate distinct functionalities, promoting code reuse and easier maintenance.

Dependency Management: Discover techniques for managing dependencies between modules, ensuring clear boundaries and minimising tight coupling.

Scalable Architecture: Explore strategies for designing monoliths that can scale vertically and horizontally to accommodate growing demands.

Architecture enforcement: Dive into architecture testing and other approaches that help with maintaining the architecture and design.

Performance Optimization: Gain insights into optimizing module communication and data flow to enhance the overall performance of your application.

Future Migration Considerations: Explore how modular monoliths can serve as a stepping stone towards a microservices architecture, and the factors to consider when planning a future migration.

Reverse migration: Understand the considerations and techniques for reverse migration from distributed system back to a monolithic architecture.

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


This workshop is aimed at backend developers with some experience writing web applications using C# and .NET. The workshop will not cover .NET Framework.


This is a hands-on practical workshop where you will be writing a lot of code. You will need to have the following to effectively participate:

SQL Server 2017 or later, with SQL Server Management Studio or Azure Data Studio

Building Future-Proof Apps with the Modular Monolith 

Speaking in front of an audience, whether in person or online, can be daunting – but it doesn’t have to be.

Dylan Beattie has delivered keynote presentations at conferences all over the world: NDC, JFokus, BuildStuff, DotNext, YOW!, and many more. In this 2-day workshop, Dylan will teach you everything he knows about how to create and deliver great presentations for technical audiences, whether you’re speaking at industry conferences, doing a talk at your local meetup group, or just sharing ideas with your own team.

On day 1, we’ll focus on structure and stagecraft. You’ll learn how to design a talk - yes, great presentation don’t just magically appear out of nowhere. Like any other product, success starts with design. Gather ideas, create a structure, figure out what works. You need to understand your constraints: format, time limits, what kind of audience you’ll be speaking to. You need to understand the tools you can use: language, storytelling, humour, rhetoric. We’ll learn about how to rehearse effectively: how do you actually make sure you’re getting better each time, instead of just repeating the same mistakes over and over? Even seasoned presenters get nervous before a talk - so how do you deal with nerves?

We’ll look at some examples of great – and not-so-great – presentations, figure out what makes them work, and talk about what we can do to incorporate those ideas and techniques into our own presentations. Then we’ll put what we’ve learned into action: everybody in the group will prepare and present a short talk – just words, no slides – on a topic of their choice.

On day 2, we’ll concentrate on visual material – slides, multimedia, and live demos. We’ll look at techniques you can use to make your presentations clear, accessible and engaging, and how to use images, animation and photography to support and reinforce the points you’re making in your presentation. We’ll look at tips for presenting code, the challenges of doing live demos, and how to use screen recording and video editing to take your live code presentations to the next level.

Then on the afternoon of day 2, everybody will prepare and deliver another short presentation – this time using slides, multimedia and/or live demos, depending on their choice of topic.

Introduction: Who is everybody? What are you all hoping to get out of this workshop?

Collecting ideas, brainstorming, structures

Classic talk structures – the narrative, the ‘top ten’ list, the three-act play

Pacing and timing – how do you know how much content to prepare?

How to present diagrams and technical detail

Working with videos and screen recordings

How to prepare for the things you can’t prepare for

Preparation timelines and coping mechanisms

Speaker horror stories (and why they weren’t that bad after all!)

This workshop is suitable for anybody who is looking to begin public speaking, or to improve their presentation technique.

Around 25% of the workshop is specifically focused on presenting software code and technology; the rest of the workshop is applicable to presentations on any topic and to any kind of audience.

Attendees will need a laptop and a presentation tool. I recommend Microsoft PowerPoint – most examples are presented in PowerPoint, and the course includes some specific discussion around using PowerPoint for creating animation effects and slide transitions – but for the attendee presentations element of the workshop, Keynote or a web-based solution will work just fine.

NDC { London }

Workshops

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

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

Designing APIs

Irina Dominte

Public Speaking: From Keyboard to Keynote

Dylan Beattie

Reliable Messaging in Azure

Daniel Marbach

Domain Modeling Made Functional

Scott Wlaschin

High Performance .NET Development

Rendle .

The Architect Elevator: Visiting the Upper Floors

Gregor Hohpe

Building AI-powered applications with .NET

Steve Sanderson

Diego Colombo

Building Future-Proof Apps with the Modular Monolith

Layla Porter

Practical Messaging

Ian Cooper

Advanced Software Architecture with Residuality Theory

Barry O'Reilly