Why Domain Driven Design (DDD) is so great

This article aims to describe why I think that DDD aids you tremendously in creating robust and flexible applications.

Today we have several cool frameworks and libraries that we can use. ORMs, WCF, ServiceStack, SignalR, WebApi, IoC etc etc. Just thinking of them all can make any serious developer go crazy with joy.

All those tools are so great that we almost can’t wait to use them. Here is a typical conversation with a customer:

Customer: I want to create a forum
You: Oohh ohh, wait! Yeah. I could use Sharepoint. No no. It’s so bloated and slow. oh oh! I’ve got it. wait! SignalR+WebApi and KnockoutJS. So cool! Let’s do that!
Customer: But but. We just need a basic forum.
You: Shut it! Me wanna do SignalR

And so on. My point is that it’s so easy to forget that we should focus on solving a problem for the customer and not on which technology we should use.

The role of the database

A couple of years ago we said that we developed database driven applications. Erhm. Maybe a bit more than a couple of years ago, I’m getting old. It was the shit. If you said to a DBA that you have normalized the DB according to 3NF he would probably have gotten an orgasm. Today the view of applications as data driven has become so widespread that most applications are modeled according to the database model and its relations.

The problem with that is that the database forces you to couple your application thanks to all DB relations. It also forces you to model the business layer after the DB model. Especially today if you are using an OR/M.

Database centric applications usually lead to CRUD influenced UIs. That is, you show a big fat screen saying “Go ahead and edit the fields you want. I trust that you have full knowledge of which combinations of changes that are valid given the current state of the object“. That’s also a huge problem. Business rules are hard to test since it’s the user that enforces them. It will undoubtedly lead to you having to go into the database and fix things: “Hey, it’s me the customer. Order XX has the field Y set to Z. That shouldn’t be possible, can you fix that?”. Those kinds of bugs are very hard to locate and therefore fix.

Enter DDD

Domain driven design is all about understanding the problem that the customer is trying to solve. During the initial phase you don’t even think about architecture or programming. Your prime goal is to understand the business, all terms that the customer uses and how they model the domain. The customer is in fact the architect. They might not draw everything, but they guide you and tell you how everything should be modeled.

So what you do is sit down with the customer and discuss each business case. You listen to them and draw something which the customer can understand (read: NO UML). Then you use all of those sketches and notes to build the model = code.

Coding

In DDD you shouldn’t care about persistence, UIs or anything else. You just code vanilla classes which represent the model that the customer described. And since you just have POCOs it’s incredibly easy to test everything. I highly recommend that you try to use a TDD inspired approach together with DDD.

In DDD every class in the model should always be in a consistent state (i.e. being valid). That means that you’ll have no (or very few) public setters in your classes. Instead you have methods in each class that represents an action that the customer described. If one or more classes (entities) are involved in an action you’ll create a new class which coordinates the work for the both entities (that class is called a service). Read this if you would like to know more about how private setters affect your application.

Using methods also means that we can’t have CRUD UIs but instead have to code task based UIs. It’s hard when you come from CRUD type of applications, but the task based UI tends to become a lot less cluttered when you get used to coding them.

Finally you have a nice domain model where all business rules are encapsulated in your classes and hopefully tested with unit tests. The likelihood of bugs like the ones I described for CRUD applications is a lot lower.

The event

Each time something happens (something that the customer described) in a DDD application there is an event generated. These events allow you to create a more loosely coupled application.

For instance when a new user registers a UserRegistered event is generated. It can be subscribed to by a NotifyAdminOfNewUser handler or a SendAnWelcomeEmail handler. Or both. The point is that any part of the system can handle any event. You can even create a module/plugin based application where the plugins handle each others events. How cool isn’t that?

Persistence

Most people who have a hard time with DDD have it because they start at the wrong end. They start with the database and then try to fit the domain model according to the db model. That’s the wrong approach (which there of course are solutions for, but that’s out of the scope of this article).

It’s much better to start with the domain model as it’s seldom that you know all business requirements from start. If you start with the domain model you can test drive the model with your customer/client. Go through different scenarios and ask them what they think. By doing so you’ll find requirements that weren’t known from the start. Once completed you can build the database design. As you now have a much better understanding of how and when the persistence layer is going to be used. As such, you know where you have to add relations, where you should use third normal form (3NF) and where you can put the child aggregates as a JSON string in a root aggregate column.

The repositories are used to abstract away all that knowledge. The calling layer should not have to be aware of if you are using table relations or have serialized child aggregates as JSON. That’s why the repositories are called an abstraction layer. And that’s where many developers get it wrong and think that their OR/M is an abstraction, when it in reality just mirrors the database design.

This new point of view also allows us to separate the data model into several data sources if we would like (since the data is decoupled in your domain model). We do not have to use one database normalized to 3NF. We can use one big denormalized database (disk space is so expensive, isn’t it?) or even web services in our repositories.

The UI

Now that we have some data and a domain model it’s time to start creating the UI. Again we model it after the domain model. Since it’s dictated by all methods that we have in our domain model it’s quite easy to know how we should structure it.

Outsourcing?

When you’ve modeled the domain model it’s fully possible to let others take care of the persistence and the UI. Just send them the domain model. In fact, you could even let two different teams take care of it. One that builds and optimizes the data layer (caching, db etc), and one that builds the UI.

Let the original team (the domain experts) continue with the next project (or iteration if you’re agile).

Conclusion

That’s why I love DDD 😉