Wer das Pro­gram­mie­ren lernt, der stößt zwangs­läu­fig auch auf den Begriff „Debugging“. Hinter diesem Prozess verbirgt sich eine Rundum-Un­ter­su­chung des Quell­codes eines Com­pu­ter­pro­gramms, die darauf abzielt, ent­hal­te­ne Fehler ausfindig zu machen. Wer also Wert darauf legt, dass eine ent­wi­ckel­te Software auf allen ge­wünsch­ten Ziel­platt­for­men und -geräten wie gewünscht funk­tio­niert, sollte auf den Einsatz eines Debuggers nicht ver­zich­ten. Im nach­fol­gen­den Artikel erfahren Sie, was genau ein Debugger ist, wie diese nütz­li­chen Programme funk­tio­nie­ren und wo sie ei­gent­lich zum Einsatz kommen.

Was ist ein Debugger?

Ein Debugger ist ein Com­pu­ter­pro­gramm, das das Aufspüren und Dia­gnos­ti­zie­ren von Fehlern in Com­pu­ter­soft­ware er­mög­licht. Ziel eines solchen Hilfs­werk­zeugs ist es, die Funk­tio­na­li­tät der über­prüf­ten Software auf allen an­vi­sier­ten Geräten und Platt­for­men lang­fris­tig zu ge­währ­leis­ten. Aus diesem Grund über­prü­fen viele Debugger nicht nur den je­wei­li­gen Quellcode, sondern auch die In­ter­ak­ti­on mit dem aus­füh­ren­den Be­triebs­sys­tem und der zu­grun­de­lie­gen­den Hardware. Der Debugging-Prozess findet direkt während der Laufzeit statt, sodass die über­prüf­te Software für die Über­prü­fung nicht beendet werden muss.

Hinweis

Der Begriff „Debugging“ be­zeich­net den Vorgang, bei dem Pro­gramm­feh­ler auf­ge­spürt werden. Er findet häufig auch dann Ver­wen­dung, wenn zu diesem Zweck kein Debugger, sondern eine andere Methode zur Feh­ler­über­prü­fung zum Einsatz kommt.

Der Debugging-Begriff geht auf das englische Präfix de- (dt. ent-) und das englische Wort bug (dt. Käfer) zurück. Letztere Be­zeich­nung wird in der Software-Ent­wick­lung seit Jahr­zehn­ten für Pro­gramm­feh­ler ver­schie­dens­ter Art verwendet – unter In­ge­nieu­ren war er sogar schon im 19. Jahr­hun­dert als Be­zeich­nung für Fehl­funk­tio­nen in Gebrauch. In Anlehnung an diesen Begriff be­zeich­net man die Behebung eines Software-Fehlers auch als „Bugfix“.

De­fi­ni­ti­on: Debugger

Debugger sind Com­pu­ter­pro­gram­me, die Ent­wick­ler bei der Feh­ler­su­che in Software un­ter­stüt­zen. Die beim Debugging erfassten Fehler, die auch als Bugs be­zeich­net werden, lassen sich dadurch leicht be­rei­ni­gen, wodurch sich die lang­fris­ti­ge Funk­tio­na­li­tät der Software ge­währ­leis­ten lässt.

Welche Funk­tio­nen erfüllt ein Debugger?

Eine perfekte Software ohne Fehler gibt es nicht, was die tägliche Op­ti­mie­rung quasi un­ver­zicht­bar macht. Das große Problem besteht dabei häufig gar nicht darin, feh­ler­haf­te Abläufe im Pro­gramm­ab­lauf fest­zu­stel­len, sondern darin, die genaue Ursache dafür aus­zu­ma­chen. Schon eine falsch gesetzte Klammer oder ein nicht korrekt ver­wen­de­ter Operator können dafür sorgen, dass ein Programm nicht mehr ord­nungs­ge­mäß funk­tio­niert. Bei hunderten oder gar tausenden Zeilen Code böte die manuelle Suche – Zeichen für Zeichen – al­ler­dings wenig Aussicht auf Erfolg. Moderne Debugger liefern aus diesem Grund nicht nur die In­for­ma­ti­on darüber, dass ein Problem fest­ge­stellt wurde, sondern auch de­tail­lier­te Angaben zu der Art des Fehlers und häufig auch darüber, in welcher Codezeile er zu finden ist.

Ty­pi­scher­wei­se arbeiten sich Debugger Schritt für Schritt durch den je­wei­li­gen Pro­gramm­code. Zu diesem Zweck werden in der zu de­bug­gen­den Software so­ge­nann­te Hal­te­punk­te (engl. break­points) definiert. Das Debugging-Tool erkennt diese Punkte und kann sie dazu nutzen, die Aus­füh­rung der Software an eben diesen Stellen zu stoppen. Für Ent­wick­ler ergeben sich dadurch folgende zwei Mög­lich­kei­ten:

  • Es ist möglich, den exakten Zustand des Programms zu diesem Zeitpunkt zu un­ter­su­chen. So lässt sich bei­spiels­wei­se ganz einfach über­prü­fen, ob alle ein­ge­bun­den Variablen die er­war­te­ten Werte aus­ge­ge­ben haben.
     
  • Es ist möglich, das Programm ab dem je­wei­li­gen Hal­te­punkt ab­zu­spie­len, um etwaige Probleme oder Feh­ler­quel­len ein­zu­gren­zen.

