Reprise de code legacy : la méthode pour éviter les régressions
Une méthode issue de reprises réelles (une plateforme B2B en production depuis plusieurs années, un e-commerce refait à fonctionnalités identiques, une DXP repartie d’une base existante) : comprendre avant de modifier, sécuriser chaque mise en production, documenter et remettre à neuf par petites étapes validées avec les parties prenantes.
Quand j’arrive sur une base de code existante, ma première envie est rarement de commencer à la modifier. J’ai d’abord besoin de comprendre pourquoi elle fonctionne comme ça. Je l’ai fait sur plusieurs projets : une plateforme B2B en production depuis 2021 dont j’étais le développeur référent, un e-commerce refait à fonctionnalités identiques sur une API maintenue par un prestataire externe et une DXP repartie d’une base écrite par d’anciens collègues. Les contextes étaient différents, mais une même question revenait, celle d’améliorer une application que l’on ne connaît pas encore sans casser ce qui fonctionne déjà. Cet article reprend la méthode qui en est sortie. Elle s’appuie sur trois techniques applicables à d’autres projets, la lecture de l’historique git pour repérer les zones coûteuses, les tests de caractérisation pour figer le comportement existant, et le remplacement de l’ancien code module par module.
Par où commencer quand on arrive sur un code existant ?
Je commence par poser des questions. Comment le système est-il découpé ? Quelles applications et quelles bases de données interviennent ? De quels services tiers dépend-il ? Qui appelle qui ? Et, avant tout, qu’est-ce qui est critique pour le produit ?
Un schéma griffonné en dix minutes avec quelqu’un qui connaît le projet m’a souvent fait gagner plus de temps qu’une longue lecture de code. Je préfère donc commencer par l’architecture et par les personnes qui la connaissent avant de chercher à comprendre chaque fichier.
Je lance ensuite le projet et je m’en sers comme un utilisateur. L’étape paraît évidente, mais avant de chercher ce qui ne va pas dans le code, je veux savoir ce que l’application essaie de faire.
- à quoi sert l’application, et pour qui ;
- quels parcours utilisateurs doivent absolument être préservés ;
- quels sont les enjeux métier, ce qui rapporte, ce qui coûte et ce que le client surveille ;
- pourquoi certaines décisions ont été prises, quand la raison n’est pas évidente dans le code.
Je passe ensuite du parcours au code : de l’écran à l’API, puis de l’API à la base de données. Cela permet de relier assez rapidement ce que voit l’utilisateur à ce que l’on devra réellement modifier. Et lorsqu’un comportement me surprend, je préfère poser la question à l’équipe plutôt que d’inventer une explication à partir du code.
Comment repérer ce qui coûte cher ?
Une fois que l’on comprend mieux le projet, les problèmes commencent généralement à apparaître. Mais tout n’a pas besoin d’être corrigé, et une imperfection visible n’est pas forcément un problème prioritaire.
Sur la plateforme B2B que j’ai reprise, la friction venait de couches écrites à des époques différentes, d’un outil devenu plus lourd que nécessaire, de composants encore écrits en classes et de pages lentes, comme le détaille l’article sur SRS.
Je ne cherche donc pas à rendre toute la base « propre ». Je regarde d’abord ce que chaque problème coûte lorsqu’on doit faire évoluer le produit. Un module vieillissant que personne ne touche peut attendre. À l’inverse, un module central qui ralentit chaque livraison mérite rapidement de l’attention.
L’historique git permet de le mesurer. Adam Tornhill appelle hotspots les fichiers à la fois modifiés très souvent et complexes. C’est là que le code ralentit l’équipe, et là qu’un refactoring rapporte le plus. La fréquence de modification se lit en une commande :
# Files changed most often over the last 12 months
git log --since="12 months ago" --format=format: --name-only \
| grep -v '^$' | sort | uniq -c | sort -rn | head -20En croisant cette liste avec la taille ou la complexité des fichiers, on obtient une courte liste de candidats. Un gros fichier jamais modifié peut attendre ; un fichier moyen touché à chaque sprint mérite d’être assaini en premier.
Comment préserver l’existant lorsqu’aucun test ne permet de le garantir ?
On entend souvent qu’on ne peut pas refactoriser sans tests. L’absence de tests automatisés ne dispense pourtant pas d’un filet de sécurité ; elle oblige à le construire autrement :
- plusieurs environnements, dont un staging aussi proche que possible de la production, où chaque modification est vérifiée avant de partir ;
- une recette manuelle qui rejoue les parcours concernés et les parcours critiques, pas seulement l’écran qui a changé ;
- une seconde paire d’yeux avant chaque grosse mise en production, le chef de projet ou le lead dev repassant sur les parcours critiques ;
- des changements petits et fréquents, plus faciles à vérifier qu’une grosse livraison ;
- une documentation et des specs à jour, pour garder une trace des décisions et de ce qui doit être préservé.
Ce filet manuel ne vaut pas une bonne suite de tests automatisés, mais il réduit le risque pendant la période où l’on remet le projet en ordre. Les tests peuvent ensuite arriver par la partie que l’on s’apprête à modifier, avec ce que Michael Feathers appelle des tests de caractérisation : au lieu de vérifier ce que le code devrait faire, ils enregistrent ce qu’il fait aujourd’hui.
// Characterization test: record what the code does today, not what it should do
import { computeShippingFee } from '../legacy/shipping'
describe('computeShippingFee (current behaviour)', () => {
// Expected values come from running the existing code, not from the spec
it.each([
[0, 'FR', 4.9],
[49.99, 'FR', 4.9],
[50, 'FR', 0],
[50, 'BE', 7.5],
])('total %s, country %s', (total, country, expected) => {
expect(computeShippingFee(total, country)).toBe(expected)
})
})Les valeurs attendues viennent de l’exécution du code existant. Si l’une d’elles surprend, on la note et on pose la question, sans la corriger dans le test. Le test sert à détecter tout changement de comportement pendant le refactoring ; la valeur correcte se tranche à part, avec l’équipe.
Comment obtenir le temps d’améliorer le code ?
Le refactoring est rarement visible dans une roadmap produit. Personne ne vient demander une nouvelle fonctionnalité parce qu’un composant est difficile à maintenir. Pourtant, cette difficulté finit par se retrouver dans les délais et dans les corrections.
Sur la plateforme B2B, j’ai donc proposé au chef de projet et au client de réserver une partie du temps de TMA (tierce maintenance applicative) à la qualité du code et aux temps de chargement, en plus des corrections. Ils l’ont validé, ce qui nous a permis de travailler sur ces sujets sans créer un chantier séparé.
Le reste se faisait au fil de l’eau. Lorsqu’une évolution nécessitait de toucher une partie vieillissante, c’était l’occasion de l’assainir dans le périmètre convenu. Cette approche me paraît plus réaliste qu’un grand chantier de « nettoyage » que l’on repoussera finalement pendant plusieurs mois.
Quand remplacer un outil au lieu de le maintenir ?
C’est le genre de décision que je préfère fonder sur des faits, et non sur une préférence technique. Un outil ancien n’est pas forcément mauvais, et utiliser une technologie plus récente ne constitue pas à lui seul une raison de changer.
La question utile porte sur deux coûts, celui du statu quo et celui du changement. Il faut ensuite regarder le risque, le temps nécessaire, les compétences disponibles et l’impact pour le produit. La décision appartient à l’équipe et au client ; mon rôle est de faire apparaître le problème et de proposer une solution argumentée.
Sur la plateforme B2B, ce raisonnement a conduit à retirer Redux au profit de quelques contextes React et de l’état local, comme je le raconte dans l’article sur la modernisation de SRS. Le changement s’est fait progressivement, sans figer l’application.
Refaire à l’identique : comment garantir la parité ?
Une refonte à fonctionnalités identiques demande une autre forme de rigueur. Cette fois, l’objectif n’est pas d’améliorer le produit au passage : il faut d’abord reproduire fidèlement ce qui existe.
Sur l’e-commerce Cora, le nouveau site web devait reprendre les parcours des applications mobiles iOS et Android, sur une API maintenue par un prestataire externe. Il fallait donc constamment vérifier que ce que nous construisions correspondait bien à l’existant.
Pour garantir la parité, nous nous appuyions notamment sur :
- les maquettes, comme référence commune ;
- des échanges réguliers avec les équipes mobiles, qui connaissaient les règles métier ;
- la comparaison avec les applications existantes ;
- des variables de style identiques à celles de Figma, pour éviter que couleurs, espacements et typographies ne dérivent.
Ici, une amélioration que personne n’a demandée peut être une régression. C’est un cas où savoir ne pas « améliorer » est aussi important que savoir améliorer.
Et quand l’équipe d’origine n’est plus là ?
Sur la DXP Goodbizz, le projet partait d’une base écrite par d’anciens collègues et mise en pause depuis. L’équipe qui l’avait commencée n’était plus là pour expliquer ses choix.
Avec le lead dev et le chef de projet, nous avons donc dû comprendre la base en avançant et trier ce qu’elle contenait :
- des modules qui n’étaient plus à l’ordre du jour ;
- des modules commencés mais jamais terminés ;
- des modules attendus qui n’existaient pas encore.
Dans ce genre de situation, le code devient lui-même une source d’information. On le lit pour comprendre ce que l’ancien développeur semblait vouloir faire, puis on vérifie cette hypothèse avec le comportement de l’application. Mais cela montre aussi très vite ce qui manque lorsqu’il n’y a plus personne pour raconter l’histoire du projet : les décisions, les contraintes et les raisons disparaissent facilement.
L’historique git garde une partie de cette histoire. Quand un passage du code ne s’explique pas, quelques commandes retrouvent le commit qui l’a introduit, et parfois le ticket ou le message qui en donne la raison :
# Last commit for each line of the file, ignoring whitespace changes
git blame -w src/orders/pricing.js
# Every commit that added or removed this text
git log -S 'applyDiscount' --oneline
# History of the file, renames included
git log --follow --oneline -- src/orders/pricing.jsC’est l’une des raisons pour lesquelles je considère aujourd’hui les specs et la documentation comme faisant partie du travail technique, et pas comme quelque chose à faire uniquement « si on a le temps ». Elles donnent à l’équipe suivante un point de départ que le code seul ne peut pas toujours fournir.
Faut-il tout réécrire ?
Je propose rarement de réécrire entièrement une application en production. La réécriture totale promet un code propre, mais elle gèle les évolutions, peut faire perdre au passage des règles métier que personne n’avait documentées et livre d’un bloc ce qu’il aurait fallu vérifier petit à petit.
Je préfère donc une mise à neuf progressive : remettre les bonnes pratiques en place, aligner le code sur les conventions du projet, mettre les dépendances à jour et reprendre les modules lorsqu’ils sont concernés par une évolution. Cela demande parfois plus de patience, mais chaque morceau reste livrable et vérifiable.
Quand une partie doit vraiment être remplacée, le pattern Strangler Fig décrit par Martin Fowler permet de le faire progressivement : le nouveau code se construit à côté de l’ancien, derrière un point d’entrée commun, et reprend les fonctionnalités une par une jusqu’à ce que l’ancien puisse être retiré. La refonte du front-end de Cora était une vraie réécriture, mais limitée à une couche, à fonctionnalités identiques et sur une API conservée. C’est ce périmètre restreint qui la rendait raisonnable.
Sur un projet de grand compte, je préfère proposer, chiffrer et livrer par étapes que décider seul qu’il faut tout refaire. Même sur la DXP Goodbizz, où il a fallu trier ce qui restait, nous sommes repartis de la base existante et j’ai repris plusieurs modules sur le code en place au lieu de les réécrire de zéro.