Modularizing the Monolith

The journey into microservices started clean - we had small, independent services that worked great on our local machine. Everything was greenfield and productivity couldn't be higher. Until the production switch flipped and nothing worked in a proper distributed environment.

Something went horribly awry in our microservice megadisaster, but monoliths can ease the pain by removing the distributed nature of our system. However, we don't want to repeat our mistakes of creating a big ball of mud, or a big ball of distributed mud. Enter the modular monolith, an architecture that preserves the beneficial aspects of a single application and the advantages of isolated areas of data and behavior.

In this talk, we'll look at the various patterns of modularizing a monolith. We'll answer such questions as "what even is a Module?", how to draw module boundaries, and evolutionary design techniques to migrate an existing monolith. Finally, we'll look at techniques to extract modules into services, giving the best possible chance for a microservice architecture to thrive.

The Long Lost Art of Refactoring

The architecture was planned perfectly for the new system. All code would fit neatly into a slice and a layer. Sure this time we would not fall back into a big ball of mud! Fast forward some time, and we still ended up with (smaller) balls of mud. The developers are still complaining that the code is confusing, hard to understand, and hard to maintain. What went wrong?

In this session we'll rediscover the long lost art of recognizing code smells and applying various refactoring techniques. We'll also look at more complex refactorings that leverage modern tools such as generics and dependency injection. Finally, we'll see how to balance up-front design with emergent design to avoid big balls of mud over the lifetime of a system.

Tales from the .NET 8 Migration Trenches

It’s served its users well, but now our .NET 4.8 app is looking a bit long in the tooth. Although technically still supported, the framework as a whole is at a dead end. It’s time to modernize, but that doesn’t mean rewrite.

In this talk, I’ll walk through migrating a typical enterprise .NET 4.8 web app from soup to nuts. We’ll look at tools and techniques for migrating features and components incrementally (and still deploying to production). I’ll also highlight some of the newer analyzers to see what we can easily migrate, adapt, or replace. We’ll look at many of the common dependencies and components most systems incorporate, such as Entity Framework, SignalR, and DI containers, and how to modernize and migrate those components. There may even be Web Forms!

Migrating to modern frameworks can seem daunting, but luckily for us, we can do so in a safe, deliberate approach that I will walk through in a real-world example.

From SQL to Azure Cosmos DB

We've built on relational databases for decades, and even used SQL databases in the cloud. But the relational model, as flexible as it is, cannot model every modern scenario we see in our applications. With Cosmos DB, we finally have many kinds of NoSQL database at our disposal, all under one umbrella. Key-value, columnar, document, and graphs, we have many more options to build on.

But with all these options, how do are systems change? How do we model differently? How does our application need to change? And finally, how do our domain models change?

In this session, we'll look at modeling techniques for the NoSQL document DB models in Cosmos DB, and how we can move from the familiar confines of our SQL world into modeling via documents. We'll also look at the tradeoffs and how we can work with the change in transactional, querying, and usage models of Cosmos DB.

Vertical Slice Architecture

Moving from a layered architecture to a vertical slice architecture can be a bit daunting. We remove abstractions, complex structures, and focus building on the axis of change, then what's next? What new structures, patterns, and policies will need to be introduced in this style of architecture? How will we deal with common business functionality, and where do concepts like CQRS and DDD fit in?

In this session, we'll introduce the idea of vertical slice architectures, and dive into the patterns, tools, and techniques used with slices. We'll also cover how you can fit vertical slices into different kinds of systems, from desktop, SPA, and normal MVC applications. Finally, we'll look at some of the new challenges that come with slices and layers, and how a different approach provides a much more maintainable end result.

Splitting the Monolith

Convincing management seemed easy, but now we have to deliver. Take the years old legacy system and break it apart into smaller services we can actually maintain.

