Por que a depuração é melhor em um IDE? [fechadas]

Sou desenvolvedor de software há mais de vinte anos, programando em C, Perl, SQL, Java, PHP, JavaScript e recentemente Python. Eu nunca tive um problema que não poderia depurar usando uma reflexão cuidadosa e printinstruções de depuração bem colocadas .

Respeito que muitas pessoas digam que minhas técnicas são primitivas, e usar um depurador real em um IDE é muito melhor. Contudo, pela minha observação, os usuários do IDE não parecem depurar mais rápido ou com mais êxito do que eu, usando minhas facas de pedra e peles de urso. Sinceramente, estou aberto a aprender as ferramentas certas; nunca me foi mostrada uma vantagem convincente no uso de depuradores visuais.

Além disso, nunca li um tutorial ou livro que mostrasse como depurar efetivamente usando um IDE, além do básico de como definir pontos de interrupção e exibir o conteúdo de variáveis.

o que estou perdendo? O que torna as ferramentas de depuração do IDE muito mais eficazes do que o uso ponderado de printinstruções de diagnóstico ?

Você pode sugerir recursos (tutoriais, livros, screencasts) que mostram as melhores técnicas de depuração do IDE?

Respostas doces! Muito obrigado a todos por reservar um tempo. Muito iluminador. Votei em muitos e não em nenhum.

Alguns pontos notáveis:

• Depuradores podem me ajudar a fazer inspeção ad hoc ou alteração de variáveis, código ou qualquer outro aspecto do ambiente de tempo de execução, enquanto a depuração manual exige que eu pare, edite e reexecute o aplicativo (possivelmente exigindo recompilação).
• Depuradores podem se conectar a um processo em execução ou usar um despejo de memória, enquanto que na depuração manual, "etapas para reproduzir" um defeito são necessárias.
• Depuradores podem exibir estruturas de dados complexas, ambientes com vários threads ou pilhas de tempo de execução completas facilmente e de maneira mais legível.
• Depuradores oferecem muitas maneiras de reduzir o tempo e o trabalho repetitivo para executar quase todas as tarefas de depuração.
• Depuradores visuais e depuradores de console são úteis e têm muitos recursos em comum.
• Um depurador visual integrado a um IDE também oferece acesso conveniente à edição inteligente e a todos os outros recursos do IDE, em um único ambiente de desenvolvimento integrado (daí o nome).

Alguns exemplos de algumas habilidades que um depurador IDE fornecerá sobre mensagens de rastreamento no código:

• Visualize a pilha de chamadas a qualquer momento, fornecendo um contexto para o quadro atual da pilha.
• Entre nas bibliotecas que você não pode recompilar com a finalidade de adicionar rastreamentos (supondo que você tenha acesso aos símbolos de depuração)
• Alterar valores de variável enquanto o programa está sendo executado
• Editar e continuar - a capacidade de alterar o código enquanto está em execução e ver imediatamente os resultados da alteração
• Ser capaz de observar variáveis, vendo quando elas mudam
• Ser capaz de saltar ou repetir seções de código , para ver como o código irá executar. Isso permite testar alterações teóricas antes de realizá-las.
• Examine o conteúdo da memória em tempo real
• Alertá-lo quando certas exceções forem lançadas, mesmo que sejam tratadas pelo aplicativo.
• Ponto de interrupção condicional ; parando o aplicativo apenas em circunstâncias excepcionais para permitir que você analise a pilha e as variáveis.
• Visualize o contexto do encadeamento em aplicativos com vários encadeamentos , o que pode ser difícil de obter com o rastreio (como os rastreios de diferentes encadeamentos serão intercalados na saída).

Em resumo, as instruções de impressão são (geralmente) estáticas e você precisará recompilar para obter informações adicionais se as instruções originais não forem detalhadas o suficiente. O IDE remove essa barreira estática, oferecendo um kit de ferramentas dinâmico ao seu alcance.

Quando comecei a codificar, não conseguia entender qual era o problema dos depuradores e pensei que poderia conseguir algo com o rastreamento (concedido, que estava no unix e o depurador era o GDB). Mas depois que você aprender a usar corretamente um depurador gráfico, não precisará voltar para imprimir instruções.

