Depuração de programa

9.1 Surgimento de Bugs

Depuração de software é o processo de encontrar e corrigir erros ou bugs em um programa. Essa é a parte mais interessante do desenvolvimento de software, que ajuda a garantir que os programas funcionem corretamente.

História do termo "bug"

O termo "bug" (erro) no contexto de programas de computador começou a ser usado nos anos 1940. Embora a própria ideia de "bug" já existisse antes do surgimento dos computadores, referindo-se a falhas mecânicas em diversos dispositivos.

O primeiro caso documentado do uso do termo "bug" em tecnologia computacional foi com uma equipe trabalhando no computador Mark II na Universidade de Harvard em 1947(!). A equipe descobriu que um dos relés da máquina não funcionava porque uma mariposa entrou nele. Eles removeram o inseto e registraram isso no diário como o "primeiro caso real de descoberta de um inseto" (literal bug).

Embora não tenha sido a primeira vez que o termo "bug" foi usado para descrever um erro, esse incidente tornou-se bem conhecido e ajudou a popularizar o termo "bug".

Depuração de programa

Depuração é o processo de busca, diagnóstico e correção de bugs no software. O processo de depuração envolve várias etapas:

1. Detecção de erro: identificar sintomas que indicam a presença de um erro no programa.
2. Reprodução do erro: criar condições sob as quais o erro reaparece, para entender melhor sua natureza.
3. Diagnóstico do problema: usar diversas ferramentas e métodos para analisar o código e encontrar a causa do erro.
4. Correção do erro: fazer alterações no código para corrigir o erro.
5. Teste: verificar a correção e testar o programa para garantir que o erro foi eliminado e não surgiram novos problemas.

Então, bug é o nome geral para quaisquer erros em programas, e debug é o processo de detecção e eliminação desses erros.

9.2 Ferramentas e métodos de depuração

Log

Adicionar logs no código do programa permite monitorar sua execução e obter informações sobre o estado de variáveis e operações em diversos pontos da execução do programa. Para logging em JavaScript, tem uma biblioteca excelente chamada winston.

Exemplo de uso de logging:

    
      const { createLogger, format, transports } = require('winston');

      // Criar um logger com nível de depuração
      const logger = createLogger({  level: 'debug' });

      // Função de divisão
      function divide(a, b) {
        logger.debug(`Dividindo ${a} por ${b}`);
        if (b === 0) {
          logger.error("Tentativa de divisão por zero!");
          return null;
        }
        return a / b;
      }

      // Exemplo de uso da função
      const result = divide(10, 2);
      console.log(result); // Vai imprimir: 5
    
  

Uso de depuradores (Debuggers)

Depuradores são ferramentas que permitem aos desenvolvedores executar o programa passo a passo, definir breakpoints, verificar valores de variáveis e alterá-los durante a execução do programa.

Depuradores populares para JavaScript:

• Chrome DevTools: depurador embutido no navegador Google Chrome
• Firefox Developer Tools: depurador embutido no navegador Mozilla Firefox
• Node.js Debugger: depurador embutido para JavaScript no servidor em Node.js
• Visual Studio Code Debugger: depurador embutido no editor Visual Studio Code

Exemplo de uso de um depurador em Node.js:

    
      // Importar módulo de depuração embutido
      const { inspect } = require('util');

      // Exemplo de função com erro
      function faultyFunction(a, b) {
        debugger; // Definir breakpoint
        let result = a / b;
        return result;
      }

      // Chamar função com erro
      console.log(faultyFunction(10, 0));
    
  

Quando o programa atinge debugger, ele para, e você pode usar comandos do depurador, como step over, step into, step out, verificar valores de variáveis, entre outros.

Vamos estudar depuração de programas com o depurador embutido no Intellij IDEA (necessário versão Ultimate Edition).

9.3 Uso do debug

Em geral, o debug envolve o uso ativo de ferramentas de depuração e práticas para identificar e corrigir erros.

Etapas de depuração:

1. Definir breakpoints: configure breakpoints no código para interromper a execução do programa nos locais de interesse.
2. Execução passo a passo: execute o programa passo a passo, observando as alterações no estado do programa e nos valores das variáveis.
3. Análise de variáveis: estude os valores das variáveis e expressões em várias etapas da execução do programa para identificar dados incorretos ou erros lógicos.
4. Correção de erros: faça alterações no código para corrigir os erros encontrados.
5. Reteste: após corrigir os erros, teste o programa novamente para garantir que o erro foi corrigido e não surgiram novos problemas.

Parece simples, né? Na próxima palestra vamos nos aprofundar em cada etapa :)