Domain-driven Design

Domain-driven Design (DDD) ist eine Herangehensweise an die Modellierung komplexer Software. Die Modellierung der Software wird dabei maßgeblich von den umzusetzenden Fachlichkeiten der Anwendungsdomäne beeinflusst. Der Begriff „Domain-driven Design“ wurde 2003 von Eric Evans in seinem gleichnamigen Buch geprägt.^[1]

Domain-driven Design ist nicht nur eine Technik oder Methode. Es ist vielmehr eine Denkweise und Priorisierung zur Steigerung der Produktivität von Softwareprojekten im Umfeld komplexer fachlicher Zusammenhänge.^[2] Domain-driven Design basiert auf folgenden zwei Annahmen:

• Der Schwerpunkt des Softwaredesigns liegt auf der Fachlichkeit und der Fachlogik.
• Der Entwurf komplexer fachlicher Zusammenhänge sollte auf einem Modell der Anwendungsdomäne, dem Domänenmodell, basieren.

Domain-driven Design ist an keinen bestimmten Softwareentwicklungsprozess gebunden, orientiert sich aber an agiler Softwareentwicklung. Insbesondere setzt es iterative Softwareentwicklung und eine enge Zusammenarbeit zwischen Entwicklern und Fachexperten voraus.^[3]

Der Sinn jeder Software ist es, die Aufgabenstellungen einer bestimmten Anwendungsdomäne zu unterstützen. Um dies erfolgreich leisten zu können, muss die Software zur Fachlichkeit der Anwendungsdomäne passen, für die sie bestimmt ist. Domain-driven Design ermöglicht dies, indem die Software grundlegende Konzepte und Elemente der Anwendungsdomäne sowie deren Beziehungen modelliert.^[4]

Die Architektur ist geprägt durch die Existenz einer expliziten Geschäftslogikschicht. Diese Schicht soll die Domänen-Klassen von anderen Funktionen des Systems entkoppeln und möglichst leicht erkennbar machen. Verschiedene Architekturstile können eingesetzt werden, um die Geschäftslogikschicht einzubetten. Dazu zählen die Schichtenarchitektur und die hexagonale Architektur.^[5][6]

Die Klassen des Domänenmodells enthalten im Domain-driven Design sowohl die Daten als auch die gesamte Funktionalität der umzusetzenden Fachlichkeit, also die gesamte Fachlogik. Reine Datenklassen nur mit Zugriffsmethoden aber ohne fachliche Funktionalität gelten als Code-Smell. Ein auf Datenklassen aufbauendes Domänenmodell wird anämisch genannt und gilt demzufolge als Antipattern, da es ein Domänenmodell ohne Fachlogik beschreibt.^[7]

Domain-driven Design steht in Kontrast zum weniger komplexen Entwicklungsmuster Smart UI. Bei Anwendung von Smart UI wird die Anwendungslogik direkt in die Benutzeroberfläche integriert. Dadurch kann keine dezidierte Schicht für Anwendungslogik entstehen, die von verschiedenen Komponenten wieder verwendet werden kann.^[1]

Domain-driven Design basiert auf einer Reihe von Konzepten, welche bei der Modellierung – aber auch anderen Tätigkeiten der Softwareentwicklung – berücksichtigt werden sollten. Das Hauptaugenmerk hierbei fällt auf die Einführung einer ubiquitären (allgemein verwendeten, allgegenwärtigen, ubiquitous) Sprache, welche in allen Bereichen der Softwareerstellung verwendet werden sollte. Eine Sprache für die Beschreibung der Fachlichkeit, der Elemente des Domänenmodells, der Klassen und Methoden etc. Sie wird definiert als:

Domain-driven Design ist selbst unabhängig von Programmiersprachen, Werkzeugen und Frameworks. Dennoch gibt es eine Reihe von Werkzeugen, Frameworks, Leitfäden und Vorgehensmodellen, die Unterstützung für die Realisierung spezifischer DDD-Patterns anbieten oder die Herangehensweise von DDD organisieren.^[9][10][11]

Domain-driven Design unterscheidet die folgenden Bestandteile des Domänenmodells:

Entitäten (Entities, reference objects)

