Tweet

O que é um bug em programação?

E por que ele pode custar milhões (ou mesmo vidas)

Se você estuda ou trabalha em alguma área relacionada à tecnologia, é altamente provável – quase certeza – que já se deparou com a expressão “bug” ou com algum verbo “abrasileirado”, como “bugar” ou “bugado”. Mas o que significa exatamente isso?

Considere a seguinte situação: um comando simples, por exemplo programado para imprimir uma mensagem na tela dez vezes, acaba executando indefinidamente, sem qualquer critério de parada. O sistema permanece responsivo, mas o comportamento é claramente incorreto. Trata-se de um erro lógico comum — chamado de loop infinito — e é um exemplo clássico de bug em programação.

Entendendo o conceito de bug

Bugs são falhas no código-fonte que levam um programa a se comportar de forma inesperada ou incorreta. Podem resultar em pequenos transtornos, como uma interface mal formatada, ou em consequências graves, como perda de dados, travamentos do sistema e até riscos à segurança – ou ainda mais graves.

Qualquer pessoa que já tenha escrito código, por mais simples que seja, inevitavelmente se depara com esse tipo de problema.

Mas o que caracteriza, de fato, um bug? E por que eles continuam sendo tão prevalentes mesmo com os avanços nas ferramentas de desenvolvimento e boas práticas de engenharia de software? 

Ao contrário do que muitos pensam, computadores não “pensam” ou “entendem” intenções. Eles fazem exatamente o que mandamos — o problema é que nem sempre mandamos a coisa certa. Eles costumam surgir por erro humano: um código mal projetado, uma lógica mal pensada ou até mesmo por uma simples distração na digitação.

A origem do termo “bug”

A palavra bug (que literalmente significa “inseto” em inglês) foi popularizada pela almirante Grace Hopper em 1947. Durante a manutenção de um computador eletromecânico Mark II, uma mariposa foi encontrada presa em um relé, provocando falhas. O inseto foi cuidadosamente colado no diário de bordo com a legenda: “First actual case of bug being found” (em português, “Primeiro caso real de um bug sendo encontrado”).

A partir de então, o termo passou a ser usado para qualquer tipo de erro ou falha que ocorra em sistemas computacionais, não só de hardware, mas também (e hoje, principalmente) de software.

Os três principais tipos de bug

Os bugs nem sempre se manifestam da mesma forma. Alguns são fáceis de identificar, outros podem passar despercebidos por muito tempo. Os principais tipos incluem:

1. Erros de sintaxe

São falhas na escrita do código — algo como esquecer de fechar aspas, colocar um ponto e vírgula onde não devia (ou não colocar), ou ainda digitar comandos inválidos. A boa notícia? São geralmente detectados imediatamente na hora da compilação ou interpretação, ou mesmo apontados pelo IDE antes mesmo de tentar executar o programa para testá-lo.

2. Erros de execução (runtime)

Esses erros só aparecem quando o programa está rodando. Um exemplo clássico é a tentativa de divisão de um número por zero. O código-fonte parece correto, a aplicação roda normalmente, realiza cálculos com precisão, até que… bum!,  a execução para bruscamente quando uma tentativa de divisão por zero ocorre, podendo ocasionar desde a parada da execução da aplicação até o travamento completo do sistema.

3. Erros semânticos (ou de lógica)

São os mais traiçoeiros e difíceis de detectar. O programa roda, executa tudo sem travar, apresenta a saída para o usuário, mas os resultados estão errados — e às vezes ninguém percebe. Um caso comum ocorre com determinados cálculos matemáticos – o sistema efetua os cálculos solicitados, mas por conta de um bug lógico o resultado apresentado é incorreto, e o usuário pode não perceber o problema.

Esse tipo de erro pode causar grandes transtornos, desde perdas financeiras até acidentes fatais.

Quando um bug deixa de ser só um incômodo

Se você acha que um bug é só um erro inofensivo que causa irritação, pense de novo. Bugs já causaram prejuízos bilionários e, em casos extremos, até mortes.

Citemos alguns exemplos notáveis:

• Nuclear Gandhi: No jogo Sid Meier’s Civilization (1991), um erro no sistema de agressividade das civilizações fazia com que o personagem do pacifista Mahatma Gandhi, inicialmente programado com o menor nível possível de agressividade, se tornasse extremamente beligerante após adoção de políticas democráticas. Devido a um underflow (valor abaixo do mínimo) no valor da variável, seu nível de agressividade era reduzido para um valor negativo, que acabava sendo interpretado como o valor máximo permitido.
  O resultado: um Gandhi obcecado por armas nucleares — um bug icônico da história dos games. Divertido? Sim. Mas ainda um bug.
• Therac-25: Entre 1985 e 1987, um equipamento de radioterapia de nome Therac-25, usado no tratamento de câncer, apresentou falhas críticas causadas por erros de programação em seu sistema de controle. Devido à ausência de verificações adequadas e à confiança excessiva em software, o dispositivo permitia que doses de radiação muito acima do limite seguro fossem aplicadas nos pacientes em tratamento.
  Seis pacientes morreram por exposição acidental a níveis fatais de radiação. 
