Débogage de programme

9.1 Apparition des bugs

Le débogage logiciel est le processus de recherche et de correction d'erreurs ou de bugs dans un programme. C'est la partie la plus intéressante du développement logiciel, qui aide à assurer le bon fonctionnement des programmes.

Histoire de l'apparition du terme "bug"

Le terme "bug" dans le contexte des programmes informatiques a commencé à être utilisé dans les années 1940. Bien que le concept de "bugs" existait déjà avant l'apparition des ordinateurs, désignant des dysfonctionnements mécaniques dans divers appareils.

Le premier cas documenté de l'utilisation du terme "bug" en technique informatique a été avec une équipe travaillant sur l'ordinateur Mark II à l'Université de Harvard en 1947(!). L'équipe a découvert qu'un des relais de la machine ne fonctionnait pas parce qu'une mite y était entrée. Ils ont retiré l'insecte et l'ont noté dans le journal comme "le premier cas réel de découverte d'un insecte" (literal bug).

Bien que ce ne soit pas le premier cas d'utilisation du terme "bug" pour désigner une erreur, cet incident est devenu célèbre et a contribué à populariser le terme « bug ».

Débogage de programme

Le débogage est le processus de recherche, de diagnostic et de correction des bugs dans un logiciel. Le processus de débogage comprend plusieurs étapes :

1. Détection d'erreur : identification des symptômes indiquant la présence d'une erreur dans le programme.
2. Reproduction de l'erreur : création des conditions dans lesquelles l'erreur réapparaît pour mieux comprendre sa nature.
3. Diagnostic du problème : utilisation de divers outils et méthodes pour analyser le code et trouver la cause de l'erreur.
4. Correction de l'erreur : apporter des modifications au code pour corriger l'erreur.
5. Test : vérification de la correction et test du programme pour s'assurer que l'erreur est corrigée et que de nouveaux problèmes ne sont pas apparus.

Donc, un bug est un nom générique pour toutes les erreurs dans les programmes, et le débogage est le processus de détection et de correction de ces erreurs.

9.2 Outils et méthodes de débogage

Logging

Ajouter des logs au code du programme permet de suivre son exécution et d'obtenir des informations sur l'état des variables et des opérations à divers points d'exécution du programme. Pour le logging en JavaScript, il y a une excellente bibliothèque : winston.

Exemple d'utilisation du logging :

    
      const { createLogger, format, transports } = require('winston');

      // Créer un logger avec un niveau de débogage
      const logger = createLogger({  level: 'debug' });

      // Fonction de division
      function divide(a, b) {
        logger.debug(`Division de ${a} par ${b}`);
        if (b === 0) {
          logger.error("Tentative de division par zéro!");
          return null;
        }
        return a / b;
      }

      // Exemple d'utilisation de la fonction
      const result = divide(10, 2);
      console.log(result); // Affichera : 5
    
  

Utilisation des débogueurs (Debuggers)

Les débogueurs sont des outils qui permettent aux développeurs d'exécuter le programme pas à pas, de définir des points d'arrêt (breakpoints), de vérifier les valeurs des variables et de les modifier pendant l'exécution du programme.

Débogueurs populaires pour JavaScript :

• Chrome DevTools : débogueur intégré dans le navigateur Google Chrome
• Firefox Developer Tools : débogueur intégré dans le navigateur Mozilla Firefox
• Node.js Debugger : débogueur intégré pour le JavaScript côté serveur dans Node.js
• Visual Studio Code Debugger : débogueur intégré dans l'éditeur Visual Studio Code

Exemple d'utilisation d'un débogueur dans Node.js :

    
      // Importer le module de débogage intégré
      const { inspect } = require('util');

      // Exemple de fonction avec erreur
      function faultyFunction(a, b) {
        debugger; // Définir un point d'arrêt
        let result = a / b;
        return result;
      }

      // Appel de la fonction avec erreur
      console.log(faultyFunction(10, 0));
    
  

Lorsque le programme atteint le debugger, il s'arrête et vous pouvez utiliser des commandes de débogage comme avancer (step over), entrer (step into), sortir (step out), vérifier les valeurs des variables, etc.

Nous allons étudier le débogage de programmes à l'aide du débogueur intégré dans Intellij IDEA (version Ultimate Edition requise).

9.3 Utilisation du debug

En général, le debug inclut une utilisation active des outils de débogage et des pratiques pour identifier et corriger les erreurs.

Étapes de débogage :

1. Définition de points d'arrêt : définissez des points d'arrêt dans le code pour arrêter l'exécution du programme aux endroits qui vous intéressent.
2. Exécution pas à pas : exécutez le programme étape par étape, en observant les modifications dans l'état du programme et les valeurs des variables.
3. Analyse des variables : examinez les valeurs des variables et des expressions à différentes étapes de l'exécution du programme pour détecter des données incorrectes ou des erreurs logiques.
4. Correction des erreurs : apportez des modifications au code pour corriger les erreurs trouvées.
5. Re-test : après la correction des erreurs, testez à nouveau le programme pour vous assurer que l'erreur est corrigée et que de nouveaux problèmes ne sont pas apparus.

Ça a l'air simple, non ? Dans la prochaine conférence, nous allons parcourir chaque étape en détail :)