Debuggen

Debuggen is het opsporen en verhelpen van bugs in computerprogramma's en elektronische hardware.

Voor het debuggen van software zijn speciale programma's ontwikkeld, debuggers geheten. Met behulp van deze programma's kan de programmeur de uitvoering van de code nader bekijken door breekpunten te plaatsen: bij een breekpunt wordt de uitvoering gestopt zodat de programmeur de waarde van variabelen kan inspecteren of veranderen. Ook kan men in een debugger variabelen bekijken om te zien hoe de waarde verandert tijdens het programma. De term 'debugger' verwijst ook wel naar de persoon die aan het debuggen is.

In eenvoudige situaties kan de programmeur de waarde van variabelen op het scherm tonen door instructies toe te voegen aan de broncode. Door deze instructies kan de programmeur tijdens het uitvoeren van het programma de waarde van variabelen lezen op het scherm. Deze aanpak wordt doorgaans alleen gebruikt als er weinig variabelen op het scherm getoond moeten worden; bij veel variabelen of variabelen die regelmatig veranderen kan deze methode onoverzichtelijk worden.

Een eenvoudige manier om het effect van een stuk code te bepalen is door het uit te commentariëren (in commentaar te plaatsen) en vervolgens het programma uit te voeren. Door systematisch stukken code wel of niet in commentaar te zetten, wordt getracht de bug te lokaliseren.

Er wordt ook gebruikgemaakt van programma's die statische codeanalyse kunnen uitvoeren: deze programma's sporen specifieke foutsituaties op door de broncode van een programma te analyseren. Deze programma's controleren niet de syntaxis van de broncode maar meer de semantiek. Deze programma's kunnen fout-positieve resultaten geven aangezien ze niet zoeken naar fouten maar naar situaties die waarschijnlijk niet zo bedoeld zijn. Er bestaan commerciële en vrije programma's voor statische codeanalyse voor allerlei programmeertalen. Deze programma's zijn met name handig voor grote softwareprojecten waarbij een handmatige controle van de broncode ondoenlijk zou zijn.

High-level-programmeertalen, zoals Java, bevatten vaak functionaliteit die het opsporen van bugs vergemakkelijkt, zoals het gooien van excepties. In low-level-programmeertalen, zoals assembly en C, kunnen bugs subtiele fouten veroorzaken, zoals bufferoverloop of geheugenlekken, die lastig te traceren zijn.

Debuggen begint doorgaans bij het reproduceren van de bug door een situatie te vinden waarin de bug zich voordoet, zoals bepaalde instellingen of waarden van een variabele. Het vinden van zo'n situatie kan lastig zijn in gecompliceerde systemen. Ook kan de fout veroorzaakt worden door lokale instellingen of bestanden op een systeem waardoor hetzelfde programma op een ander systeem wel functioneert.

Na het vinden van een situatie waarin het probleem zich voordoet, wordt getracht deze situatie te versimpelen om het opsporen van de fout te vereenvoudigen. Zo'n versimpelde situatie waarin een bug zich voordoet wordt een testcase genoemd, bijvoorbeeld een bestand of een lijst met handelingen. Een bug in een compiler kan zich bijvoorbeeld voordoen als het een groot bestand tracht te ontleden; in zo'n geval bekijkt de programmeur of de fout zich nog steeds voordoet als delen uit dat grote bestand worden gehaald. Een kleiner bestand is makkelijker te hanteren en analyseren wat het lokaliseren van de bug vergemakkelijkt. Bij het opsporen van een fout met de grafische gebruikersomgeving van een programma kan de programmeur bepaalde handelingen overslaan om te kijken of de overgebleven handelingen ook voldoende zijn om te fout te laten gebeuren.

De programmeur of het team softwareontwikkelaars kunnen ook om een testcase vragen wanneer gebruikers een bug rapporteren. Deze wordt bijgevoegd bij de beschrijving van de bug in de bugtracker, een systeem om overzichtelijk te zien welke bugs opgelost zijn en welke nog niet.

Na het vereenvoudigen van de situatie kan de programmeur de bug lokaliseren met een van de beschreven technieken. Zodra de oorzaak van het probleem is gevonden, kan de programmeur een oplossing voor het probleem bedenken en het implementeren.

Debuggen komt oorspronkelijk van 'a bug' of 'een mot'. Dit komt uit de tijd dat de computers nog uitgerust waren met relais. Deze relais kwamen veelal uit de telefoonindustrie en waren niet ingekapseld in een behuizing. Daardoor kon klein ongedierte als vliegen of motten zich nestelen tussen de contacten van het relais. Dit leidde tot storingen. Het debuggen was het vinden van die storingen en verwijderen van het ongedierte. Vandaar dat de term 'debuggen' of 'de bug wegnemen' ontstond, en nu nog steeds in de vaktermen van het programmeren geworteld zit. Zie bug voor een meer uitgebreide geschiedenis.

• Assertie
• Dode code
• Testen (software)