Domain-Driven Design et EventStorming : des frontières du domaine qui tiennent dans le code comme dans les équipes

Le Domain-Driven Design (DDD) conçoit le logiciel à partir du domaine métier, c’est-à-dire des mots, des règles et des frontières avec lesquels l’entreprise travaille. Nous animons l’EventStorming avec ceux qui connaissent le métier et ceux qui écrivent le code, puis nous restons auprès de votre équipe pour traduire ce qui en sort en bounded contexts, context map et modèles dans le code, jusqu’à ce qu’elle sache tenir ces frontières seule.

Ce travail s’impose avant deux décisions coûteuses : comment refactorer l’architecture et comment organiser les équipes autour du produit.

Réservez un appel

Quand a-t-on besoin du Domain-Driven Design ?

Le moment vient quand les frontières du logiciel ne correspondent plus à celles du métier, et que chaque évolution produit traverse des modules et des équipes qu’elle ne devrait pas toucher.

  • Une fonctionnalité qui s’explique en deux lignes demande des modifications dans de nombreux modules et la coordination de plusieurs équipes
  • Le même mot (client, commande, contrat) veut dire des choses différentes selon les parties du code et selon les réunions
  • Vous voulez modulariser le monolithe ou passer aux microservices, et personne ne sait dire où couper
  • Les règles métier sont éparpillées entre des services partagés, des requêtes et des interfaces, et seules deux ou trois personnes savent où les trouver
  • Les équipes sont organisées par couche technique ou par projet, et chaque mise en production oblige à les synchroniser

Tous ces signaux ont la même racine : l’architecture, l’organisation et le métier ont grandi chacun de leur côté. C’est pourquoi la cartographie du domaine vient avant le refactoring architectural et avant de redessiner les équipes. Découper un monolithe ou déplacer des personnes sans savoir où passent les frontières du métier revient à reporter le couplage ailleurs dans le système.

Que faisons-nous ?

Nous animons l’EventStorming aux trois niveaux, puis nous travaillons avec votre équipe pour installer le modèle qui en résulte dans le code et dans l’organisation.

EventStorming Big Picture

Nous déroulons sur un mur, physique ou numérique, tout le flux du métier raconté par événements, avec les équipes produit, métier et développement devant le même mur. Apparaissent les endroits où le travail s’enraye, les termes sur lesquels les gens ne s’accordent pas et les premières frontières possibles entre un contexte et un autre.

EventStorming Process Level

Nous prenons un processus à la fois, celui qui coûte le plus à modifier aujourd’hui, et nous le décomposons en commandes, règles, acteurs et systèmes externes. Les règles qui vivent dans la tête de quelques personnes deviennent explicites, et tout le monde peut les discuter.

EventStorming Design Level

Du processus, nous passons au logiciel avec les agrégats, les invariants à protéger et les événements de domaine que le code doit publier. Le modèle devient alors assez précis pour guider la conception des modules et des tests.

Bounded contexts et context map

Nous traçons les bounded contexts là où le langage change de sens, puis nous dessinons la context map des relations entre contextes. Elle dit qui dépend de qui, qui s’aligne sur le modèle de l’autre et où il faut une couche anti-corruption pour protéger un modèle d’un système externe ou legacy. Elle montre aussi quelles frontières le code ne respecte pas aujourd’hui.

Modélisation du domaine dans le code

Nous écrivons le modèle avec vos développeurs, en pair et en mob programming. Le langage du métier entre dans les noms des modules, des classes et des tests, et les patterns tactiques (agrégats, value objects, événements de domaine) arrivent là où ils résolvent un vrai problème. Le premier pas est souvent un monolithe modulaire aux frontières explicites, qui peut très bien tenir des années avant qu’il soit pertinent de parler de microservices.

Formation ciblée sur votre domaine

Quand l’équipe a besoin d’un socle commun, nous construisons des sessions de formation sur votre domaine et votre code, en début de parcours ou au fil du travail. Les exemples viennent de votre système, de sorte que ce qui s’apprend s’applique dès le lendemain.

Comment travaillons-nous avec votre équipe ?

L’atelier ouvre le travail, et le gros vient après, dans le code, avec les personnes qui le maintiendront.

Un mur de post-it change peu de choses à lui seul. Si, dans les semaines qui suivent, personne n’installe le modèle dans les modules, les noms et les tests, le système redevient ce qu’il était et l’atelier reste un beau souvenir partagé. C’est pourquoi, après l’animation, nos extreme programmers très seniors travaillent en binôme avec vos développeurs sur les évolutions que la roadmap demande de toute façon, et profitent de chacune pour déplacer une frontière ou clarifier un concept.

Les décisions de modèle restent à votre équipe. Nous animons et nous proposons, et le code s’écrit avec ceux qui en seront responsables. Un modèle écrit par ceux qui l’utilisent chaque jour est aussi celui qui reste à jour quand le produit évolue.

Le service peut être le début d’un parcours, avec une Big Picture et les premiers contextes portés dans le code, ou un travail continu qui accompagne le refactoring architectural ou la réorganisation des équipes. Les ateliers se tiennent sur site ou à distance avec un tableau numérique, de préférence sur site, car la discussion devant le mur fait partie du résultat. Nous adoptons votre stack et vos outils.

Que mesurons-nous pour nous orienter ?

