Sponsor: Do you build complex software systems? See how NServiceBus makes it easier to design, build, and manage software systems that use message queues to achieve loose coupling. Get started for free.

Which Software Architecture Patterns do you use?

What software architecture patterns do you use? If I asked this question, what would be your answer? I’d probably get a lot of responses that say Clean Architecture, and some people would say Microservices or a Monolith. But really, your software architecture is usually unique. In this video, I will cover how you buffet architecture to mix and match different architectural styles that fit together to make your specific architecture.

YouTube

Check out my YouTube channel, where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Architectural Styles & Patterns

When you think of going to a buffet-style restaurant, you have all these different types of food available, and you likely pick a few different dishes to make your plate. The same is true with your software architecture. It’s not a single architecture but a composition of different architectural styles and patterns.

Here’s a menu of the most popular/familiar options. What are your needs and what are you choosing?

Software Architecture Patterns

Maybe you’re using a microservices architecture because of organizational concerns and the need for independently deployable and scalable services. You also have a lot of complex domain logic and you want to apply a clean architecture to manage coupling.

Software Architecture Patterns Microservices

Or perhaps you’re creating a monolith with well-defined logical boundaries. You’re using an event-driven architecture to handle asynchronous workflows between logical boundaries. Some logical boundaries might be using a clean architecture and also focusing on features, and using a vertical slice architecture as way to organize code.

Software Architecture Patterns Monolith

Monolith

That last example might be unfamiliar to some. You can have a monolith that isn’t a big ball of mud. It can be a combination of software architecture patterns. As mentioned, you can define explicit boundaries and loosely couple between them. Because not all boundaries have the same domain complexity, they might not all need to be organized the same way. Some might use vertical slices, and others might be more CRUD driven.

Loosely Coupled Monolith

I refer to this combination of architectural patterns as the Loosely Coupled Monolith.

Instead of coupling between types or making calls in-process between logical boundaries, you’re communicating via events. Your monolith is the producer and consumer of events.

One logical boundary can produce an event and send it to a topic on the broker when a particular business event occurs.

Producer

Other logical boundaries within the monolith can consume and react to that event asynchronously. This might be a part of a business process or used for communication.

Consumer

4+1 Architectural View Model

It’s important to remember there are different ways to look at your system. The 4+1 architectural view model illustrates this.

4+1 Architectural View Model

The fallacy in the current industry is thinking a logical view and a physical view are always the same.

Meaning a logical boundary (or service) must be independently deployable. This is not the case. Physical boundaries aren’t logical boundaries.

In my monolith example, multiple logical boundaries are hosted within the same process (physical). There are advantages and also disadvantages to this. But the point is they don’t have to be the same. They don’t need to be one-to-one.

This is important because if you’re loosely coupling between boundaries, then you could decide to host them all together (physical), or you may decide to carve off a logical boundary and deploy it independently.

Logical vs Physical Boundaries

Logical boundaries are also important because they aren’t all created equally. Not every logical boundary will have the same value to the overall system. Some boundaries might be the core of your domain and contain a lot of complexity. Other boundaries might be simpler with no actual domain logic and can be purely CRUD-driven. These are often more in a supporting role. Defining logical boundaries allows us to understand how we want to handle coupling and cohesion within a single boundary.

Logical Boundaries

In one boundary, we might use a vertical slice architecture with a more task-based UI that uses event sourcing and an event store. Another logical boundary might use an entirely different way of persisting state.

Mix and Match

When someone asks you what software architecture patterns you use, your answer likely is a mix and match of different architectural styles and patterns that make it unique based on your requirements.

I hear people shouting: “Just make it simple. Adding all these architectural patterns make things overly complex!”.

I’m not advocating making a heaping plate of architectural patterns for no reason! Be pragmatic and understand your needs. What is often perceived as “simplicity” can also lead to complexity, typically by forcing all use cases into the same mold and not adopting the approach that fits best.

Join!

Developer-level members of my YouTube channel or Patreon get access to a private Discord server to chat with other developers about Software Architecture and Design and access to source code for any working demo application I post on my blog or YouTube. Check out my Patreon or YouTube Membership for more info.

Follow @CodeOpinion on Twitter

Software Architecture & Design

