Best Practices beim Debuggen

Debugging ist nicht nur Technik – es ist Denkweise.
Die besten Entwickler zeichnen sich nicht dadurch aus, dass sie keine Fehler machen,
sondern dadurch, dass sie Fehler systematisch finden und daraus lernen.

1. Grundhaltung: Ruhe und System

Der häufigste Fehler beim Debugging ist Hektik.
Schnelle Codeänderungen ohne Plan verschlimmern das Problem oft nur.

Falsches Verhalten	Besserer Ansatz
Mehrere Zeilen ändern und hoffen	Eine Hypothese pro Schritt testen
Fehler schnell „wegmachen“	Ursache verstehen und dokumentieren
Zufällig neue Inputs probieren	Fehler reproduzieren unter kontrollierten Bedingungen

Merksatz:

Debugging ist wie Detektivarbeit – du brauchst Beweise, keine Vermutungen.

2. Schrittweise vorgehen

2.1 Hypothese bilden
Bevor du etwas änderst, notiere, was du vermutest.
Z. B. „Vielleicht ist c in der Berechnung 0, weil Input leer ist.“

2.2 Eingrenzen
Suche das kleinste Stück Code, das den Fehler noch erzeugt.
Das nennt man Minimalbeispiel (oder „repro case“).
So erkennst du, ob das Problem im Algorithmus oder in den Daten liegt.

2.3 Verifizieren
Nach jeder Änderung → erneut testen.
Wenn der Fehler bleibt, Hypothese verwerfen und neue bilden.

Beispiel:

def average(a,b,c):
    return (a+b+c)/c

# Fehler tritt bei c=0 auf
# Hypothese: Eingabeprüfung fehlt
def average_safe(a,b,c):
    if c == 0:
        raise ValueError("Nenner darf nicht 0 sein")
    return (a+b+c)/c

3. Sauberes Logging – dein Gedächtnis im Code

Logs sind die Augen des Debuggers, wenn du nicht danebenstehst.

Regel	Begründung
Konsistente Struktur	Suchbar & auswertbar (z. B. JSON-Logs, Zeilenformat)
Level nutzen	`DEBUG`, `INFO`, `WARN`, `ERROR`, `CRITICAL`
Kontext mitschreiben	Eingaben, User-ID, Request-ID, Zeit
Nichts Sensibles loggen	DSGVO, Sicherheit
Fehler mit Stacktrace loggen	Besser analysierbar im Nachhinein

Beispiel (Python):

import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")

def divide(a,b):
    logging.debug(f"Starte Division a={a} b={b}")
    try:
        result = a / b
    except ZeroDivisionError:
        logging.error("Division durch Null!")
        raise
    else:
        logging.info(f"Ergebnis = {result}")
    return result

4. Fehlerquellen festhalten – für die Zukunft lernen

Viele Fehler tauchen wieder auf – oft Monate später.
Erfahrene Entwickler dokumentieren sie kurz und prägnant.

Fehler-Notiz (Beispiel):

Feld	Beispiel
Datum	06. 11. 2025
Problem	Berechnung in `average()` liefert falsche Werte
Ursache	Operatorpriorität – fehlende Klammern
Lösung	`(a + b + c) / 3`
Lerneffekt	Immer Klammern bei zusammengesetzten Ausdrücken prüfen

→ Solche kleinen Notizen (oder ein internes Wiki) sparen dir beim nächsten Mal Stunden.

5. Systematische Strategien

Strategie	Erklärung	Beispiel
Binary Search Debugging	Große Funktion halbieren, testen, dann weiter eingrenzen	Bei 200 Zeilen Code nur jede 2. prüfen
Print/Log Debugging	Gezielt Zwischenwerte loggen	z. B. `print(f"Zwischenergebnis: {x}")`
Version Control	Letzte funktionierende Version finden	`git bisect` zur Fehlerstelle
Test First	Test schreiben, bevor du den Fix einbaust	Prüft sofort, ob’s wieder kaputtgeht
Rubber Duck Debugging	Problem laut erklären	Schon beim Erzählen fällt oft der Denkfehler auf

6. Debugging-Fehler vermeiden

Schlechte Praxis	Besser
Direkt im Produktivcode rumprobieren	In einer sicheren Testumgebung debuggen
Kein Backup vor Änderungen	Immer vorher committen / snapshotten
Fehlermeldungen ignorieren	Immer ganz lesen, nicht nur den ersten Satz
Zu viele Log-Ausgaben	Nur das Nötige loggen, Level sauber trennen
Fehler fixen, ohne zu verstehen	Erst Ursache finden, dann korrigieren

Systematisches Debugging

8. Debugging-Checkliste (zum Mitnehmen)

Was genau ist falsch?
Kann ich es reproduzieren?
Wo im Code passiert es?
Welche Werte haben die Variablen dort?
Warum treten sie so auf?
Wie kann ich es bestätigen?
Wie verhindere ich, dass es wieder passiert?

→ Diese Fragen funktionieren in jeder Sprache, auf jedem System.

9. Zusammenfassung

Debugging ist analytisches Denken, kein „Trial & Error“.
Arbeite in kleinen, nachvollziehbaren Schritten.
Nutze Debugger, Watch, Stack und Logs bewusst.
Dokumentiere Ursachen – Debugging ist auch Wissensaufbau.
Fehler werden nie verschwinden – aber du wirst sie immer schneller verstehen.