Digamos que temos uma função como esta:
public void myStart()
{
for (int i = 0; i<10; i++) myFunction(i);
}
private int myFunction(int a)
{
a = foo(a);
a = bar(a);
return a;
}
private int foo(int a)
{
//do something here
//something gnarly here
//etc
return aValue;
}
private int bar(int a)
{
// do something here
//return aValue;
}
Agora, por qualquer motivo, nosso código não está funcionando. Talvez esteja gerando um erro, talvez esteja retornando o valor errado, talvez tenha ficado preso em um loop infinito.
A primeira coisa que qualquer programador de primeiro ano, é imprimir no console / padrão, (aprendendo a imprimir o Hello World antes de aprender a usar um depurador).
Por exemplo, para depurar esse código, eles podem fazer o seguinte:
private int myFunction(int a)
{
print("before foo: a=" + a);
a = foo(a);
print("before bar: a=" + a);
a = bar(a);
return a;
}
private int foo(int a)
{
//do something here
print ("foo step1: a=" + a);
//something gnarly here
print ("foo step2: a=" + a + " someOtherValue="+ someOtherValue + " array.length= " + someArray.length());
//etc
return aValue;
}
private int bar(int a)
{
// do something here
//return aValue;
}
Agora eles executam o código, obtêm uma grande impressão do console, pela qual podem rastrear onde as coisas estão dando errado.
Uma alternativa, é claro, é definir pontos de interrupção e percorrer o código em cada ponto.
Uma grande vantagem da impressão no console é que o desenvolvedor pode ver o fluxo dos valores de uma só vez, sem precisar clicar nas etapas etc.
Mas a desvantagem é que seu código é repleto de todas essas instruções de impressão que precisam ser removidas.
(É possível, talvez, pedir ao depurador para imprimir apenas determinados valores em um log ?, os pontos de interrupção podem ser facilmente adicionados ou removidos sem modificar o código.)
Eu ainda uso a impressão de console como método primário de depuração, estou me perguntando o quão comum / eficaz isso é em comparação com outra coisa por aí.