Get all my latest YouTube Vidoes and Blog Posts on Software Architecture & Design

Why is Clean Architecture so Popular?

You’ve probably noticed many videos and blogs that somewhat explain what Clean Architecture is and show you how to use it. So its Clean Architecture is popular, but should it be? Should you be using it? Here’s why I think it’s popular, the problems it addresses, and some aspects that almost nobody ever mentions.

YouTube

Check out my YouTube channel, where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Clean Architecture

As a quick primer, what is clean architecture? Well, it’s a way to manage coupling. Specifically, in this diagram, you can see how the outer parts of the circle reference the inner parts of the circle. The dependencies between layers are pointing in a single direction inward.

It’s about managing coupling.

As an example, with the Clean Architecture template for .NET/C#, the project structure and dependencies are as follows.

Clean Architecture Direction of Dependencies

The top (outer layer), called WebUI, is ASP.NET Core. It references an Infrastructure project that contains the entity framework DBContext and other concerns. The WebUI and Infrastructure reference the Application project, which contains the interfaces for implementations in the infrastructure and any application-level code, such as commands, queries, and handlers. Finally, the application project references the Domain project, which contains (or should) your domain models and business logic.

Sounds great. Separation of technical concerns. But why?

Coupling

degree of interdependence between software modules

ISO/IEC/IEEE 24765:2010
Systems and software engineering — Vocabulary
Big ball of Mud

There are two forms of coupling Clean Architecture addresses. Afferent and Efferent.

Efferent Coupling: Who do you depend on? From the perspective of the Domain project, who does it depend on? Nothing.

Afferent Coupling: Who depends on you? From the same perspective of the domain project, which projects depends on it? The Application Project.

This is about stability. Because the Domain project has no dependencies, nothing can force it to change. All our business logic is isolated and cannot be forced to change because of a change within the infrastructure project or any other project. The reverse is true for WebUI. Changes we make in the infrastructure or Application could force us to make changes in the WebUI.

Do you need Clean Architecture?

It would be best if you asked yourself a few questions. What is the size of the application? Do I have complex domain logic? Do I need to control coupling?

Clean architecture is about forcing a direction of dependencies. In .NET, projects were used in the template above to force the separation. However, you do not need separate projects. Coupling is the dependence between types. If you merged the template into one project, you still have the same degree of coupling.

Prescription

Do not use Clean Architecture as a prescription or template. Understand that you’re trying to manage coupling. It doesn’t need to be by projects. However, it can be to help with physical separation. It doesn’t need to be those exact layers. It’s not a prescription.

Large System

You should consider decomposing it into logical boundaries if you have a large system. What’s a large system? Something that takes a team of developers, possibly years to develop. I’ve covered this in many different blog posts and videos. Check out my post Microservices gets it WRONG defining Service Boundaries and Should you use Domain Driven Design? where I talk about logical boundaries. Logical boundaries are about grouping a cohesive set of capabilities within your system. It allows you to decompose a large system into smaller subsystems.

Logical Boundaries

Why does this matter? When you break up a large system into smaller parts, you’ll realize that not all parts provide the same value. While all the boundaries are important, some are more in a supporting role and often built around CRUD (Create-Read-Update-Delete). This is also very similar if you’re creating a smaller app that may take a couple of weeks or months to develop.

If you have no domain logic, do you need to all the same layers as another part of your system that is at the core of the solution space and contains complex business logic? No.

Clean Architecture within logical boundaries

This is why it’s not a prescription or template. Each boundary within a system has different concerns. If you don’t have any business rules, you have an underlying data model. Or perhaps you only have a dozen or so routes/endpoints that have data access. Do you need to add an abstraction to data access in that case? What if your database changes? Then change the 12 or so routes/endpoints!

Clean Architecture

Clean architecture is about coupling. There’s no prescription for the layers you define or how you define the coupling. You don’t need to define layers by projects. It’s about the direction of dependencies between types. Afferent and Efferent coupling are what define the stability of each layer. Do you need stability in a particular layer? Then maybe consider isolating it.

Join!

Developer-level members of my YouTube channel or Patreon get access to a private Discord server to chat with other developers about Software Architecture and Design and access to source code for any working demo application I post on my blog or YouTube. Check out my Patreon or YouTube Membership for more info.

