Come and Join the Innovative DDD Community

Domain Driven Design went out of programming fashion a long time ago, but in my experience many of its principles and practices can provide significant benefits to most software projects. That’s why DDD still has a passionate community who are continually evolving the way development and the business can work ever more synergistically.

In this post I am going to skim over some DDD innovations to show how being part of the DDD community can enhance you as a developer and compel you as an innovator.

Since the inception of DDD there have been stunning developments on both the social and technical sides of DDD. Alberto Brandolini has conjured up Event Storming — an efficient collaboration technique enabling technical and non-technical people to rapidly explore domains.

On the technical side, respected figures like Greg Young and Udi Dahan have been showing us ways to make DDD applications scale to huge loads, using event-centric techniques like distributed pub/sub and Event Sourcing.

DDD Connects Business and TechnicalThe Shift Towards Behaviours aka Domain Events

Modern DDD practitioners tend to think in terms of real-world concepts that involve state changes, known as Domain Events. These are behaviours that occur in the real-world domain such as: “Account Created”, “Funds Transferred”, or “Goal Scored”.

We find that focusing on domain events helps us to better understand the domains we are modelling; especially in comparison to the traditional (and incomplete) view of DDD as being merely about Entities, Value Types and Repositories.

DDD is a far greater mindset than just small design patterns. It’s about the way development and the business collaborate. And it’s about consistent use of language in conversation, code and diagrams. The shift toward event-centric thinking has pervaded all of these aspects of DDD.Collaboration Innovations

Many developers fail to harness the true benefits of DDD because they focus solely on small technical details. But DDD is as much about cross-function communication. At the very core of DDD is the Ubiquitous Language — a shared vocabulary that helps everyone, technical and non-technical, to understand domain concepts, and be part of domain conversations.

As we’ve moved to event-centric thinking, Domain Events have been incorporated into the Ubiquitous Language. For many DDD practitioners, Domain Events are the most important entries in a project’s Ubiquitous Language.

One of the DDD community’s most passionate and charismatic members, Alberto Brandolini, over the past couple of years has been teaching us how we can better work with the business to identify and relate Domain Events using a collaborative technique known as Event Storming.Event Storming

Alberto describes Event Storming as:

“Event Storming is a workshop format for quickly exploring complex business domains.”

If you read his initial post on the topic you’ll see that this involves getting a big space (unlimited in fact), inviting key business and technical people, and having lots of fun along the way to creating a whiteboard-sticky-note-based model of the domain using events.

DDD practitioners and Domain Experts storming up events — http://verraes.net/2013/08/facilitating-event-storming/

You’ll also see how Alberto looks to identify key criteria during the session, including: aggregates, acceptance tests, and a deeper understanding of the source of each event.

Event Storming is a valuable collaboration tool, and Alberto Brandolini is a valuable member of the DDD community. I’m very excited to see what collaborative improvements will emerge in the future — you can be a part of it.Technical Innovations

Over on the other side of DDD where we turn conceptual models into working software, we’ve faced up to the challenge of building systems that are focused on expressing Domain Events. At the same time we’ve had to deal with the needs of building ever more scalable systems.

By good fortune it turns out that event-driven (or more broadly Reactive) systems often provide a better platform for scalability. The technical innovations around event-modelling are equally as exciting as Alberto’s collaboration innovations.Event-driven Messaging

Asynchronous messaging is widely regarded as one of the better solutions for building scalable systems. It’s the main principle of Erlang and a key ingredient of Reactive Programming.

In the DDD community, we’ve learned to express our Domain Events as asynchronous messages that occur in our software applications, using a variety of technologies including Message Buses and HTTP.

Message Bus

Much-lauded DDD advocate Udi Dahan prefers a Message Bus as the key infrastructural component for asynchronous delivery of Domain Events.

Udi actually has a detailed philosophy that combines SOA with other DDD concepts such as Bounded Contexts. The overall result is aimed at building domain-oriented scalable systems.

REST

You don’t have to use a Message Bus to build scalable, event-driven systems that explicitly detail domain concepts. Another option used by DDD practitioners is HTTP and REST.

This approach is similar to Udi’s in that Bounded Contexts are isolated and communicate asycnhronously. However, events are exposed as an Atom feed that is polled by subscribers akin to asynchronous messaging.

Credits for this approach should be attributed to the authors of REST in Practice. However, kudos to the DDD community for adopting the approach and combining it with DDD/Domain events.Event Sourcing

One of DDD’s most famous faces, Greg Young, has revitalised a traditional approach to persistence, based on events, under the new name Event Sourcing. Using Event Sourcing, Domain Events are appended to a read-only stream.

Because event streams are append-only, context always remains — you can always look back in time to understand how you arrived at the current state — much like a bank statement shows the sequence of transactions that resulted in the bank balance at a given date.

Event Sourcing has proved to be so popular with the DDD community that Greg Young formed a team to build Event Store: a purpose-built tool for Event Sourcing.The Actor Model

Asynchronous message passing is at the heart of many interpretations of the Actor Model. So it can be used in a similar way to messaging except at a much more fine-grained level.

With the Message Bus approach, events are shared across processes. With an Actor Model such as Akka, messages are shared between “objects” inside the same process.

Vaughn Vernon is one DDD practitioner who has been showing how the Actor Model can be combined with DDD for heightened levels of expressiveness, code clarity, and out-of-the-box concurrency.Where to Get Started or Learn More

If you want to innovate in the ways people collaborate or the ways we can express domain concepts in our code then you will love being part of the DDD community. But it’s also a great place if you just want to learn. Even by applying existing techniques you can share your experiences and drive incremental improvements and meet some great people.

Here are a list of resources to get you started.Twitter

Perhaps the easiest way to get involved with DDD is to follow a few members of the community. This way you will constantly be exposed to snippets of DDD knowledge:

Hashtags: #ddd #dddesignBooks

It’s always worth checking out the seminal DDD book, but it’s a long read and is a touch old now. Scott Millet’s free eBook aims to make it easier to get started with DDD for newbies and people who have read the big blue book but aren’t quite sure where to start in the real world.

Principles, Practices and Patterns of Domain Driven Design is a new book that is shortly being launched that covers many collaboration and technical aspects of DDD including how to build event-driven systems with messaging and REST. I made a small contribution to this book myself

Vaughan Vernon’s Implementing DDD is also highly-regarded.Conferences

DDD eXchange 2014 will be held in London on the 20th June (I’ll be there if you want to catch up in person). You can also catch recordings of all the sessions from last year’s event.