Tornando-se um Melhor Reparador de Erros

Eu amo ser um programador. Lá, eu disse. No entanto, com isso dito, percebi recentemente que realmente não suporto a correção de erros. Em absoluto.

De fato, enquanto estou desenvolvendo algo, minha produtividade é extremamente alta. Mesmo ao escrever testes de unidade e ao autoteste de meu desenvolvimento, geralmente sou realmente produtivo. Consigo me concentrar bem e posso realizar tarefas.

No entanto, quando o tempo de controle de qualidade chega e eu estou trabalhando para corrigir bugs, minha inspiração leva uma enorme queda livre. Eu tenho que me forçar a tomar medidas extremas (você sabe, música alta em BPM, quantidades excessivas de cafeína etc.) para fazer qualquer coisa . Meu trabalho geralmente está envolvido em entrar em um projeto massivo existente e adicionar novos recursos ou corrigir bugs, por isso não posso dizer exatamente ao meu empregador que preciso de algumas semanas para escrever testes de unidade para todo o código deles :) Além disso, o A tecnologia de servidor que costumamos usar é muito proibitiva para os testes de unidade e de integração, pois apresenta muitos problemas no Java classloader. Não sou totalmente contra a correção de bugs, às vezes pode ser divertido, mas não é nada divertido quando você precisar fazer pequenas alterações e aguardar 30 segundos a 3 minutos para poder ver se funcionaram ou não (devido à maneira como o sistema funciona).

Como posso melhorar minha produtividade e motivação ao corrigir bugs? Isso é algo com o qual a maioria dos programadores lida?

não é nada divertido quando você precisa fazer pequenas alterações e aguardar 30 segundos a 3 minutos para ver se funcionou ou não

Esse é o verdadeiro problema aqui. Você se sente improdutivo quando precisa esperar tanto tempo para obter feedback, eu conheço o sentimento. Talvez seja possível falsificar mais serviços e criar melhores ferramentas de teste para que você possa obter feedback imediato.

O código legado do teste de unidade é caro ou pode envolver refatorações perigosas. No entanto, a criação de melhores equipamentos de teste pode permitir o teste manual em segundos, em comparação com minutos, e você pode obter quase a mesma produtividade que trabalhar com o novo código testável por unidade.

Esperar tanto tempo por feedback é chato e desmotivador, não o ato de corrigir bugs.

A correção de bugs é uma habilidade extremamente importante que você deve aprender. Li em algum lugar que, normalmente , passamos 80% do tempo corrigindo os 20% dos problemas em um aplicativo.

Acredito em aprender com os erros, e a correção de erros é uma oportunidade de aprender com os erros dos outros . Você pode aprender isso e ajudará a ser um programador melhor no futuro. Essa é a motivação que tive quando comecei a corrigir muitos bugs e a avançar para refazer o código .

Pessoalmente, achei útil parar de pensar em bugs como "pequenas coisas", mas como grandes obstáculos que são tão importantes quanto grandes recursos, mesmo que envolvam a alteração de algumas linhas de código após horas de depuração. Dessa forma, gastar um dia inteiro para matar três entradas de rastreadores de bugs é muito menos deprimente (a abordagem depende um pouco da sua capacidade pessoal de convencer-se a acreditar :-).

Talvez ajude a torná-lo um jogo, por exemplo, junto com seus colegas de trabalho ( quem corrige mais erros por dia? Ou, pior ainda, quem fez o menor número de reconstruções por dia? )

Eu estive no seu lugar. Crie testes automatizados quando e onde puder. Não precisa ser tudo de uma vez. Quando você encontrar um bug, reserve um minuto para tentar programar um caso de teste. Se você não pode programar um caso de teste, escreva um resumo rápido sobre como testá-lo manualmente, por exemplo, clique aqui, digite isso etc. e coloque-o em algum tipo de Base de Conhecimento.

A depuração pode ser muito cansativa, especialmente com código complicado que você não escreveu. Crie um objetivo: "Corrija o bug 13533 na sexta-feira". Em seguida, configure uma recompensa se você atingir a meta "Pegue uma cerveja com meus amigos na sexta à noite". Isso ajudará a torná-lo um pouco mais gratificante.

Fora isso, às vezes trabalho é apenas isso ... trabalho.

