Bohrbug : ce que c’est, causes et méthodes de correction

Qu’est-ce qu’un Bohrbug ?

Bohrbug est un type d’erreur logicielle qui se manifeste de manière déterministe : avec les mêmes données d’entrée, il produit toujours la même panne. Le terme a été introduit par les chercheurs Jim Gray et Andreas Reuter dans le livre « Transaction Processing : Concepts and Techniques » (1993).

Contrairement au Mandelbug, qui change son comportement de manière chaotique, Bohrbug est stable : un développeur peut le reproduire les yeux fermés en fournissant au système les mêmes paramètres. Cela en fait un candidat idéal pour le débogage pas à pas dans un IDE.

Bohrbug survient à toutes les étapes du cycle de vie du logiciel — du développement à l’exploitation. Il est souvent découvert lors des tests, car les ingénieurs QA exécutent des scénarios répétitifs qui garantissent déclencher la panne.

Définition selon Gray et Reuter

Selon la classification de Gray et Reuter, un Bohrbug est un défaut qui remplit trois conditions : un ensemble fixe de données d’entrée, le même état du système et le même résultat de panne. Si au moins une condition n’est pas respectée, le bogue cesse d’être « Bohr ».

Les auteurs soulignent qu’un Bohrbug n’est pas nécessairement une erreur simple. Il peut être arbitrairement complexe dans sa logique, mais son déterminisme le distingue de tous les autres types de pannes dans la classification.

Origine du nom Bohrbug

Le nom Bohrbug vient du physicien danois Niels Bohr, créateur du modèle planétaire de l’atome. L’analogie est simple : comme un électron dans le modèle de Bohr se déplace sur une orbite strictement fixe, ce bogue répète le même comportement à chaque exécution.

Gray et Reuter ont choisi ce nom pour opposer les erreurs déterministes aux erreurs chaotiques, qu’ils ont appelées Mandelbug — en hommage au mathématicien Benoit Mandelbrot, fondateur de la théorie du chaos et des fractales.

Fait intéressant, dans la littérature anglophone, le terme Bohrbug est souvent utilisé comme synonyme d’« erreur déterministe », bien qu’il soit moins courant dans les environnements francophones. La plupart des développeurs appellent simplement ces bogues des « erreurs reproductibles ».

Caractéristiques principales de Bohrbug

Bohrbug possède un ensemble de propriétés distinctives qui aident à l’identifier parmi les autres types de défauts logiciels. Examinons chaque caractéristique en détail.

Déterminisme

La principale caractéristique de Bohrbug est la prévisibilité totale. Si l’application a planté avec certaines données d’entrée sur la machine du développeur, elle plantera exactement de la même manière sur la machine du testeur et en production. Aucun facteur aléatoire.

Reproductibilité

Bohrbug se reproduit dans 100 % des tentatives. Cela signifie que le débogage ne nécessite pas d’outils spéciaux — un IDE et un débogueur standard suffisent. Le développeur place un point d’arrêt, lance l’application, fournit les données d’entrée et parcourt le code pas à pas.

Stabilité dans le temps

Si un Bohrbug n’est pas corrigé, il se reproduira dans toute version du programme jusqu’à sa correction. Les facteurs temporels — charge CPU, phase de la lune, heure de la journée — n’affectent pas sa manifestation.

Causes principales d’apparition de Bohrbug

Les causes d’apparition de Bohrbug peuvent être divisées en plusieurs catégories. Comprendre ces catégories aide à trouver la racine du problème plus rapidement.

Erreurs logiques

Une condition mal construite est la cause la plus fréquente de Bohrbug. Par exemple, un développeur a utilisé l’opérateur `||` au lieu de `&&`, ce qui a entraîné l’exécution incorrecte d’une branche de code chaque fois que la fonction est appelée avec certains arguments.

Erreurs de conditions limites

Utiliser l’opérateur `<=` au lieu de `<` ou la situation inverse est une source classique de Bohrbug. Si une boucle doit s’exécuter 10 fois mais s’exécute 11 fois en raison d’une condition incorrecte, il s’agit d’une erreur déterministe qui se manifestera à chaque exécution.

Constantes incorrectes et nombres magiques

Des constantes codées en dur qui ne correspondent pas à la logique métier créent des pannes stables. Par exemple, un délai d’expiration de connexion au serveur défini à 100 millisecondes au lieu de 5000 — la connexion sera interrompue à chaque requête.

Comment détecter Bohrbug dans le code

Détecter un Bohrbug est la tâche la plus facile pour un développeur par rapport aux autres types de bogues. La nature déterministe permet d’appliquer des méthodes de débogage standard.

public class DiscountCalculator {
    public double calculate(double amount, boolean isPremium) {
        // Bogue : les utilisateurs premium bénéficient d’une réduction de 5 % au lieu de 10 %
        if (isPremium) {
            return amount * 0.95;
        }
        return amount * 0.90;
    }
}

Dans cet exemple, le Bohrbug est évident : en appelant `calculate(1000, true)`, la méthode retourne toujours 950 au lieu de 900. Un test unitaire simple avec des données d’entrée fixes révélera instantanément le problème.

Les tests unitaires comme méthode principale

Pour détecter Bohrbug, les tests unitaires sont l’outil le plus efficace. Il suffit de couvrir la fonction avec un ensemble de tests avec diverses valeurs limites, et l’erreur déterministe apparaîtra dès la première exécution.

Débogage pas à pas

Une fois qu’un Bohrbug est détecté, le débogage pas à pas dans un IDE est la meilleure façon de trouver la cause racine. Le développeur place un point d’arrêt à l’entrée de la fonction et parcourt chaque ligne, en observant les valeurs des variables.

Différence entre Bohrbug et autres types de bogues

Bohrbug se distingue des autres types d’erreurs logicielles par une caractéristique principale — le déterminisme. Comparons dans un tableau.

Bohrbug est le seul type d’erreur qui peut être reproduit de manière fiable dans des conditions contrôlées. Cela le rend le plus sûr du point de vue du diagnostic, mais pas moins dangereux pour l’utilisateur.

Pourquoi on confond Bohrbug et Heisenbug

Heisenbug est un bogue qui disparaît lorsqu’on essaie de le déboguer. Contrairement à Bohrbug, Heisenbug peut ne pas se reproduire dans un débogueur en raison de changements dans les temporisations d’exécution du code. Les développeurs débutants confondent souvent ces deux types.

Exemple de Bohrbug dans le code

Regardons un exemple réel de Bohrbug dans une application de boutique en ligne. La fonction calcule le coût total de la commande avec la taxe.

public double calculateTotal(double subtotal, double taxRate) {
    // Bogue : le développeur a défini taxRate en pourcentage
    // mais a oublié de diviser par 100
    return subtotal + (subtotal * taxRate);
}

En appelant `calculateTotal(1000, 20)`, la fonction retourne 21000 au lieu des 1200 attendus. C’est un Bohrbug classique : les mêmes données d’entrée conduisent toujours au même résultat incorrect. La correction est triviale — ajouter la division par 100.

Version corrigée

Après la correction, la fonction traite correctement le taux de taxe :

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

Cet exemple montre clairement qu’un Bohrbug peut être causé par une simple erreur mathématique. C’est pourquoi la revue de code et les tests unitaires sont les principaux outils de prévention de ces défauts.