Qualité interne et ralentissement du rythme de livraison : pourquoi le code se dégrade et comment l'éviter
Introduction
Un étonnement revient souvent dans les équipes avec qui je travaille : "Pourquoi est-ce que faire un changement prend deux semaines ? Il y a deux ans, faire un changement similaire prenait deux jours."
Un des facteurs est un problème de visibilité. Une fonctionnalité livrée est visible : elle est dans le backlog, anticipée et estimée. La dégradation progressive du code, elle, est invisible. On ne la voit pas s'accumuler. On a du mal à la mesurer. Et son poids se fait sentir avec un effet retard, quand il est déjà devenu coûteux et non trivial de la corriger.
De plus, les arbitrages se font naturellement en faveur du visible sur l'invisible, jusqu'au jour où l'invisible devient le problème dominant.
La dégradation silencieuse du design interne
Qu'est-ce que la dégradation progressive du code ? Pourquoi se produit-elle ?
Martin Fowler décrit le phénomène dans *Refactoring* :
Without refactoring, the internal design — the architecture — of software tends to decay. As people change code to achieve short-term goals, often without a full comprehension of the architecture, the code loses its structure. It becomes harder for me to see the design by reading the code. Loss of the structure of code has a cumulative effect. The harder it is to see the design in the code, the harder it is for me to preserve it, and the more rapidly it decays.
Sans refactoring, la structure interne — l'architecture — du logiciel tend à se dégrader. À mesure qu'on change le code pour atteindre des objectifs à court termes, souvent sans une compréhension complète de l'architecture, le code perd sa structure. Il devient plus difficile pour moi de voir la structure en lisant le code. La perte de la structure du code a un effet cumulatif. Plus il est difficile de voir la conception dans le code, plus il est difficile pour moi de la préserver, et plus elle se dégrade rapidement.
Un point important dans cette citation, c'est l'effet cumulatif. La dégradation n'est pas linéaire : plus le code perd sa structure, plus il est difficile de la retrouver et de la maintenir. C'est un cercle vicieux.
Fowler ajoute cette observation :
Poorly designed code usually takes more code to do the same things, often because the code quite literally does the same thing in several places.
Du code mal conçu nécessite généralement plus de code pour faire la même chose, souvent parce que le code fait littéralement la même chose à plusieurs endroits.
Dans cet exemple un code dégradé produit de la duplication, et la duplication ralentit toutes les modifications futures.
Comme le dit J. B. Rainsberger, lutter contre ce phénomène n'est pas (que) une question de beauté du code. L'éventuelle "beauté" du code n'est qu'un moyen. Le but recherché est de garder le contrôle du coût des features.
Refactoring reduces the volatility in the marginal cost of features!
Le refactoring réduit la volatilité du coût marginal des fonctionnalités !
En comptabilité, le coût marginal est défini comme la variation du coût engendrée par la production ou la vente d'une unité supplémentaire (Wikipedia). Quand cette variation augmente, réaliser une feature donnée devient de plus en plus imprévisible et coûteux. On comprend l'intérêt de réduire ce coût.
La cuisine et le garage
Comment lutter contre ce phénomène ? Pour commencer à répondre, je propose de s'intéresser à sa dynamique. Pour l'illustrer, je prends l'exemple de la cuisine et du garage.
Dans une cuisine, on alterne constamment entre cuisiner et nettoyer. Pendant qu'on fait revenir les oignons, on lave la planche à découper. Ce n'est pas du temps perdu, c'est ce qui permet de continuer à travailler. Le plan de travail reste utilisable en permanence.
Dans un garage, on accumule. Et une fois par an, si on a le courage, on décide de "ranger le garage". Cela prend des heures, parfois des jours, et plusieurs voyages à la déchèterie.
Les bases de code qui deviennent difficiles à modifier sont souvent gérées comme des garages. Pendant leur développement comme on l'a vu plus haut, les dégradations de design se sont accumulées de manière peu visible, et on n'a pas rangé au fur et à mesure comme dans une cuisine. On s'est régulièrement dit : "on verra ça plus tard", "on verra à la fin", ou "on n'a pas le temps de ..." Jusqu'au jour où "plus tard" c'est maintenant, et la correction demande plusieurs semaines de travail. On se retrouve alors à devoir vider le garage sous pression, et au plus mauvais moment. Car on n'a toujours pas le temps, mais en plus maintenant on n'a plus le choix.
Do the right thing, do the thing right : alterner vite, pas différer
Je reviens sur "On verra ça plus tard". Il y a un adage qu'on entend parfois :
Do the right thing, do the thing right.
Cet adage est souvent mal compris. On pourrait l'interpréter comme une invitation à d'abord faire fonctionner quelque chose, puis à ne s'occuper de la qualité qu’à la fin. Ce n’est pas ce que cet adage signifie dans les contextes où il est employé.
En passant, on retrouve la même idée dans Unix et Extreme Programming :
Make it work, make it right, make it fast.
Le contresens serait de comprendre que c’est une invitation à reporter toutes les améliorations à la fin de mon développement. Il s’agit plutôt d’alterner rapidement entre faire fonctionner un cas et améliorer le code qu’on vient d’écrire, de ne jamais séparer longtemps ces deux préoccupations.
Il est en effet intéressant de commencer par faire fonctionner mon code (make it work), puis de l’améliorer ensuite (make it right). De la même manière que je ne peux pas écrire un roman parfait au premier jet, j’ai besoin d’étapes pour faire évoluer mon code. Mais On retrouve cette alternance rapide dans le cycle TDD : rouge, vert, refactor. On écrit un test qui exprime l'intention. On le fait passer le plus simplement possible. Puis on améliore l'implémentation dans la foulée.
Ce cycle se compte en minutes, pas en jours. À la fin de la journée, le code n'est pas en attente d'amélioration : il a été amélioré au fil de l'eau. Ce n'est donc pas une invitation à remettre la qualité à plus tard. C'est une invitation à inclure la qualité dans notre façon de fabriquer du logiciel.
Trois exemples d'activités invisibles
J'ai parlé de dégradation du design interne, mais il y a d'autres activités invisibles qui sont importantes et qui nous freinent si on les ignore longtemps. Il est utile de les avoir en tête pour pouvoir les expliciter, les inclure dans le développement de features, et en parler avec les parties prenantes non techniques.
Limiter la dégradation du design interne
On en parle depuis le début. Elle est limitée par le refactoring régulier, la revue de code, et l'alignement de pratiques entre les membres de l'équipe. Ce n'est pas du travail "en plus" de la fonctionnalité : c'est une partie intégrante de la livraison.
Ne pas casser l'existant
Chaque modification du code apporte le risque de régression sur des comportements existants. Les tests automatisés sont le principal outil pour détecter ces régressions rapidement. Sans eux, ce travail se fait manuellement et plus tard, donc coûte plus cher. Ou ne se fait pas, et les conséquences se retrouvent en production au plus mauvais moment, sous la forme des fameuses régressions. Éviter ces régressions fait partie de nos activités et prend du temps.
Faciliter l'extension future
Certains choix de conception rendent les modifications futures plus faciles, d'autres les rendent plus difficiles. Ce n'est pas visible immédiatement, mais cela explique pourquoi deux fonctionnalités apparemment similaires peuvent avoir des coûts de développement très différents. À nouveau, c’est une tâche qui fait implicitement partie des développements logiciels et qui prend du temps.
Je ne propose pas ici d’anticiper de nombreux cas en amont, mais quand il y a plusieurs solutions possibles, de prendre le temps de les évaluer et de choisir la solution la plus adaptée avec le niveau de connaissances qu’on a. La solution la plus simple par exemple (the simplest thing that could work). Un autre exemple est de supprimer les duplications de connaissances dans le code si on en a introduites. Faciliter l’extension future peut rester très simple, c’est même un bon but à se donner. L’idée est que ça fait partie du travail à faire.
Une autre façon de faciliter l’extension future est de s'entraîner à changer notre code, et de conserver un code relativement facile à changer. On voit bien qu’il ne s’agit pas de prévoir le futur, mais au contraire de s’assurer qu’on pourra s’y adapter avec un effort raisonnable quand le futur adviendra avec son lot d'imprévus. Dans Tidy First, Kent Beck parle de conserver nos options.
Software design is preparation for change; change of behavior. [...] Design we do today is the premium we pay for the “option” of “buying” the behavior change tomorrow.
La conception logicielle est une préparation au changement, un changement de comportement. [...] La conception que nous réalisons aujourd’hui est le prix à payer pour s’offrir l’« option » d’« acquérir » ce changement de comportement demain.
Ces trois activités se recoupent, mais elles ne sont pas identiques. Les nommer séparément aide à avoir des conversations plus précises dans l'équipe et aide à créer un alignement.
Ce qu'il faut accélérer : le feedback, pas le développement
Pourquoi veut-on aller vite ? Si on veut accélérer, qu'est-ce qu'on veut accélérer ? Est-ce que “accélérer” c'est "écrire plus de code plus vite" ? Je pense qu'il y a mieux.
Ce qui distingue les équipes qui maintiennent leur vélocité dans la durée, c'est la rapidité de leur boucle de feedback : feedback sur le comportement du code (tests automatisés), feedback sur la direction produit (démos fréquentes), feedback sur la qualité interne (revues de code régulières, tests automatisés, revues d'architecture).
C'est ce feedback rapide qui permet de réagir aux désalignements, de réduire les coûts de les corriger et d’éviter le coût de ne pas les corriger.
Quand la boucle de feedback s'allonge, tout se dégrade. Les problèmes s'accumulent avant d'être détectés. Les corrections deviennent plus coûteuses. C'est souvent le premier signe d'alerte en agilité : quand les rétrospectives s'espacent, que les démos deviennent des rapports, que les tests automatisés ne sont plus maintenus, l'agilité réelle disparaît, même si le vocabulaire reste.
Sur-capacité silencieuse
Comment est-ce qu'on en arrive là ? Quand le développement de features s'allonge, ce n'est pas forcément que l'équipe fait moins d'efforts. C'est souvent qu'elle est en sur-capacité : une part croissante de son énergie part dans la navigation d'un code dégradé, les contournements, le travail non prévu. Le backlog ne le montrera pas. Mais vous observerez sans doute une baisse progressive de vélocité.
Attention à une fausse bonne idée répandue. On pourrait imaginer que si l'équipe a trop de travail, ajouter des personnes pourrait améliorer la situation. Ce n'est pas impossible pour des situations très spécifiques. Par exemple, si : parmi les tâches du moment il y a "intégrer Keycloak", alors : ajouter temporairement un ou une experte Keycloak dans l'équipe va beaucoup aider. Cependant, le cas général est qu'ajouter des personnes à un projet en retard ne fait qu'ajouter au retard. Comme le dit la loi de Brooks :
Adding manpower to a late software project makes it later.
On verra plus bas de meilleures idées pour aider à sortir de l'ornière et éviter la surchauffe.
Les leviers de l'équipe
Qu'est-ce qui peut nous aider en tant qu'équipe à gérer cette qualité au fil de l'eau, un peu comme quand on range un cuisine, et à ne pas nous retrouver en surchauffe ?
Je précise "en tant qu'équipe" car une bonne pratique individuelle ne suffit pas si le reste de l'équipe ne la partage pas. C'est en équipe qu'on aborde au mieux les trois activités invisibles décrites plus haut, et les traiter nécessite un alignement de nos pratiques.
Intégrer la qualité dans la définition du "done"
Si les critères de "done" n'incluent pas explicitement la qualité interne du code, le refactoring sera toujours optionnel, donc toujours différé. Le rendre explicite change le statut du travail : ce n'est plus une bonne intention, c'est une condition de livraison. Cependant c'est difficile à mesurer et à rendre concret comme critère. Ce que j'ai observé et qui fonctionne, est d'avoir dans l'équipe des personnes compétentes en la matière, et pour qui c'est important. Elles peuvent jouer le rôle de porte parole régulier de la qualité, dans les code review et dans l'animation des compétences de l'équipe par exemple, et si c'est nécessaire, de "poil à gratter". Quelqu'un qui va savoir porter un sujet impopulaire sans crainte, tout en sachant l'analyser et l'expliquer. Attention à éviter un antipattern cependant : le "garant" de la qualité en mode "gate keeper".
Aligner nos pratiques en tant qu’équipe
Quand on n’a pas le temps de s’améliorer en tant qu’équipe, on n’a pas le temps non plus d’aligner nos pratiques. Or, tous nos désalignements vont accélérer la dégradation de notre base de code. Aligner nos pratiques est un des leviers que nous avons pour limiter cette dégradation. Christophe Thibaut donne de nombreux conseils à ce sujet dans sa série sur la dette technique et les procédés en conflit :
Découper le travail pour que "Make it work + Make it right" soit possible
Quand les tâches sont trop grosses, on ne peut pas alterner vite entre "faire fonctionner" et "bien faire". Découper finement, c'est ce qui rend le cycle cuisine possible plutôt que le cycle garage. On retrouve cette idée de découper finement dans la capacité Working in Small Batches de DORA (DevOps Research & Assessment).
Inclure la gestion de la dégradation du design dans nos priorités
"On n'a pas le temps de bien faire" est rarement une contrainte objective. C'est souvent le signe que les arbitrages se font sans visibilité sur ce qui s'accumule. Nommer la dégradation, la montrer concrètement (temps passé sur des bugs, fonctionnalités qui prennent de plus en plus longtemps), en discuter permet de changer les arbitrages et de prioriser.
On entend souvent parler de "dette technique" à ce sujet. J'ai essayé d'éviter cette expression le plus possible, car cette expression a tendance à abstraire les problèmes. Je préfère parler des problèmes eux-mêmes et de leurs conséquences que de leur catégorie. De plus, beaucoup de choses ont déjà été écrites sur la dette technique. Si vous souhaitez utiliser cette métaphore et rendre visible votre dette technique, vous trouverez de nombreuses références sur le sujet. Attention cependant à ne pas vous contenter de produire un beau dashboard de dette technique. Sans actions concrètes de l'équipe (voir autres sections), le sujet n'avancera pas.
Rendre le coût de la dégradation visible, la clarifier est utile. On pourrait avoir envie de la quantifier, avec des indicateurs qu’on pourrait suivre. Si vous avez ce genre d’indicateurs, ou si vous savez les mettre en place, vous pouvez le faire. Attention cependant à la loi de Goodhart :
Toute régularité statistique observée tend à perdre toute crédibilité dès qu'elle est mise sous tension à des fins de contrôle.
Dit plus simplement :
Quand une mesure devient un objectif, elle cesse d'être une bonne mesure.
On pourrait aussi essayer de calculer le coût de ne pas traiter cette dégradation. Ou bien le ROI (Return On Investment) de cette prise en compte des facteurs invisibles. Si vous êtes dans un contexte où c’est possible, vous pouvez le faire. Attention cependant à ce que propose Etienne Girot dans son article Accélérer le développement : une histoire de plomberie :
calculer le ROI d'un changement de pratique dans un système comprenant plusieurs dizaines de personnes, tout autant de briques techniques et des boucles de rétroaction à retardement c'est (presque) mission impossible. Pour pouvoir arriver à donner un tel chiffre, il faudrait lisser tout ça en faisant de nombreuses approximations, et, même comme ça, il serait nécessaire d'avoir accès à des grandeurs dont la plupart des entreprises n'ont pas conscience, préfèrent ignorer ou ne souhaitent pas divulguer : le coût de la non-qualité (taux de rework) et la valeur des features produites. Entre ces grandeurs inconnues et les simplifications de la réalité faites à la hache, un calcul de ROI, même fait consciencieusement, serait tellement bancal qu'il ne réussirait pas à convaincre.
Mais calculer et rendre visible sont des moyens, pas des objectifs. j’aime garder en tête que l’objectif principal est de prendre en compte cette dégradation, et les autres facteurs invisibles, dans nos conversations et dans le choix de nos priorités. Alors, comment inclure la gestion de la dégradation du design dans nos priorités ? Plutôt que d’appliquer une recette, ma préférence est de demander à l’équipe afin d’avoir une solution adaptée au contexte. Voici ce que propose Todd Conklin dans sa conférence “The New View of Safety” :
Workers are not the problem – They are the problem solvers. We don’t tell the workers what to do – ask them what they need.
Éviter la surchauffe
Un début de solution évidente quand on se rend compte qu'on n'arrive pas à absorber la charge actuelle est... D'accepter de faire moins de choses. C'est le plus difficile à faire dans mes observations, mais ça reste souvent la meilleure chose à faire en attendant que l'équipe soit capable d'encaisser une charge plus importante. Grâce par exemple à l'amélioration continue, à la formation, à une meilleure qualité interne, à un meilleur alignement, tout ce qu'on aura eu le temps de mettre en place pour nous améliorer ensemble. Pour caricaturer, je dirais que si la voiture est en panne, il vaut mieux prendre le temps d'aller chercher de l'essence que de continuer à pousser.
Comme dit plus haut, on peut aussi estimer la part du travail non prévu à chaque sprint et la nommer en rétrospective plutôt que de l'absorber en silence. Ça permet de rendre la situation visible et analysable.
Réduire le WIP (Work In Progress) libère de la bande passante pour finir proprement ce qui est commencé ("Stop starting, start finishing").
Autre technique : supprimer des items du backlog. On a notre backlog produit, peut-être notre backlog technique, notre backlog individuel, nos todo lists… Gérer ces listes peut devenir un frein si elles deviennent trop grosses. Savoir choisir ce qu’on ne fera pas est tout aussi important que savoir choisir quoi faire. Ce ticket qui est dans le backlog depuis deux ans est probablement un poid mort qui vous ralentit, l’équipe peut décider de le supprimer. Ce travail de suppression est utile quand il est fait régulièrement. Si une personne a le rôle de Product Owner, elle peut vous aider : choisir ce qu’on ne fera pas fait partie de ses responsabilités. Elle pourra même éviter que trop de choses entrent dans le backlog en amont.
Du côté du management, la réaction instinctive quand la vélocité baisse est d'augmenter la pression, ce qui risque d'aggraver le problème et d'inciter à le masquer. Il vaut mieux interpréter la vélocité comme un indicateur de santé du système, et, quand elle est mauvaise, créer de l'espace dans les cycles pour les améliorations proposées plus haut, plutôt que de mettre ces améliorations en compétition avec les features. On retrouve l'idée de la cuisine et du garage.
Communiquer en continu
Comme nous n’avons jamais assez de temps pour faire toutes les améliorations que nous espérions, ni pour réaliser toutes les fonctionnalités que nous souhaiterions, il y a un équilibre à trouver. Toutes les propositions déjà citées sont à arbitrer en permanence.
Donc nous devrons continuer à avoir des conversations sur ces sujets pendant toute la durée de vie du projet. Pour éviter l’effet “conversation qui revient en boucle”, conservez de la curiosité pour le sujet et pour les contraintes de votre projet. Et peut-être plus important, prenez soin de vos relations entre personnes. Conservez les canaux de communication ouverts.
Conclusion
La vélocité d'une équipe ne dépend pas seulement de ses compétences ou de ses outils. Elle dépend aussi de l'état de son code, de la rapidité de ses boucles de feedback, et de la charge qu'elle absorbe.
Les équipes qui maintiennent leur capacité à livrer dans la durée ne sont pas celles qui vont le plus vite à court terme. Ce sont celles qui traitent la qualité interne comme une partie intégrante du flux de travail, pas comme une activité différée. C'est la différence entre une cuisine qui tourne et un garage qu'on n'ose plus ouvrir.
Références
- Refactoring, 2nd edition (Martin Fowler)
- Make it work, make it right, make it fast (wiki C2)
- The Eternal Struggle Between Business and Programmers (J. B. Rainsberger)
- Loi de Goodhart (Wikipedia)
- Working in Small Batches (DORA)
- Accélérer le développement logiciel : une histoire de plomberie (Étienne Girot)
- The New of Safety (Todd Conklin)