An Introduction to .NET Aspire

The latest release of .NET includes .NET Aspire. .NET Aspire is a framework from the Microsoft ASP.NET team that simplifies the development, observance, and delivery of distributed applications. Focused on cloud-native, .NET Aspire (currently in preview) supports cloud components, database components, containers, as well as observing, scaffolding, and deploying components automatically. The session will cover creation of a distributed system with a host orchestrator, a Web API and cached web front end. The features and benefits of Aspire will be detailed in the example distributed application.

Domain-Driven Design, Being Ontological

The patterns and practices of Domain-Driven design are very similar to creating an ontology. Ontologies deal with the nature of being. Domain-Driven Design in a way deals with the question “what does it mean to be a part of this domain?”.

This session compares and contrasts Domain-Driven Design and ontologies. It then answers, “How can taking an ontological view of a domain help in successfully gathering accurate needs and expectations of stakeholders to design a system with the domain in mind?” This session also discusses how to translate the information gathered from answering these questions into strategic plans, such as designs and architecture.

How being successful with ontological with domain-driven design, such as tactics and measure will also be covered.

Delivering with Azure DevOps Pipelines

Build pipelines, branch policies, stages, jobs, tasks, oh my! Azure Pipelines is a powerful technology that empowers teams to perform a variety of CI/CD actions.

Azure Pipelines (sometimes called "YAML Pipelines") are very powerful, but YAML can be unforgiving. Geared towards technologists new to but familiar with Azure Pipelines, this session details strategies and tactics for making the most of pipelines.

This session will describe how to clearly understand the desired results of CI/CD guided by the motivation of the solution and target infrastructure. Based on this understanding, strategies for choosing what goes in a pipeline, stage, or job will be detailed. Tactics on what individual pipelines are necessary and how to make the stages and jobs in each pipeline efficient and effective will round out the session. The session will include examples of common actions in CI/CD, and well-established best practices will be introduced and referenced throughout the session.

A Deep Dive into .NET DI: Tales from Implementing ConsoleApplicationBuilder

ConsoleApplicationBuilder is a small package that brings ASP.NET and .NET Worker Services-style application building with a .NET builder pattern and DI support to plain-old console applications. ConsoleApplicationBuilder makes supporting DI and using tried-and-true extensions like logging and configuration (including appsettings and environments) transparent and extensible.
But transparently supporting DI outside of ASP.NET and console Worker Services doesn't come for free.
This session reviews the common application builder patterns in .NET and how they promote and enable DI. It then peeks behind the curtain to show that implementation in ConsoleApplicationBuilder. Additionally, the audience will learn how builders can be extended by detailing ConsoleApplicationBuilder's builder and DI support for System.CommandLine.

Identity Obsession: What is it and Why It Should Be Avoided

Identity Obsession is a code smell that can occur in the context of Domain-Driven Design where entity identities are misinterpreted as always being global identities. This session details how it can happen, how you can recognize it, and the issues that arise and solutions:

- leaking domain model in API responses and separating response model from domain model
- leaking data model in API responses and separating response model from data model
- leaking primary keys in non-aggregate root entities and abstracting data model with Entity Framework
- how everything having global identity affects local identities and what to do about it

Session #H: Naming Things

There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors. This session is about naming things. In software, we need to name classes, methods, properties, libraries, solutions, etc. We also have to give names to variables, parameters, namespaces, interfaces, services, resources, etc. And most of the time, they can't conflict. Sometimes it's easy but sometimes it can be hard. We'll do a quick review of some of the easy guidelines that avoid some (somewhat easy) decisions then look into the things that require names that involve a deeper understanding of context. What the contexts are, their granularity, and how that can alleviate naming issues will be covered. How the types of contexts and their motivation and good compartmentalization make for easier naming will be detailed. We'll leverage some English grammar rules to relegate naming to a code smell—something recognizable with proven solutions. And finally, time permitting, some techniques and ideas to relegate *naming is hard* to problems of the past will be outlined.

Naming is hard, even with existing guidelines. Let's dig deeper to find out why and how to make it easier.