Objekte des Modells, welche nicht durch ihre Eigenschaften, sondern durch ihre Identität definiert werden. Beispielsweise wird eine Person meist als Entität abgebildet. Eine Person bleibt somit dieselbe Person, wenn sich ihre Eigenschaften ändern; und sie unterscheidet sich von einer anderen Person, auch wenn diese dieselben Eigenschaften hat. Entitäten werden oft mit Hilfe von eindeutigen Identifikatoren modelliert.

Wertobjekte (value objects)

Objekte des Modelles, welche keine konzeptionelle Identität haben oder benötigen und somit allein durch ihre Eigenschaften definiert werden. Wertobjekte werden üblicherweise als unveränderliche Objekte (immutable objects) modelliert, damit sind sie wiederverwendbar (vgl. Flyweight) und verteilbar.

Aggregate (aggregates)

Aggregate sind Zusammenfassungen von Entitäten und Wertobjekten und deren Assoziationen untereinander zu einer gemeinsamen transaktionalen Einheit. Aggregate definieren genau eine Entität als einzigen Zugriff auf das gesamte Aggregat. Alle anderen Entitäten und Wertobjekte dürfen von außerhalb nicht statisch referenziert werden. Damit wird garantiert, dass alle Invarianten des Aggregats und der einzelnen Bestandteile des Aggregats sichergestellt werden können.

Assoziationen (associations)

Assoziationen sind, wie bei UML definiert, Beziehungen zwischen zwei oder mehr Objekten des Domänenmodells. Hier werden nicht nur statische, durch Referenzen definierte Beziehungen betrachtet, sondern auch dynamische Beziehungen, die beispielsweise erst durch die Abarbeitung von SQL-Abfragen entstehen.

Serviceobjekte (services)

Bei Domain-driven Design werden Funktionalitäten, welche ein wichtiges Konzept der Fachlichkeit darstellen und konzeptionell zu mehreren Objekten des Domänenmodells gehören, als eigenständige Serviceobjekte modelliert. Serviceobjekte sind üblicherweise zustandslose (engl. stateless) und daher wiederverwendbare Klassen ohne Assoziationen, mit Methoden, die den angebotenen Funktionalitäten entsprechen. Diese Methoden bekommen die Wertobjekte und Entitäten übergeben, die zur Abarbeitung der Funktionalität notwendig sind.

Fachliche Ereignisse (domain events)

Fachliche Ereignisse sind Objekte, welche komplexe, sich unter Umständen dynamisch ändernde, Aktionen des Domänenmodells beschreiben, die ein oder mehrere Aktionen oder Änderungen in den Fachobjekten bewirken. Fachliche Ereignisse ermöglichen auch die Modellierung verteilter Systeme. Die einzelnen Subsysteme kommunizieren ausschließlich über fachliche Ereignisse, damit werden sie stark entkoppelt und das gesamte System somit wartbarer und skalierbarer.^[12]

Module (modules, packages)

Module teilen das Domänenmodell in fachliche (nicht technische) Bestandteile. Sie sind gekennzeichnet durch starke innere Kohäsion und geringe Kopplung zwischen den Modulen.

Darüber hinaus kennt Domain-driven Design noch zwei weitere Bestandteile des Domänenmodells – Factories und Repositorys. Diese implementieren zwar selbst nicht Fachlichkeit, sind aber dennoch Bestandteil des Domänenmodells, da sie für den Lebenszyklus der Fachobjekte wichtige Funktionalität bereitstellen.

Fabriken (factories)

Fabriken dienen dazu, die Erzeugung von Fachobjekten in spezielle Fabrik-Objekte auszulagern. Dies ist sinnvoll, wenn entweder die Erzeugung komplex ist (und beispielsweise Assoziationen benötigt, die das Fachobjekt selbst nicht mehr benötigt) oder die spezifische Erzeugung der Fachobjekte zur Laufzeit ausgetauscht werden können soll. Fabriken werden üblicherweise durch erzeugende Entwurfsmuster wie abstrakte Fabrik, Fabrikmethode oder Erbauer umgesetzt.

Repositorys