Nous nous orientons toujours avec des mesures quand c’est possible, et quand ça ne l’est pas, nous décrivons les effets systémiques observés ou les facteurs à approfondir. Les mesures regardent dans quelle mesure les frontières du code et des équipes suivent celles du domaine, et si le travail circule mieux pendant que nous les déplaçons.

  • Le nombre de modules ou de contextes qu’une évolution produit typique doit toucher
  • Les parties du code qui changent toujours ensemble alors qu’elles sont dans des contextes différents, relevées dans l’historique des modifications
  • Le nombre de dépendances entre équipes nécessaires pour livrer une fonctionnalité en production

À côté de celles-ci, les métriques DORA, le cycle time, le lead time et le value stream mapping font partie des métriques et techniques que nous utilisons pour nous orienter dans l’amélioration continue.

Qu’est-ce qui change pour l’équipe et pour le produit ?

Métier et développement parlent la même langue, et une évolution produit typique reste à l’intérieur d’un seul contexte.

  • Les équipes produit et les développeurs emploient les mêmes termes en réunion et dans le code
  • Les règles métier ont une place précise et sont décrites par les tests
  • Le refactoring architectural suit une carte : on sait quoi séparer et dans quel ordre, et chaque découpe s’explique par une frontière du domaine que tout le monde reconnaît
  • Les frontières des équipes peuvent suivre celles du domaine, et les dépendances entre équipes diminuent
  • Les nouveaux arrivants comprennent le système en lisant le modèle, sans devoir interroger ceux qui étaient là avant
  • L’équipe sait refaire un EventStorming et mettre à jour la context map seule quand le produit évolue

Par où commencer ?

Vous pouvez commencer directement par un EventStorming Big Picture sur votre produit, ou par le diagnostic de la delivery logicielle, que nous conseillons quand on ne sait pas si le goulot d’étranglement vient des frontières du domaine ou d’ailleurs.

Le diagnostic examine ensemble le code, les pratiques, le processus et l’organisation, et indique si la cartographie du domaine est le pas qui débloque le reste. Ce n’est qu’un conseil : si vous savez déjà que le problème tient à l’endroit où passent les frontières, nous commençons par l’atelier.

Services associés

La cartographie du domaine est le point de départ de deux services, qui tirent de la context map l’ordre des travaux. Le diagnostic, si besoin, passe avant et dit s’il faut commencer ici.

  • Refactoring du code legacy : la context map dit quelles parties séparer en premier et où poser les frontières quand le monolithe doit être modularisé ou qu’une partie doit être remplacée
  • Organisation des équipes de développement : avec les bounded contexts en main, on peut dessiner des équipes alignées sur les frontières du domaine, chacune avec la responsabilité claire d’une partie du système
  • Diagnostic de la delivery logicielle : pour comprendre, avant de commencer, à quel niveau se trouve le goulot d’étranglement

Questions fréquentes

Qu’est-ce que l’EventStorming ?
L’EventStorming est une technique d’atelier, imaginée par Alberto Brandolini, où métier et développement reconstituent un domaine en alignant les événements qui s’y produisent. Elle s’emploie à trois niveaux de détail, Big Picture pour le flux entier, Process Level pour un processus et Design Level pour la conception du logiciel. En une seule session, elle fait ressortir des désaccords et des règles implicites qui, sinon, apparaîtraient dans le code, bien plus tard.
Quelle différence entre un atelier d’event storming et ce service ?
Un atelier laisse une carte partagée, et sa valeur dépend de ce qui se passe ensuite. En plus de l’animer, nous travaillons avec votre équipe dans le code pour porter cette carte jusqu’aux bounded contexts, aux modules et aux tests, et nous accompagnons les choix d’architecture et d’organisation qui en découlent.
Le Domain-Driven Design est-il utile si nous ne voulons pas passer aux microservices ?
Oui. Les bounded contexts sont des frontières logiques et fonctionnent aussi dans un monolithe, qui devient un monolithe modulaire dès que les frontières sont explicites. Dans beaucoup de systèmes, c’est le meilleur choix, et les microservices restent une option à évaluer quand un contexte a besoin de mises en production ou d’une montée en charge indépendantes.
Proposez-vous de la formation au Domain-Driven Design ?
Oui, une formation ciblée, construite sur votre domaine et votre code, en début de parcours ou au fil du travail. Nous n’avons pas de cours au catalogue, car le DDD s’apprend en l’appliquant à un problème que l’équipe connaît.
Qui doit participer à l’EventStorming ?
Les personnes qui connaissent le métier et celles qui écrivent le code, ensemble : product managers, experts du domaine, développeurs et ceux qui décident de l’architecture. Si l’un des deux côtés manque, la carte ne raconte que la moitié du système.
Sur quelles technologies travaillez-vous ?
Nous sommes agnostiques quant à la stack et nous adoptons les langages, frameworks et outils que votre équipe utilise déjà. Le Domain-Driven Design porte sur la façon de découper et de nommer les parties du système, et il s’applique dans toutes les technologies.

Vous voulez savoir où passent les frontières de votre domaine ?

Nous partons d’un appel : vous nous racontez le produit et les endroits où les modifications coûtent le plus, et nous voyons ensemble par quel niveau d’EventStorming commencer

Nous utilisons vos données pour répondre à votre demande. Consultez notre Politique de confidentialité.