20-22 APR 2023

You've signed up for that streaming service, but now you can't unsubscribe. You put a single item in your basket, and somehow there are now also two warranties in there. Boxes of vitamin supplements are piling up every month like a subscription, but you are absolutely sure you only bought one bottle! Not to mention, you bought way too much online. You're sitting on a big pile of stuff you don't really want, and you feel bad about it because now you're way over budget! If you've had something like this happen then you've experienced a dark pattern - which is something software does to trick you into taking an action you wouldn't have otherwise taken. In this talk, you'll learn how to spot these dark patterns. You'll also learn how to avoid them, both when using software as well as when creating it. We'll look at a few physical world examples of dark patterns too.

Achieving performance goals while managing costs through efficient resource allocation can be a difficult task, especially for complex database workloads that have diverse usage patterns. The Azure SQL Database serverless setup offers a viable solution to tackle these challenges. However, previously, serverless was only accessible in the General Purpose tier. Workloads that could benefit from serverless may require increased scale and performance, along with other distinct capabilities exclusive to the Hyperscale tier. But now, the advantages of both serverless and Hyperscale have merged into a single database solution. Let’s see what it’s all about.

Instead, we will be using WebAssembly to achieve a similar result. You might know that .NET can be hosted within WebAssembly - this is how Blazor works in the browser after all! But we can also leverage the strict security model of WebAssembly on the server in order to run isolated .NET code on Windows or other operating systems. Why would we want to do that? Security for once - perhaps we have some user code that we want to execute (think LeetCode), or maybe we need to run some automated tests and we want to guarantee they are completely independent. Another useful scenario could be microservices or serverless computing, where we could deploy .NET binaries in a container with a much smaller footprint and improved performance compared to "traditional" virtualization technologies such as Docker. Join me on this talk to discover more about the exciting potential of this technology and tinker with some experimental C# code along the way.

People love to stay in their comfort zone and do what they've always done. But what if you could take your web applications to the next level just by getting the fundamentals right?

In this .NET 7 demo-rich session, I will show you how to make your applications more testable, maintainable and resilient.
Whether you are working with a monolith or a vast distributed application, the areas we'll cover will be applicable.
Join me and learn about the following topics and more!

- Minimal APIs, top-level statements and good design practise
- Dependency injection and inversion of control
- HTTP clients and policies
- Resiliency and circuit breakers with Polly
- Discovery clients with Steeltoe OSS

Elasticsearch is a leading search and analytics solution used by thousands of companies worldwide for use cases, including search, analytics, monitoring and security information and event management. With an emphasis on speed, scale, and relevance, it's transforming how the world uses data. In this session, we'll learn about leveraging the power of Elasticsearch within .NET applications, utilising the Elasticsearch.NET client library. Join Steve to learn about the .NET client, how to install it in .NET applications and use it to begin indexing and searching documents. This session is aimed at software developers, looking to get started by combining the capabilities of Elasticsearch with their .NET applications. You'll leave with the core knowledge, required to begin using Elasticsearch and the NEST client library.

Teodor will cover the fundamental elements of migrating to the cloud, such as recommended guidelines and potential missteps to steer clear of, along with a discussion on prevalent obstacles and successful tactics to avoid them. Additionally, he'll delve into the primary benefits of leveraging a cloud environment for your solution.

During this session, we'll put our architect hats on and dive into some considerations about upgrading business-proven applications to up-to-date future-proof software. The task may seem easy with all the modern tools that are available nowadays, but the constraints imposed by the business make the decision-making process difficult. It's all about tradeoffs and the potential profits that legacy applications can still bring to the business in modern day fast-paced society. In the end, it's not only the technology that drives the profits up, but also business continuity has a strong input.

.NET is a powerful, comprehensive framework for building all kinds of apps: web, mobile and desktop, cloud, microservices, games, machine learning, and more. We just released .NET 7 in November, and the .NET 8 previews are already rolling out. It's exciting, but sometimes a little overwhelming to keep up with! In this session, you'll get a look at the most important features you can use now, and a look at the top new features being added in .NET 8.

Everyone who has worked with GraphQL knows just how powerful and flexible this API query language is.
The first principle of Principled GraphQL is One Graph – the rule which encourages the implementation of a single graph to maximize the value of GraphQL. We want this ubiquitous API that exposes our business model in a much richer way.

But as our graph grows over time and multiple teams start working on it, we often hit a wall where they need to federate their graph to align its development with their organizational structure. We want to make sure that teams are not blocked in their flows to deliver new features to the customer.

In this talk, we will look at how we can distribute our GraphQL API into sub-graphs and the challenges and advantages that come along with distributed graphs.

We are used to treating coupling as the necessary evil. Hence, we aim to break systems apart into the smallest services possible, in the ever-lasting quest of decoupling everything. But what results are we getting by following this reasoning? — Instead of the promised land of evolvable systems, many such “decouple everything” endeavors lead straight into the chains of distributed monoliths. Can we do better? What if there is a better way to handle coupling in distributed systems? Or even, what if instead of fighting coupling, we can use it as a heuristic for designing systems that are actually evolvable and maintainable? That’s exactly what you will learn in this session: what coupling is, and how you can use it as a design tool. We will start by taking a journey through time, and explore the different models of evaluating coupling. Next, we will combine the existing knowledge into a coherent model — a simple function for evaluating a system’s decomposition into components. This function will allow you to assess the expected effort for evolving a system and use it as a heuristic for optimizing architectural design decisions.

In this session, I will explain why performance testing is important and what can you get from doing it. We will see the differences between Web, Microservice & Monolith APIs as well as mission vs non-mission critical APIs. Also, why Murdering your own API is the best way to make them stronger. All this along the different ways to test their performance, what metrics to check, what to test and how to get it done. Then, we will do it and get our hands dirty! :) - We will implement some tests and run them against some test-ready APIs hosted at K6 and some custom Azure hosted APIs. For this, we will use one of the best tools available for the job of API performance testing (and also API-murdering ) - K6 ( along with some Azure) We will dive from a simple k6 test into a full fledged performance test, where we will see and learn some best practices, that will gets us the results that we want! For this we will combine K6 open source with K6 cloud for visualizing the results in thrilling, effortless, visualizations. After this session you will have learned on the different kinds of APIs and how to approach them in regards to performance testing as well as how to use K6 for getting the job done - along some best practices - all the slides and code will be available for you to try this at home - if you dare! ;)

AI Copilots and Fusion Teams. Have there been any terms more hyped in the past century? What if we brought them TOGETHER? The dream is that AI people, Devs, Makers, IT Pros and Business folks work together to build AI Copilot solutions that do the boring and redundant parts of your jobs for you.

 

You'll learn:

What exactly *is* a fusion team?

What is the best way for a fusion team to work together?

How you build and care for a Fusion Team without drama and culture issues?

What role does everyone play in the AI-verse?

 

Best of all, you'll get a peek at the super-secret Power Platform/Azure Open AI based product our 27 person Fusion Team is building that will shipping in November (don't tell our management, they don’t know yet!)

Logging is a vital part of every application that runs in production. It is in place to tell a story about the lifecycle of its runtime and make it easy for developers to debug a system and identify what failed and how when things go wrong.