En ingénierie logicielle, il EST possible d'estimer le coût d'un ticket de production de manière efficace. C'est difficile, mais possible.

Cependant, ce n'est pas le cas pour tous les projets, ni pour toutes les équipes, ni pour tous les développeurs, ni pour tous les produits. La réponse dépend du code, des personnes et du problème que vous avez devant vous. Cet article explique pourquoi, et quoi faire.

De quoi est fait le coût réel d'une feature ?

Le coût réel d'une feature est la somme de ses complications essentielles et accidentelles. Les complications accidentelles dominent les essentielles. C'est le cœur de tout le problème.

Frederick Brooks a tracé la même ligne dans « No Silver Bullet ». La difficulté essentielle du logiciel est inhérente au problème. La difficulté accidentelle vient de notre façon de construire la solution : nos outils, nos représentations et nos choix passés.

La complication essentielle, c'est le problème lui-même. C'est la règle qu'un client a vraiment, le cas limite qui arrive vraiment, et le comportement qui doit tenir après le changement. La complication accidentelle, c'est tout le reste. C'est l'ancien design, la spécification floue, le bug que personne n'a corrigé, le passage de relais entre deux personnes et la librairie qui se comporte autrement en production.

Pourquoi peut-on estimer une partie et pas l'autre ?

Tout ingénieur logiciel expérimenté peut estimer, avec une précision acceptable, le coût de la complication essentielle. Estimer le reste est presque impossible.

La raison, c'est la visibilité. La partie essentielle est un problème sur lequel vous pouvez raisonner avant d'ouvrir l'éditeur. Vous avez déjà résolu des problèmes semblables, donc la forme est familière, et vous voyez les étapes.

La partie accidentelle vit dans du code que vous n'avez pas encore lu. Elle vit dans l'état d'un module, dans le comportement d'une dépendance et dans les personnes qui doivent se mettre d'accord sur le résultat. Vous ne la voyez pas tant que vous n'y touchez pas, et chaque changement en révèle un autre. C'est pour cela que l'estimation part de travers. Vous avez estimé la première couche, et le reste est apparu pendant que vous travailliez.

Les raccourcis font grossir la partie accidentelle. Ward Cunningham a introduit la métaphore de la dette en 1992 pour décrire cet effet. Martin Fowler explique la suite de la métaphore : chaque raccourci ajoute des intérêts. Chacun rend le changement suivant plus dur, donc l'estimation suivante est moins fiable que la précédente.

Qu'est-ce qui réduit la partie accidentelle ?

La partie accidentelle rétrécit quand le code est facile à changer, que le processus est clair et que les bugs sont rares. Ce ne sont pas des objectifs séparés. Ils se soutiennent. Voici ma liste.

  1. Refactorez avant d'ajouter la feature, pour que le pas suivant se fasse sans accroc.
  2. Respectez les principes SOLID, pour que le modèle soit prêt pour le changement.
  3. Améliorez le processus et la communication au sein de l'équipe produit.
  4. Traitez les bugs tout de suite. Un fix doit prendre des minutes, pas des jours.
  5. Ne livrez du code qu'avec des tests, et gardez les suites de tests en bon état.
  6. Continuez à lire et à étudier l'architecture, et appliquez-la à votre code.
  7. Monitorez la production, et prouvez chaque choix de design avec des données réelles.
  8. Gardez les spécifications fonctionnelles simples, et supprimez le code inutilisé.
  9. Amenez toute l'équipe à adhérer à cette culture et à ces pratiques.

Le refactoring est le premier point pour une raison. Martin Fowler le définit ainsi : changer la structure du code sans changer son comportement, par petits pas. C'est ce qui vous permet de refactorer sans peur. Les tests vous disent que le comportement a tenu. La pyramide des tests de Fowler décrit comment y arriver : beaucoup de tests unitaires rapides, moins de tests end-to-end lents, et une suite en laquelle vous avez confiance.

Le monitoring est le septième point, et c'est celui que les équipes sautent le plus. Release It!, de Michael Nygard, est une bonne référence pour concevoir un logiciel qui tombe en panne de façon connue. Un choix de design est une hypothèse tant que la production n'a pas montré ce qu'il donne. Si vous ne pouvez pas mesurer l'effet, vous devinez.

Les bugs méritent une attention particulière. Un bug qui reste ouvert une semaine rend peu fiable toute estimation autour de lui. Corrigez-le tout de suite, ou notez pourquoi vous ne le pouvez pas. Le fix doit être petit, et le test qui attrape le bug doit rester dans la suite.

Et si on n'estimait pas du tout ?

La réponse pratique est au bout de mon raisonnement. Faites assez petit pour éviter les étapes longues et risquées. Vous n'avez alors plus besoin d'une estimation pour l'ensemble.

Découpez petit. Travaillez avec l'équipe produit pour transformer une feature en toutes petites étapes, chacune utile en elle-même. Une petite étape porte peu de complication accidentelle, donc son estimation ne peut être fausse que de peu. Vous découvrez le reste du tableau en livrant la tranche, pas en le prédisant.

Continuez à travailler avec l'équipe produit, en continu. Les tranches changent à mesure que vous apprenez. Chaque tranche livrée vous donne des faits sur le code, et ces faits rendent la tranche suivante plus facile à dimensionner.

Le but n'est pas d'être précis sur toute la feature. Le but est d'avoir raison sur la prochaine étape, à chaque fois.

Quand une estimation reste-t-elle nécessaire ?

Parfois, il faut donner une date. Un budget a besoin d'un chiffre, ou un contrat a besoin d'un engagement. Ces cas sont réels, et ils ne disparaissent pas parce que le travail est difficile.

Dans ces cas, estimez seulement la partie essentielle, et dites à voix haute que la partie accidentelle est inconnue. Puis time-boxez la première tranche. Le résultat de cette tranche est plus utile que n'importe quelle estimation faite avant. Servez-vous-en pour mettre à jour l'engagement suivant.

Cette approche a aussi besoin d'une fondation. Une équipe sans tests, avec des spécifications floues et des bugs fréquents, ne tirera pas de bénéfice du découpage seul. Dans ce cas, les premiers pas sont les tests, la règle de traitement des bugs et les conversations avec l'équipe produit. Le découpage vient quand le sol est solide.

La méthode ne remplace pas le jugement. Elle change ce sur quoi il porte. Vous arrêtez de demander combien de temps prend toute la feature, et vous commencez à demander quelle est la plus petite étape utile, et ce que vous en apprendrez.

💡 À retenir : vous ne ramènerez jamais les complications accidentelles à zéro. Gardez-les assez petites pour ne plus avoir besoin de les estimer.

Ressources et bibliographie

Publié d'abord sur LinkedIn : le post d'origine