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 

 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 

 Core. You must be able to read, write, and debug C# at a decent level and have some experience with 

Visual Studio, JetBrains Rider or VS Code

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 an API with respect to the non-functional requirements that are paramount to any serious application running in production. For this, we will use .NET 8.

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

By the end of the workshop, you will know how to enforce architectural decisions and what it means to have an API that is evolvable, reliable and ready to scale.


- Why API design matters
- How we address the NFRs


- Modular design
- What makes a good API


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.   
- Http methods
- Http status codes
- Http headers
- Endpoint naming
- Media-type selection, design & custom media types
- Caching & Conditional caching
- Input & Output formatters
- Generating clients with SwaggerGen


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 cover the concept of a Query-Based API and we explore OData and GraphQL


In this section we learn the messaging fundamentals and we deep dive into a new world that covers queues, topics, message brokers and different tools. While we are here we will have a look at what AWS and Azure has to offer in order to understand what to use.


Part 3 - Addressing non-functional requirements


- What are NFRs and why should we care?
- Designing for change
- Reliability
- Performance, Optimization and Scalability
- Observability
- Documenting the APIs
- Testing the APIs
- Protecting the API
- Maintainability


- Difference between APIs and microservices.
- Challenges
- Evolutionary architectures


- Moving from a monolith to a microservice architecture
- Identifying business capabilities
- Balance and quality attributes
- Tradeoffs


The workshop targets .NET Software developers that want to have a more architecture-focused view over designing APIs or simply 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 are the non-functional requirements needed for APIs
- Design and build APIs that are ready for production
- Address the most important “ilities” of any API

Please bring your laptop with the following installed:
-Visual studio or preffered IDE 
-.NET 8 SDK 
-SQL Server with SQL management studio (or a tool that can access databases) Or docker with a sql server image and RabbitMQ RabbitMQ

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

These business processes are usually non-trivial, exceed the boundaries of a single method- or service invocation, and require us to redefine certain concepts, including coupling and time.

If you've been exposed to the basic building blocks of messaging and want to transition your system from a collection of meaningless and often highly-coupled service-to-service calls to one composed of carefully designed processes that reflect your business domain, this workshop is for you. Throughout this workshop, we'll discuss numerous real-world scenarios based on years of experience in the banking and retail domains, making you better equipped to recognize patterns in whichever domain you may be working on.


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.

Have experience using message brokers, such as Azure Service Bus, RabbitMQ, or other queuing or broker technologies.


Throughout this workshop, you’ll learn to:

How to identify complex business processes within your domain

Techniques to help identify the right service boundaries

Coordinate complex business processes with orchestration and choreography

Engage in thorough tradeoff analysis to get to the right design

Manage requirements that need to occur at different points in time

Test complex, long-running processes in an automated way

Leverage observability to troubleshoot issues where they matter most: in production!

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:

In addition, it's helpful to have accounts ready to use for:

Microsoft, so that you can access the Azure portal

GitHub, for access to exercises and additional material

Untangle complex business processes with message-based architectures

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 presentation. 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 - presenters, 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.

Introductions. 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!)

NDC { London }

Workshops

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

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

High Performance .NET Development

That Rendle

Untangle complex business processes with message-based architectures

Laila Bougria

Domain Modeling Made Functional

Scott Wlaschin

Building Future-Proof Apps with the Modular Monolith

Layla Porter

Reliable Messaging in Azure

Daniel Marbach

Practical Messaging

Ian Cooper

Advanced Software Architecture with Residuality Theory

Barry O'Reilly

Designing APIs

Irina Dominte (Scurtu)

Public Speaking: From Keyboard to Keynote

Dylan Beattie

The Architect Elevator: Visiting the Upper Floors

Gregor Hohpe

Building AI-powered applications with .NET

Steve Sanderson

Diego Colombo