← Tous les articlesInfra et cloud

Réécrire ou reprendre : que faire d'un code devenu ingérable

La réécriture complète séduit toujours. Elle se justifie rarement. Voici comment trancher, et comment remplacer un vieux code sans arrêter de livrer.

Julien Mauclair · ~6 min · intermédiaire
StackGitProxyTests

Dans la grande majorité des cas, ne réécris pas tout : reprends le code par morceaux, en remplaçant une fonctionnalité à la fois pendant que l'ancien système continue de tourner. La réécriture complète ne se justifie que dans quelques cas précis, listés plus bas.

Martin Fowler résume l'expérience de ses équipes : le plan « on reconstruit la même chose en mieux » finit le plus souvent en échec, parce qu'un vrai système met longtemps à remplacer et que ses comportements réels sont mal connus (Martin Fowler, Strangler Fig).

01Pourquoi la réécriture complète échoue si souvent

Un code « ingérable » est presque toujours un code qui marche. Ses fonctions trop longues contiennent des correctifs accumulés au fil des bugs rencontrés en production. Joel Spolsky l'a formulé dès 2000 à propos de Netscape, resté près de trois ans sans nouvelle version majeure pendant sa réécriture : jeter le code, c'est jeter toutes ces corrections et offrir des années d'avance à ses concurrents (Joel Spolsky, Things You Should Never Do).

Trois mécanismes reviennent à chaque fois :

·le produit gèle : les utilisateurs attendent des évolutions, l'équipe recode l'existant ;
·les règles métier implicites se perdent, parce que personne ne les avait écrites ailleurs que dans le code ;
·une partie de l'ancien comportement n'était plus utile, mais on la reconstruit quand même faute de savoir laquelle.

Il y a aussi un biais humain. Lire du code est plus difficile qu'en écrire, donc le code des autres paraît toujours pire qu'il n'est. Dans un fil de r/cto, un ancien CTO de deux startups raconte avoir traité chaque choix d'architecture comme définitif, alors que beaucoup ont été remplacés quelques mois plus tard (discussion sur r/cto). Le code n'est pas un monument : c'est un état provisoire qu'on fait évoluer.

02Les critères pour trancher

Avant de décider, réponds à ces questions. Chaque réponse pousse dans un sens.

QuestionCe que ça indique
Le système est petit et bien compris ?Réécrire peut être plus simple que migrer
La technologie n'est plus maintenue ou plus déployable ?Argument sérieux pour réécrire, au moins la couche concernée
Les requêtes peuvent passer par un proxy ou une façade ?Migration progressive possible
Tu peux modifier le code source ou la base de l'ancien système ?Migration progressive possible
Le produit doit continuer à livrer pendant le chantier ?Migration progressive, presque obligatoire
Les règles métier ne sont documentées nulle part ?Ne réécris pas sans tests de caractérisation
Le problème vient de quelques fichiers seulement ?Refactoring ciblé, pas de réécriture

La documentation Azure du pattern dit la même chose sous un autre angle : la migration progressive est inadaptée quand on ne peut pas intercepter les requêtes, quand on n'a aucun point d'intégration modifiable, ou quand le système est assez petit pour être remplacé d'un coup (Microsoft, Strangler Fig pattern). Hors de ces cas, la reprise par morceaux gagne.

Trouver où le code fait vraiment mal

Le ressenti « tout est à jeter » se vérifie. Les zones à traiter en premier sont celles qui changent souvent : c'est là que la dette coûte, à chaque livraison. Cette commande Git liste les fichiers les plus modifiés sur les douze derniers mois :

hotspots.shBASHCopier
git log --format=format: --name-only --since=12.month \
| grep -v '^$' \
| sort | uniq -c | sort -nr | head -20

Croise cette liste avec les fichiers qui concentrent les bugs et les incidents. Si une poignée de fichiers ressort, le diagnostic est clair : un refactoring ciblé suffit, la réécriture serait disproportionnée. Si la douleur est partout et que la technologie elle-même bloque, la question de la réécriture devient légitime. Ce tri est aussi le cœur d'un audit technique avant une levée ou un rachat.

03Migrer par morceaux avec le strangler fig

Le principe, décrit par Fowler et repris par Microsoft : une façade placée devant l'ancien système reçoit toutes les requêtes. Au début, elle les envoie presque toutes à l'ancien code. À chaque étape, une fonctionnalité est réécrite dans le nouveau système et la façade lui envoie le trafic correspondant. Quand plus rien ne dépend de l'ancien système, on l'éteint, puis on retire la façade (Microsoft, Strangler Fig pattern).

L'ordre qui limite le risque :

1. Fixe les résultats attendus : livrer plus vite, réduire les incidents, quitter une techno morte. Sans objectif commun, la migration dérive. 2. Écris des tests de caractérisation sur les parcours critiques : ils figent le comportement actuel, bugs compris, pour détecter toute différence. 3. Place la façade : un reverse proxy, une passerelle d'API ou un routage dans l'application. 4. Choisis la première coupe là où la valeur est forte et le couplage faible, idéalement une nouvelle fonctionnalité. 5. Bascule le trafic progressivement, avec un retour arrière possible à chaque étape. Un déploiement ennuyeux rend ces bascules banales. 6. Décommissionne au fur et à mesure, pour ne pas maintenir deux systèmes indéfiniment.

Attention

Le code de transition (façade, adaptateurs, double écriture des données) est fait pour disparaître. Il paraît être du gaspillage, mais c'est le prix d'une migration sans arrêt de service. Surveille qu'il ne devienne pas un point de défaillance unique.

Le point le plus délicat reste la base de données partagée entre l'ancien et le nouveau système. Prévois dès le départ qui écrit quoi, et une couche d'adaptation pour que le nouveau code n'hérite pas des conventions de l'ancien.

Enfin, change aussi la façon de travailler. Fowler insiste : sans changement d'organisation, le nouveau système finira dans le même état que l'ancien. C'est souvent là qu'un CTO à temps partagé apporte le plus : poser les critères, arbitrer l'ordre des coupes, tenir le cap sur plusieurs mois.

04Questions fréquentes

Combien de temps dure une migration progressive ?

Elle dure plus longtemps qu'une réécriture sur le papier, mais elle livre de la valeur dès la première coupe et peut s'arrêter à tout moment sans tout perdre. La durée dépend du nombre de coupes et du couplage avec la base de données.

Quand faut-il quand même tout réécrire ?

Quand le système est petit et bien compris, quand la technologie ne peut plus être maintenue ni déployée, ou quand aucune interception des requêtes n'est possible. Même dans ce cas, écris d'abord des tests de caractérisation pour ne rien perdre en route.

Refactorer, ce n'est pas juste repousser le problème ?

Non, si le refactoring vise les zones qui changent le plus et suit un objectif mesurable. Repousser le problème, c'est corriger au hasard sans priorité. La commande de hotspots plus haut sert justement à choisir.

En résumé

Réécrire d'un bloc revient à parier le produit sur un chantier dont tu ne vois pas la fin. Remplace par morceaux, mesure chaque étape, et garde la réécriture complète pour les rares cas où rien d'autre ne tient.

Parlons de ton projet ↗
Julien MauclairJulien Mauclair est cofondateur et CTO de Klickbee : il construit les sites, le tracking et les automatisations IA de l’agence, et développe Klickbee Tracking. Il dirige aussi Stralya, qui conçoit et tient l’infrastructure AWS de scale-ups. Avant, il a construit toute l’infrastructure AWS d’un e-commerce, revendu depuis.

À lire ensuite