20-22 OCT 2022

Minimal APIs are the hottest .NET 6 feature and for good reason. They makes it extremely easy to create high performance and scalable APIs without having to deal with any boilerplate code. In this session I will introduce you to the beautiful world of Minimal APIs. I will show you how easy it is to build an API using them, with just a few lines of code, compare it to the "old-fashioned" approach within .NET and explore what that means for the .NET ecosystem and community in general.

In this presentation, we will discuss a few concerns about moving an enterprise from on-premise to cloud.
We will first define the type of system we are addressing and then explore why we are making the shift in the first place.
Following this, we will get right into some infrastructure and application concerns, concluding with what an architect's responsibilities are in this transformation.

Build and release configuration as code has become the de facto way for most continuous build and release solutions on the market today. Most commonly this manifests itself through a custom task-based domain-specific language using YAML or JSON files. But wouldn't it be nice if you instead of using a markup language, could use a proper programming language, with already well-defined and documented control structures, flow statements like for, white, do, etc. This session will step by step go through how you using C# can orchestrate your GitHub Actions build and release pipelines. A pipeline that you can test and debug not only by tedious push and wait for CI to fail/succeed, but also locally using standard developer tools like VS Code with full fidelity inspecting variables, breakpoints, etc. reusing the language skill your team already has, reducing friction and unnecessary context switching. All this made possible using the open-source build orchestration tool Cake.

Over the last couple of years, I have been hired as the software-architect for several development teams with the assignment to build a new cloud-native and event-driven system based on a microservices architecture. .NET was selected as the primary development stack and this turned out to be a great choice. Most systems are still running in production today and fulfill the functional and non-functional requirements that were defined for the them. The session will give an insight into the way .NET was used for implementing DDD, the CQRS pattern and Event Sourcing for storing state. It will cover the rationale behind the choices made and the lessons learned while designing and building this system. The session will cover both concepts as well as code.

What do you need to build a serverless application that can communicate with client devices in realtime? In this session I'll show how to combine Azure Functions, Durable Functions and serverless WebSockets (Ably) to achieve this. The context is a multi-player ADnD style game (with pixel-art of course) running on Azure Static Web Apps. I'll cover: - How the clients interact with HTTP triggered functions in the .NET based Azure Functions back-end. - How Durable Entities are used for the centralized game state. - How serverless WebSockets are used to sync the state to the clients. We will play the game live as well! https://quest.ably.dev/

Blazor is a free and open-source web framework that enables developers to create web apps using C# and HTML. Being a .NET developer as well as a big fan of classic point-and-click adventure games, I’ve ported my Game-a-Tron 4000 adventure game engine to Blazor. In this session I’ll show you the resulting game and how it was implemented using Blazor. We’ll dive deep into Blazor Components and JavaScript interoperability, all while you can feel nostalgic for the good old days when games came on floppy disks and graphics were pixelated!

When you have several repositories for different purposes but also the need to create a consistency between them, it can get demanding to maintain this consistency. As such, we need some mechanisms to maintain this consistency with the most minimum effort required. Join me in this talk where I will propose one such mechanic using NuGet packages. I will present some advantages but also disadvantages to this approach.

So you built your own web app in Blazor WASM. Deployed using Azure Static Web Apps, even added some dynamic content with an Azure Function or two.

But what about making sure that you are you?

Azure Static Web Apps provide simple integration to GitHub, Facebook and Twitter to provide authentication without having to store passwords yourself!

We'll add authentication, look at how to fit this into the developer inner loop with the Static Web App CLI and how to pass the authentication through to your Azure Function!

Finally, we'll look at the flexibility a Standard Tier app provides by swapping out the simple authentication for a custom authentication!

Be it any industry, applications need to talk to each other. So, developers often build bridges – Application Programming Interfaces (API) – to allow one system to communicate to another. Over time, different API architectural styles have been released. Each of them has its own characteristics, patterns of data exchange, pros, and cons. REST, GraphQL and gRPC are three main options when it comes to API development and implementation In my session I will cover what REST, GraphQL, and gRPC are, how APIs can be implemented using each of these, and give you a comparison between them.

Distributed Tracing has been around for a while, but was always quite niche, reserved for the Netflix and Amazon's of the world. With your company likely looking more at Microservices as a path forward to scale and modernisation, you will almost certainly start to think about debugging and monitoring this in production. Luckily, there's a new(ish) project that is here to help, and provide familiar hooks into your applications to get the vital information you need to have confidence in your production environment. We'll walk through what distributed tracing is, how it relates to Observability (o11y), and then run through some examples of how to get started with it in your .NET Core applications. Finally, we'll demo a few different backends for storing and visualizing the data, Jaegar (OpenSource) and Honeycomb.io (Hosted)

Have you considered using an actor model to build an event based CQRS system? Why not? Actors and DDD are a match made in heaven! When developers learn about DDD, they tend to find a way to work the principles into their codebase. After a while, they may end up with some form of event sourcing or CQRS. But often times, the possibilities of using an actor model, such as Akka.NET, are overlooked. In this talk I will show you to all the things you need to know if you want to build such a system using .NET 6 and Akka.NET. Expect to see a lot of code! An elementary knowledge of DDD principles is required to attend this session.

Anyone who worked on a big enterprise project knows memory leaks are like rats in a big hotel. You might not notice when there are few of them, but you always must be on guard in case they overpopulate, break into the kitchen, and poop on everything. Let’s look at the common causes for memory leaks in .NET and how to avoid them.

The Azure, and by extension, Microsoft Technology stack is a powerful suite of tools and services that present an enterprise numerous capabilities and possibilities for internal projects. One of the best parts is that it already comes packaged with a "corporate" responsability ladder: RBAC (Role Based Access Control), making one of the most stress inducing project stages, desiging the authentication and authorization layer of an applicaiton, into a streamlined and simple process. The question then arrises: how do we do authentication and authorization with respect to RBAC in the Azure world? Who has this responsability? The Front-End? Back-End? Both? Neither? Join me on this journey of auth discovery as we go through these options and hopefuly learn from my mistakes on how not to waste hours from your time to design what should be a simple resource-based authorization system.

Among the challenges developers face are naming things, cache invalidation, and off-by-one errors. But the one we never talk about is date logic! Date logic is full of fallacies and challenges that we as developers often hand-wave away, only to be bitten later! In this talk, we will explore and explain some of the more common fallacies and challenges, such as daylight savings, non-standard timezones, and the ever present challenge of presenting back to the user. Along the way, we will discuss how to properly store dates and times in SQL Server, how to leverage the new types in .NET 6, and what to do with browser display. Lastly, we will talk through what to do with systems that already exist and are suffering date and time-related issues.

It seemed like an easy feature to implement, a checkout page to place an order. But this payment gateway has a simple API, so we added that. And this email service provider makes it possible to send an email with one line of code! Finally we can notify downstream systems via a message queue. The code looks simple, 6 little lines of distributed systems code.

But those lines hid a dark secret that we only found after launching. Customers complained they didn't get their email. The back end system wasn't getting updated from our messages. And by far the worst of all, customers complained they saw an error page but still got charged!

Clearly it wasn't as easy as calling a few APIs and shipping, we actually need to worry about those other systems. In this session, we'll look at taking our 6 lines of distributed systems fail, examining the inevitable failures that arise, and possible mitigating scenarios. We'll also look at the coupling our code contains, and the ways we can address it. Finally, we'll refactor towards a truly resilient checkout process that embraces, instead of ignoring, the fallacies of distributed computing.