Dans le premier épisode de cette série, je défendais une idée : beaucoup d'organisations traitent des problèmes d'ingénierie comme des problèmes d'organisation.

Il existe un deuxième réflexe, tout aussi répandu et tout aussi coûteux.

Lorsqu'un système devient difficile à faire évoluer, on cherche à produire davantage : plus de fonctionnalités, plus de développeurs, plus de composants, plus d'outils.

On se demande rarement s'il fallait construire tout cela.

Le Manifeste Agile contient pourtant un principe qui pose exactement cette question :

« La simplicité – c'est-à-dire l'art de minimiser la quantité de travail inutile – est essentielle. »

C'est probablement le principe le plus court du manifeste. C'est aussi l'un des moins appliqués, parce qu'il demande à une organisation de valoriser ce qu'elle n'a pas fait.

Ce que dit vraiment le principe

La traduction française officielle est plus sage que l'original.

Le texte anglais ne parle pas de travail inutile. Il dit : « the art of maximizing the amount of work not done ». L'art de maximiser la quantité de travail non fait.

La nuance est importante.

« Minimiser le travail inutile » ne dérange personne. Aucune équipe ne pense produire de l'inutile, et chacun peut approuver le principe sans rien changer à ses habitudes.

« Maximiser le travail non fait » est une tout autre exigence. Le travail non fait devient un résultat à part entière, que l'on recherche activement, au même titre qu'une livraison.

  • Le principe ne demande pas de travailler moins. Il demande de considérer chaque chose que l'on renonce à construire comme une décision d'ingénierie, et non comme un manque d'ambition.

Simple ne veut pas dire facile

Le mot « simplicité » est trompeur, parce qu'on le confond presque toujours avec la facilité.

Rich Hickey a formulé cette distinction dans une conférence devenue une référence, Simple Made Easy. Est simple ce qui n'est pas entremêlé : un composant qui remplit un rôle, sans dépendre de dix autres. Est facile ce qui est à portée de main : l'outil que l'on connaît déjà, la solution que l'on peut installer en une commande.

La simplicité est une propriété du système. La facilité dépend de celui qui regarde.

Les deux s'opposent souvent.

  • Ajouter un paramètre de configuration est facile. Un système qui en compte trois cents n'est pas simple.
  • Ajouter une bibliothèque est facile. Un système qui en embarque quatre cents n'est pas simple.
  • Ajouter un cas particulier dans une règle métier est facile. Une règle métier qui en contient quarante n'est pas simple.

La complexité d'un système ne vient presque jamais d'une grande décision. Elle vient de l'accumulation de petites décisions faciles, dont chacune était raisonnable le jour où elle a été prise.

  • Faire simple demande plus de travail de conception que faire compliqué. C'est pour cela que la simplicité prolonge l'excellence technique : une équipe qui ne maîtrise pas la conception ne peut pas se permettre de faire simple.

« On en aura besoin plus tard »

S'il fallait résumer en une phrase l'origine de la complexité inutile, je choisirais celle-ci :

« Autant le prévoir maintenant, on en aura besoin plus tard. »

La phrase est prononcée de bonne foi. Elle ressemble à de l'anticipation, et l'anticipation est une qualité que l'on attend d'un ingénieur.

L'Extreme Programming lui a pourtant donné un nom peu flatteur : YAGNI, pour « You Aren't Gonna Need It ». Vous n'en aurez pas besoin.

Martin Fowler a détaillé ce que coûte une capacité construite par anticipation. Il distingue quatre coûts :

  • Le coût de construction : le temps passé à développer une capacité dont personne ne se sert encore.
  • Le coût du retard : tout ce qui aurait pu être livré à la place et qui attend.
  • Le coût de portage : le code existe, donc il faut le lire, le tester, le migrer et le contourner à chaque évolution.
  • Le coût de réparation : lorsque le besoin arrive enfin, il ne ressemble pas à ce qui avait été imaginé, et il faut refaire.

Les trois premiers coûts sont payés même lorsque l'anticipation était juste. Le quatrième s'y ajoute lorsqu'elle était fausse.

  • Anticiper un besoin n'est pas gratuit, même quand on a raison. Et l'on a raison moins souvent qu'on ne le croit.

Le coût de ce qui existe déjà

Les organisations comptent ce qu'elles livrent. Elles comptent rarement ce qu'elles possèdent.

Or une fonctionnalité livrée n'est pas seulement un actif. C'est aussi une charge : elle doit être maintenue, testée, sécurisée, documentée et comprise par chaque nouveau développeur. Cette charge court tant que la fonctionnalité existe, qu'elle soit utilisée ou non.

La question devient alors : quelle part de ce que nous construisons sert réellement ?

Les chiffres disponibles sont imparfaits, mais ils vont tous dans le même sens. L'un des plus solides vient de Microsoft, où Ronny Kohavi et ses collègues ont mesuré, par expérimentation contrôlée, l'effet réel des idées mises en production :

≈ 1/3 des idées testées améliorent réellement l'indicateur qu'elles devaient améliorer Source : Kohavi et al., Online Experimentation at Microsoft

Les autres n'ont aucun effet mesurable, ou dégradent l'indicateur.

Il s'agit pourtant d'idées portées par des équipes compétentes, dans une entreprise qui dispose de plus de données que la plupart. Rien n'indique que le reste du secteur fasse mieux. La seule différence est que la plupart des organisations ne mesurent pas.

