Voici comment traiter un bug de façon inefficace. Suivez ces étapes et vous reverrez le même bug.

À quoi ressemble le cycle inefficace ?

  1. Foncez modifier le code.
  2. Faites quelques tests dans l'UI pour vérifier que le bug disparaît.
  3. Foncez déployer.
  4. Corrigez les bugs liés que les utilisateurs déclarent 24 heures plus tard, à cause de la régression.
  5. Retournez à l'étape 1, jusqu'à ce que le churn apparaisse, à cause de la frustration.
  6. Prenez le temps de faire une QA complète, et impliquez l'équipe produit et les experts métier, avant de livrer à nouveau.

Bien sûr, vous pouvez avoir de la chance avec quelques situations faciles à corriger. Mais ce n'est ni une façon de faire ni une méthodologie durable. Cela peut durer quelques semaines ou quelques mois, et les impacts business peuvent être très mauvais.

Regardez où part le temps. L'étape 6 est la plus chère, et elle n'arrive qu'après que les utilisateurs ont déjà trouvé les problèmes.

Pourquoi le cycle revient-il sans cesse ?

Regardez les étapes 1 et 2. Le code est modifié, puis quelqu'un regarde l'écran et voit que le bug a disparu. Cette vérification couvre un seul chemin dans l'application. Elle ne dit rien du code autour du changement.

Le bug est traité comme un événement isolé. Il ne l'est pas. C'est un trou dans les tests, et le trou est toujours là après le fix. C'est pour cela que la même zone de l'application continue de produire des bugs. Le symptôme est parti, et le test manquant manque toujours.

Une régression, c'est ce qui se cache dans ce trou. Le fix a touché une fonction partagée, et un autre écran s'appuie maintenant sur l'ancien comportement. Aucun test ne couvre ce comportement, donc le build reste vert. L'utilisateur trouve le problème un jour plus tard.

Chaque tour coûte un fix, un deuxième déploiement et une deuxième vague de plaintes. L'équipe reste occupée, et pourtant le nombre de bugs ne baisse pas. Les métriques de livraison logicielle de DORA incluent le change failure rate, la part des déploiements qui causent une panne en production. Accelerate, de Forsgren, Humble et Kim, relie ces mesures de livraison à la performance de l'organisation.

Ne vous laissez pas piéger par l'« illusion » d'aller vite !

Comment corriger un bug efficacement ?

Les premières étapes suivent le rythme red, green, refactor du test-driven development. Kent Beck le décrit ainsi : écrire un test qui échoue, le faire passer, puis nettoyer. Chaque étape ci-dessous est une seule action. Suivez-les dans l'ordre.

  1. Ajoutez le scénario buggé à votre suite de tests, d'abord comme test unitaire.
  2. Si le test reste vert sur le code buggé, il n'a pas attrapé le bug. Réécrivez-le en test d'intégration.
  3. S'il est toujours vert, écrivez un test end-to-end.
  4. Une fois le test rouge obtenu, demandez des clarifications aux experts métier et à l'équipe produit.
  5. Écrivez le code qui corrige le bug comme attendu, sous la forme la plus maintenable.
  6. Partagez le changement avec vos pairs, pour que le fix soit relu avant de partir.
  7. Savourez les retours de vos clients satisfaits.

Pourquoi commencer au niveau unitaire ? La TestPyramid de Martin Fowler décrit la forme qu'une suite saine devrait avoir : beaucoup de tests unitaires rapides, moins de tests d'intégration, et seulement quelques tests UI au sommet. Commencer en bas ne coûte pas cher, et la forme de la pyramide dit que l'essentiel des vérifications doit vivre là.

Pourquoi interroger l'équipe produit avant d'écrire le code ? Les bugs peuvent venir d'une mauvaise logique métier. Si le code fait ce pour quoi il a été écrit, mais que la règle elle-même est fausse, un test écrit à partir du code passera. La question va donc d'abord aux experts métier. Ainsi le test capture la règle qui devrait exister, pas celle qui se trouve exister.

L'étape 5 demande la forme la plus maintenable, et c'est le test rouge qui rend cela sûr. Refactoring, de Martin Fowler, repose sur la même idée. Avec des tests en place, vous pouvez changer la structure du code sans changer son comportement.

Quand la méthode efficace ne s'applique-t-elle pas ?

Toute méthode a un coût, et celle-ci en a deux.

Le premier test rouge prend du temps à écrire. Dans une vieille codebase, il n'y a parfois aucun « seam » par où tester. Michael Feathers, dans Working Effectively with Legacy Code, décrit les characterization tests pour ce cas. Vous écrivez un test qui enregistre ce que le code fait aujourd'hui, puis vous changez le code sous sa protection.

Le second coût, c'est la revue avec l'équipe produit. Elle prend du temps de calendrier. Toute la boucle peut être très rapide, et cela dépend de la réactivité de l'équipe.

Cette échelle de tests n'est pas pour tous les bugs. Pour une faute de frappe dans un script interne que personne ne relancera, l'échelle complète est de trop. Elle est rentable quand le bug a atteint les utilisateurs, ou quand la même zone va encore changer. Ajustez l'effort à ce que coûterait le retour du bug.

Comment savoir que la méthode marche ?

Comptez ce qui revient. Si un fix crée un deuxième fix dans le même cycle de release, le process a un trou. Mesurez les régressions après chaque release, et gardez le compteur visible pour l'équipe.

Pas besoin de reconstruire toute la suite pour commencer. Prenez les derniers bugs remontés par les utilisateurs après une release, retrouvez pour chacun le changement qui l'a causé, et écrivez le test manquant pour ce chemin. Chaque nouveau test ferme une porte de retour dans la boucle.

Si vous ne mesurez pas, vous devinez, et vous devinez mal.

💡 Un bug corrigé de façon efficace est corrigé une fois. Un bug corrigé dans la précipitation est corrigé encore, et encore.

Ressources et bibliographie

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