Repositorys abstrahieren die Persistierung und Suche von Fachobjekten. Mittels Repositorys werden die technische Infrastruktur sowie alle Zugriffsmechanismen auf diese von der Geschäftslogikschicht getrennt. Für alle Fachobjekte, welche über die Infrastruktur-Schicht geladen werden, wird eine Repository-Klasse bereitgestellt, welche die verwendeten Lade- und Suchtechnologien nach außen abkapselt. Die Repositorys selbst sind Teil des Domänenmodells und somit Teil der Geschäftslogikschicht. Sie greifen als einzige auf die Objekte der Infrastruktur-Schicht zu, welche meist mittels der Entwurfsmuster Data Access Objects, Query Objects oder Metadata Mapping Layers umgesetzt werden.

Die Namen der diesen Mustern entsprechenden Klassen der Geschäftslogikschicht sind Teile der ubiquitären Sprache und sollten entsprechend benannt werden. Eine Änderung des Namens eines Fachobjektes durch Refactoring entspricht somit einer Änderung der Fachlichkeit der Applikation.

Domain-driven Design beschreibt und empfiehlt eine Reihe weiterer Techniken und Herangehensweisen für die Umsetzung des Domänenmodells:

Evolvierende Struktur (evolving order)

geht davon aus, dass große Strukturen im Domänenmodell idealerweise erst mit der Zeit entstehen beziehungsweise sich über die Zeit entwickeln. Große Strukturen sollten möglichst einfach und mit möglichst wenigen Ausnahmen umgesetzt sein.

Systemmetapher (system metaphor)

ist ein Konzept aus Extreme Programming, welche die Kommunikation zwischen allen Beteiligten erleichtert, indem es das System mittels einer Metapher, einer inhaltlich ähnlichen, für alle Seiten verständlichen Alltagsgeschichte beschreibt. Diese sollte möglichst gut passen und zur Stärkung der ubiquitären Sprache verwendet werden.

Verantwortlichkeitsschichten (responsibility layers)

ist die Aufteilung des Domänenmodells in Schichten gemäß Verantwortlichkeiten. Domain-driven Design schlägt folgende Schichten vor: Entscheidungsschicht, Regelschicht, Zusagen, Arbeitsabläufe, Potential.

Wissenslevel (knowledge level)

beschreibt das explizite Wissen über das Domänenmodell. Es ist in Situationen notwendig, wo die Abhängigkeiten und Rollen zwischen den Entitäten situationsbedingt variieren. Das Wissenslevel sollte diese Abhängigkeiten und Rollen von außen anpassbar enthalten, damit das Domänenmodell weiterhin konkret und ohne unnötige Abhängigkeiten bleiben kann.

Erweiterungsframeworks (pluggable component framework)

ist die Überlegung, verschiedene Systeme über ein Komponentenframework miteinander zu verbinden.

Intentionen beschreibende Schnittstellen (intention-revealing interfaces)

bezeichnen Schnittstellen von Klassen und Komponenten, welche es den Entwicklern ermöglichen, ebendiese zu verwenden, ohne deren Sourcecode studieren zu müssen. Damit wird sowohl bei Verwendung als auch bei der Wartung dieser Klassen und Komponenten sichergestellt, dass diese gemäß deren Intentionen erfolgt.

Nebeneffektfreie Funktionen (side-effect-free functions)

sind Methoden, welche keinen Einfluss auf den Zustand eines Moduls haben. Diese sind einfacher zu testen und sollten somit bevorzugt werden. Sie sollten daher den Großteil der Applikationslogik enthalten. Den Zustand verändernde Methoden – sogenannte command Methoden – sollten von ihnen getrennt werden, möglichst einfach gehalten werden und keine Klassen des Domänenmodells retournieren.

Assertions

dienen im Domain-driven Design dazu, Nebeneffekte von aufgerufenen Methoden sichtbar zu machen, ohne deren Sourcecode studieren zu müssen. Diese – dem Design by contract nahe – Vorgangsweise führt dazu, dass Entwickler die Auswirkungen der verwendeten Methoden verstehen können, und somit erst Datenkapselung richtig eingesetzt werden kann.

Eigenständige Klassen (standalone classes)

sind Klassen, welche keine expliziten oder impliziten Abhängigkeiten zu anderen Klassen haben. Sie sind einfacher zu verstehen und sollten somit durch Eliminierung aller unnötigen Abhängigkeiten angestrebt werden.

Konzeptionelle Konturen (conceptual contours)

