Bohrbug: Was es ist, Ursachen und Methoden zur Behebung

Was ist ein Bohrbug?

Bohrbug ist eine Art von Softwarefehler, der sich deterministisch manifestiert: Bei denselben Eingabedaten führt er immer zum gleichen Fehler. Der Begriff wurde von den Forschern Jim Gray und Andreas Reuter in dem Buch „Transaction Processing: Concepts and Techniques“ (1993) in den wissenschaftlichen Sprachgebrauch eingeführt.

Im Gegensatz zum Mandelbug, der sein Verhalten chaotisch ändert, ist Bohrbug stabil: Ein Entwickler kann ihn mit geschlossenen Augen reproduzieren, indem er dem System dieselben Parameter übergibt. Dies macht ihn zu einem idealen Kandidaten für das schrittweise Debugging in einer IDE.

Bohrbug tritt in allen Phasen des Softwarelebenszyklus auf — von der Entwicklung bis zum Betrieb. Er wird oft während der Testphase entdeckt, da QA-Ingenieure wiederholte Szenarien ausführen, die garantiert zum Fehler führen.

Definition nach Gray und Reuter

Nach der Klassifikation von Gray und Reuter ist ein Bohrbug ein Defekt, der drei Bedingungen erfüllt: einen festen Satz von Eingabedaten, denselben Systemzustand und dasselbe Fehlerergebnis. Wenn mindestens eine Bedingung verletzt wird, ist der Bug nicht mehr „Bohr“.

Die Autoren betonen, dass ein Bohrbug nicht unbedingt ein einfacher Fehler ist. Er kann in der Logik beliebig komplex sein, aber sein Determinismus unterscheidet ihn von allen anderen Fehlertypen in der Klassifikation.

Ursprung des Namens Bohrbug

Der Name Bohrbug stammt von dem dänischen Physiker Niels Bohr, dem Schöpfer des Planetarmodells des Atoms. Die Analogie ist einfach: So wie sich ein Elektron im Bohr-Modell auf einer streng festgelegten Umlaufbahn bewegt, wiederholt dieser Bug bei jeder Ausführung dasselbe Verhalten.

Gray und Reuter wählten diesen Namen, um deterministische Fehler von chaotischen Fehlern abzugrenzen, die sie Mandelbug nannten — nach dem Mathematiker Benoit Mandelbrot, dem Begründer der Fraktaltheorie und Chaostheorie.

Interessanterweise wird der Begriff Bohrbug in der englischsprachigen Literatur oft als Synonym für „deterministischen Fehler“ verwendet, obwohl er im deutschsprachigen Raum weniger verbreitet ist. Die meisten Entwickler nennen solche Bugs einfach „reproduzierbare Fehler“.

Hauptmerkmale von Bohrbug

Bohrbug besitzt eine Reihe von unterscheidenden Eigenschaften, die helfen, ihn unter anderen Softwaredefekttypen zu identifizieren. Betrachten wir jedes Merkmal im Detail.

Determinismus

Das Hauptmerkmal von Bohrbug ist die vollständige Vorhersagbarkeit. Wenn die Anwendung auf dem Entwicklerrechner mit bestimmten Eingabedaten abstürzt, stürzt sie auf dem Testerrechner und in der Produktion genauso ab. Keine zufälligen Faktoren.

Reproduzierbarkeit

Bohrbug reproduziert sich in 100% der Versuche. Das bedeutet, dass zum Debuggen keine speziellen Werkzeuge erforderlich sind — eine Standard-IDE und ein Debugger reichen aus. Der Entwickler setzt einen Breakpoint, startet die Anwendung, gibt Eingabedaten ein und durchläuft den Code Schritt für Schritt.

Stabilität über die Zeit

Wenn ein Bohrbug nicht behoben wird, reproduziert er sich in jeder Version des Programms bis zur Behebung. Zeitliche Faktoren — CPU-Last, Mondphase, Tageszeit — beeinflussen seine Manifestation nicht.

Hauptursachen von Bohrbug

Die Ursachen von Bohrbug lassen sich in mehrere Kategorien einteilen. Das Verständnis dieser Kategorien hilft, die Problemursache schneller zu finden.

Logische Fehler

Eine falsch konstruierte Bedingung ist die häufigste Ursache von Bohrbug. Beispielsweise verwendete ein Entwickler den Operator `||` statt `&&`, was dazu führte, dass ein Codezweig bei jedem Aufruf der Funktion mit bestimmten Argumenten falsch ausgeführt wurde.