On cite aussi souvent une étude du Standish Group selon laquelle près des deux tiers des fonctionnalités seraient rarement ou jamais utilisées. Le chiffre repose sur un échantillon très réduit et mérite d'être pris avec prudence. L'ordre de grandeur, lui, surprend rarement ceux qui ont déjà consulté les statistiques d'usage de leur propre produit.

  • Une fonctionnalité inutilisée n'est pas neutre. Elle ralentit toutes les évolutions suivantes, sans jamais apparaître dans un budget.

La sur-architecture, version technique du même réflexe

Ce qui vaut pour les fonctionnalités vaut pour l'architecture.

Je retrouve régulièrement les mêmes situations :

  • Une application découpée en vingt microservices, maintenue par une équipe de six personnes.
  • Un moteur de règles générique construit pour un seul cas d'usage.
  • Une couche d'abstraction destinée à pouvoir changer de base de données, alors que personne n'en changera jamais.
  • Une plateforme interne conçue pour dix équipes, dans une organisation qui en compte deux.

Chacune de ces décisions a été prise pour préparer l'avenir. Chacune se paie au présent : en déploiements plus lourds, en incidents plus difficiles à diagnostiquer, en semaines d'intégration pour chaque nouvel arrivant.

Fred Brooks distinguait déjà la complexité essentielle, celle du problème à résoudre, de la complexité accidentelle, celle que nous ajoutons nous-mêmes en le résolvant. Une organisation ne choisit pas la première. Elle est entièrement responsable de la seconde.

John Gall l'a formulé autrement : un système complexe qui fonctionne est presque toujours issu d'un système simple qui fonctionnait. L'inverse est rare. Un système conçu complexe dès le départ fonctionne rarement, et on ne le répare pas en le corrigeant.

  • Une architecture ne se juge pas à ce qu'elle permettrait de faire un jour. Elle se juge à ce que coûte, aujourd'hui, le prochain changement.

Pourquoi les organisations récompensent la complexité

Si la simplicité est si rentable, pourquoi est-elle si rare ?

Pour la même raison que l'excellence technique : elle ne se voit pas.

Une fonctionnalité livrée se montre en démonstration. Une fonctionnalité que l'on a eu raison de ne pas construire ne laisse aucune trace. Une plateforme ambitieuse justifie un budget et une équipe. La décision de s'en passer ne justifie rien, et personne ne la présente en comité de direction.

Les indicateurs renforcent ce biais. Une feuille de route mesurée au nombre de livraisons, une équipe évaluée à sa vélocité ou un projet jugé au respect de son périmètre initial poussent tous dans la même direction : produire ce qui était prévu, que cela serve ou non.

Dans ce cadre, supprimer une fonctionnalité ressemble à un aveu d'échec, et refuser une demande ressemble à de la mauvaise volonté.

  • Tant qu'une organisation mesure ce qu'elle produit plutôt que ce qu'elle obtient, la complexité sera récompensée et la simplicité passera pour un manque d'ambition.

Ce que l'IA change

Ce principe était important lorsque le code coûtait cher à écrire. Il l'est davantage maintenant que le code ne coûte presque plus rien à produire.

Avec les assistants de programmation, le coût de construction s'effondre. Les trois autres coûts restent intacts : le code généré doit toujours être lu, testé, exploité et corrigé par quelqu'un.

Lorsque écrire devient gratuit, la tentation d'écrire davantage devient permanente. Une équipe peut désormais produire en une semaine plus de code qu'elle ne pourra en comprendre en un mois.

  • L'IA ne rend pas la simplicité obsolète. Elle supprime le dernier frein naturel à la complexité, qui était l'effort nécessaire pour la produire. Savoir ne pas construire devient une compétence centrale.

Par où commencer ?

Maximiser le travail non fait ne demande ni nouveau framework ni réorganisation. Cela demande de poser quelques questions, et d'accepter les réponses.

  • Quelle part de nos fonctionnalités est réellement utilisée, et savons-nous seulement le mesurer ?
  • Quand avons-nous supprimé une fonctionnalité, un service ou une dépendance pour la dernière fois ?
  • Combien de composants de notre architecture existent pour un besoin qui ne s'est jamais présenté ?
  • Lorsqu'une demande arrive, quelqu'un a-t-il le droit de répondre « pas maintenant », et l'utilise-t-il ?
  • Nos décisions d'architecture sont-elles écrites, avec l'option la plus simple explicitement examinée et la raison de son rejet ?

La dernière question est celle que je pose le plus souvent. Dans une revue de décision d'architecture, demander « quelle est la version la plus simple qui répondrait au besoin actuel ? » suffit régulièrement à faire disparaître la moitié du projet.

  • Une équipe qui ne supprime jamais rien n'est pas une équipe prudente. C'est une équipe dont le système grossit plus vite que sa capacité à le comprendre.

Conclusion

Nous avons pris l'habitude d'évaluer les équipes à ce qu'elles produisent. Le Manifeste Agile proposait une mesure plus exigeante : ce qu'elles ont su éviter de produire.

Ce n'est pas un appel à en faire moins. Chaque fonctionnalité, chaque composant et chaque abstraction ajoute un coût qui dure aussi longtemps que le système, et le seul moment où ce coût est nul est celui où l'on décide de ne pas construire.

L'excellence technique, sujet du premier épisode, détermine ce que coûte un changement. La simplicité détermine la quantité de système qu'il faudra changer.

  • Les deux principes vont ensemble. Une organisation qui néglige le premier construit mal. Une organisation qui néglige le second construit trop. Dans les deux cas, elle finit par ne plus pouvoir avancer.

Pour aller plus loin

Ressources liées

Voir tous les articles

Si certains de ces constats résonnent avec votre organisation, je serai heureux d'en discuter avec vous. Nous contacter