• Mars Climate Orbiter: Em setembro de 1999, a NASA perdeu contato com a sonda Mars Climate Orbiter pouco antes de sua inserção na órbita do planeta Marte. A falha ocorreu porque um módulo do software produzia dados de impulso na unidade libras-força (sistema imperial), enquanto outro módulo esperava receber esses dados em newtons (sistema métrico).
  A ausência de conversão entre unidades resultou em um erro de trajetória fatal, fazendo com que a sonda descesse demais na atmosfera marciana e fosse destruída. O prejuízo estimado ultrapassou US$ 327 milhões.
• Guitar Hero II: Em 2007, uma atualização lançada para o jogo Guitar Hero II em sua versão para o console Xbox 360 causou problemas sérios de estabilidade em diversos aparelhos. Alguns dispositivos passaram a apresentar falhas críticas após a atualização, incluindo travamentos frequentes e, em muitos casos, o temido “Red Ring of Death” (Anel Vermelho da Morte) — um erro fatal de hardware que inutilizava o console. Embora o bug fosse de software, seu impacto foi sentido no hardware, resultando em muitas unidades defeituosas.

Como lidar com bugs: a arte da depuração

O processo de encontrar e corrigir bugs é conhecido como debugging (em português, depuração). Ferramentas chamadas depuradores (ou debuggers) ajudam a examinar o código linha por linha, inspecionar variáveis e identificar o ponto exato em que tudo começa a dar errado.

Ambientes de desenvolvimento (IDEs) modernos geralmente vêm com depuradores embutidos, tornando essa tarefa um pouco menos ingrata e mais fácil de realizar.

Prevenção de bugs: manipulação de exceções

Outro recurso fundamental é o tratamento de exceções. Trata-se de prever que algo pode dar errado (como dividir um número por zero em um cálculo) e preparar o programa para lidar com isso de forma antecipada, sem falhar completamente. Linguagens de alto nível como Java, Python e C# têm mecanismos específicos para isso, como os blocos try…catch.

Exemplo em Java:

import java.util.Scanner;
public class Divisao {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    int c = a / b; // BUG EM POTENCIAL: pode lançar ArithmeticException se b = 0
    System.out.println("Resultado = " + c);
    entrada.close();
  }
}

Neste exemplo, se o usuário digitar o valor zero ao entrar com o valor de b, será feita uma divisão por zero ao executar o cálculo da variável c. Qualquer outra divisão funcionará, exceto essa.

Ou seja, se b for igual a zero, o programa lançará uma exceção do tipo ArithmeticException e será encerrado abruptamente. Esse é um exemplo clássico de erro de tempo de execução (runtime error), causado por não tratar uma condição excepcional comum.

Como tratar isso? Uma solução é realizar a manipulação dessa exceção, como segue:

import java.util.Scanner;
public class DivisaoSegura {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    try {
      int c = a / b;
      System.out.println("Resultado = " + c);
    }
    catch (ArithmeticException e) {
      System.out.println("Não é possível dividir por zero.");
      System.out.println(e);
    }
    entrada.close();
  }
}

Neste caso a exceção (erro) ArithmeticException foi tratada por meio do uso de um bloco try .. catch, que impedirá o travamento do sistema caso seja fornecido o valor zero à variável b, exibindo em vez disso a mensagem mais amigável “Não é possível dividir por zero” ao usuário..

Testes: prevenindo problemas

A melhor forma de combater bugs é evitá-los desde o início. Testes de software — tanto manuais quanto automatizados — são parte essencial do desenvolvimento. Eles verificam se o programa atende aos requisitos e ajudam a identificar falhas antes que elas possam causar estragos maiores.

Entre os tipos de testes mais comuns estão:

• Testes unitários: verificam o funcionamento de partes específicas do código.
• Testes de integração: checam se os módulos interagem corretamente.
• Testes de sistema: avaliam o sistema como um todo.
• Testes de aceitação: garantem que o software atende ao que o cliente espera.

Bugs no mundo real: onde menos se espera

É importante lembrar que nem só de software vive o mundo dos bugs. Hardware também pode apresentar falhas semelhantes, como erros de projeto em placas, aquecimento excessivo ou falhas elétricas. Mas no fim das contas, tudo parte da mesma raiz: uma falha humana durante a concepção ou implementação de um projeto.

Conclusão: errar é humano, depurar é essencial

Bugs fazem parte da vida de qualquer programador. Não há como evitá-los completamente, mas é possível preveni-los, detectá-los rapidamente e corrigi-los antes que causem problemas sérios.

Com boas práticas de codificação, testes constantes e ferramentas adequadas, dá para dormir mais tranquilo. Ou ao menos, sem sonhar com mariposas voando entre os relés.