Domain-Driven Design: Tackling Complexity in the Heart of Software

The heart of software is its ability to solve domain-related problems for its user.

A model is a selectively simplified and consciously structured form of knowledge.

In the old waterfall method, the business experts talk to the analysts, and analysts digest and abstract and pass the result along to the programmers, who code the software. This approach fails because it completely lacks feedback.

To communicate effectively, the code must be based on the same language used to write the requirements—the same language that the developers speak with each other and with domain experts.

Every software program relates to some activity or interest of its user.

Success comes in an emerging set of abstract concepts that makes sense of all the detail. This distillation is a rigorous expression of the particular knowledge that has been found most relevant.

Knowledge trickles in one direction, but does not accumulate.

That shallowness of knowledge produces software that does a basic job but lacks a deep connection to the domain expert’s way of thinking.

Diagrams are a means of communication and explanation, and they facilitate brainstorming. They serve these ends best if they are minimal.

They show design constraints, but they are not design specifications in every detail. They represent the skeletons of ideas.

the model is not the diagram.

The behavior of running code is unambiguous.

documenting exclusively through code has some of the same basic problems as using comprehensive UML diagrams.

A document shouldn’t try to do what the code already does well.

Written documents should complement the code and the talking.

you may hear the UBIQUITOUS LANGUAGE changing naturally while a document is being left behind.

It takes fastidiousness to write code that doesn’t just do the right thing but also says the right thing.

There is no need for explanatory models to be object models, and it is generally best if they are not.

The astrolabe was a mechanical implementation of an object-oriented model of the sky.

If the design, or some central part of it, does not map to the domain model, that model is of little value, and the correctness of the software is suspect.

The heart of software is its ability to solve domain-related problems for its user. All other features, vital though they may be, support this basic purpose. When the domain is complex, this is a difficult task, calling for the concentrated effort of talented and skilled people. Developers have to steep themselves in the domain to build up knowledge of the business. They must hone their modeling skills and master domain design. Yet these are not the priorities on most software projects. Most talented developers do not have much interest in learning about the specific domain in which they are working, much less making a major commitment to expand their domain-modeling skills. Technical people enjoy quantifiable problems that exercise their technical skills. Domain work is messy and demands a lot of complicated new knowledge that doesn’t seem to add to a computer scientist’s capabilities. Instead, the technical talent goes to work on elaborate frameworks, trying to solve domain problems with technology. Learning about and modeling the domain is left to others. Complexity in the heart of software has to be tackled head-on. To do otherwise is to risk irrelevance.

When we set out to write software, we never know enough.

The vital detail about the design is captured in the code. A well-written implementation should be transparent, revealing the model underlying it.

there should be some learning when a domain model is discussed.

The domain experts had learned more and had clarified the goal of the application.

Most talented developers do not have much interest in learning about the specific domain in which they are working, much less making a major commitment to expand their domain-modeling skills. Technical people enjoy quantifiable problems that exercise their technical skills.

Any technical person contributing to the model must spend some time touching the code, whatever primary role he or she plays on the project. Anyone responsible for changing code must learn to express a model through the code. Every developer must be involved in some level of discussion about the model and have contact with domain experts. Those who contribute in different ways must consciously engage those who touch the code in a dynamic exchange of model ideas through the UBIQUITOUS LANGUAGE

The kind of knowledge captured in a model such as the PCB example goes beyond “find the nouns.