Bugs e depuração

Uma coisa que você vai notar enquanto aprende sobre programação é que você costuma cometer um certo número de erros e suposições que fazem com que o seu programa: 1) não possa ser compilado; ou 2) produza resultados inesperados na execução. Esses problemas são conhecidos como bugs (erros), e a ação de removê-los chama-se depuração. Os programadores costumam passar metade do seu tempo fazendo isso.

Eu sei que você é capaz e vai ter tempo e oportunidade de sobra para criar os seus próprios bugs, mas vou criar alguns para deixá-lo mais familiarizado com as possibilidades. No seu programa, apague um dos "ponto e vírgula" do final de uma linha e tente compilar o programa com o javac. O compilador vai lhe mostrar uma mensagem de erro. Isso se chama erro de compilador e temos de eliminar todos eles antes de poder executar o programa. Outra possibilidade é cometer um erro de digitação no nome de uma função. Experimente esquecer de digitar um "{" ou eliminar uma das linhas import para ficar acostumado com os diferentes erros de compilador. A primeira vez que você vir um certo tipo de erro de compilador, pode ficar bem frustrado. No entanto, se fizer experiências assim (com erros conhecidos criados de propósito), vai se sentir mais familiarizado com vários dos erros comuns.

Um bug, também conhecido como erro de execução ou erro em tempo de execução, acontece quando o programa é compilado, normalmente e consegue ser executado, mas não produz o resultado planejado durante a programação. Por exemplo, este código produz um triângulo vermelho com duas linhas diagonais que o cruzam: 

          g.setColor(Color.red);
            g.fillRect(0, 0, 200, 200);
            g.setColor(Color.black);
            g.drawLine(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);

O código a seguir, por outro lado, produz apenas o retângulo vermelho (ele cobre as 2 linhas): 
          g.setColor(Color.black);
            g.drawLine(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);
            g.setColor(Color.red);
            g.fillRect(0, 0, 200, 200);

Embora o código seja quase idêntico, o resultado é completamente diferente na execução. E se o resultado esperado for visualizar 2 linhas diagonais, o código do segundo exemplo contém um bug.

Lá vai outro exemplo: 

          g.drawLine(0, 0, 200, 200);
            g.drawRect(0, 0, 200, 200);
            g.drawLine(200, 0, 0, 200);
Este código produz uma caixa com uma moldura em preto e 2 diagonais. Já este próximo pedacinho de código produz apenas uma diagonal: 
          g.drawLine(0, 0, 200, 200);
            g.drawRect(0, 0, 200, 200);
            g.drawLine(0, 200, 0, 200);
Novamente, se o que você queria era ver 2 diagonais, o segundo código contém um bug (examine-o até descobrir o que há de errado). Este é o tipo de bug que, por ser muito sutil, pode levar tempo para ser encontrado.

E não se preocupe, pois você vai ter bastante tempo para praticar a "arte" de encontrar seus próprios bugs. O programador comum gasta cerca de metade de seu tempo procurando, encontrando e eliminando esses erros. Então, tente não ficar frustrado quando ocorrerem, eles fazem parte da vida de um programador.