beschreibt die Konzepte, welche der Struktur eines Designs zugrunde liegen. Diese sollten durch sukzessive Refactorings an die stabilen Aspekte der Fachlichkeit angepasst werden. Damit steigt die Wahrscheinlichkeit, dass zukünftige Änderungen mit dem bestehenden Design leichter umgesetzt werden können.

Funktionsabschlüsse (closure of operations)

sind beim Domain-driven Design Methoden, deren Rückgabetyp derselbe ist wie derjenige ihrer Argumente oder der in der Methode verwendeten Attribute. Diese Methoden erweitern zwar die Möglichkeiten einer Klasse, führen aber keine Abhängigkeiten auf andere Konzepte ein. Sie sind daher gegenüber Methoden vorzuziehen, deren Rückgabe andere Typen einführen.

Antikorruptionsschicht (anticorruption layer)

ist eine architekturelle Schicht, welche das Domänenmodell von anderen Modellen trennt. Selbst ein Teil des Domänenmodells, ermöglicht es die Antikorruptionsschicht, dass auf das fremde Modell so zugegriffen werden kann wie das eigene Domänenmodell es benötigt. Dabei werden die eigenen Konzepte und Sprachelemente auf die des fremden Modells übersetzt, das eigene Domänenmodell wird nicht durch das fremde Modell beeinflusst. Dies wird zumeist mit den Entwurfsmustern Fassade, Adapter und Transferobjekt implementiert.

Diese und weitere gängige Designtechniken der Objektorientierung führen zu einem deklarativen Stil (declarative style) des Designs. Damit wird der Code nicht nur kürzer, leichter zu verstehen und einfacher zu testen, sondern sie ermöglichen es auch, die Kernfachlichkeit herauszuarbeiten und sich somit auf die relevanten fachlichen Funktionen einer Software zu konzentrieren.

Darüber hinaus definiert Domain-driven Design eine Reihe von Vorgehensweisen, welche dazu dienen, die Integrität der Modelle zu gewährleisten. Dies ist insbesondere dann notwendig, wenn mehrere Teams unter unterschiedlichem Management und Koordination an verschiedenen Fachlichkeiten, aber in einem großen Projekt zusammenarbeiten sollen.^[13]

Die Grafik zeigt die Abhängigkeiten zwischen diesen und anderen Elementen von Domain-driven Design.

Vision der Fachlichkeit (domain vision statement)

ist eine kurze Beschreibung der hinter der Kernfachlichkeit stehenden Vision und der damit verbundenen Ziele. Sie gibt die Entwicklungsrichtung des Domänenmodells vor und dient als Bindeglied zwischen Projektvision/Systemmetapher und den Details der Kernfachlichkeit und des Codes.

Kontextübersicht (context map)

dient einer gesamthaften Übersicht über alle Modelle, deren Grenzen und Schnittstellen. Dadurch wachsen die Kontexte nicht in Bereiche anderer Kontexte, und die Kommunikation zwischen den Kontexten läuft über wohldefinierte Schnittstellen.

Kontextgrenzen (bounded context)

beschreiben die Grenzen jedes Kontexts in vielfältiger Hinsicht wie beispielsweise Teamzuordnung, Verwendungszweck, dahinter liegende Datenbankschemata. Damit wird klar, wo ein Kontext seine Gültigkeit verliert und potentiell ein anderer Kontext seinen Platz einnimmt.

Kernfachlichkeit (core domain)

ist der wertvollste Teil des Domänenmodells, der Teil, welcher am meisten Anwendernutzen stiftet. Die anderen Teile des Domänenmodells dienen vor allem dazu, die Kernfachlichkeit zu unterstützen und mit weniger wichtigen Funktionen anzureichern. Bei der Modellierung sollte besonderes Augenmerk auf die Kernfachlichkeit gelegt werden, und sie sollte durch die besten Entwickler umgesetzt werden.

Geteilter Kern (shared kernel)

ist ein Teil der Fachlichkeit, der zwischen unterschiedlichen Projektteilen geteilt wird. Dies ist sinnvoll, wenn die verschiedenen Projektteile nur lose miteinander verbunden sind und das Projekt zu groß ist, um in einem Team umgesetzt zu werden. Der geteilte Kern wird hierbei von allen Projektteams, die ihn nützen, gemeinsam entwickelt. Dies benötigt sowohl viel Abstimmungs- als auch Integrationsaufwand.

