We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
An introduction to DDD - Rob Allen
Discover the fundamentals of Domain-Driven Design, a crucial approach to software development. Learn how to improve communication, simplify language, and prioritize understanding business problems for better software outcomes.
- Don’t assume familiarity with Domain-Driven Design (DDD); start with a simple overview and glossary.
- Understanding the broader picture of how software fits within the business is crucial.
- Keep track of state changes by identifying where they occur; this is essential for making good software.
- Traditional DDD addresses topics like repositories, mappers, and separating state from entities, but doesn’t build software; start with simpler concepts like post-it notes.
- Strive to have a common language and shared understanding among team members and business stakeholders.
- Prioritize simplicity and friendliness in language to facilitate cooperation with business experts.
- Avoid “death by documentation” and aim for just-in-time documentation and explicit communication.
- Recognize that language will change over time and adapt to accommodate this.
- Organize processes and code using bounded contexts, which help prevent misunderstandings and keep the domain model from diluting.
- Establish a separate glossary for each team or project to maintain a consistent vocabulary.
- Use visual diagrams and storytelling to communicate domain knowledge and facilitate agreement.
- Highlight the importance of intentional thought and problem-solving to write good software.
- Don’t shy away from complexity; recognize that software development is inherently complex.
- Prioritize understanding the business problem and how the software fits within it.
- Aim for a “good enough” understanding of the domain; it’s not necessary to know everything.
- Emphasize the need for simplicity and friendliness in language to facilitate communication with non-technical stakeholders.
- Use visual tools like event storming to facilitate communication and understanding with business experts.
- Avoid premature optimization and focus on solving the immediate problem.
- Recognize the importance of updating documentation and glossaries as the software evolves.
- Aim for a flexible architecture that can adapt to changing requirements.