Follow @CodeOpinion on Twitter

Software Architecture & Design

Get all my latest YouTube Vidoes and Blog Posts on Software Architecture & Design

That’s NOT an Aggregate in Domain Driven Design

Are you frustrated that you have to open multiple files across multiple layers to make what seems like a simple change? One of the culprits for this is following structure and templates that apply patterns or concepts to solve problems you might not have. One typical case of this is using aggregate from domain drive design. In this video, I’ll give examples of where an aggregate can make sense and where it’s not and adds useless indirection.

YouTube

Check out my YouTube channel, where I post all kinds of content accompanying my posts, including this video showing everything in this post.

Useless Indirection

The idea for this video/blog came from a common I received on a YouTube video on my channel where I was talking about indirection.

The sentiment of this comment is all too common. I have many similar comments and have conversations with developers all the time about this. One of the culprits to this is applying patterns or concepts that are solutions to problems you don’t have in a given context.

One such pattern is the usage of an Aggregate from Domain Driven Design. The purpose of an aggregate is to create a consistency boundary. Unfortunately, the way it’s often explained more illustrates it as an object model or hierarchy.

Aggregate Domain Driven Design

The stereotypical example is to model a shopping basket. You would have a basket that would have many basket items. Many think this is an aggregate because you cannot have a basket item without a basket. In this case, this would be the aggregate, and the Basket would be the aggregate root.

Typically you’d then use a Repository to save and fetch the aggregate out, only exposing the aggregate root (Basket) to consumers.

Aggregate Domain Driven Design

But does this need to be an aggregate?

Most commonly, aggregates are often incorrectly used to model an object/data hierarchy and to old domain logic, which I often think is a more trivial validation than complex domain logic.

However, an aggregate is about creating a consistency boundary. It’s not about modeling a hierarchy.

Do you need consistency within this aggregate?

Useless Setters

Here’s a made-up example of an aggregate based on a sample I found on GitHub.

This is a simplified example. However, you can see two methods for setting the Name and the Price of this Entity. There is also some logic for setting the price: the price must be greater than zero. To do this, it’s using a specification.

What value does the specification serve? What value do the SetName and SetPrice have? None.

The SetName method is just setting the underlying Name property. It’s useless indirection.

The SetPrice contains some validation logic, which is nice. However, the separate ProductNegativePriceSpecification is useless indirection. The SetPrice is also putting our entity in an invalid state even though it’s throwing. The caller could catch the exception and carry on.

We could just put the conditional check directly in the SetPrice method. But we can also use value objects and types to enforce a valid value directly from the caller.

Now, what value do the SetName and SetPrice have? Zero value. They are just setting the underlying properties. We’ve enforced our product price when the caller needs to construct a ProductPrice type.

We don’t have an aggregate (root). We have a data model with useless setters. Remove the SetPrice and SetName, then set the properties directly from the calling code.

Consistency Boundary

So when do you need an aggregate? Well, here’s an example of an Order Aggregate (root)

This slimmed-down version of the Order Aggregate Root illustrates what’s important. When we add an order item, we do it through the aggregate root (Order) because we want to only have a single unique product per order. Also, if we have a discount for the product, we want to use the discount with the greatest value. This is a consistency boundary. We need an aggregate and all operations to go through the root to perform this logic. We don’t want random data access code or transaction scripts managing order items. This gives us consistency.

Lastly, in the SetStockconfirmedStatus method, we’re making a state change, but we’re also publishing a domain event OrderStatusChangedToStockConfirmed. Other parts of our system likely rely on this event when that state changes. We must always publish this event when the order status changes to StockConfirmed. Again, consistency on state change and publishing an event.

Aggregate or Data Model

If you need a consistency boundary, use an aggregate and aggregate root. You’re not getting any of the benefits if you have a data model with just setters. Don’t add useless indirection. Just use a data model with transaction scripts.

Join!

Developer-level members of my YouTube channel or Patreon get access to a private Discord server to chat with other developers about Software Architecture and Design and access to source code for any working demo application I post on my blog or YouTube. Check out my Patreon or YouTube Membership for more info.

Follow @CodeOpinion on Twitter

Software Architecture & Design

Get all my latest YouTube Vidoes and Blog Posts on Software Architecture & Design