Kunde-Lieferant (customer-supplier)

ist die Metapher für die Beziehung zwischen Projektteams, bei denen ein Team eine Fachlichkeit umsetzt, auf die das andere Team aufbaut. Damit wird sichergestellt, dass das abhängige Team vom umsetzenden Team gut unterstützt wird, da ihre Anforderungen mit derselben Priorität umgesetzt werden wie die eigentlichen Anforderungen an das Lieferantenteam.

Separierter Kern (segregated core)

bezeichnet die Überlegung, die Kernfachlichkeit, auch wenn sie eng mit unterstützenden Modellelementen gekoppelt ist, in ein eigenes Modul zu verlagern und die Kopplung mit anderen Modulen zu reduzieren. Damit wird die Kernfachlichkeit vor hoher Komplexität bewahrt und die Wartbarkeit erhöht.

Generische Sub-Fachlichkeiten (generic subdomains)

bezeichnet die Idee, diejenigen Teile des Domänenmodells, welche nicht zur Kernfachlichkeit gehören, in Form von möglichst generischen Modellen in eigenen Modulen abzulegen. Diese könnten, da sie nicht die Kernfachlichkeit repräsentieren und generisch sind, outgesourct entwickelt oder durch Standardsoftware ersetzt werden.

Kontinuierliche Integration (continuous integration)

dient beim Domain-driven Design dazu, alle Veränderungen eines Domänenmodells laufend miteinander zu integrieren und gegen bestehende Fachlichkeit automatisiert testen zu können.

Eric Evans beschreibt in seinem Buch Techniken für das Design neuer Software. Domain-driven Design kann aber auch für die Verbesserung und Transformation bestehender Legacy-Software verwendet werden.^[14] Dabei behilflich sind spezielle Refactorings.^[15]

Objektorientierte Analyse und Design

Obwohl sich DDD theoretisch nicht auf objektorientierte Konzepte beschränkt, wird DDD in der Praxis hauptsächlich für objektorientierte Analyse und Design eingesetzt. Viele der Konzepte von DDD basieren auf Paradigmen der objektorientierten Softwareentwicklung. DDD kann somit als Methodik für objektorientierte Analyse und Design angesehen werden.

Modellgetriebene Softwareentwicklung und modellgetriebene Architektur (MDA)

DDD ist zwar mit modellgetriebener Softwareentwicklung kompatibel, hat aber unterschiedliche Intentionen. Modellgetriebene Softwareentwicklung befasst sich mehr mit den Techniken, wie Modelle in unterschiedlichen Softwareplattformen umgesetzt werden können, während DDD sich hauptsächlich damit befasst, wie bessere Domänenmodelle erreicht werden können. DDD setzt stark auf ein kontinuierlich evolvierendes Modell, welches durch laufendes Refactoring verbessert wird, und dessen Umsetzung auf Softwareplattformen durch modellgetriebene Softwareentwicklung unterstützt werden kann.

Plain Old Java Objects (POJOs) und Plain Old CLR Objects (POCOs)

POJOs und POCOs sind technische Konzepte aus Java und .NET. Sie basieren allerdings auf der in DDD ebenfalls propagierten Ansicht, dass Fachobjekte ausschließlich Anforderungen der Fachlichkeiten des Domänenmodells und nicht technologiespezifische Anforderungen implementieren sollen.

Naked Objects

Naked Objects ist ein Architekturmuster, welches wie DDD davon ausgeht, dass die gesamte Fachlogik in Fachobjekten abzubilden ist. Darüber hinaus propagiert das Naked Objects Architekturmuster, dass die Benutzerschnittstelle eine direkte Abbildung der Fachobjekte sei und somit vollständig aus den Fachobjekten generiert werden sollte – eine Forderung, die DDD nicht stellt.^[16]

Objektorientierte Persistenzmechanismen

Objektorientierte Persistenzmechanismen wie Objektrelationale Abbildung oder Objektdatenbanken beschäftigen sich mit dem Ersatz der Datenzugriffsschicht unter den Fachobjekten. Sie sind somit eine synergetische Ergänzung für Domain-driven Design, da sich damit die Architektur noch stärker auf die Fachobjekte zentriert.