• Um depurador IDE permite alterar os valores das variáveis ​​em tempo de execução.

• Um depurador IDE permite ver o valor das variáveis ​​que você não sabia que queria ver quando a execução começou.

• Um depurador IDE permite ver a pilha de chamadas e examinar o estado da função que passou valores estranhos. (pense que essa função é chamada de centenas de lugares, você não sabe de onde vêm esses valores estranhos)

• Um depurador IDE permite interromper condicionalmente a execução em qualquer ponto do código, com base em uma condição, não em um número de linha.

• Um depurador IDE permitirá que você examine o estado do programa no caso de uma exceção não tratada, em vez de apenas cagar.

Aqui está uma coisa que você definitivamente não pode depurar com a instrução "print", que é quando um cliente traz um despejo de memória e diz "seu programa travou, você pode me dizer por quê?"

• Imprimir instruções em todo o código reduz a legibilidade.
• Adicioná-los e removê-los apenas para fins de depuração consome muito tempo
• Os depuradores rastreiam a pilha de chamadas, facilitando a visualização de onde você está
• Variáveis ​​podem ser modificadas em tempo real
• Comandos Adhoc podem ser executados durante uma pausa na execução para auxiliar no diagnóstico
• Pode ser usado em CONJUNÇÃO com instruções de impressão: Debug.Write ("...")

Acho que a depuração usando instruções de impressão é uma arte perdida e muito importante para todo desenvolvedor aprender. Depois que você sabe como fazer isso, certas classes de bugs se tornam muito mais fáceis de depurar dessa maneira do que através de um IDE. Os programadores que conhecem essa técnica também têm uma idéia muito boa das informações úteis para colocar em uma mensagem de log (sem mencionar que você realmente acabará lendo o log) para fins de não depuração também.

Dito isso, você realmente deve saber como usar o depurador passo a passo, pois para uma classe diferente de erros é MUITO mais fácil. Deixarei as outras excelentes respostas já postadas para explicar o porquê :)

Em cima da minha cabeça:

1. Depurando objetos complexos - Depuradores permitem avançar profundamente nas entranhas de um objeto. Se o seu objeto tiver, digamos, uma matriz de matriz de objetos complexos, as instruções de impressão o levarão até agora.
2. A capacidade de ultrapassar o código - Depuradores também permitirá que você pule o código que você não deseja executar. É verdade que você também pode fazer isso manualmente, mas é muito mais código que precisa injetar.

Como alternativa à depuração no IDE, você pode tentar a grande Console PHP da extensão do Google Chrome com a biblioteca php que permite:

• Veja erros e exceção no console JavaScript do Chrome e em pop-ups de notificação.
• Despejar qualquer variável de tipo.
• Execute o código PHP remotamente.
• Proteja o acesso por senha.
• Agrupe os logs do console por solicitação.
• Vá para o arquivo de erro: linha no seu editor de texto.
• Copie dados de erro / depuração para a área de transferência (para testadores).

Não desenvolvo há quase 20 anos, mas acho que usando um IDE / depurador, posso:

• ver todos os tipos de coisas que talvez eu não tivesse incluído em uma declaração impressa
• percorrer o código para ver se ele corresponde ao caminho que eu pensei que seria
• definir variáveis ​​para determinados valores para fazer o código assumir certas ramificações

Um motivo para usar o IDE pode ser que os IDEs modernos suportem mais do que simples pontos de interrupção. Por exemplo, o Visual Studio oferece os seguintes recursos avançados de depuração:

• definir pontos de interrupção condicionais (interrompa apenas se uma condição for atendida ou somente na n-ésima vez que a instrução no ponto de interrupção for executada)
• quebra em uma exceção não tratada ou sempre que uma exceção (específica) for lançada
• alterar variável durante a depuração
• repetindo um pedaço de código, definindo a próxima linha a ser executada
• etc.

Além disso, ao usar o depurador, você não precisará remover todas as instruções de impressão depois de concluir a depuração.

Uma coisa que me surpreende não ter visto em outra resposta é que os dois métodos de depuração não são mutuamente exclusivos .

printfa depuração pode funcionar muito bem, mesmo se você estiver usando um depurador padrão (baseado no IDE ou não). Em particular com uma estrutura de log, para que você possa deixar todo ou parte do produto liberado para ajudar no diagnóstico de problemas do cliente.

