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.

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


• Provide hands-on experience with Azure technologies to secure cloud solutions.
• Explore the paradigm shift towards Zero Trust architecture.
• Emphasize the critical role of identity and networking in building a robust security framework.
• Gain insights into principles of Zero Trust, including continuous verification, least privilege access, and micro-segmentation.
• Integrate identity management systems for secure access.
• Understand the significance of networking in maintaining a resilient security posture.
• Learn actionable strategies to enhance security posture against evolving threats.



This session is an invaluable opportunity for developers, architects, and IT professionals seeking to future-proof their security strategies. Attendees will gain comprehensive knowledge and practical skills to integrate Zero Trust principles, identity management, and advanced networking into their Azure solutions. Through real-world examples and best practices, participants will leave equipped with the tools and methodologies necessary to safeguard their organizations against sophisticated cyber threats. Join us to secure your future with Microsoft’s Secure Future initiative.

Securing Azure: Network Design and Security with Zero Trust

Cloud

Security

Tools

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

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

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

Using this foundational knowledge, we will move into understanding responsible AI (RAI) practices, covering topics like fairness (bias evaluation and mitigation), explainability, and privacy. Attendees will explore actionable strategies to incorporate RAI principles into their workflows, ensuring models are not only functional but also ethical.

Throughout this workshop, we will use hands-on exercises using Python-based tools and provided datasets, with options to work either on personal laptops or hosted environments like Google Colab.

Machine Learning Foundations for Developers

Machine Learning

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

Our systems are filled with business processes that are anything but trivial. They exceed the boundaries of a single method- or service invocation and require us to redefine many concepts, from how we think about the domain entities and how coupling affects our designs to how we handle time-based requirements and the joys of eventual consistency. The true power of event-driven architectures surfaces when we start expressing complex business processes with intention-revealing messages (both commands and events) to reflect what's happening in the real world.

If you've moved beyond the basic building blocks of messaging and want to transition your designs from meaningless and often tightly coupled service-to-service calls to carefully designed processes that reflect your business domain, this workshop is for you.

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.

Understand concepts like idempotency, eventual consistency and Outbox.

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

Throughout this workshop, you’ll learn:

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!

How to deal with the inevitable: change...

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!

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

Miro account, for design exercises (a free account is sufficient)

GitHub, for access to exercises and additional material

Mastering complex event-driven architectures

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

Mastering complex event-driven architectures

Laila Bougria

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

Learn Distributed Systems Through Play

William Brander

Machine Learning Foundations for Developers

Michelle Frost

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

CSS for Engineers

Dylan Beattie

Securing Azure: Network Design and Security with Zero Trust

Anders Lybecker

Building an Event Sourced System in .NET with Marten

Hannes Lowette