Data Context Interaction (DCI)

Data Context Interaction ist ein Architekturmuster, welches die Bestandteile des Domänenmodells des Domain-driven Designs (Entitäten, Wertobjekte, Aggregate, Serviceobjekte und Fachliche Ereignisse) ergänzen kann, beziehungsweise durch diese ergänzt werden kann. So können die Datenobjekte von DCI durch die Entitäten, Wertobjekte und Aggregate von DDD verfeinert werden, Kontext Objekte wiederum lassen sich durch Serviceobjekte und Fachliche Ereignisse abbilden. Die Rollen der Interaktionen von DCI jedoch erweitern wiederum die Bestandteile des Domain-driven Designs. Beide Technologien können also durchaus als kompatibel und einander ergänzend betrachtet werden.

Domänenspezifische Sprache (DSL)

Eine domänenspezifische Sprache (domain-specific language, DSL) ist eine formale Sprache, die speziell für ein bestimmtes Problemfeld (die Problemdomäne) entworfen und implementiert wird. DDD ist selbst keine und benötigt auch keine DSL, um funktionieren zu können.

Aspektorientierte Programmierung (AOP)

AOP ist eine Technologie, die es im DDD ermöglicht, bestimmte, sonst üblicherweise tief verwobene technische Aspekte (wie Logging, Security, Transaktionsmanagement) vom Domänenmodell zu trennen. Damit wird es einfach, dem von DDD gestellten Anspruch der vollständigen Trennung des Domänenmodells vom Rest der Applikation gerecht zu werden.

Werkzeug- und Materialansatz (WAM)

WAM ist eine Methode zur Software-Entwicklung, die auf Anwendungsorientierung und hohe Gebrauchsqualität ausgerichtet ist und viele Ähnlichkeiten zu DDD hat. Insbesondere die „Building Blocks“ aus DDD entsprechen in großen Teilen den Entwurfsmetaphern in WAM. Wichtige Idee von WAM ist es, die Werkzeuge und Materialien, mit denen ein Anwender in der realen Welt arbeitet auch in die Software zu übertragen. Sie sollen dort für den Anwender, aber auch im Code vorhanden sein.

Anämisches Domänenmodell und Transaction Scripts

Bei einem anämischen (lat. für blutleer) Domänenmodell enthalten die Fachklassen keine Businesslogik, Entities sind beispielsweise reine Datenstrukturen. Die Businesslogik wird dann üblicherweise in Service-Klassen mit je einer Methode je Fachlichkeit abgebildet. Diese Methode nennt man auch Transaction Script, da sie alle notwendigen Schritte, von Berechnungen über Validierungen bis zu direkten Datenbankzugriffen innerhalb einer Transaktion abbildet.^[17] Für Software mit simpler Fachlichkeit und trivialen Datenstrukturen ohne komplexes Mapping auf eine Datenbank, ist ein anämisches Domänenmodell und Transaction Scripts oft eine geeignete Lösung.

• Eric Evans: Domain-Driven Design. Tackling Complexity in the Heart of Software. Addison-Wesley, 2003, ISBN 0-321-12521-5 (englisch, domaindrivendesign.org). 
• Floyd Marinescu, Abel Avram: Domain-Driven Design Quickly. Lulu Press, 2006, ISBN 1-4116-0925-5 (englisch, InfoQ). 
• Jimmy Nilsson: Applying Domain-Driven Design and Patterns. With Examples in C# and .NET. 2006, ISBN 0-321-26820-2 (englisch, Artikel auf InfoQ). 
• Tim McCarthy: .NET Domain Driven Design with C#. Problem – Design – Solution. Wiley, 2008, ISBN 978-0-470-38402-2 (englisch). 
• Dan Haywood: Domain-Driven Design using Naked Objects. Pragmatic Programmers, 2009, ISBN 978-1-934356-44-9 (englisch, pragprog.com). 
• Vaughn Vernon: Implementing Domain-Driven Design. Addison-Wesley, 2013, ISBN 978-0-321-83457-7 (englisch). 
• Vaughn Vernon: Domain-Driven Design kompakt. dpunkt, 2017, ISBN 978-3-86490-439-4 (englisch: Domain-Driven Design Distilled. 2016. Übersetzt von Carola Lilienthal und Henning Schwentner). 

