Bohrbug: cos’è, cause e metodi di correzione

Cos’è un Bohrbug?

Bohrbug è un tipo di errore software che si manifesta in modo deterministico: con gli stessi dati di input, produce sempre lo stesso guasto. Il termine è stato introdotto dai ricercatori Jim Gray e Andreas Reuter nel libro “Transaction Processing: Concepts and Techniques” (1993).

A differenza del Mandelbug, che cambia caoticamente il suo comportamento, Bohrbug è stabile: uno sviluppatore può riprodurlo a occhi chiusi fornendo al sistema gli stessi parametri. Ciò lo rende un candidato ideale per il debug passo passo in un IDE.

Bohrbug si verifica in tutte le fasi del ciclo di vita del software — dallo sviluppo all’operatività. Viene spesso scoperto durante i test, poiché gli ingegneri QA eseguono scenari ripetitivi che garantiscono di innescare il guasto.

Definizione secondo Gray e Reuter

Secondo la classificazione di Gray e Reuter, un Bohrbug è un difetto che soddisfa tre condizioni: un insieme fisso di dati di input, lo stesso stato del sistema e lo stesso risultato di guasto. Se almeno una condizione viene violata, il bug cessa di essere “Bohr.”

Gli autori sottolineano che un Bohrbug non è necessariamente un errore semplice. Può essere arbitrariamente complesso nella logica, ma il suo determinismo lo distingue da tutti gli altri tipi di guasti nella classificazione.

Origine del nome Bohrbug

Il nome Bohrbug deriva dal fisico danese Niels Bohr, creatore del modello planetario dell’atomo. L’analogia è semplice: come un elettrone nel modello di Bohr si muove su un’orbita strettamente fissa, questo bug ripete lo stesso comportamento a ogni esecuzione.

Gray e Reuter hanno scelto questo nome per contrapporre gli errori deterministici a quelli caotici, che hanno chiamato Mandelbug — in onore del matematico Benoit Mandelbrot, fondatore della teoria del caos e dei frattali.

Curiosamente, nella letteratura in inglese, il termine Bohrbug viene spesso usato come sinonimo di “errore deterministico,” sebbene sia meno comune negli ambienti italiani. La maggior parte degli sviluppatori chiama questi bug semplicemente “errori riproducibili.”

Caratteristiche principali di Bohrbug

Bohrbug possiede un insieme di proprietà distintive che aiutano a identificarlo tra gli altri tipi di difetti software. Esaminiamo ogni caratteristica in dettaglio.

Determinismo

La caratteristica principale di Bohrbug è la totale prevedibilità. Se l’applicazione è crashata con determinati dati di input sulla macchina di uno sviluppatore, crashirà esattamente allo stesso modo sulla macchina di un tester e in produzione. Nessun fattore casuale.

Riproducibilità

Bohrbug si riproduce nel 100% dei tentativi. Ciò significa che il debug non richiede strumenti speciali — un IDE e un debugger standard sono sufficienti. Lo sviluppatore imposta un breakpoint, avvia l’applicazione, fornisce i dati di input e percorre il codice passo dopo passo.

Stabilità nel tempo

Se un Bohrbug non viene corretto, si riprodurrà in qualsiasi versione del programma fino alla correzione. I fattori temporali — carico della CPU, fase lunare, ora del giorno — non influenzano la sua manifestazione.

Cause principali di Bohrbug

Le cause di Bohrbug possono essere suddivise in diverse categorie. Comprendere queste categorie aiuta a trovare la radice del problema più rapidamente.

Errori logici

Una condizione mal costruita è la causa più comune di Bohrbug. Ad esempio, uno sviluppatore ha usato l’operatore `||` invece di `&&`, causando l’esecuzione errata di un ramo di codice ogni volta che la funzione viene chiamata con determinati argomenti.

Errori di condizioni limite

Usare l’operatore `<=` invece di `<` o la situazione inversa è una fonte classica di Bohrbug. Se un ciclo deve eseguire 10 volte ma ne esegue 11 a causa di una condizione errata, si tratta di un errore deterministico che si manifesterà a ogni esecuzione.

Costanti errate e numeri magici

Costanti hard-coded che non corrispondono alla logica di business creano guasti stabili. Ad esempio, un timeout di connessione al server impostato a 100 millisecondi invece di 5000 — la connessione si interromperà a ogni richiesta.

Come individuare Bohrbug nel codice

Individuare un Bohrbug è il compito più facile per uno sviluppatore rispetto ad altri tipi di bug. La natura deterministica consente di applicare metodi di debug standard.

public class DiscountCalculator {
    public double calculate(double amount, boolean isPremium) {
        // Errore: gli utenti premium ricevono uno sconto del 5% invece del 10%
        if (isPremium) {
            return amount * 0.95;
        }
        return amount * 0.90;
    }
}

In questo esempio, il Bohrbug è evidente: chiamando `calculate(1000, true)`, il metodo restituisce sempre 950 invece di 900. Un semplice test unitario con dati di input fissi rivelerà immediatamente il problema.

Test unitari come metodo principale

Per individuare Bohrbug, i test unitari sono lo strumento più efficace. Basta coprire la funzione con una serie di test con vari valori limite, e l’errore deterministico apparirà al primo tentativo.

Debug passo passo

Una volta individuato un Bohrbug, il debug passo passo in un IDE è il modo migliore per trovare la causa principale. Lo sviluppatore imposta un breakpoint all’ingresso della funzione e percorre ogni riga, osservando i valori delle variabili.

Differenza tra Bohrbug e altri tipi di bug

Bohrbug si differenzia da altri tipi di errori software per una caratteristica principale — il determinismo. Confrontiamoli in una tabella.

Bohrbug è l’unico tipo di errore che può essere riprodotto in modo affidabile in condizioni controllate. Ciò lo rende il più sicuro dal punto di vista diagnostico, ma non meno pericoloso per l’utente.

Perché Bohrbug e Heisenbug vengono confusi

Heisenbug è un bug che scompare quando si cerca di eseguirne il debug. A differenza di Bohrbug, Heisenbug potrebbe non riprodursi in un debugger a causa di cambiamenti nei tempi di esecuzione del codice. Gli sviluppatori principianti spesso confondono questi due tipi.

Esempio di Bohrbug nel codice

Vediamo un esempio reale di Bohrbug in un’applicazione di e-commerce. La funzione calcola il costo totale dell’ordine incluse le tasse.

public double calculateTotal(double subtotal, double taxRate) {
    // Errore: lo sviluppatore ha impostato taxRate come percentuale
    // ma ha dimenticato di dividere per 100
    return subtotal + (subtotal * taxRate);
}

Chiamando `calculateTotal(1000, 20)`, la funzione restituisce 21000 invece dei previsti 1200. Questo è un classico Bohrbug: gli stessi dati di input portano sempre allo stesso risultato errato. La correzione è banale — aggiungere la divisione per 100.

Versione corretta

Dopo la correzione, la funzione elabora correttamente l’aliquota fiscale:

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

Questo esempio mostra chiaramente che un Bohrbug può essere causato da un semplice errore matematico. Ecco perché la revisione del codice e i test unitari sono i principali strumenti di prevenzione di tali difetti.