Nesse tipo de situação, você precisa de algum tipo de desafio criativo. Normalmente, está escrevendo código, mas aqui não está.

Mas tudo não está perdido. Trabalhe na solução de seus meta-problemas e despeje sua energia nisso. Por que demora 30 segundos a 3 minutos para obter feedback? Como você pode reduzir esse tempo? (Talvez você possa escrever algum tipo de script ou aplicativo utilitário que não faça check-in que o ajude a fazer isso). Esse é o seu novo domínio de problemas - seu novo desafio criativo.

Pessoalmente, sempre que estou em uma fase de correção de defeitos, identifico minhas maiores barreiras para fazê-lo de forma rápida e indolor e automatizo o que preciso automatizar para remover essas barreiras. Isso geralmente resulta em aumento de produtividade e acréscimos ao meu portfólio pessoal para inicializar.

Então, resumindo, eu diria "sempre estar desenvolvendo". :)

O seu problema está depurando ou corrigindo erros? Se você puder depurar o suficiente para isolar o componente que está causando o problema, veja-o como uma nova tarefa de desenvolvimento.

1. Escreva alguns testes de unidade apenas para o trecho de código que está sendo quebrado. Verifique se você tem testes para validar toda a funcionalidade desejada, além de alguns que isolam particularmente o comportamento do buggy.
2. Escreva um novo código que passe em todos os testes que você acabou de escrever.
3. Substitua o código antigo pelo novo.
4. Execute alguns testes de integração. É aqui que você executa as reinicializações de três minutos do servidor, mas deve ser minimizado se você executar bem as etapas 1 a 3.
5. Voila!

Talvez você deva examinar Debugging Myself , de Brian Hayes , um artigo publicado na American Scientist em 1995. Você pode tomar medidas (como o uso habitual das Condições Yoda ) para reduzir ou eliminar os tipos mais odiados de erros que você produz.

Sou da opinião de que a depuração é uma habilidade diferente da programação, embora relacionada. Em particular, a depuração de programas multiencadeados é quase totalmente diferente de escrevê-los.

Se o desenvolvimento de software é chato, você está fazendo errado. Em outras palavras, não é um problema para você, mas um problema com sua plataforma e processo. Você já pensou em procurar uma posição usando uma linguagem dinâmica (por exemplo, Python, Ruby, JavaScript), onde não precisa esperar pela reinicialização do servidor?

Faz parte do trabalho, infelizmente. Você terá projetos ruins e empregadores ruins (não estou dizendo que esse seja o caso aqui, apenas generalizando).

Você pode escrever testes de unidade com o código deles. Esgueirar-se como você pode. Depois que você tiver algo que possa mostrar aos chefes, poderá mudar a maré.

Use as ferramentas de depuração para corrigir a lentidão, use os testes de unidade para testar o novo código e use-os para corrigir os problemas do código existente, além de dividir o código existente em partes menores.

Você pode fazer disso um desafio e se tornar um herói de melhoria de processos. E, se não funcionar, você terá uma boa experiência para levar ao próximo empregador.

A maioria dos programadores precisa lidar com problemas pessoais de correção de erros em algum momento de sua carreira.

O senso certo de distância de pessoa para trabalho é essencial para sua motivação. Não identifique demais ou subidentifique seu trabalho. Se você está se identificando demais com o seu trabalho, problemas como os que você descreveu podem surgir: Você pode ficar muito relutante em corrigir os erros, já que está na metade do tempo se culpando. Obtenha alguma distância interna e descubra como você pode trabalhar racionalmente no seu problema.

Em relação aos problemas específicos em sua plataforma, existem algumas maneiras de reduzir os longos tempos de implantação e teste (e, por outro lado, o seu não é particularmente longo).

Em primeiro lugar, quanto maior o tempo de teste, mais avesso você deve ser ao culto à carga. Se você fizer uma alteração, pense nisso até ter certeza de que ele corrigirá o erro . Obviamente, o quão confiante está sujeito à duração do seu ciclo de teste. Mas se seus ciclos de teste ficarem mais longos e não for possível evitar longos testes, gaste mais tempo pensando e você será recompensado e mais feliz na depuração, porque é mais rápido e tem o efeito gratificante de um bom momento de "fiat lux" "