Conforme observado em praticamente todas as outras respostas aqui, a coisa mais importante sobre um depurador padrão é que ele permite que você examine mais facilmente (e potencialmente altere) os detalhes do estado do programa. Você não precisa saber de antemão o que gostaria de ver - está tudo disponível na ponta dos dedos (mais ou menos).

Na minha experiência, impressões simples têm uma enorme vantagem que ninguém parece mencionar.

O problema com um depurador IDE é que tudo acontece em tempo real. Você interrompe o programa em um determinado momento e, em seguida, percorre os passos um de cada vez, e é impossível voltar atrás se de repente você quiser ver o que aconteceu antes. Isso está completamente em desacordo com o funcionamento do nosso cérebro. O cérebro coleta informações e gradualmente forma uma opinião. Pode ser necessário repetir os eventos várias vezes, mas depois de passar por um determinado ponto, você não pode voltar.

Em contraste com isso, uma série selecionada de impressões / registros fornece uma "projeção espacial dos eventos temporais". Ele fornece uma história completa do que aconteceu, e você pode voltar e quarta várias vezes com muita facilidade, basta rolar para cima e para baixo. Torna mais fácil responder perguntas como "A ocorreu antes de B acontecer". Pode fazer você ver padrões que você nem procurava.

Então, na minha experiência. O IDE e os depuradores são ferramentas fantásticas para resolver problemas simples quando algo em uma única pilha de chamadas deu errado e explorar o estado atual da máquina em uma determinada falha.

No entanto, quando abordamos problemas mais difíceis, onde uma mudança gradual de estado está envolvida. Onde, por exemplo, um algoritmo corrompeu uma estrutura de dados, que por sua vez causou uma falha no algoritmo do ano anterior. Ou, se quisermos responder perguntas como "com que frequência isso acontece", "as coisas acontecem na ordem e da maneira que eu imagino que elas aconteçam". etc. Então, a técnica de registro / impressão "antiga" tem uma clara vantagem.

O melhor é usar uma das técnicas quando for mais adequada, por exemplo, usar registros / impressões para obter alguns erros e fazer uma pausa em um ponto de interrupção em que precisamos explorar o estado atual mais detalhadamente.

Existem também abordagens híbridas. Por exemplo, quando você executa console.log (object), obtém um widget de estrutura de dados no log que pode ser expandido e explorado com mais detalhes. Isso muitas vezes é uma clara vantagem sobre um log de texto "inativo".

Como a depuração de aplicativos multithread com instruções de impressão o levará a bananas. Sim, você ainda pode fazê-lo com instruções print, mas precisará de muitas delas e desvendar a impressão sequencial das instruções para emular a execução multiencadeadag levaria muito tempo.

Infelizmente, os cérebros humanos são unicamente rosqueados.

Desde que você pediu ponteiros para livros ... No que diz respeito à depuração do Windows, John Robbins tem várias edições de um bom livro sobre depuração do Windows:

Depurando aplicativos para Microsoft .NET e Microsoft Windows

Observe que a edição mais recente ( Depurando aplicativos Microsoft .NET 2.0 ) é apenas .NET, portanto, você pode querer uma versão mais antiga (como no primeiro link) se desejar depuração de código nativo (abrange .NET e nativo).

Pessoalmente, acho que a resposta é tão simples quanto "Um depurador / IDE integrado fornece rapidamente uma variedade de informações diferentes, sem a necessidade de digitar comandos. As informações tendem a estar à sua frente sem que você tenha que dizer o que fazer. te mostrar.

A facilidade com que as informações podem ser recuperadas é o que as torna melhores do que apenas a depuração na linha de comando ou a depuração "printf".

Vantagens de um depurador sobre um printf ( observe não um depurador IDE, mas qualquer depurador )

1. Pode definir pontos de controle. Esta é uma das minhas maneiras favoritas de encontrar corrupção de memória

2. Pode depurar um binário que você não pode recompilar no momento

3. Pode depurar um binário que demora muito para recompilar

4. Pode alterar variáveis ​​em tempo real

5. Pode chamar funções em tempo real

6. Não tem o problema em que os conjuntos de estados de depuração não são liberados e, portanto, o problema de temporização não pode ser depurado com precisão

