Quatre points clés qui distinguent une équipe performante
On peut parler de craft, de pipelines CI/CD et d'automatisations, de pratiques et de culture tech. Tout cela est essentiel, mais ce n'est pas mon top quatre.
Voici mon top quatre :
- Ils analysent la complexité en profondeur, et cela se passe dans les conversations plutôt que dans le code.
- Ils exposent et testent les choix d'architecture pour garantir l'adaptabilité future, là aussi par la conversation plutôt que par le code.
- Ils co-créent une solution qui peut se développer de façon itérative, en se concentrant d'abord sur ce qui compte et en apportant de la valeur dès la toute première étape.
- Dès leur premier morceau codé, ils vont chercher du feedback et évaluent l'impact de leur effort.
Chaque point a sa section ci-dessous, avec le mécanisme qui va avec.
Pourquoi la complexité vit-elle dans les conversations plutôt que dans le code ?
Le code enregistre les décisions. Il n'enregistre pas les questions qui les ont produites. Une équipe qui commence à coder avant d'avoir répondu à ces questions les retrouvera plus tard : dans un rapport de bug, un appel au support ou une réécriture.
Deux personnes peuvent utiliser le même mot et parler de deux choses différentes. « Compte » peut vouloir dire un login, un contrat ou une entité de facturation. Le code ne montrera pas la différence tant qu'un bug ne l'aura pas fait. Dans une conversation, la différence sort dès que quelqu'un demande ce que le mot veut dire.
C'est pour cela que la complexité doit être analysée en conversation. Chaque fichier écrit par-dessus une décision rend cette décision plus chère à changer. Une réponse donnée en réunion coûte quelques minutes. La même réponse, donnée après un mois de code, peut coûter un refactoring de tous les modules qui utilisent le mauvais concept.
Comment tester un choix d'architecture avant de le coder ?
Les choix d'architecture sont des paris sur l'avenir. Un pari peut se tester dans une salle, avant que quiconque écrive une ligne.
Écrivez le choix en un paragraphe. Puis écrivez le changement qui le rendrait faux. Demandez à l'équipe comment le design survit à ce changement. Des questions comme « que se passe-t-il quand le prestataire de paiement change ? » ou « que se passe-t-il quand un deuxième pays arrive ? » en révèlent souvent plus qu'un schéma de boîtes et de flèches.
Le mécanisme : l'adaptabilité ne se voit que sous le changement. Le code montre comment quelque chose marche aujourd'hui. Une conversation peut pousser un design dans un futur qui n'existe pas encore. Les points faibles apparaissent alors dans la salle, pas en production.
David Parnas a donné en 1972 le critère pour tracer ces lignes. Un module doit cacher les décisions de design qui ont le plus de chances de changer. Une frontière tracée autour d'un changement probable garde ce changement local. Une frontière tracée ailleurs propage chaque changement dans tout le système.
Heuristique : changez le scénario dans la conversation, pas le code dans le dépôt.
Sur quoi une équipe doit-elle se mettre d'accord avant la première ligne de code ?
Le point trois parle de valeur. Une complexité sans valeur nommée, c'est un coût sans retour. L'équipe doit donc écrire qui utilise la feature et ce qui change pour cette personne. Tout ce qui ne peut pas être rattaché à un utilisateur et à une valeur est du gaspillage.
Mary et Tom Poppendieck rangent « eliminate waste » parmi les principes du lean software development. En pratique, le gaspillage, c'est la feature que personne n'a demandée, l'option que personne ne configurera et la couche dont personne n'a encore besoin.
Alistair Cockburn appelle walking skeleton la plus petite version d'un système qui tourne de bout en bout. Elle n'a pas besoin du design final. Elle doit relier les parties principales et livrer une petite fonction du début à la fin. Une fois qu'elle tourne, l'équipe a quelque chose de réel à discuter.
Le user story mapping de Jeff Patton est fait pour cette conversation. L'équipe pose à plat ce que font les utilisateurs, puis découpe dans cette carte une première release fine. La première tranche est celle qu'il faut co-créer, parce que c'est d'elle que l'équipe apprendra en premier.
Quand demander du feedback sur le premier morceau ?
Le point quatre dit que l'évaluation a lieu quelques jours après le code, si possible dès le premier jour, et pas à la fin du projet. Dès que le morceau marche de bout en bout, et avant que l'équipe construise dessus, mettez-le devant des utilisateurs et demandez-leur ce qu'ils voient.
Le mécanisme est une question de coût. Apprendre coûte le moins cher tant que la décision suivante est encore ouverte. Une fois que l'équipe a construit sur une hypothèse, la tester coûte plus cher, et la changer coûte plus cher. Mary et Tom Poppendieck comptent « amplify learning » parmi leurs principes lean pour la même raison.
Chaque morceau de code est une question posée aux utilisateurs. La réponse doit revenir tant que l'équipe peut encore en faire quelque chose. Posez la question avant de coder : qu'allons-nous apprendre de ce morceau, et comment le saurons-nous ?
Comment appliquer les quatre points, et les mesurer ?
Une équipe performante est data-driven, élimine le gaspillage en continu, et réussit grâce à ses compétences en communication et à son mélange d'expertises.
Mesurer demande une liste fixe. La recherche présentée dans Accelerate, sur laquelle s'appuie le travail de DORA, mesure la performance de livraison logicielle avec quatre métriques : la fréquence de déploiement, le lead time des changements, le taux d'échec des changements et le temps de restauration du service. Ces four keys sont une autre liste que les quatre points de cet article. Sans mesures, une équipe ne peut que deviner si ses conversations ont payé.
Voici comment mettre les points en pratique :
- Écrivez le problème sur une page avant de coder : les utilisateurs, les règles et les questions ouvertes.
- Listez les concepts que deux personnes pourraient définir différemment, et définissez chacun par écrit.
- Écrivez chaque choix d'architecture à côté du changement auquel il doit survivre.
- Découpez la première tranche jusqu'au plus petit chemin de bout en bout qui apporte de la valeur.
- Retirez toute feature qui n'a ni utilisateur nommé ni valeur nommée.
- Livrez le premier morceau, et récoltez du feedback en quelques jours.
- Décidez de l'étape suivante à partir de ce feedback, et notez la décision.
La conversation peut devenir du gaspillage, elle aussi. Une réunion sans décision coûte du temps à l'équipe. Un petit changement facile à annuler peut partir directement en code, et le résultat devient le feedback. Les quatre points comptent le plus quand un changement coûte cher à défaire.
💡 À retenir : think twice, code once !
Ressources et bibliographie
- Mary Poppendieck, Tom Poppendieck, Lean Software Development: An Agile Toolkit (Addison-Wesley, 2003). https://www.oreilly.com/library/view/lean-software-development/0321150783/
- David L. Parnas, On the Criteria To Be Used in Decomposing Systems into Modules (Communications of the ACM, 1972). https://dl.acm.org/doi/10.1145/361598.361623
- Alistair Cockburn, Crystal Clear: A Human-Powered Methodology for Small Teams (Addison-Wesley, 2004). https://www.oreilly.com/library/view/crystal-clear-a/0201699478/
- Jeff Patton, User Story Mapping (O'Reilly, 2014). https://www.oreilly.com/library/view/user-story-mapping/9781491904893/
- Nicole Forsgren, Jez Humble, Gene Kim, Accelerate: The Science of Lean Software and DevOps (IT Revolution, 2018). https://itrevolution.com/product/accelerate/
- DORA (Google Cloud), DORA's software delivery metrics: the four keys (dora.dev). https://dora.dev/guides/dora-metrics-four-keys/
Publié d'abord sur LinkedIn : le post d'origine
