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

High Performance .NET Development

.NET

We’ve all seen the “hello world” demos: models, views, controllers, a DbContext, maybe some minimal API endpoints. In this workshop, we’ll go beyond the basics and explore the full potential of C# 12, ASP .NET Core 8, EF Core, and the rich ecosystem of libraries and packages that’s available for building web apps with .NET in 2024.

The workshop is based around “Rockaway”, a .NET web app for selling concert tickets. Our favourite developer-themed rock bands, from Dev Leppard to Mott the Tuple, are going on tour around the world, and we're going to build the platform that'll sell tickets to all their shows. Along the way we’ll encounter dozens of real-world scenarios, from data modelling, to timezones and currencies, to responsive layouts and email delivery. We’ll use asynchronous patterns and channels to build lightning-fast web apps which stay responsive even under heavy load. We’ll look at how to extend the built-in Bootstrap libraries with Blazor and Razor Components to create beautiful, responsive frontend layouts that work seamlessly with 

, and we’ll see how to test our applications at every level, from low-level isolation testing, to end-to-end integration tests which exercise the entire HTTP pipeline.

Principles of web application architecture: areas, services, components and dependencies

 Applications: WebApplicationFactory, Shouldly, AngleSharp

Deploying web apps using Azure and GitHub Actions

Observability with OpenTelemetry and .NET Aspire

Interactive frontends with Blazor and Razor Components

Advanced EF Core: mapping conventions and custom types

Testing database code using EF Core and Sqlite

Globalisation: dates, times and currencies

Async processing with threads and channels

This is a hands-on, interactive workshop: we’ll be sharing code throughout using GitHub and VS LiveShare, you’ll go home with a fully working copy of the sample application, and all the workshop code is published under the MIT license so you can use it for whatever you like. Application code is all built on .NET 8 using C# 12, so we can use new C# language features like primary constructors and collection expressions. You’ll also get to learn about many of my favourite developer tools like zoxide, oh-my-posh, MailTrap, Papercut, Postman, and ngrok: they’re not specific to .NET, but they do make building and testing .NET applications a lot easier.

What people have said about Dylan Beattie’s .NET workshops:

“Everything was great, content, presentation, examples, answers to questions. All clear and understandable.”

“I liked the way the lecturer kept the tempo and captured attention. Everything was well prepared and worked right away or almost right away.”

“I really enjoyed the humour and that Dylan showed personality throughout the workshop.”

“Really great organization and preparation. It shows that you have experience with this kind of workshops.”

This workshop is for developers who already have some experience with 

 Core; you should already be familiar with the model/view/controller patterns, the Razor view engine, and basic data access using Entity Framework. 


Attendees will need a laptop running the .NET 8 SDK, and a code editor such as Visual Studio 2022, JetBrains Rider, or VS Code.

Beyond the Basics: Advanced Web Apps with .NET 8

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

In this workshop you'll get your hands on using OpenTelemetry in a realistic microservice system. You'll be adding the libraries in the applications, Using the "Agents" to instrument applications without code changes, and touching various languages (whatever you're comfortable with) and more.

You'll come out of this workshop understanding:

How to implement OpenTelemetry in your language of choice (and possibly some others)

Auto-instrumentation of OpenTelemetry (where you can't change the code)

What the OpenTelemetry Collector is, when to use it, and how to use it

Finally, we'll cover Querying and using the data we see to find some hidden patterns.

Attendees must bring a laptop, their favourite IDE for the language they want to write in, and a way to run docker-compose (docker-desktop is free for personal use).

Hands On OpenTelemetry

DevOps

Architecture


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 workshop, we'll share some framing for microservice architectures that explore the various forces that can drive the design and evolution of microservices, and then you'll participate in a series of interactive architectural kata exercises to put your newfound knowledge to the test. Afterwards, you'll have a series of tools to take back to your own organisations to put into practice.

Understand what makes a good microservice

Learn how to use concepts from domain-driven design to define service boundaries

Understand how to plan and manage a migration from a monolith to the microservice architecture

Understand how technical choices can impact the architecture itself

Learn about managing change and governance in a microservice environment

This is a participatory workshop. You won't get to just sit there and watch – the more you participate in the workshop, the more you'll get out!

Designing Microservices

Architecture and Design

This is exactly the type of problems the event sourcing pattern tries to solve. If we preserve all the events that led up to the current state, we can replay history and derive the current state from that, but we also open the door for more flexibility in our system.

During this workshop we will explore all the concepts that are associated with event sourcing. We will use C# to implement our own event sourced system over the course of the workshop, so we can see things in practice. Eventually, we will look at a couple of frameworks and libraries that can be useful when you start building your own event sourced system.

During this workshop, you will learn about:

How to build this code in a test-friendly way

Enabling feature development with history applied

To attend this workshop, you should be a developer with:

Working knowledge of the C# programming language

A basic knowledge of how to use a SQL Server database from code

You will spend a lot of time coding during this workshop. I will present concepts for the whole class, which you will then apply in code on your own, or as a group. This workshop will be very hands-on. If you prefer watching slide decks for most of the day, this workshop might not be for you.

Your .NET IDE of choice (Visual Studio or Rider)

A working SQL server instance (LocalDB will do just fine)

Building an event sourced system in C#

Event Sourcing

CQRS

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

NDC { Porto }

Workshops

09:00 - 17:00 (UTC+01)

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

Advanced Software Architecture with Residuality Theory

Barry O'Reilly

Untangle complex business processes with message-based architectures

Laila Bougria

Designing Microservices

Sam Newman

Beyond the Basics: Advanced Web Apps with .NET 8

Dylan Beattie

High Performance .NET Development

That Rendle

Hands On OpenTelemetry

Martin Thwaites

Building an event sourced system in C#

Hannes Lowette