Die Hal­te­punk­te müssen dabei nicht zwangs­läu­fig fix sein: Viele Debugger erlauben es, die Break­points an in­di­vi­du­el­le Be­din­gun­gen zu knüpfen. Auf diese Weise lässt sich das Programm auch unter be­stimm­ten Vor­zei­chen anhalten. Läuft eine Schleife bei­spiels­wei­se 20 Durch­gän­ge korrekt ab und erst beim 21. Durchgang kommt es zu einem Pro­gramm­feh­ler, kann der Debugger dank einer ent­spre­chen­den Bedingung direkt in den Pro­blem­fall ein­stei­gen. Die vor­an­ge­gan­ge­nen, er­eig­nis­lo­sen Schleifen müssen also nicht noch einmal extra durch­lau­fen werden.

Zu den weiteren Funk­tio­nen von Debuggern zählen unter anderem die In­spek­ti­on von Daten wie bei­spiels­wei­se die Inhalte von Variablen, Speichern oder Registern sowie die Mo­di­fi­zie­rung von Speichern wie dem Haupt­spei­cher (Ar­beits­spei­cher) oder dem Prozessor-Register.

Wie funk­tio­niert der Einsatz von Debuggern?

Wie genau sich ein Debugger für die Feh­ler­über­prü­fung einer Software einsetzen lässt, hängt ei­ner­seits von dem Tool selbst, an­de­rer­seits natürlich auch von dem Be­triebs­sys­tem ab, auf dem Software (und Debugger) aus­ge­führt werden. Als Nutzer geben Sie dem Über­prü­fungs­werk­zeug dabei die In­for­ma­ti­on weiter, an welchen Prozess er anknüpfen soll – wahlweise eine Prozess-ID oder einen Namen. In letzterem Fall bringt der Debugger zunächst die da­zu­ge­hö­ri­ge Prozess-ID in Erfahrung. An­schlie­ßend wird über einen Sys­tem­auf­ruf die Debugging-Sitzung initiiert.

Generell lassen sich zwei ver­schie­de­ne Ansätzen für den Einsatz von Debugging-Tools un­ter­schei­den:

  • Der Über­prü­fungs­pro­zess wird innerhalb des Systems ab­ge­wi­ckelt, auf dem die zu über­prü­fen­de Software läuft.
     
  • Der Über­prü­fungs­pro­zess wird nicht auf dem Computer gestartet, auf dem die zu über­prü­fen­de Software läuft, sondern von einem ent­fern­ten System aus, auch Remote-Debugging genannt.

Moderne Debugger sind häufig dazu in der Lage, Än­de­run­gen am Quellcode einer Software noch während der Aus­füh­rung in die Feh­ler­über­prü­fung mit­ein­zu­be­zie­hen. Dieses Just-in-time-Debugging ist ins­be­son­de­re in der frühen Ent­wick­lungs­pha­se einer Com­pu­ter­soft­ware gefragt, wo kleinere, aber auch größere Code-Fehler keine Sel­ten­heit sind. Nicht von ungefähr verfügen auch die Ent­wick­lungs­um­ge­bun­gen ver­schie­dens­ter Skript­spra­chen und Frame­works über einen in­te­grier­ten Debugger.

Debugger: Wo kommen sie zum Einsatz?

Geht es um Debugger bzw. das Debugging im All­ge­mei­nen lässt sich folgendes fest­hal­ten: Soll Com­pu­ter­code lang­fris­tig möglichst feh­ler­frei funk­tio­nie­ren, ist der Einsatz dieses prak­ti­schen Über­prü­fungs­pro­ze­de­res un­ver­zicht­bar – egal, ob Sie ein einfaches Skript, einen einzelnen Prozess, ein Modul, ein komplexes Programm oder ein kom­plet­tes Be­triebs­sys­tem pro­gram­mie­ren bzw. wei­ter­ent­wi­ckeln und testen wollen.

Auch für Nicht­pro­gram­mie­rer ist es von Vorteil, wenn eine Software über einen passenden Debugger verfügt: Ent­spre­chend entworfen und kon­fi­gu­riert kann das Hilfstool bei­spiels­wei­se als Sprach­rohr zwischen Pro­gramm­nut­zer und Ent­wick­ler dienen, wenn es bei der Nutzung zu Fehlern kommt. Durch die Berichte des Debuggers können die Ent­wick­ler nämlich we­sent­lich besser nach­voll­zie­hen, wo es hakt und wie der User das Problem mit der Software lösen kann. Je nach Programm, Debugger und Schwere des Fehlers kann ein be­reit­ge­stell­tes Debugging-Tool den Nutzern einer Software zudem sogar die Feh­ler­be­he­bung auf eigene Faust er­mög­li­chen.

Zum Hauptmenü