Définition de la dette technique
La dette technique est le coût différé d’un choix technique. Lorsqu’une équipe retient une solution rapide ou imparfaite plutôt que celle qui aurait été durable, elle gagne du temps tout de suite et s’engage à en perdre plus tard. Ce temps perdu, ce sont les intérêts : chaque évolution demande plus d’effort, chaque correction risque de casser autre chose. Le capital, c’est le travail qu’il faudrait fournir pour remettre le logiciel dans l’état souhaitable.
La métaphore est attribuée à Ward Cunningham, au début des années 1990. Son sens s’est élargi depuis. On range aujourd’hui sous ce terme tout écart accumulé entre un système tel qu’il est et ce qu’il devrait être pour évoluer à un coût raisonnable, que cet écart ait été choisi ou subi.
À quoi sert la notion
Son intérêt est de fournir un langage commun entre les équipes techniques et ceux qui décident des priorités. Un responsable métier ne voit pas la complexité d’un module. Il comprend en revanche qu’un emprunt non remboursé coûte de plus en plus cher. La notion permet de poser la bonne question : non pas « le code est-il propre ? », mais « combien nous coûte cet état, et vaut-il la peine d’y remédier maintenant ? ».
Elle rappelle aussi qu’une dette n’est pas une faute. S’endetter pour saisir une occasion est une décision de gestion. Ce qui pose problème, c’est la dette contractée sans le savoir et celle que l’on ne suit pas.
Les origines de la dette technique
- Le compromis assumé. Une échéance impose un raccourci. L’équipe le sait et prévoit d’y revenir.
- Le manque de connaissance. La conception retenue paraissait bonne. La compréhension du besoin a progressé, et elle ne l’est plus.
- Le vieillissement. Le code ne change pas, mais son environnement évolue : un langage, un composant ou un système d’exploitation n’est plus maintenu par son éditeur. La dette croît sans que personne n’ait rien fait.
- L’organisation. Le départ des personnes qui connaissaient le système, des équipes qui modifient le même code sans règles communes ou le rapprochement de deux systèmes d’information produisent de la dette sans décision technique.
L’ingénieur Martin Fowler a proposé de classer la dette selon deux axes : délibérée ou involontaire, prudente ou imprudente. Une dette délibérée et prudente se gère. Une dette involontaire et imprudente se découvre le jour où une évolution simple devient impossible.
Les formes de la dette technique
| Forme | Manifestations typiques |
|---|---|
| Code | Duplication, fonctions trop longues, code mort, règles métier dispersées |
| Architecture | Couplage fort entre modules, base de données partagée par plusieurs applications, absence d’interfaces stables |
| Tests | Tests automatisés absents ou peu fiables, validation manuelle à chaque livraison |
| Infrastructure et dépendances | Versions obsolètes, composants hors support, déploiements manuels |
| Documentation et savoir | Fonctionnement connu d’une seule personne, décisions de conception non tracées |
La dette d’architecture est souvent la plus coûteuse, car elle ne se rembourse pas par petites touches. La dette de tests est particulièrement insidieuse : elle rend risqué le remboursement de toutes les autres. Les systèmes d’apprentissage automatique ajoutent leurs propres formes de dette, liées aux données et aux modèles, que traitent les pratiques décrites dans notre fiche sur le MLOps.
Dette technique, bug et obsolescence : ne pas confondre
Un bug est un défaut visible du comportement. La dette est un défaut de structure, invisible pour l’utilisateur. L’obsolescence est une forme particulière de dette, celle qui vient du vieillissement des composants, avec un enjeu de sécurité lorsque les correctifs ne sont plus publiés.
Un système ancien n’est pas nécessairement endetté. Une application âgée, bien testée et bien comprise peut coûter moins cher à faire évoluer qu’une application récente écrite dans l’urgence. Enfin, la dette technique n’est pas la liste de tout ce que les développeurs aimeraient refaire. Seul compte ce qui renchérit ou fragilise réellement les évolutions à venir.
Comment rendre la dette visible
Une dette que seuls les développeurs connaissent ne sera jamais arbitrée. Trois pratiques la font apparaître.
L’inventaire. Chaque élément de dette est inscrit dans le même backlog que les évolutions fonctionnelles, avec une description de ce qu’il ralentit ou met en danger et une estimation de l’effort de correction.
Le croisement avec l’activité. Une dette logée dans un module que personne ne modifie ne coûte presque rien. La même dette dans un module modifié chaque semaine pèse sur toutes les livraisons. Croiser la qualité du code avec la fréquence des changements désigne les zones à traiter en premier.
Des indicateurs lisibles par la direction. Délai entre une demande d’évolution et sa mise en production, part des livraisons suivies d’un incident, part de la capacité consacrée aux corrections, nombre de composants hors support. Les mesures des outils d’analyse statique (complexité, duplication, couverture de tests) complètent ce tableau sans le remplacer.
Comment réduire la dette technique
Quatre leviers se combinent.
- Cesser d’emprunter sans le savoir. Revue de code, tests automatisés et critères de qualité intégrés à la définition du travail terminé limitent la dette nouvelle.
- Rembourser au fil de l’eau. Chaque évolution est l’occasion d’améliorer le code qu’elle touche. Cette pratique, le refactoring continu, traite la dette là où elle gêne.
- Réserver une capacité. Une part explicite de chaque cycle de développement est consacrée à la dette, négociée avec le responsable du produit et non prise en cachette.
- Conduire des chantiers ciblés. Une montée de version majeure ou le découplage d’un module demandent un projet à part entière. Le remplacement progressif, composant par composant, est en général moins risqué qu’une réécriture complète.
Il existe un cinquième choix, légitime : ne pas rembourser. Pour une application promise au retrait, payer les intérêts jusqu’à la fin coûte moins cher que de corriger.
Exemple : une règle de calcul écrite trois fois
Dans une application de gestion des commandes, le calcul des remises a été copié dans trois modules au fil des urgences : la saisie, la facturation et l’édition des devis. Aucun test automatisé ne le couvre. À chaque changement de politique commerciale, il faut modifier trois endroits, et l’un d’eux est régulièrement oublié. Des factures erronées partent chez les clients.
L’équipe inscrit cette dette au backlog en décrivant son effet : toute évolution tarifaire est lente et risquée. Le responsable du produit, qui prévoit plusieurs évolutions de ce type, accepte de la traiter. L’équipe écrit d’abord des tests qui fixent le comportement attendu, puis regroupe le calcul en un seul endroit à l’occasion de l’évolution suivante. Le remboursement a été décidé parce que son coût et celui de l’inaction avaient été rendus comparables.
Pour le traitement d’une dette à l’échelle d’un parc applicatif, consultez nos pages consacrées à la modernisation applicative et à la qualité logicielle.