But where to start? In this session, we’ll look at strategies to bust apart the monolith, from the front end to the back. We’ll also look at database refactoring techniques to help us keep our risk down. Finally, we’ll look at analysis tools to guide our way through the tangled dependencies of legacy code to help us deliver new systems without breaking the old.

Life Beyond Distributed Transactions: An Apostate's Implementation

Over a decade ago, Pat Helland authored his paper, "Life Beyond Distributed Transactions: An Apostate's Opinion" describing a means to coordinate activities between entities in databases when a transaction encompassing those entities wasn't feasible or possible. While the paper and subsequent talks provided great insight in the challenges of coordinating activities across entities in a single database, implementations were left as an exercise to the reader!

Fast forward to today, and now we have NoSQL databases, microservices, message queues and brokers, HTTP web services and more that don't (and shouldn't) support any kind of distributed transaction.

In this session, we'll look at how to implement coordination between non-transactional resources using Pat's paper as a guide, with examples in Azure Cosmos DB, Azure Service Bus, and Azure SQL Server. We'll look at a real-world example where a codebase assumed everything would be transactional and always succeed, but production proved us wrong! Finally, we'll look at advanced coordination workflows such as Sagas to achieve robust, scalable coordination across the enterprise.

The DDD Do-Over

It was our first multi-year project as a young consulting company, and while we all had experience building projects using DDD, it was our first major effort as a team. It was also our client's first DDD project, as well as their first Agile project. With all of these firsts, we were determined to do things by the book. We debated endlessly the different ways of implementing the DDD patterns, consulted the experts, and even became experts in our own right.

We shipped, and our clients were happy, but we were not entirely pleased with the results. It wasn't until years later we understood what we had created - a Monolith!

A few years later, we got the opportunity to embark on a new multi-year effort in a nearly identical domain with nearly identical constraints. In this talk, we'll explore where we went wrong in the first project and how we righted our wrongs in the second, using concepts and techniques from both DDD and microservices, to a solution that we could finally say we were completely happy with.

Compositional UIs - the Microservices Last Mile

A key tenet of microservice architecture is autonomy. This is all well and good when the business users dutifully follow Conway's law and rarely if ever use multiple applications from multiple services. But it can get worse, much worse, where we have a single application needing to expose information and capabilities through a single, consistent window. But those that do not learn history are doomed to repeat it, and we certainly do not want to repeat the same mistakes that felled SOA.

In this session, we'll look at the common reasons why we need to build composite applications, and some of the ways we can avoid doing so. As we continue, we'll look at integration patterns from a number of tiers, from the database up to the UI, examining patterns, techniques, and frameworks that close the last mile of microservices to build a maintainable, autotonomy-embracing compositional UI.

Fixing Distributed Systems Fail

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.

Effective Microservice Communication and Conversation Patterns

Orchestration or choreography? Sagas or process manager? REST, RPC, or events? Are we just making this all up as we go along?

Microservices introduce major complexities the moment we move away from a single service and process to multiple ones. Immediately, the problem hits: services have to communicate. The architect mandates REST. But nothing works in production. Then come events. But nothing is ever completed. So now what?

Let’s look at the problem holistically: We want to uphold the fundamental autonomy of any microservice-based architecture while designing a communication strategy that enables services to achieve their purpose in the world.

That’s where patterns come in. In this talk, we’ll look at some basic communication patterns, see where we might run into problems and how advanced conversational patterns can help. We’ll walk you through some real-world scenarios to demonstrate how complex coordination and conversation patterns can get services communicating effectively while retaining our all-important autonomy and loose coupling.

Messaging with Metaphors

So you've decided to try messaging. You've built distributed systems before - everyone's called a web service, right? You've looked at RabbitMQ, Azure Service Bus or Amazon SQS.

But where do these technologies fit in? How will working with asynchronous, durable messages change the way you build applications? And most importantly, what about the UI?