7. Depuradores ajudam com core dumps, instruções de impressão não '

É o que eu mais uso nas janelas de depuração do VS.NET:

• Pilha de chamadas, que também é uma ótima maneira de descobrir o código de outra pessoa
• Locals e relógios.
• Janela imediata, que é basicamente um console C # e também permite alterar o conteúdo variável, inicializar coisas etc.
• A capacidade de pular uma linha, defina a próxima instrução a ser executada em outro lugar.
• A capacidade de passar o mouse sobre as variáveis ​​e ter uma dica de ferramenta mostrando seus valores.

Em resumo, ele me dá uma visão de 360 ​​graus do estado do meu código de execução, não apenas uma pequena janela.

Nunca encontrei um livro ensinando esse tipo de coisa, mas, novamente, parece ser bastante simples, é praticamente o WYSIWYG.

• Um depurador pode se conectar a um processo em execução

• Geralmente é mais fácil depurar código encadeado de um depurador

Com um depurador IDE, é possível ver os valores de TODAS as variáveis ​​no escopo atual (até a pilha de chamadas) sempre que você interrompe a execução.

Instruções de impressão pode ser grande, mas despejar tanta informação para a tela em qualquer lugar pode produzir um todo monte de instruções de impressão.

Além disso, muitos depuradores de IDE permitem digitar e avaliar métodos e avaliar membros enquanto você é interrompido, o que aumenta ainda mais a quantidade de instruções de impressão que você teria que fazer.

Eu sinto que os depuradores são melhores para alguns idiomas do que para outros, no entanto ...

Minha opinião geral é que os depuradores de IDE são absolutamente maravilhosos para linguagens gerenciadas como Java ou C #, são bastante úteis para C ++ e não são muito úteis para linguagens de script como Python (mas pode ser que eu apenas não tenha tentado depurador para qualquer linguagem de script ainda).

Adoro o depurador no IntelliJ IDEA quando desenvolvo Java. Eu apenas uso declarações de impressão quando uso Python.

Como alguém disse acima: Debugger! = IDE.

gdb e (de volta ao dia) TurboDebugger (autônomo) funcionam muito bem para os idiomas que eles suportam [ed], obrigado. (ou uma tecnologia ainda mais antiga: o depurador Clipper vinculado ao próprio executável do xBase) - nenhum deles exigia um IDE

Além disso, embora a codificação C / ++ seja mais rara, as instruções printf às vezes ocultam o bug que você está tentando encontrar! (problemas de inicialização em vars automáticos na pilha, por exemplo, ou alocação / alinhamento de memória)

Finalmente, como outros declararam, você pode usar os dois. Alguns problemas de tempo real quase requerem impressão, ou pelo menos uma impressão criteriosa "* video_dbg = (is_good? '+': '-');" em algum lugar na memória de vídeo. Minha idade está aparecendo, isso foi no DOS :-)

TMTOWTDI

Além de muito do que os outros pôsteres disseram, eu realmente gosto de percorrer uma linha de cada vez junto com o computador, pois isso me obriga a pensar em uma linha de cada vez. Frequentemente, eu pego o erro sem nem mesmo olhar para os valores das variáveis ​​simplesmente porque sou forçado a olhar para ele quando clico no botão 'próxima linha'. No entanto, não acho que minha resposta o ajude, Bill, porque você provavelmente já possui essa habilidade.

Quanto aos recursos de aprendizado, não usei nenhum - apenas exploro todos os menus e opções.

Isso é mesmo uma pergunta real do programador real?

Qualquer pessoa que tenha passado 5 minutos depurando com instruções de impressão e depurando com IDE - isso OCORRERá com ele / ela mesmo sem perguntar!

Eu usei impressões e IDEs para depuração e prefiro depurar usando um IDE. O único momento para mim, quando isso não funciona, é em situações críticas em tempo (como depurar jogos online) em que você coloca o código com instruções de impressão e, em seguida, analisa os arquivos de log depois que ele está horrivelmente errado. Se ainda não conseguir descobrir, adicione mais impressões e repita.

Só queria mencionar um recurso útil de um depurador de console vs printf e vs debugger em um IDE.

