In day one, you'll see and work with a practical example of going from no code to a deployed feature.

In day two, you'll learn various techniques for keeping an existing code base clean.

This workshop is an in-person, hands-on companion to the book 

Tools and techniques for writing and maintaining a code base that fits in your head.

Developers who have suffered through a few bad projects.

C# code examples are written in a style friendly to developers working in C#, Java, TypeScript, C++, etc. Hands-on exercises are in C# on .NET Core 3.1. You don’t have to be a professional C# developer, but you should at least feel comfortable trying your hand with C#. You can get assistance during exercises, but we will not have time to cover basics of installation, compilation, syntax, and such.

You'll need a development environment that enables you to work with C# on .NET Core 3.1, a Git client, and (for some exercises) SQL Server Express. If on Windows, Visual Studio Community Edition is a great fit. In general, free versions of those application will be sufficient.

2 Days

Code That Fits in Your Head

.NET

Architecture

Once upon a time, software was simple. You built a website, connected it to a database, and you were done. Then customers started asking for APIs, mobile apps, notification emails, realtime chat… Today, cloud hosting lets us build “elastic” systems – websites that automatically scale up to handle demand; message queues and publish/subscribe patterns to handle spikes in traffic and workload without impacting your end users.

If you’re just starting out with distributed systems design, the possibilities can be overwhelming. APIs, message queueing, REST, GraphQL, gRPC… what should you choose, how does it work, how do you get started?

This workshop gives you a hands-on introduction to the most important messaging patterns used in modern application development. Using C# and .NET, we’ll build a series of small example apps and services, wire them together using these patterns, and discuss how – and when – you’d apply the same patterns in your own applications.

HTTP architectural patterns – XMLRPC, REST, GraphQL

HTTP frameworks: WebAPI, NancyFX, ServiceStack

Working with HTTP APIs: testing and tooling

Exercise: building an HTTP API client and server

Message queueing in .NET – Redis, MSMQ, EasyNetQ

Advanced architectural patterns: CQRS, event sourcing

Exercise: building a pub/sub system using .NET

History of RPC on .NET – SOAP, DISCO, WSDL, WCF

Exercise: high-performance architecture using gRPC

Integrating browsers with distributed systems

Exercise: real-time browser notifications using SignalR

This workshop is aimed at developers with some experience writing applications using C# and Microsoft .NET.

Attendees will be writing and running .NET code during the workshop, so will need a computer running Windows, macOS or Linux, and ideally install the Microsoft .NET SDK from https://dotnet.microsoft.com/download.

Exercises can be done in .NET Framework 4.6+ or .NET Core 2.0+

Introduction to Distributed Systems with C# and .NET

There are a lot of questions that come up when you start looking at adopting IaC. And some of them are quite important to answer correctly the first time around, as changing the answer is likely to be both costly and time consuming. The goal of this workshop is to create a way for people who are interested in adopting IaC to get more information about the choices that are involved, and the pros and cons of each option. And not just from a theoretical point of view, but also by being able to get practical experience by trying it out on their own.
We start off with an introduction to the subject in theoretical form. This covers the pros and cons of IaC, and the pre-requisites before you can start adopting it, as well as what to look at when selecting the right tool for the job. Once the theoretical part has been covered, we move into the practical section. Here you get to see some of the tools available and how they compare to each other. We will go through the most popular tools for deploying to Azure. Currently that means Azure CLI, ARM templates, Bicep, Terraform and Pulumi. For each tool, we’ll discuss the pros and cons.
After having seen the comparison between them, it’s up to you to decide which of the tools that seem best suited for your scenario (team, solution etc.). Once you have found your favorite, there are labs for each one of them that allows you to get a better feel for what it is like to work with them. This makes it much easier to make an informed decision about the path you want to choose for your future IaC journey. And a truly informed decision is the best way to set yourself up for success!

Exploring Infrastructure as Code

DevOps

ASP.NET Core 6, gRPC, Protobuf, Visual Studio, .NET CLI, Docker, Kubernetes, services meshes, monitoring, distributed tracing

Day 1: Building gRPC applications in ASP.NET Core

Day 2: Security, Deployment and Observability

Service mesh (using Linkerd as an example)

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

Bring a laptop with the following installed:

Visual Studio 2022 or JetBrains Rider EAP or VS Code

Modern distributed systems with gRPC in ASP.NET Core 6

This 2-day workshop will quickly progress you from Blazor fundamentals through to creating rich interactive UI experiences using the more advanced framework features. The objective of this workshop is that attendees walk away with a solid understanding of the Blazor framework as well as practical experience of building a real application with it.

Leveraging browser APIs and existing JavaScript libraries

This course assumes attendees are familiar with .NET, C# and web technologies such as HTML, CSS and JavaScript. Attendees will also need to bring a laptop with the following:

An IDE such as Visual Studio 2019, Visual Studio for Mac or JetBrains Rider. VS Code can also be used.

Blazor Workshop

If this sounds familiar, then this workshop is for you. We cover both the theory and patterns of Domain-Driven Design, and connect it to code with hands-on examples in .NET 6.

Where DDD fits in to software delivery and what business problems it addresses

How to craft and enforce a ubiquitous language

The role of refactoring in shaping and reshaping our model

How to define bounded contexts and microservices

Realizing a pragmatic implementation with ASP.NET Core 6 and EF Core 6

We spend day 1 on the theory and concepts of DDD and day 2 applying it to a real-world, complex example with hands-on code exercises.

Attendees will need to bring a laptop with the following installed:

Visual Studio 2022 Professional or higher

Domain-Driven Design: Theory and Practice

Microservices

In this tutorial, we will look at why asynchronous messaging is often the preferred solution to the problems of integrating and distributed solution, and look at the implementation of common messaging patterns.

If you have ever been put off moving from 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

The session will be a hands-on introduction and take you from simple messaging scenarios like "Hello World" through to more complex ideas like routing, brokers, and publish-subscribe.

Day 1: Messaging Architectures and Simple Patterns

Day 2: Distributed Systems Advanced Patterns

There will be hands on coding exercises in C#, JavaScript, Python and Go enabling you to implement simple and more complex messaging scenarios.


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

NDC { London }

Workshops

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

Introduction to Distributed Systems with C# and .NET

Dylan Beattie

Exploring Infrastructure as Code

Chris Klug

Jakob Ehn

Modern distributed systems with gRPC in ASP.NET Core 6

Mark Rendle

Practical Messaging

Ian Cooper

Blazor Workshop

Chris Sainty

Domain-Driven Design: Theory and Practice

Jimmy Bogard

Code That Fits in Your Head

Mark Seemann