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 an event sourced system over the course of the workshop, so we can see things in practice. Our framework of choice will be Marten, an open-source, production-ready event sourcing framework in .NET.


During this workshop, you will learn about:

• The event sourcing pattern
• Relation between event sourcing and DDD
• Commands, Events, Aggregates, etc.
• Read projections and the CQRS pattern
• Testing command handlers and projections
• Performance-optimizations in the system
• 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 relational databases (Marten uses Postgres)

You will spend some time coding during this workshop. Concepts will be presented for the whole class, which you will then apply in code on your own, or as a group. This workshop will be hands-on. If you prefer watching slide decks for the whole day, this workshop might not be for you.

2 Days

Building an Event Sourced System in .NET with Marten

.NET

Architecture

Database

In this workshop, we'll build an application that embodies the good practices we recommend in OpenTelemetry, and look at how those translate into good observability practices when looking at production applications.



Getting started, through to telemetry curation

Observing Event Driven Architectures (RabbitMQ, Azure ServiceBus, Kafka)

Local Visualisation techniques using .NET Aspire

OpenTelemetry Collector's and where they fit

Naming consistency through OpenTelemetry Weaver

You'll come away with a deep understanding of why Observability is important, how it's changed, and why it's now part of your job not simply an "Ops problem".

Modern Observability for .NET Applications

CSS is one of the fundamental building blocks of the web, and it's not just about making websites look pretty. Layout, accessibility, responsive design, validation, interaction - understanding CSS is vital to creating usable, accessible web and mobile applications. But let's face it - CSS is also weird. No functions, no control flow... in fact, some people say it isn't even a real programming language.

Dylan Beattie's been building web applications since before CSS was invented. (Yes, really.) In this hands-on workshop, he'll show you everything you need to know to make CSS a trusted part of your engineer's toolkit, from fundamental principles like selectors and specificity, to modern web standards like CSS grids, flexbox, variables and transitions. Learn how to build interactive forms and dialogs that work flawlessly on everything from mobile phones to projectors; how to use scoped CSS to target components and subsystems, and how to plan, deploy and test CSS just like you would any other code that's being deployed to production.

CSS for Engineers

We'll start with a working minimal implementation of an escape room with microservice puzzles that follow a typical naive implementation of a "microservice architecture", and see how they fail. From the failures we will see how each of the puzzles can be improved to be made more scalable and fault tolerant. We'll then explore some more advanced distributed systems concepts

Senior developers beginning to take steps into the world of distributed systems

Developers interested in learning IoT basics

Anyone that wants to learn how to make their existing microservices more scalable and fault tolerant

Introducing messaging via Azure Service Bus

What further patterns should attendees learn about

Let's escape! A full play through of our escape room

This will give attendees an overview of the basic patterns of distributed systems enabling attendees to see how to transition their current systems to a better distributed systems architecture. Attendees will also get a basic introduction to IoT devices.

This is a Bring Your Own Device (BYOD) workshop. Therefore, attendees are required to bring their own device with the necessary software already installed:

Recommended: Visual Studio 2022 with the 

The NanoFramework does not work with Jetbrains Rider.

The NanoFramework extenions will not work on 32 bits OSs or ARM platforms.

If you are bringing an ARM CPU machine, then you will have to have access to a cloud VM to do some parts of the workshop development. The bulk of the workshop will work on ARM CPU devices though.

Learn Distributed Systems Through Play

Microservices

Cloud

You will not only learn how to use Entra ID to protect your apps, but also to protect the environment they run in and how to use Entra ID to enforce policies for resource access.




• The basics of OAUTH/OpenID.
• Identity concepts in Entra ID.
• How to integrate your applications with Entra ID and use single-sign-on (SSO).
• How to secure your APIs using Entra ID.
• Several ways of granularly granting permissions to various resources, both by role, application or user.
• What is the difference between an app registration and a service principal?
• Getting rid of passwords and using managed identities.
• Using identity to access Azure resources
• Role-based access control
• Granting access to external collaborators.
• Implementing just-in-time, auditable permissions for protected resources.

There will be hands-on labs you can do on-site and take home with you to reinforce the concepts and techniques you learn.




Developers who want to get a better understanding of how Entra ID works and how to use it to secure their applications and environments.

While the concepts can be used with any language, the workshop examples and labs will be in C# on the .NET platform.

No prior knowledge about Azure Active Directory or identity assumed. Basic programming skills and familiarity with C# are necessary to follow code examples and do the hands-on labs.



To do the labs you will need to bring a computer with the latest .NET SDK and the editor of your choice (for instance Visual Studio, JetBrains Rider or VS Code).

Awesome Azure Authentication Adventures

Security

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

Bring your laptop, because we'll implement many ideas together. 

This workshop encapsulates hard-learned lessons from specializing in React for over a decade.

Advanced React Workshop: Lessons from 10 Years

JavaScript

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 9.




- Where DDD fits in to software delivery and what business problems it addresses
- When to use DDD and when not to use it
- How to craft and enforce a ubiquitous language
- The fundamental modeling building blocks
- 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 9 and EF Core 9

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.

Domain-Driven Design: Theory and Practice

Many developers, data scientists and companies are rushing to adopt and leverage these developments in their business process, products and solutions.

What do I need to consider when developing an LLM based solution?

What is a generative pre-trained transformer, and how does it work?

How can these models be leveraged by application developers to deliver real business value?

In this workshop, you will explore how to leverage the OpenAI and 3rd party models to develop AI enhanced solutions. You will learn options for hosting and consuming different models and develop code and prompts to explore their capabilities. The integration with company knowledgebases to provide a ChatGPT experience tailored to your business requirements will be covered along with the concepts of using prompt engineering to influence the outputs generated by the model.

Hands-on labs using the latest LLM frameworks will be available in C# and Python, ranging from walk-through exercises to advanced challenges and group activities.

Open AI & GPT Workshop

Machine Learning

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

NDC { Copenhagen }

Workshops

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

Open AI & GPT Workshop

Alan Smith

Building Future-Proof Apps with the Modular Monolith

Layla Porter

Building an Event Sourced System in .NET with Marten

Hannes Lowette

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

Learn Distributed Systems Through Play

William Brander

CSS for Engineers

Dylan Beattie

Modern Observability for .NET Applications

Martin Thwaites

Awesome Azure Authentication Adventures

Glenn F. Henriksen

Domain-Driven Design: Theory and Practice

Jimmy Bogard

Advanced React Workshop: Lessons from 10 Years

Cory House