• Putting the Model to Work und Strategic Design, 2-teiliger Vortrag von Eric Evans auf der JAOO vom 6. November 2007
• Domain Driven Design, Interview mit Jimmy Nilsson
• Eric Evans: What I’ve learned about DDD since the book. Vortrag, ursprünglich präsentiert auf der QCon London 2009, aufgenommen bei DDD-NYC SIG.
• DDD Community
• Dan Haywood: An Introduction to Domain Driven Design. Methods & Tools, 2009, abgerufen am 12. Juli 2010 (englisch). 
• Eric Evans: Domain-Driven Design: Reference Definitions and Pattern Summaries. (PDF; 473 kB)
• Golo Roden: DDD & co. (deutsch) abgerufen am 24. Juli 2021

1. ↑ ^{a b} Eric Evans: Domain-Driven Design. Tackling Complexity in the Heart of Software. Addison-Wesley, 2003, ISBN 0-321-12521-5 (englisch, dddcommunity.org [abgerufen am 3. März 2023]). 
2. ↑ Definition von DDD lt. dddcommunity.org
3. ↑ Eric Evans: Domain-Driven Design. Tackling Complexity in the Heart of Software. Addison-Wesley, 2003, ISBN 0-321-12521-5, S. xxii (englisch, dddcommunity.org [abgerufen am 3. März 2023]). 
4. ↑ Floyd Marinescu, Abel Avram: Domain-Driven Design Quickly. Lulu Press, 2006, ISBN 1-4116-0925-5, Kap. 1, S. 4 (englisch, InfoQ: Domain Driven Design Quickly). 
5. ↑ hexagonale Architektur
6. ↑ An Introduction to Domain Driven Design. In: www.methodsandtools.com. Abgerufen am 21. Oktober 2016. 
7. ↑ Anemic Domain Model
8. ↑ Präsentation auf der JAOO vom 6. November 2007 von Eric Evans, Präsentation auf InfoQ
9. ↑ Domain-driven Design (DDD): Back to the roots. In: SMF. 20. April 2022, abgerufen am 30. Juni 2022 (deutsch). 
10. ↑ Domain-Driven Design Starter Modelling Process. Domain-Driven Design Crew, 30. Juni 2022, abgerufen am 30. Juni 2022. 
11. ↑ Vaugh Vernon: Implementing Domain-Driven Design. Addison-Wesley, 2013, ISBN 978-0-321-83457-7 (englisch, 612 S.). 
12. ↑ Eric Evans: What I’ve learned about DDD since the book. (Video) Domain Language, Inc., Mai 2009, abgerufen am 23. Oktober 2010 (englisch, Diskussion der Domain Events von 13:00 bis 28:05. Präsentation aufgenommen bei DDD-NYC SIG, ursprünglich präsentiert auf der QCon London 2009). 
13. ↑ Domain-driven Design Quickly, Kapitel 5 Seiten 67ff
14. ↑ Carola Lilienthal, Henning Schwentner: Domain-Driven Transformation. Monolithen und Microservices zukunftsfähig machen. Hrsg.: dpunkt.verlag. dpunkt.verlag, Heidelberg 2023, ISBN 978-3-86490-884-2 (312 S.). 
15. ↑ Henning Schwentner: Domain-Driven Refactorings. Abgerufen am 22. Juni 2025 (englisch). 
16. ↑ Dan Haywood: Domain-Driven Design using Naked Objects. Hrsg.: Pragmatic Programmers. Pragmatic Programmers, 2009, ISBN 978-1-934356-44-9 (englisch, Domain-Driven Design using Naked Objects). 
17. ↑ Martin Fowler: Transaction Script. Organizes business logic by procedures where each procedure handles a single request from the presentation. Abgerufen am 9. Juli 2022 (englisch): „Most business applications can be thought of as a series of transactions. A transaction may view some information as organized in a particular way, another will make changes to it. Each interaction between a client system and a server system contains a certain amount of logic. In some cases this can be as simple as displaying information in the database. In others it may involve many steps of validations and calculations. A Transaction Script organizes all this logic primarily as a single procedure, making calls directly to the database or through a thin database wrapper. Each transaction will have its own Transaction Script, although common subtasks can be broken into subprocedures.“