Debugging

So funktioniert das Debuggen von Software

Typischerweise beginnt Debugging nach dem Schreiben des Codes, und wird in aufeinanderfolgenden Phasen fortgesetzt, wenn Code mit anderen Programmiereinheiten kombiniert wird, um die fertige Software zu bilden. In einem großen Programm mit Tausenden und Abertausenden von Codezeilen vereinfachen Entwickler der Debugging-Prozess durch Strategien wie Unit-Tests, Code-Reviews und Pair Programming.

Fehler lassen sich unter anderem in den Protokolldateien des Codes identifizieren, aber auch ein eigenständiges Debugger Tool oder den Debug-Modus einer integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) können hilfreich sein. Dazu sollten Entwickler mit Standardfehlermeldungen vertraut sein. Haben sie den Code jedoch beim Schreiben nicht angemessen kommentiert, kann Debugging selbst im saubersten Code zur Herausforderung werden.

In einigen Fällen ist das es offensichtlich, in welchem Modul der Fehler ist, aber nicht, in welcher Codezeile. In diesem Fall können Unit-Tests – wie JUnit und xUnit, die es dem Programmierer ermöglichen, eine bestimmte Funktion mit bestimmten Eingaben auszuführen – beim Debuggen unterstützen.

Mit Breakpoints lassen sich Programme in Etappen ausführen, so dass es leichter ist, die fehlerhafte Stelle einzugrenzen. Außerdem haben Programmierer in IDEs die Möglichkeit, Speicher und Variablen anzuzeigen, das Programm bis zum nächsten Breakpoint auszuführen, nur die nächste Codezeile auszuführen und in einigen Fällen den Wert von Variablen zu ändern oder sogar zu ändern den Inhalt der Codezeile, die gerade ausgeführt werden soll.

Bedeutung des Debuggens

Das Debuggen ist ein wichtiger Schritt, um herauszufinden, warum ein Betriebssystem, eine Anwendung oder ein Programm fehlerhaft ist. In vielen Fällen kann das Debuggen eines neuen Programms mehr Zeit in Anspruch nehmen als das Schreiben des Programms. Ausnahmslos werden die Fehler in Softwarekomponenten, die am häufigsten verwendet werden, zuerst gefunden und behoben.

Debuggen versus Testen

Debuggen und Testen sind komplementäre Prozesse. Mit einem Test können Sie herausfinden, was passiert, wenn ein Fehler im Quellcode eines Programms vorliegt. Der Zweck des Debuggens besteht darin, den Fehler zu lokalisieren und zu beheben.

Dadurch kann der Entwickler jedoch lediglich herausfinden, welche Auswirkungen der Codefehler auf das Programm hat. Sobald der Fehler identifiziert wurde, hilft das Debugging dem Entwickler, die Ursache zu ermitteln, um ihn zu finden.

Beispiele

Einige Beispiele für häufige Codefehler sind die folgenden:

• Syntaxfehler
• Laufzeitfehler
• Semantischer Fehler
• Logikfehler
• Missachtung übernommener Konventionen im Kodierungsstandard
• Aufruf der falschen Funktion
• der falsche Variablenname an der falschen Stelle
• Fehler beim Initialisieren einer Variablen, wenn dies unbedingt erforderlich ist
• Überspringen einer Prüfung auf eine Fehlerrückgabe

Debugging-Strategien

Quellcode-Analysatoren, die Code auf Sicherheit, Fehler und Komplexität hin absuchen, sind eine weitere Stütze beim Debuggen. Ein Komplexitätsanalysator kann Module finden, die so kompliziert sind, dass sie schwer zu verstehen und zu testen sind. Andere Debugging-Strategien umfassen die folgenden:

• Statische Analyse – der Entwickler untersucht den Code, ohne das Programm auszuführen.
• Print Debugging (auch Tracing genannt) – der Entwickler beobachtet live oder aufgezeichnete Print-Anweisungen und den Fluss.
• Remote-Debugging – Der Debugger des Entwicklers läuft auf einem anderen System als das Programm, das er prüft.
• Post-mortem-Debugging – der Entwickler stoppt das Debuggen des Programms nur, wenn es zu schwerwiegenden Ausnahmen kommt.

Debugging Tools

Ein Debugger ist ein Softwaretool, das den Softwareentwicklungsprozess unterstützen kann, indem es Codierungsfehler in verschiedenen Phasen der Betriebssystem- oder Anwendungsentwicklung identifiziert.

Einige Debugger analysieren einen Testlauf, um zu sehen, welche Codezeilen nicht ausgeführt wurden. Andere Debugging-Tools stellen Simulatoren bereit, mit denen der Programmierer modellieren kann, wie eine App auf einem bestimmten Betriebssystem oder Computer sich verhalten wird.

Viele Open-Source-Debugging-Tools und Skriptsprachen laufen nicht in einer IDE und erfordern daher einen eher manuellen Ansatz beim Debuggen. USB-Debugging ermöglicht beispielsweise die Kommunikation eines Android-Geräts mit einem Computer, auf dem das Android SDK ausgeführt wird

In dieser Situation kann der Entwickler ein Programm debuggen, indem er Werte in einem Protokoll ablegt, umfangreiche Tracing-Anweisungen erstellt, um die Codeausführung zu überwachen, oder hartcodierte Wartebefehle implementiert, die einen Haltepunkt simulieren, indem er in bestimmten Intervallen auf Tastatureingaben wartet.

Herausforderungen beim Debuggen

Der Debugging-Prozess kann ziemlich schwierig sein und genauso viel Arbeit erfordern – wenn nicht sogar mehr – als das Schreiben des Codes zu Beginn. Faktoren, die diese Aufgabe in die Länge ziehen sind:

• Die negative Auswirkung des Codierungsfehlers ist klar, die Ursache jedoch nicht.
• Der negative Effekt des Codierungsfehlers ist schwer zu reproduzieren – zum Beispiel wenn Webinhalte Dropdown-Menüs enthalten.
• Abhängigkeiten sind nicht klar, so dass das Beheben eines Codefehlers in einem Teil des Programms versehentlich neue Fehler in anderen Teilen des Programms einführt.

Geschichte des Debuggens

Die Verwendung des Wortes Bug als Synonym für Fehler hat seinen Ursprung in der Technik. Admiral Grace Hopper gilt als der Erfinderin des Begriffs. Sie war eine Pionierin der Computerprogrammierung, die auch für ihren trockenen Humor bekannt war. Als ein tatsächliches Insekt (eine Motte) zwischen elektrischen Relais festhingt und ein Problem im ersten Computer der US-Marine verursachte, debuggten Admiral Hopper und ihr Team den Computer und entfernten die Motte. Sie befindet sich heute im Smithsonian Museum.