Programm-Debugging

9.1 Entstehung von Bugs

Debugging von Software ist der Prozess des Auffindens und Behebens von Fehlern oder Bugs in einem Programm. Das ist der spannendste Teil der Softwareentwicklung, der hilft, die korrekte Funktion der Programme sicherzustellen.

Herkunft des Begriffs „Bug“

Der Begriff „Bug“ im Kontext von Computerprogrammen wurde erstmals in den 1940er Jahren verwendet. Obwohl das Konzept von „Bugs“ auch vor den Computern existierte, um mechanische Fehlfunktionen in verschiedenen Geräten zu beschreiben.

Der erste dokumentierte Fall der Verwendung des Begriffs „Bug“ in der Computertechnik geschah mit einem Team, das 1947 am Mark-II-Computer der Harvard-Universität arbeitete. Das Team entdeckte, dass ein Relais der Maschine aufgrund einer in sie eingedrungenen Motte nicht funktionierte. Sie entfernten das Insekt und vermerkten das im Logbuch als den „ersten tatsächlichen Fall eines gefundenen Bugs“ (literal bug).

Obwohl dies nicht der erste Fall der Verwendung des Begriffs „Bug“ zur Bezeichnung eines Fehlers war, machte dieser Vorfall den Begriff „Bug“ populär.

Debugging eines Programms

Debugging ist der Prozess zur Suche, Diagnose und Behebung von Bugs in Software. Der Debugging-Prozess umfasst mehrere Schritte:

1. Fehler entdecken: Feststellen von Symptomen, die auf das Vorhandensein eines Fehlers im Programm hinweisen.
2. Fehler reproduzieren: Bedingungen schaffen, unter denen der Fehler erneut auftritt, um seine Ursache besser zu verstehen.
3. Problem diagnostizieren: Verwendung verschiedener Werkzeuge und Methoden zur Analyse des Codes und zur Identifikation der Fehlerursache.
4. Fehler beheben: Änderungen am Code vornehmen, um den Fehler zu beseitigen.
5. Testen: Überprüfung der Behebung und Testen des Programms, um sicherzustellen, dass der Fehler entfernt wurde und keine neuen Probleme aufgetaucht sind.

Zusammengefasst: Ein Bug ist ein allgemeiner Begriff für jeden Fehler in einem Programm, und „debug (de-bug)“ bezeichnet den Prozess des Auffindens und Behebens dieser Fehler.

9.2 Tools und Methoden fürs Debugging

Logging

Das Hinzufügen von Logs in den Programmcode ermöglicht es, die Ausführung des Programms zu verfolgen und Informationen über den Zustand von Variablen und Operationen zu verschiedenen Zeitpunkten zu erhalten. Für Logging in JavaScript gibt es eine ausgezeichnete Bibliothek – winston.

Beispiel für Logging:

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

      // Logger mit Debug-Level erstellen
      const logger = createLogger({ level: 'debug' });

      // Division-Funktion
      function divide(a, b) {
        logger.debug(`Division von ${a} durch ${b}`);
        if (b === 0) {
          logger.error("Versuch der Division durch null!");
          return null;
        }
        return a / b;
      }

      // Beispiel für die Nutzung der Funktion
      const result = divide(10, 2);
      console.log(result); // Gibt aus: 5
    
  

Verwendung von Debuggern

Debugger sind Werkzeuge, die Entwicklern ermöglichen, ein Programm Schritt für Schritt auszuführen, Breakpoints zu setzen, Variablenwerte einzusehen und diese während der Programmausführung zu ändern.

Beliebte Debugger für JavaScript:

• Chrome DevTools: Eingebauter Debugger im Browser Google Chrome
• Firefox Developer Tools: Eingebauter Debugger im Browser Mozilla Firefox
• Node.js Debugger: Eingebauter Debugger für serverseitiges JavaScript in Node.js
• Visual Studio Code Debugger: Debugger in Visual Studio Code integriert

Beispiel für die Verwendung eines Debuggers in Node.js:

    
      // Importieren des eingebauten Debugging-Moduls
      const { inspect } = require('util');

      // Beispiel einer fehlerhaften Funktion
      function faultyFunction(a, b) {
        debugger; // Breakpoint setzen
        let result = a / b;
        return result;
      }

      // Aufruf der Funktion mit einem Fehler
      console.log(faultyFunction(10, 0));
    
  

Wenn das Programm den debugger erreicht, stoppt es, und du kannst Debugging-Befehle verwenden, wie zum Beispiel Step Over, Step Into, Step Out, Variablenwerte prüfen und weitere.

Wir werden das Debugging von Programmen anhand des Debuggers studieren, der in Intellij IDEA integriert ist (Ultimate Edition erforderlich).

9.3 Verwendung von Debug

Im Allgemeinen umfasst Debug die aktive Nutzung von Debugging-Tools und -Praktiken, um Fehler zu finden und zu beheben.

Debugging-Schritte:

1. Breakpoints setzen: Setze Breakpoints im Code, um die Programmausführung an interessanten Stellen zu stoppen.
2. Schrittweises Ausführen: Führe das Programm Schritt für Schritt aus und beobachte Änderungen im Programmzustand und Variablenwerte.
3. Analyse von Variablen: Prüfe Werte von Variablen und Ausdrücken in verschiedenen Phasen der Programmausführung, um falsche Daten oder logische Fehler zu identifizieren.
4. Fehler beheben: Nimm Änderungen im Code vor, um die gefundenen Fehler zu beseitigen.
5. Erneutes Testen: Führe nach der Fehlerbehebung Tests durch, um sicherzustellen, dass der Fehler behoben ist und keine neuen Probleme aufgetreten sind.

Ziemlich einfach, oder? In der nächsten Vorlesung gehen wir jeden Schritt im Detail durch :)