Votre prestataire vous promet une application de qualité, ou votre équipe vous assure que son code est propre ? Vous ne lisez pas le code, et vous vous demandez ce que « qualité » recouvre, et comment le vérifier ?
Un code de qualité, c’est un code que l’on peut modifier facilement.
Le code est ce que les développeurs écrivent pour faire fonctionner votre application. La définition porte sur ce qu’il en coûte de faire évoluer cette application.
Pourquoi un code de qualité ?
Une application construite à partir des retours de ses utilisateurs change sans cesse. Chaque retour demande une modification. Si chaque modification coûte cher, ou casse autre chose, la boucle ralentit, et une part croissante du budget sert à réaliser des réparations au lieu de faire évoluer l’application.
Martin Fowler, l’un des signataires du Manifeste agile et directeur scientifique de Thoughtworks, distingue deux qualités. La qualité externe est celle que voient les utilisateurs : l’interface, les erreurs. La qualité interne est celle de l’architecture du code, que personne ne voit en se servant de l’application. Dans « Is High Quality Software Worth the Cost? » (Un logiciel de qualité vaut-il ce qu’il coûte ?), il écrit qu’une qualité interne élevée réduit le coût des fonctionnalités futures. Il ajoute que les développeurs constatent qu’un code de mauvaise qualité les ralentit nettement au bout de quelques semaines.
Pour garder bas le coût des évolutions, il faut savoir au plus tôt qu’une modification a cassé quelque chose. C’est le rôle de la livraison continue, l’approche que Jez Humble et Dave Farley, ses pionniers, ont décrite dans le livre Continuous Delivery (Livraison continue). Chaque petite modification passe par un pipeline de déploiement, qu’on appelle souvent pipeline CI/CD : il la vérifie automatiquement et garde l’application prête à être mise en production à tout moment. Une erreur est donc repérée avant d’atteindre vos utilisateurs, quand elle se corrige encore facilement.
DORA, le programme de recherche de Google Cloud sur le développement et la mise en production des logiciels, relie la livraison continue à la qualité du code. Son rapport « State of DevOps » de 2017 indique que la livraison continue dépend d’abord de la capacité d’une équipe à changer la conception de son application sans attendre les autres équipes : elle suppose donc un code facile à modifier. Le même rapport compare les organisations les plus performantes en livraison logicielle aux moins performantes : les premières consacrent 44 % de temps en plus aux nouvelles fonctionnalités, et 21 % de temps en moins au travail imprévu et au travail à refaire. Pour votre budget, cela veut dire moins d’heures passées à de la réparation. Demandez à votre équipe quelle part de son temps est allouée au développement de nouvelles fonctionnalités.
Facile à trouver, à lire, à comprendre, donc à modifier
Avant de modifier un code, un développeur doit trouver l’endroit où intervenir. Puis il lit le code à cet endroit, et il comprend ce que fait ce code. Chaque étape sur laquelle on coince nous retarde sur le passage à la suivante. Un code ne devient facile à modifier que lorsque les étapes précédentes sont respectées.
Dans Modern Software Engineering (Ingénierie logicielle moderne), Farley écrit que le code sert d’abord à communiquer avec d’autres humains.
Ce que les développeurs regardent dans le code
Dans Modern Software Engineering, Farley décrit les propriétés qui rendent un code facile à modifier. Un développeur les vérifie en lisant le code :
- la modularité : le code est découpé en parties assez petites pour être comprises seules ;
- la cohésion : ce qui va ensemble est rangé ensemble, et ce qui n’a pas de rapport est rangé à part ;
- la séparation des préoccupations : chaque partie du code ne s’occupe que d’une chose ;
- les niveaux d’abstraction : chaque partie cache ses détails, et on peut s’en servir sans savoir comment elle fonctionne ;
- la testabilité : chaque partie peut être vérifiée par un test automatisé, sans le reste de l’application.
Vous n’avez pas à les vérifier vous-même : elles se voient de l’extérieur, dans deux mesures décrites plus bas.
Quatre pratiques de conception associées à la qualité du code
Quatre pratiques de conception reviennent souvent quand on parle de qualité du code. Chacune sépare deux choses qu’il vaut mieux ne pas mélanger :
- la conception pilotée par le domaine (DDD), décrite par Eric Evans, auteur de référence sur la modélisation métier, dans Domain-Driven Design (Conception pilotée par le domaine), sépare les règles d’un domaine métier de celles d’un autre : une « commande » n’a pas le même sens pour la vente et pour la facturation ;
- l’architecture hexagonale, décrite par Alistair Cockburn, lui aussi signataire du Manifeste agile, sépare les règles métier de l’infrastructure (base de données, écrans, services externes) : on peut changer de technologie sans toucher aux règles ;
- la séparation commande-requête (CQS), formulée par Bertrand Meyer, le créateur du langage Eiffel, sépare le code qui modifie une information du code qui la lit ;
- les vérifications et les tests automatisés (tests unitaires, d’intégration, de bout en bout ; analyse du code par un linter, compilation ou transpilation) séparent le comportement attendu de la façon de l’obtenir. Ils vérifient chaque modification du code, et chaque changement de comportement de l’application.
Le développement piloté par le comportement (BDD), formulé par Dan North, fait aussi des tests un guide de conception. Chaque fonctionnalité part d’exemples de ce que l’application doit faire, qui deviennent des tests d’acceptation automatisés (ATDD). Ces tests guident à leur tour des tests plus fins, écrits juste avant chaque petite partie du code (TDD, décrit par Kent Beck, le créateur de l’Extreme Programming).
On choisit un outil parce qu’on sait précisément pourquoi on en a besoin. Ici, le besoin est la facilité de modification : toutes ces pratiques existent pour garder un code facile à trouver, à lire, à comprendre, donc à modifier. Appliquées sans comprendre cette raison, elles mènent à une dérive, et nous y reviendrons plus loin.
À quoi reconnaître un code de qualité
Pour savoir si un code est de qualité sans le lire, deux mesures se regardent ensemble : le débit et la stabilité.
DORA les a d’abord suivis à travers quatre indicateurs, que ses chercheurs ont présentés dans le livre Accelerate (2018). Deux mesurent le débit : le délai pour qu’une modification arrive en production, et la fréquence des mises en production. Deux mesurent la stabilité : la part des modifications qui posent problème une fois en production, et le temps qu’il faut pour rétablir le service après une panne.
Ces deux mesures sont en tension. On peut gagner en débit en prenant des raccourcis, et la stabilité baisse. On peut aussi tout verrouiller pour ne rien casser, et le débit s’effondre. Les recherches de DORA montrent pourtant que les équipes les plus performantes font mieux sur les quatre indicateurs à la fois. C’est là que se lit la qualité du code : tenir les deux en même temps suppose un code facile à modifier. À ce jour, en 2026, ces résultats restent des corrélations observées dans des enquêtes, qui ne prouvent pas à elles seules que le code en est la cause.
Demandez ces quatre chiffres à votre équipe ou à votre prestataire, et regardez-les ensemble. Des mises en production fréquentes suivies de pannes fréquentes, ou une stabilité obtenue en ne mettant presque jamais en production, indiquent l’une comme l’autre que le code résiste au changement.
Un état d’esprit d’ingénieur
Farley définit l’ingénierie logicielle comme une approche empirique et scientifique pour trouver des solutions efficaces et économiques aux problèmes du logiciel.
Il résume la démarche de l’ingénieur : formuler une hypothèse, trouver comment la confirmer ou la réfuter, mener l’expérience, observer le résultat, recommencer, et faire tout cela par le chemin le plus court.
Il reconnaît à l’artisanat logiciel (software craftsmanship) le mérite d’avoir remis au premier plan le savoir-faire, la créativité et l’apprentissage, mais il écrit que celui-ci ne suffit pas. Dans sa vidéo « Software Craftsmanship vs Software Engineering » (Artisanat logiciel ou ingénierie logicielle), il explique que l’artisanat juge un code sur des critères subjectifs, et il donne le critère de l’ingénieur : un code de qualité se modifie facilement et sans risque.
Sans ce critère, le DDD, l’architecture hexagonale ou le développement piloté par les tests deviennent des fins en soi. La conception devient un concours du plus beau code : l’entreprise n’y gagne rien, seul l’ego des développeurs y trouve son compte.
Le standard que nous appliquons à chaque projet repose sur deux choses. L’agilité, la vraie, celle d’une approche adaptative : adapter le produit aux besoins de ses utilisateurs et rester centré sur eux. Et la livraison continue (Dave Farley, Jez Humble) : un code de qualité, facile à changer. L’un ne va pas sans l’autre. Les meilleures idées ne servent à rien si le code est difficile à changer : c’est un champion de Formule 1 au volant d’une 2CV. Et un code facile à changer (donc de qualité) ne sert à rien si l’on ne met pas ses utilisateurs au centre des décisions : c’est une Formule 1 confiée à quelqu’un qui vient d’avoir son permis.
Nous pratiquons, entre autres, le DDD, l’architecture hexagonale, la séparation commande-requête et le développement piloté par le comportement et par les tests. Nous veillons à la modularité, à la cohésion, à la séparation des préoccupations, aux niveaux d’abstraction et à la testabilité de notre code. Ce sont ces propriétés qui permettent de mettre en production à bon rythme, sans régression ni dysfonctionnement, et de garder les coûts sous contrôle, sans payer plus tard les pots cassés. Nous jugeons si le code reste facile à modifier d’après le débit et la stabilité de nos mises en production, regardés ensemble.
Pour le développement d’un logiciel sur mesure, nous travaillons pour un budget fixe, facturé chaque fin de mois pour le travail réalisé. Votre application est utilisable en un mois, en quelques fonctionnalités essentielles : vos utilisateurs s’en servent immédiatement, et c’est leur usage qui définit les fonctionnalités suivantes à développer.
Et pour que ce qui fonctionnait le mois dernier fonctionne encore ce mois-ci, nous appliquons une garantie zéro régression : chaque régression est corrigée et couverte par un test automatisé, pour qu’elle ne revienne pas, et sans surcoût.
Pour aller plus loin
Pourquoi fixer le budget plutôt que la liste des fonctionnalités ? L’approche adaptative laisse cette liste évoluer avec l’usage de vos utilisateurs.
Vous voulez savoir si le code de votre application reste facile à modifier ? On en parle ?