Déboguer

Déboguer, c’est enquêter

Le défaut et la défaillance

La défaillance est ce que l’on observe : un résultat erroné, un programme qui ne termine pas, un rapport du détecteur (sanitizer). Le défaut (ou erreur) est la cause : une ligne, une condition ou une décision de conception qui ne correspond pas à la spécification. La défaillance se voit ; le défaut, il faut le trouver, et il peut être loin d’elle. Il s’ensuit que corriger là où se voit la défaillance, par exemple en retranchant 2 au résultat parce qu’« il sort toujours 2 de trop », corrige le symptôme et laisse la cause, qui reviendra avec d’autres données.

S’il en est ainsi, déboguer est une enquête sur la cause, et sa méthode est celle des sciences expérimentales :

1. Observer et reproduire. Décrire avec précision la défaillance (avec quelle entrée, ce qu’on attendait, ce qu’on a obtenu) et obtenir qu’elle se produise chaque fois qu’on le veut. Un défaut qui ne se reproduit pas ne peut pas être étudié, et l’on ne peut pas non plus vérifier qu’il a été corrigé.
2. Formuler une hypothèse. Une affirmation sur la cause qui puisse se révéler fausse : « le tri ne trie pas », « l’indice de la seconde donnée centrale a un de trop ».
3. Concevoir une expérience. Choisir un point du programme et prédire quel état on devrait y voir si l’hypothèse est vraie et lequel si elle est fausse.
4. Conclure et circonscrire. Écarter l’hypothèse ou la confirmer ; dans les deux cas, l’intervalle suspect se réduit. On recommence jusqu’à ce que l’intervalle soit une ligne.

Or la méthode exige de la discipline : changer une seule chose à la fois, noter chaque hypothèse avec son résultat, et ne pas toucher au code tant qu’on ne sait pas ce qu’on cherche. Changer des lignes au hasard jusqu’à ce que la sortie paraisse bonne peut masquer la défaillance sans supprimer le défaut.

#include <algorithm>#include <cstddef>#include <print>#include <vector>​// Médiane d’une liste de données.// Précondition : values n’est pas vide.// Postcondition : renvoie la donnée centrale de la liste triée, ou la moyenne des deux centrales.double median(std::vector<double> values){    std::ranges::sort(values);    const std::size_t n{values.size()};    const std::size_t middle{n / 2};    if (n % 2 == 1) {        return values[middle];    }    return (values[middle] + values[middle + 1]) / 2.0;}​int main(){    const std::vector<double> odd{7.0, 1.0, 5.0, 3.0, 9.0};    const std::vector<double> even{7.0, 1.0, 5.0, 3.0};    std::println("Médiane de {} : {}", odd, median(odd));    std::println("Médiane de {} : {}", even, median(even));}

Médiane de [7, 1, 5, 3, 9] : 5Médiane de [7, 1, 5, 3] : 6

La dichotomie

Quand il n’y a pas d’hypothèse claire, il reste une méthode qui n’échoue pas : la dichotomie. On suppose que l’état du programme est correct au début et erroné à la fin, et qu’en chaque point intermédiaire on peut décider s’il est correct (en le comparant à une valeur calculée à la main, ou en vérifiant un invariant). On examine l’état au milieu de l’intervalle suspect : s’il est correct, le défaut est dans la seconde moitié ; sinon, dans la première. C’est la recherche dichotomique de la leçon Rechercher et trier, appliquée aux lignes d’un programme (ou aux itérations d’une boucle, ou aux versions d’un fichier).

La figure suit la dichotomie de seize lignes avec le défaut à la ligne 11 ; chaque trait est une expérience sur l’état après cette ligne : correct (✓) ou erroné (✗).

Le décompte est celui de la recherche dichotomique : chaque expérience divise l’intervalle par deux, de sorte que $k$ expériences suffisent pour $2^k$ lignes. Pour un programme de mille lignes, dix suffisent, car $2^{10} = 1024$. D’où l’avantage de la méthode : son coût croît comme le logarithme de la taille, et elle n’exige pas de comprendre tout le programme, mais de savoir décider, en un point, si l’état est celui qu’il doit être. Or cette décision est la partie difficile : les spécifications et les invariants sont le critère avec lequel on juge chaque état intermédiaire.