Bohrbug: o que é, causas e métodos de correção

O que é um Bohrbug?

Bohrbug é um tipo de erro de software que se manifesta deterministicamente: com os mesmos dados de entrada, ele sempre produz a mesma falha. O termo foi introduzido pelos pesquisadores Jim Gray e Andreas Reuter no livro “Transaction Processing: Concepts and Techniques” (1993).

Ao contrário do Mandelbug, que muda caoticamente seu comportamento, o Bohrbug é estável: um desenvolvedor pode reproduzi-lo de olhos fechados fornecendo ao sistema os mesmos parâmetros. Isso o torna um candidato ideal para depuração passo a passo em uma IDE.

O Bohrbug ocorre em todas as fases do ciclo de vida do software — do desenvolvimento à operação. Frequentemente é descoberto durante os testes, pois os engenheiros de QA executam cenários repetitivos que garantem a ocorrência da falha.

Definição segundo Gray e Reuter

De acordo com a classificação de Gray e Reuter, um Bohrbug é um defeito que satisfaz três condições: um conjunto fixo de dados de entrada, o mesmo estado do sistema e o mesmo resultado de falha. Se pelo menos uma condição for violada, o bug deixa de ser “Bohr.”

Os autores enfatizam que um Bohrbug não é necessariamente um erro simples. Ele pode ser arbitrariamente complexo em lógica, mas seu determinismo o distingue de todos os outros tipos de falhas na classificação.

Origem do nome Bohrbug

O nome Bohrbug vem do físico dinamarquês Niels Bohr, criador do modelo planetário do átomo. A analogia é simples: assim como um elétron no modelo de Bohr se move em uma órbita estritamente fixa, este bug repete o mesmo comportamento a cada execução.

Gray e Reuter escolheram este nome para contrastar erros determinísticos com os caóticos, que chamaram de Mandelbug — em homenagem ao matemático Benoit Mandelbrot, fundador da teoria do caos e dos fractais.

Curiosamente, na literatura em inglês, o termo Bohrbug é frequentemente usado como sinônimo de “erro determinístico,” embora seja menos comum em ambientes de língua portuguesa. A maioria dos desenvolvedores simplesmente chama esses bugs de “erros reproduzíveis.”

Características principais do Bohrbug

O Bohrbug possui um conjunto de propriedades distintivas que ajudam a identificá-lo entre outros tipos de defeitos de software. Vamos analisar cada característica em detalhes.

Determinismo

A principal característica do Bohrbug é a previsibilidade total. Se o aplicativo falhou com determinados dados de entrada na máquina de um desenvolvedor, ele falhará exatamente da mesma forma na máquina de um testador e em produção. Sem fatores aleatórios.

Reprodutibilidade

O Bohrbug se reproduz em 100% das tentativas. Isso significa que a depuração não requer ferramentas especiais — uma IDE e um depurador padrão são suficientes. O desenvolvedor coloca um ponto de interrupção, inicia o aplicativo, fornece os dados de entrada e percorre o código passo a passo.

Estabilidade ao longo do tempo

Se um Bohrbug não for corrigido, ele se reproduzirá em qualquer versão do programa até ser resolvido. Fatores temporais — carga da CPU, fase da lua, hora do dia — não afetam sua manifestação.

Principais causas do Bohrbug

As causas do Bohrbug podem ser divididas em várias categorias. Compreender essas categorias ajuda a encontrar a raiz do problema mais rapidamente.

Erros lógicos

Uma condição mal construída é a causa mais comum do Bohrbug. Por exemplo, um desenvolvedor usou o operador `||` em vez de `&&`, fazendo com que um ramo do código fosse executado incorretamente toda vez que a função é chamada com certos argumentos.

Erros de condições de limite

Usar o operador `<=` em vez de `<` ou a situação inversa é uma fonte clássica de Bohrbug. Se um loop deve executar 10 vezes mas executa 11 devido a uma condição incorreta, isso é um erro determinístico que se manifestará em cada execução.

Constantes incorretas e números mágicos

Constantes codificadas que não correspondem à lógica de negócios criam falhas estáveis. Por exemplo, um tempo limite de conexão ao servidor definido em 100 milissegundos em vez de 5000 — a conexão será interrompida a cada requisição.

Como detectar Bohrbug no código

Detectar um Bohrbug é a tarefa mais fácil para um desenvolvedor em comparação com outros tipos de bugs. Sua natureza determinística permite aplicar métodos de depuração padrão.

public class DiscountCalculator {
    public double calculate(double amount, boolean isPremium) {
        // Erro: usuários premium obtêm 5% de desconto em vez de 10%
        if (isPremium) {
            return amount * 0.95;
        }
        return amount * 0.90;
    }
}

Neste exemplo, o Bohrbug é óbvio: ao chamar `calculate(1000, true)`, o método sempre retorna 950 em vez de 900. Um teste unitário simples com dados de entrada fixos revelará o problema instantaneamente.

Testes unitários como método principal

Para detectar Bohrbug, os testes unitários são a ferramenta mais eficaz. Basta cobrir a função com um conjunto de testes com vários valores limite, e o erro determinístico aparecerá na primeira execução.

Depuração passo a passo

Uma vez detectado um Bohrbug, a depuração passo a passo em uma IDE é a melhor maneira de encontrar a causa raiz. O desenvolvedor coloca um ponto de interrupção na entrada da função e percorre cada linha, observando os valores das variáveis.

Diferença entre Bohrbug e outros tipos de bugs

Bohrbug difere de outros tipos de erros de software por uma característica principal — o determinismo. Vamos comparar em uma tabela.

Bohrbug é o único tipo de erro que pode ser reproduzido de forma confiável em condições controladas. Isso o torna o mais seguro do ponto de vista de diagnóstico, mas não menos perigoso para o usuário.

Por que Bohrbug e Heisenbug são confundidos

Heisenbug é um bug que desaparece ao tentar depurá-lo. Ao contrário do Bohrbug, o Heisenbug pode não se reproduzir em um depurador devido a mudanças nos tempos de execução do código. Desenvolvedores iniciantes frequentemente confundem esses dois tipos.

Exemplo de Bohrbug no código

Vamos ver um exemplo real de Bohrbug em um aplicativo de loja online. A função calcula o custo total do pedido com imposto.

public double calculateTotal(double subtotal, double taxRate) {
    // Erro: o desenvolvedor definiu taxRate como porcentagem
    // mas esqueceu de dividir por 100
    return subtotal + (subtotal * taxRate);
}

Ao chamar `calculateTotal(1000, 20)`, a função retorna 21000 em vez dos 1200 esperados. Este é um Bohrbug clássico: os mesmos dados de entrada sempre levam ao mesmo resultado incorreto. A correção é trivial — adicionar a divisão por 100.

Versão corrigida

Após a correção, a função processa corretamente a taxa de imposto:

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

Este exemplo mostra claramente que um Bohrbug pode ser causado por um simples erro matemático. É por isso que a revisão de código e os testes unitários são as principais ferramentas de prevenção desses defeitos.