Luckily for us, messaging is a problem already solved centuries ago. It's just up to us as developers to use real-world metaphors to guide the building of our systems. In this session, we'll look at telephones, postcards, magazines and more to see how messaging patterns perfected with human interaction can be leveraged in messaging systems.

We'll also look at complex processes and how organizations large and small can collaborate on complex tasks, and how we can model them in our systems.. Finally, we'll see where messaging sits in the overall space of distributed systems, where it fits and where it doesn't, just like we as humans have evolved our communication over the millennia.

Domain-Driven Refactoring

Books, workshops, storming and more, all build up an idealized domain model. All describe great techniques for domain-driven greenfield applications. But what about the code we have? How can we take what's already built, and move it towards a better, more cohesive design?

In this session, we'll look at anemic, procedural, boring code and examine code smells that can point us in the right direction. We'll also look at standard design patterns for more complex behaviors and models, and how to recognize when (and when not) to apply them. Finally, we'll cover how to safely apply refactoring techniques to achieve our domain-driven model nirvana.

Distributed Tracing Made Easy with .NET 7

When something goes wrong in a single application, we get a nice stack trace. In a distributed system, we get almost nothing! We add some logging, but now we have to comb through logs to understand what led to failures.

Enter distributed tracing, which provides a true end-to-end view of an operation in our system.

In this talk, we'll look at the new diagnostics capabilities in .NET 5, and how we can leverage them to expose and propagate tracing data. We'll look at new standards that help us avoid vendor lock-in for tracing. Finally, we'll look at the OpenTelemetry project and how we can leverage it to target any tracing tool with ease.

Demystifying Web API Security in Azure

Building APIs can be easy, but securing them is hard. We have external and internal applications, APIs, users, and more. Each might use a different authentication and authorization strategy, depending on customer and system needs. The stakes are high and there is no margin for error!

In this talk, we’ll look at the different categories of applications and users, and what possibilities we have for securing them. We’ll also look at what Azure provides for securing internal users and applications, and an external provider such as Auth0 for external users and applications. We’ll also cover different authentication and authorization strategies, and how we can map these to our various communication scenarios.

Finally, we’ll look at a full end-to-end example using .NET 5 and Azure, building out a playbook for the common and not-so-common scenarios we encounter.

Domain-Driven Design: Theory and Practice

Understand the concepts of DDD but feeling overwhelmed to implement? Feeling overwhelmed by complex examples and can't connect how to implement DDD in your project? Looking for more concrete guidance on the concepts and principles of DDD and want to learn how to connect it to real-world code?

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

In this workshop, you'll learn:

- 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 6 and EF Core 6

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.

Consistency and Agreements in Distributed Systems

In a monolith, achieving consistency is easy - just use a transaction! In a distributed world, where we mix legacy and greenfield, getting systems to agree becomes quite a bit more complex. We have different databases, different communication methods, caches, and more. How can we get anything to agree on the state of anything?

Building reliable communication and agreements between systems is possible - but it requires careful design and application of well-established patterns.

In this session, we'll look at how to implement various consistency and transactional patterns, to support both real-time and async updates. We'll dive in to the inbox and outbox patterns to support transactional messaging. We'll also look at long-running transaction patterns such as sagas and process managers to manage agreements between systems. Finally, we'll look at a full working example that crosses databases, APIs, messaging, and more.

Tales from the Azure Migration Trenches

Creating new systems and applications in the cloud can be a breeze. Most of us, however, live in the realities of an on-premise brownfield world. But now management wants to move to Azure, without losing data, and without disrupting users.

In this talk, I’ll share experiences of moving existing, live systems to Azure, with zero data loss and minimum to zero downtime. I’ll walk through analyzing existing applications and infrastructure, and how to decide whether to re-platform for PaaS or simply lift-and-shift.

We’ll also look at build and deployment scenarios to make sure we don’t have to stop all new development for our cloud migration. Finally, we’ll walk through a real-world, on-premise system and migrate it to Azure, live!