Você pode conectar-se a um aplicativo remoto (obviamente, compilado no modo DEBUG) e inspecionar seu estado despejando a saída do depurador em um arquivo usando o teeutilitário POSIX . Comparado ao printf, você pode escolher onde produzir o estado em tempo de execução.

Isso me ajudou muito quando depurei aplicativos Adobe Flash implantados em um ambiente agressivo . Você só precisa definir algumas ações que imprimem o estado necessário em cada ponto de interrupção, iniciar o depurador do console fdb | tee output.loge percorrer alguns pontos de interrupção. Depois disso, você pode imprimir o log e analisar as informações comparando minuciosamente o estado em diferentes pontos de interrupção.

Infelizmente, esse recurso [registrar em um arquivo] raramente está disponível nos depuradores da GUI, fazendo com que os desenvolvedores comparem o estado dos objetos em suas cabeças.

A propósito, minha opinião é que se deve planejar onde e o que depurar antes de iniciar um depurador.

Bem, outra coisa é que, se você ingressar em um novo projeto antigo e ninguém realmente souber como o código está fazendo o que está fazendo, não será possível depurar fazendo eco de variáveis ​​/ objetos / ... b / c, você não terá idéia do código. executado de todo.

No meu trabalho, estou enfrentando exatamente esse tipo de situação e o XDebuging visual me ajuda a ter uma idéia do que está acontecendo e de onde, de forma alguma.

Cumprimentos

Raffael

Além das muitas coisas que já foram mencionadas, uma das vantagens mais importantes de um depurador sobre o printf é que o uso de instruções printf pressupõe que você saiba em qual função o bug reside. Em muitos casos, você não precisa fazer algumas suposições e adicionar instruções de impressão a muitas outras funções para localizá-la. O bug pode estar no código da estrutura ou em algum lugar distante de onde você pensa que está. Em um depurador, é muito mais fácil definir pontos de interrupção para examinar o estado em diferentes áreas do código e em diferentes momentos.

Além disso, um depurador decente permitirá fazer a depuração no estilo printf, anexando condições e ações a pontos de interrupção, para que você ainda retenha os benefícios da depuração printf, mas sem modificar o código.

A depuração em um IDE é inestimável em um ambiente em que os logs de erros e o acesso ao shell não estão disponíveis, como um host compartilhado. Nesse caso, um IDE com um depurador remoto é a única ferramenta que permite fazer coisas simples, como exibir stderrou stdout.

Um problema ao usar instruções de impressão é que isso atrapalha o seu código. Ou seja, você tem uma função com 10 partes e sabe que ela trava em algum lugar, mas não sabe ao certo onde. Então você adiciona 10 instruções de impressão extras para identificar onde está o erro. Depois de encontrar e resolver o problema, você deve limpar agora removendo todas as instruções de impressão. Talvez você faça isso. Talvez você esqueça e isso acabará em produção e o console do usuário estará cheio de impressões de depuração.

Wauw, eu gosto desta pergunta. Eu nunca ousei colocá-lo ...

Parece que as pessoas apenas têm maneiras diferentes de trabalhar. Para mim, o que funciona melhor é:

• Ter um modelo sólido de meu código, incluindo gerenciamento de memória
• Usando instrumentação (como instruções de impressão) para acompanhar o que está acontecendo.

Eu ganho minha programação de vida há mais de 40 anos, trabalhando diariamente em aplicativos técnicos e científicos não triviais em C ++ e Python, e tenho a experiência pessoal de que um depurador não me ajuda um pouco.

Eu não digo que isso é bom. Eu não digo que isso é ruim. Eu só quero compartilhar.

Não é apenas depuração. Um IDE ajuda a criar um software melhor mais rapidamente de várias maneiras:

• ferramentas de refatoração
• intellisense para tornar a API mais detectável, ou lembre-se da ortografia / caso exato de itens familiares (não é muito útil se você usa o mesmo sistema há 15 anos, mas isso é raro)
• economize na digitação preenchendo automaticamente nomes de variáveis ​​e classes
• encontre certos tipos de erros antes mesmo de começar a compilar
• Pule automaticamente para a variável / método / classe declarações / definições, mesmo que não estejam no mesmo arquivo ou pasta.
• Interromper exceções não tratadas e tratadas

Eu poderia continuar.