Em segundo lugar, inclina-se mais para testes de unidade e menos para testes de integração. Remova todos os pontos de falha da plataforma difícil de depurar que puder.

A correção de bugs pode ser "impressionante" ou "tediosa". Eu tenho alguns créditos de jogos que são inteiramente devidos à correção de um único bug - o bug de falha que ninguém mais poderia corrigir. Mas a preparação diária do bugzilla é entorpecente. Erros menores são entediantes. Erros principais são dignos.

Aqui está a conclusão: o fato de você ter uma lista gigante de bugs menores é um dos principais bugs. Não é apenas um bug de código. É um bug de processo ou gerenciamento.

Encontre esse bug e corrija-o.

Uma coisa que encontrei entre colegas e conhecidos que são bons "depuradores / solucionadores de problemas / solucionadores de problemas" é que eles geralmente gostam de resolver quebra-cabeças. Isso pode significar palavras cruzadas, jogos de números (como Sudoku) e quebra-cabeças lógicos, etc.

Portanto, uma maneira de você se tornar um reparador de bugs melhor seria gastar algum tempo trabalhando nas habilidades de resolução de problemas ou resolução de quebra-cabeças.

Aqui está um link da Wikipedia que pode ser um bom ponto de partida para ajudar você a resolver melhor os problemas.

Lembre-se, algumas pessoas são melhores na solução de problemas ou apenas se divertem mais. Algumas pessoas não gostam nada disso, o que torna difícil se forçar a fazê-lo - mas não se engane - se você se esforçar para aprender a resolver problemas de quebra-cabeças, será mais fácil ser um bom solucionador de problemas no futuro. .

A correção de bugs geralmente parece uma tarefa árdua, porque pode fazer com que você sinta que os bugs estão ocupando todo o seu tempo e mantendo-o longe das coisas novas e divertidas. A realidade é, no entanto, que a correção de erros é uma parte muito grande do que fazemos, e começa assim que a primeira linha de código é escrita e a execução do compilador. Quando você libera o código pela primeira vez, provavelmente já passou horas corrigindo bugs, mas não parece assim porque os corrigiu como parte do processo de implementação de recursos. Realisticamente falando, não importa quão bom você seja um programador, os bugs surgirão no seu sistema.

Então, como você faz isso divertido? Bem, eu realmente não posso responder isso para você, porque eu realmente não posso imaginar o que é que flutua em seu barco individual. Para mim, sou um viciado em ferramentas, por isso a resposta está em ter uma cadeia de ferramentas muito confiável e um processo de desenvolvimento flexível que contribui para tornar a correção de erros menos trabalhosa e mais simplesmente um problema a ser resolvido rapidamente. Atualmente, estou desenvolvendo principalmente em C # e estou sempre procurando ferramentas que removam o tempo tedioso de desperdiçar partes do software de escrita. Eu uso uma primeira abordagem de desenvolvimento de teste suportada por uma API BDD muito boa chamada StoryQ . Eu uso o NCrunch, que executa meus testes de forma contínua e simultânea em segundo plano enquanto eu codigo, e realmente tem sido o NCrunch Resharper para automatizar grande parte da minha refatoração e o StyleCop para impedir coisas como estilo de codificação. Minha mais recente adição à cadeia de ferramentas foi incluir que provou ser o divisor de águas.

A combinação de todas essas ferramentas viu minha produtividade subir rapidamente, pois perdi muito pouco tempo esperando que as coisas fossem compiladas ou executadas. Recebo feedback instantâneo visualmente dentro do meu IDE para me informar que tenho problemas para corrigir e esqueço o código de teste de forma que seja possível localizar em apenas algumas linhas de código o local exato em que não apenas o falha ocorre, mas para onde a causa da falha ocorre devido ao adorável relatório detalhado que recebo de StoryQque me diz exatamente quais partes do meu teste passam, quais falham e onde estão as falhas no código. Com todo o desperdício de tempo removido do meu tempo de desenvolvimento, gasto muito pouco tempo ativamente na depuração e mais tempo resolvendo problemas e escrevendo testes e códigos. As questões de alta rotatividade me mantêm ocupada e traz muitas variações em minhas tarefas. Também me deu muito tempo para buscar outras áreas de interesse durante meu dia de trabalho, para que eu possa injetar idéias novas e inovadoras em nossa linha de produtos e em nossos processos.