Fehler bei Randbedingungen

Die Verwendung des Operators `<=` anstelle von `<` oder die umgekehrte Situation ist eine klassische Quelle von Bohrbug. Wenn eine Schleife 10 Mal ausgeführt werden soll, aber aufgrund einer falschen Bedingung 11 Mal läuft, ist dies ein deterministischer Fehler, der bei jeder Ausführung auftritt.

Falsche Konstanten und magische Zahlen

Hartcodierte Konstanten, die nicht der Geschäftslogik entsprechen, erzeugen stabile Fehler. Zum Beispiel ein Serververbindungs-Timeout von 100 Millisekunden statt 5000 — die Verbindung wird bei jeder Anfrage abbrechen.

So erkennen Sie Bohrbug im Code

Das Erkennen eines Bohrbug ist im Vergleich zu anderen Bug-Typen die einfachste Aufgabe für einen Entwickler. Der deterministische Charakter ermöglicht die Anwendung von Standard-Debugging-Methoden.

public class DiscountCalculator {
    public double calculate(double amount, boolean isPremium) {
        // Fehler: Premium-Benutzer erhalten 5% Rabatt statt 10%
        if (isPremium) {
            return amount * 0.95;
        }
        return amount * 0.90;
    }
}

In diesem Beispiel ist der Bohrbug offensichtlich: Beim Aufruf von `calculate(1000, true)` gibt die Methode immer 950 statt 900 zurück. Ein einfacher Unit-Test mit festen Eingabedaten wird das Problem sofort aufdecken.

Unit-Testing als primäre Methode

Zur Erkennung von Bohrbug sind Unit-Tests das effektivste Werkzeug. Es reicht aus, die Funktion mit einer Reihe von Tests mit verschiedenen Grenzwerten abzudecken, und der deterministische Fehler zeigt sich beim ersten Durchlauf.

Schrittweises Debugging

Wenn ein Bohrbug erkannt wurde, ist das schrittweise Debugging in einer IDE der beste Weg, die Ursache zu finden. Der Entwickler setzt einen Breakpoint am Funktionsanfang und geht jede Zeile durch, wobei er die Werte der Variablen beobachtet.

Unterschied zwischen Bohrbug und anderen Bug-Typen

Bohrbug unterscheidet sich von anderen Arten von Softwarefehlern durch ein Hauptmerkmal — den Determinismus. Betrachten wir den Vergleich in einer Tabelle.

Bohrbug ist der einzige Fehlertyp, der unter kontrollierten Bedingungen zuverlässig reproduziert werden kann. Dies macht ihn aus diagnostischer Sicht am sichersten, aber nicht weniger gefährlich für den Benutzer.

Warum Bohrbug und Heisenbug verwechselt werden

Heisenbug ist ein Bug, der verschwindet, wenn man versucht, ihn zu debuggen. Anders als Bohrbug kann Heisenbug aufgrund von Änderungen der Codeausführungszeiten im Debugger nicht reproduziert werden. Anfänger verwechseln häufig diese beiden Typen.

Beispiel für Bohrbug im Code

Betrachten wir ein reales Beispiel eines Bohrbug in einer E-Commerce-Anwendung. Die Funktion berechnet die Gesamtkosten der Bestellung inklusive Steuer.

public double calculateTotal(double subtotal, double taxRate) {
    // Fehler: Entwickler hat taxRate als Prozentsatz festgelegt
    // aber vergessen, durch 100 zu teilen
    return subtotal + (subtotal * taxRate);
}

Beim Aufruf von `calculateTotal(1000, 20)` gibt die Funktion 21000 statt der erwarteten 1200 zurück. Dies ist ein klassischer Bohrbug: Dieselben Eingabedaten führen immer zum gleichen falschen Ergebnis. Die Korrektur ist trivial — Division durch 100 hinzufügen.

Korrigierte Version

Nach der Korrektur verarbeitet die Funktion den Steuersatz korrekt:

public double calculateTotal(double subtotal, double taxRatePercent) {
    return subtotal + (subtotal * taxRatePercent / 100.0);
}

Dieses Beispiel zeigt deutlich, dass ein Bohrbug durch einen einfachen mathematischen Fehler verursacht werden kann. Deshalb sind Code-Reviews und Unit-Tests die wichtigsten Instrumente zur Vorbeugung solcher Defekte.