Débogage de programme

8.1 Apparition des bugs

Le débogage de logiciel est le processus de recherche et de correction des erreurs ou bugs dans un programme. Ce processus est la partie la plus intéressante et importante du développement de logiciels et aide à garantir le bon fonctionnement des programmes.

Histoire de l'apparition du terme "bug"

Le terme "bug" dans le contexte des programmes informatiques a été utilisé pour la première fois dans les années 1940. Bien que la notion de "bugs" existait déjà avant l'apparition des ordinateurs, désignant des pannes mécaniques dans différents dispositifs.

Le premier cas documenté d'utilisation du terme "bug" en informatique a été avec l'équipe travaillant sur l'ordinateur Mark II à l'université Harvard en 1947(!). L'équipe a découvert qu'un des relais de la machine ne fonctionnait pas à cause d'un papillon de nuit. Ils ont retiré l'insecte et noté cela dans le journal comme "le premier cas réel de découverte d'un insecte" (bug littéral).

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 :

• Détection de l'erreur: Définir les symptômes indiquant la présence d'une erreur dans le programme.
• Reproduction de l'erreur: Créer des conditions dans lesquelles l'erreur se manifeste à nouveau pour mieux comprendre sa nature.
• Diagnostic du problème: Utiliser divers outils et méthodes pour analyser le code et rechercher la cause de l'erreur.
• Correction de l'erreur: Apporter des modifications au code pour éliminer l'erreur.
• Tests: Vérifier la correction et tester le programme pour s'assurer que l'erreur est résolue et qu'il n'y a pas de nouveaux problèmes.

Donc, un bug est un terme générique pour toute erreur dans les programmes, et le débogage (de-bug) est le processus de détection et de correction de ces erreurs.

8.2 Outils et méthodes de débogage

Journalisation

L'ajout de logs dans le code du programme permet de suivre son exécution et d'obtenir des informations sur l'état des variables et des opérations à différents points d'exécution du programme. Pour la journalisation en Python, il existe une excellente bibliothèque — logging.

Exemple d'utilisation de la journalisation :

import logging

# Configuration de la journalisation pour afficher les informations de débogage
logging.basicConfig(level=logging.DEBUG)
            

def divide(a, b):
    # Journaliser la tentative de division
    logging.debug(f"Division de {a} par {b}")
    if b == 0:
        # Journaliser l'erreur si b est égal à 0
        logging.error("Tentative de division par zéro!")
        return None

    # Effectuer la division si b n'est pas égal à 0
    return a / b
            
result = divide(10, 2)
print(result)

Utilisation des débogueurs (Debuggers)

Les débogueurs sont des outils qui permettent aux développeurs d'exécuter le programme étape par étape, d'établir 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 :

1. GDB: GNU Debugger pour C, C++ et d'autres langages de programmation.
2. PDB: Débogueur intégré pour Python.
3. Visual Studio Debugger: Débogueur intégré dans Microsoft Visual Studio.
4. PyCharm Debugger: Débogueur intégré dans l'IDE PyCharm pour Python.

Exemple d'utilisation de PDB

import pdb

def faulty_function(a, b):
    pdb.set_trace()  # Établir un point d'arrêt
    result = a / b
    return result
            
faulty_function(10, 0)

Lorsque le programme atteint pdb.set_trace(), il s'arrête, et vous pouvez exécuter des commandes du débogueur telles que next (étape suivante), print (afficher la valeur d'une variable) et d'autres.

Nous allons étudier le débogage de programmes à l'aide du débogueur intégré dans PyCharm.

8.3 Utilisation du debug

Dans sa forme générale, le debug inclut l'utilisation active des outils de débogage et des pratiques pour identifier et corriger les erreurs.

Établissement de points d'arrêt: Établissez des points d'arrêt dans le code, pour arrêter l'exécution du programme aux endroits qui vous intéressent.

Exécution pas à pas: Exécutez le programme étape par étape, en observant les changements d'état du programme et les valeurs des variables.

Analyse des variables: Étudiez les valeurs des variables et des expressions à différents stades de l'exécution du programme, afin de détecter des données incorrectes ou des erreurs logiques.

Correction des erreurs: Apportez des modifications au code pour corriger les erreurs détectées.

Tests répétés: Après la correction des erreurs, effectuez des tests du programme, pour vous assurer que l'erreur est résolue et qu'aucun nouveau problème n'est survenu.

Ça a l'air simple, pas vrai? Dans le prochain cours, nous passerons en revue chaque étape en détail :)