Depuração: compreendendo detalhes sobre por que certas correções funcionaram? [fechadas]

Ao depurar, às vezes acho que faço algumas alterações e não tenho 100% de certeza do motivo pelo qual essas alterações corrigem algum erro no programa. É essencial entender todos os detalhes sobre por que alguns bugs estavam ocorrendo e por que certas alterações os eliminaram? Ou é comum entre os desenvolvedores, algumas vezes, colocar o programa em funcionamento sem conhecer realmente os detalhes sobre o porquê da correção funcionar?

Eu diria que é essencial entender todos os detalhes sobre por que alguns bugs estavam ocorrendo e por que certas alterações os eliminaram, e também é comum entre os desenvolvedores às vezes colocar o programa em funcionamento sem realmente saber os detalhes sobre por que a correção funcionou!

A arte de mudar as coisas até que um bug desapareça, sem entender o que o causou ou por que a mudança o corrigiu, é frequentemente chamada de "programação vodu" e não é um elogio. Não há realmente nenhuma maneira de você ter certeza de que corrigiu um bug genuinamente , em vez de corrigi-lo parcialmente para o caso específico que estava investigando, se não entender o que o causou.

Na pior das hipóteses, você não fez nada além de mudar o bug: lembro-me desde o primeiro ano de computação na universidade, quando muitos estudantes aprendiam C e ponteiros pela primeira vez, os bugs dos ponteiros costumavam parar de se manifestar quando mudavam as coisas. aleatoriamente, porque as alterações reorganizariam as estruturas de dados na memória o suficiente para fazer o bug do ponteiro pisar em um pedaço diferente de memória. Obviamente, isso não ajudou em nada .

Mas, dito isso, as realidades comerciais da programação costumam ser tais que satisfazer o cliente com a correção de um bug é mais importante do que satisfazer a si mesmo. Eu nunca recomendaria que você declarasse algo corrigido se não tivesse idéia do que o causou, mas se você pode ver que algum código era problemático e o refez, mesmo se "não tiver 100% de certeza" de como isso causou o problema específico erro para se manifestar, às vezes você só precisa passar para o próximo bug antes que o cliente grite muito alto sobre seu lento progresso.

Se você acha que um cliente está bravo por levar muito tempo para consertar um bug, imagine como ele ficará bravo com um bug recorrente que você alegou ter sido corrigido ou com uma correção para uma coisa que piora a situação. Se a sua correção for apenas uma solução alternativa ou atenuante, os clientes geralmente ainda a receberão, mas você deve ser honesto sobre o que é e colocar o registro necessário para poder realizá-la.

Se você tem certeza de que o corrigiu, mas não sabe por que a correção funciona, pergunte a alguém. A maioria dos engenheiros que conheço adora receber perguntas como essa por causa do mistério por trás disso.

Mudando as coisas até que o bug não exista mais, geralmente há uma prática ruim, mas infelizmente é uma realidade para algumas pessoas.

Sou da opinião de que você nunca deve escrever um código que não entenda o que faz ou por que faz. Como você pode ter certeza de que, apesar de ter corrigido o bug que resolveu corrigir - não quebrou mais nada?

Geralmente, antes de corrigir um problema / bug - você deve fazer uma avaliação / análise de causa subjacente para determinar por que o problema está ocorrendo e se pode ser replicado. Então você deve ler o código e entender por que o código está causando o erro. Depois de ter esse entendimento: você poderá começar a analisar como a questão será resolvida e determinar outras áreas que suas alterações afetarão. Os testes de unidade podem realmente ajudar aqui!

Eu já vi várias alterações de código que as pessoas fizeram para corrigir um problema (o que é ótimo), mas infelizmente introduziu outros problemas porque o desenvolvedor não tinha conhecimento do impacto total do que eles mudaram. Muitas dessas "correções" apenas obscurecem a causa subjacente do problema original, além de introduzir complexidade e mais bugs.

Dito isto, eu corrigi vários problemas no código puramente por associação. Onde eu mudei / refiz / refatorei algo e corrigi outros erros pendentes. Portanto, embora eu não saiba o que os causou originalmente, encontrei um código desonesto e o "consertei" - o que também corrigiu esses bugs. Abordo mudanças como essa com testes de unidade e integração para garantir a integridade dos negócios e os requisitos técnicos da função.

Ou é comum entre os desenvolvedores, algumas vezes, colocar o programa em funcionamento sem conhecer realmente os detalhes sobre o porquê da correção funcionar?

Existem pelo menos três grandes problemas com isso:

1. Isso leva a uma mentalidade de magia negra, na qual você desiste da ideia de que pode entender o código e, em vez disso, começa a mover partes esperando que os problemas desapareçam. Esse é o equivalente da programação de colocar comida no prato, esperando que o jantar pareça suficientemente comido para que seus pais não façam você comer mais vegetais.

2. Você não pode saber que o bug é realmente corrigido ou apenas mascarado por sua alteração, a menos que compreenda a) qual era o problema eb) como sua alteração resolve o problema.

3. O bug provavelmente não foi corrigido e o morderá novamente no futuro próximo.

Eu vejo dois cenários: você trabalhou em outra coisa e o bug parou de acontecer, desde que a outra coisa não tenha quebrado mais nada, você tem que deixar isso entrar - você fez o que era necessário / queria e teve um efeito colateral positivo imprevisto e inexplicável.

A outra é que você está trabalhando nesse bug e uma mudança aleatória fez as coisas funcionarem, isso é inaceitável. Se você não tem idéia do que o código antigo estava fazendo de errado, provavelmente não faz ideia do que o novo código está fazendo de errado.

Eu realmente não consigo pensar em um bom motivo para verificar o segundo caso - se é um bug crítico, é essencial fazer o certo. Se for um erro não crítico, pelo menos você pode ter certeza de que não está introduzindo um erro crítico com sua "correção".

Ou é comum entre os desenvolvedores, algumas vezes, colocar o programa em funcionamento sem conhecer realmente os detalhes sobre o porquê da correção funcionar?

Eu, pelo menos acho que isso é muito comum hoje em dia. Isso é por causa do Google e Stackoverflow. Você tem um problema com seu código, basta pesquisar no google, encontrar solução, consertar, passar para o próximo problema.