Analysis patterns are specialized, high level patterns who generically model a very well known and wide domain, they are not technical solutions.
These patterns allow us to cut down on the time spent in early stages of development, while doing knowledge crunching and trial and error iterations. They give us a head start, a solid advanced starting point from where to build what is specific to our domain, and anticipate consequences that are expensive if we have to discover them on our own.
“Analysis patterns: Reusable object models”
[Martin Fowler, 1997]
This post is part of a set of posts with my personal notes about all the chapters in the book “Domain Driven Design” by Eric Evans. I will do this as I read through the book, and take notes on the concepts I personally find more relevant.
Supple, or elegant and flexible, design is a complement to Deep Modelling. While deep modelling is about digging out domain concepts with the domain experts, and reflecting those concepts in code, Supple Design is about building that code in a way that is easy to understand, modify and extend, in sum: code that is maintainable.
If we want to maintain speed of development as the project grows, we must design code that is a pleasure to work with, code that invites change. Otherwise the code will be a mess, where a small change can aggravate or break something: developers will dread to look at it, let alone work with it.
Eric Evans came up with a set of patterns that can help achieve this supple design.
Continue reading “DDD.10 – Supple Design”
Implicit concepts are concepts that exist but , for some reason, the domain experts don’t talk about them explicitly. It takes some time until the developers actually realize the existence of those implicit concepts, by means of hints while discussing the model or at later stages, when several other concepts are already set in place.
Continue reading “DDD.9 – Making implicit concepts explicit”
The third part of the book starts in chapter 8 and talks about refactoring.
Refactoring towards deeper insight has the objective of having a domain model that closely reflects the domain. This makes the software more in tune with what the domain experts think and to the users current and future needs.
Continue reading “DDD.8 – Refactoring toward deeper insight / Breakthrough”
This chapter is a long example of how project architecture may evolve.
There aren’t many new concepts approached, nevertheless, in the end of the chapter there are three interesting design patterns mentioned:
- Anti-corruption layer
- Enterprise segments
Continue reading “DDD.7 – Using the language”
There are three main objects that can control the life-cycle of a domain object:
- Aggregates: Hold several objects in a root object and can control their creation, manipulation, query and deletion;
- Factories: Create new objects with a set of data;
- Repositories: Recreate persisted objects from queried data, possibly delegating the reconstruction of the actual object instance to a factory.
Continue reading “DDD.6 – The lifecycle of a domain object”
A model is expressed in code by several patterns of model elements:
- Value objects
Continue reading “DDD.5 – A model expressed in software”