<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Domain Driven Design :: Ma documentation</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/index.html</link><description>Le Domain Driven Design est une approche de conception logicielle formulée par Eric Evans en 2003 dans Domain-Driven Design: Tackling Complexity in the Heart of Software — le « livre bleu ». Son objet n’est ni une architecture, ni une bibliothèque de patrons : c’est une réponse à une observation simple. Dans un logiciel d’entreprise qui dure, la complexité qui coûte le plus cher n’est pas technique, elle est métier. Et le seul levier dont on dispose contre elle est un modèle — une représentation partagée du domaine, comprise autant par les développeurs que par les gens du métier, et inscrite dans le code.</description><generator>Hugo</generator><language>fr-FR</language><atom:link href="https://quentinpigne.github.io/architecture/domain-driven-design/index.xml" rel="self" type="application/rss+xml"/><item><title>Langage omniprésent</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/langage-omnipresent/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/langage-omnipresent/index.html</guid><description>VoletStratégique Le point de départ de DDD, et celui qu’on croit toujours avoir déjà réglé.
Dans un projet ordinaire, trois vocabulaires coexistent. Celui du métier — des gens qui parlent de « dossier », de « bordereau », de « régularisation ». Celui des développeurs — OrderDTO, processItem, statusFlag. Celui de la base — des tables héritées de 2011, des colonnes nommées flg_actif. Chaque conversation traverse deux traductions, et chaque traduction perd de l’information.</description></item><item><title>Sous-domaines</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/sous-domaines/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/sous-domaines/index.html</guid><description>VoletStratégique La page qui détermine où l’effort de modélisation est rentable — et où il est du gaspillage.
Problème et solution La distinction la plus clarifiante de tout DDD, et celle qu’on saute le plus souvent :
Nature Verbe Domaine et sous-domaines L’espace du problème — ce que fait l’entreprise On les découvre Contextes délimités L’espace de la solution — comment on décide de le modéliser On les conçoit Le domaine, c’est l’activité de l’entreprise : la vente de billets, le transport de colis, la gestion de sinistres. Il existe indépendamment de tout logiciel, et il ne se négocie pas. Les sous-domaines sont ses parties distinctes : la tarification, l’expédition, la comptabilité, l’authentification des utilisateurs. Ils ne sont pas non plus un choix — ils sont là, on les constate.</description></item><item><title>Contextes délimités</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/contextes-delimites/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/contextes-delimites/index.html</guid><description>VoletStratégique Le concept central de DDD. Si une seule notion doit être retenue de tout ce corpus, c’est celle-ci.
Un contexte délimité est une frontière explicite à l’intérieur de laquelle un modèle s’applique et chaque terme a exactement un sens. En dehors, le modèle ne prétend rien. Les mêmes mots peuvent y désigner autre chose, et c’est très bien.
Le problème qu’il résout Prenez le mot « client » dans une entreprise de taille moyenne, et posez la question à trois services.</description></item><item><title>Cartographie de contextes</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/cartographie-de-contextes/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/cartographie-de-contextes/index.html</guid><description>VoletStratégique Les frontières ne suffisent pas : reste à savoir qui dépend de qui, et à quelles conditions.
Une carte de contextes représente les contextes délimités d’un système et la nature de leurs relations. Sa particularité, et ce qui la rend inhabituelle pour un artefact technique, est qu’elle décrit deux choses à la fois : un flux de données et un rapport de force organisationnel. Les deux comptent, et le second est souvent le plus déterminant.</description></item><item><title>Entités et objets valeur</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/entites-objets-valeur/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/entites-objets-valeur/index.html</guid><description>VoletTactique Les deux briques de base du modèle — et le choix entre les deux est plus déterminant qu’il n’y paraît.
Warning Rappel de dosage avant d’entrer dans le détail : les patrons tactiques ne sont rentables que dans le cœur de métier. Sur un sous-domaine de support, un objet valeur par champ est une dépense sans retour. Voir Sous-domaines.
Le critère : identité ou valeur Une seule question sépare les deux notions.</description></item><item><title>Agrégats</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/agregats/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/agregats/index.html</guid><description>VoletTactique La notion la plus difficile de DDD, et celle qui rapporte le plus. C’est aussi celle qui est le plus souvent mal comprise — presque toujours de la même façon.
La question à laquelle un agrégat répond Ce n’est pas « comment regrouper mes classes ». C’est :
Quel ensemble de données doit être cohérent à chaque instant, et donc modifié dans une seule transaction ?</description></item><item><title>Services, dépôts et fabriques</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/services-depots-fabriques/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/services-depots-fabriques/index.html</guid><description>VoletTactique Les trois patrons de soutien : où loger la logique qui n’appartient à aucune entité, comment récupérer un agrégat, et comment en fabriquer un.
Service de domaine Un service de domaine porte une logique qui appartient bel et bien au domaine, mais à aucune entité ni objet valeur en particulier. Deux cas de figure, et deux seulement :</description></item><item><title>Événements de domaine</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/evenements-de-domaine/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/evenements-de-domaine/index.html</guid><description>VoletTactique Le mécanisme qui rend possible la quatrième règle des agrégats — et, plus largement, le découplage entre contextes.
Un événement de domaine est un fait métier significatif qui s’est produit. Trois caractéristiques, toutes conséquentes :
Il est au passé. ReservationConfirmee, PaiementRefuse, ColisExpedie. Un nom au présent ou à l’impératif — ConfirmerReservation — désigne une commande, c’est-à-dire une intention qui peut échouer. Un événement, lui, est déjà arrivé : on ne le refuse pas, on en tient compte.</description></item><item><title>Event storming</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/event-storming/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/event-storming/index.html</guid><description>VoletPratique L’atelier d’Alberto Brandolini. De tout DDD, c’est la pratique au meilleur rapport valeur/effort, et la seule applicable dès la semaine prochaine sans rien changer au code.
Le principe : réunir dans une même pièce les gens qui savent et les gens qui construisent, et modéliser le métier comme une suite d’événements sur un mur, avec des post-its. Pas de diagramme, pas d’outil, pas de notation à apprendre.</description></item><item><title>Mise en œuvre</title><link>https://quentinpigne.github.io/architecture/domain-driven-design/mise-en-oeuvre/index.html</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://quentinpigne.github.io/architecture/domain-driven-design/mise-en-oeuvre/index.html</guid><description>VoletPratique L’architecture qui va avec, les pièges qui font échouer les adoptions, le chemin dans un code existant — et les cas où il faut s’abstenir.
L’architecture qui va avec DDD ne prescrit aucune architecture. Il impose une seule contrainte, mais elle est forte : le domaine ne doit dépendre de rien. Ni ORM, ni framework, ni client HTTP, ni annotation.</description></item></channel></rss>