Como você programa efetivamente quando leva muito tempo para simplesmente testar seu código?

Meu fluxo de trabalho sempre foi escrever uma etapa lógica e, em seguida, executar o programa e inspecionar a saída. Esse processo me serviu incrivelmente bem para trabalhos na universidade. No entanto, à medida que desenvolvo mais, geralmente há momentos em que simplesmente compilar e executar seu código leva de 1 a 2 minutos. Os exemplos incluem o upload de um programa para um microcontrolador, exigindo interação com um servidor externo e incapaz de implementar a automação devido à autenticação, arquitetura de software ou complexidade.

Esses tipos de tarefas são muito inadequadas para como eu geralmente programa e estou tendo dificuldades em codificar com eficiência. Eu costumo cometer muitos erros de sintaxe e de lógica, a maioria dos quais eu facilmente pego testando. No entanto, com um tempo de espera tão longo, esse método consome muito tempo.

Primeiro, qualquer tipo de depuração interativa é excelente. Você quer isso no seu kit de ferramentas, porque, se ainda não, um dia você realmente se beneficiará com isso. (Os detalhes variam de acordo com idioma, plataforma e IDE.)

exigindo interação com um servidor externo e incapaz de implementar a automação devido à autenticação, arquitetura de software ou complexidade.

Eu examinaria algumas estruturas para usar objetos simulados . Isso permite que você rodeie o componente que está sendo testado com um falso ecossistema de outros componentes, para que seus testes sejam mais direcionados especificamente e você possa evitar testar tanto tudo como uma unidade inteira.

Além disso, os próprios objetos simulados podem ser programados com asserções, para que você possa verificar se o componente que está sendo testado realmente fez uma determinada chamada.

Eu trabalharia duro para reduzir o tempo de teste. Eu havia trabalhado em algumas empresas desenvolvendo código incorporado, e os testes eram dolorosos, exigindo viagens para a sala do servidor e FTPs e reinicializações manuais e vários comandos para o hardware de teste. Então entrei para um grupo muito bom, onde eu poderia simplesmente digitar 'make test' na minha mesa e obter resultados em menos de um minuto. Nesse minuto:

• Meu código foi incorporado a uma nova imagem do kernel para hardware incorporado.
• O servidor DHCP foi atualizado para apontar para o novo kernel.
• A placa de teste foi reiniciada.
• A placa de teste recuperou o kernel da minha estação de trabalho por meio de uma montagem NFS.
• A placa de teste foi reiniciada no novo kernel.
• Os testes de unidade foram executados.
• A saída do teste de unidade foi entregue de volta à minha estação de trabalho.

Demorou algum tempo para que tudo funcionasse, mas o esforço para automatizar todas essas etapas foi recuperado em cem vezes, à medida que a equipe de desenvolvimento crescia.

Testes automatizados não substituem a revisão e o entendimento.

Pode ser que você esteja usando o teste como muleta. Se você estiver fazendo isso, impedirá seu aprendizado. Não estou defendendo que você não teste. Em vez disso, recomendo que, antes de executar o teste, revise o que você escreveu. Entenda o que você escreveu, verifique se faz sentido e verifique se a sintaxe parece correta.

Você já deu a resposta: I usually make a lot of syntax errors and logic errors

Portanto, trabalhando duro para melhorar isso, você poderá reduzir o tempo de teste. Os erros de sintaxe devem ser os primeiros a serem reduzidos. Nunca teve um teste de programação com um papel e um lápis em seu estudo?

Eu tive a mesma coisa quando mudei de PHP para Java. Eu tive que aprender a depurar em vez de apenas imprimir algumas variáveis ​​e pressionar F5 no navegador ...

Você precisa de uma boa plataforma de teste unitário ou funcional que possa executar testes automaticamente para você, de preferência em segundo plano. Isso exigirá o uso de Mocks, conforme observado acima, e dependendo do idioma em que você estiver usando algum tipo de injeção de dependência.

Tornando seus objetos o mais independentes possível e, em seguida, usando métodos de injeção para adicionar restrições externas, não é difícil criar uma plataforma de teste para o seu código.

A verdadeira diversão vem quando você simplesmente não pode testar seu código, exceto usando-o com raiva. Isso acontece muito com os sistemas de negociação, pois os simuladores de troca disponíveis geralmente são ruins, inexistentes ou nem cumprem o que os fornecedores do software de troca dizem que faz. Isso faz parte da rica tapeçaria da vida, receio. Minha abordagem é garantir que pelo menos meu lado da transação seja bem escrito e bem documentado, para que possa ser facilmente alterado rapidamente.

Teste de Unidade; Zombe de aplicativos / simuladores.

Isso levará tempo, é garantido, e talvez você precise coletar e massagear dados de amostra para criar modelos apropriados, mas, no final, valerá a pena: você economizará o tempo todo e os problemas que encontrar ao tentar fazer testes externos. sistemas.

Usadas corretamente, essas ferramentas garantirão que, antes de você chegar perto de sistemas externos, você tenha 99,9% de certeza de que, se o seu código falhar, será algo no sistema externo / mudança de ambiente que o causou, não um bug no seu próprio código.

Trabalhei profissionalmente por um bom tempo, como você fazia na escola, e em muitos casos foi muito eficaz. Eventualmente, trabalhei com algumas pessoas que me forçaram a abandonar essa metodologia e usar testes e modelos de unidade.

Agora, não inicio nenhum projeto sem antes pensar na implementação das fases de teste - testes de unidade, modelos, simuladores, dados de amostra etc.

Eu costumo cometer muitos erros de sintaxe e de lógica

Talvez o uso de um Linter possa ajudá-lo um pouco aqui.

Eu estava em situação semelhante com meu empregador anterior. Nossa base de código era realmente grande e, para fazer as alterações necessárias, codifique, compile e substitua os .classarquivos em um servidor dev e reinicie o dev-sever com o script de reinicialização. E para minha consternação, levará cerca de meia hora para obter o servidor dev novamente.

Mais tarde, descobri que a depuração remota do servidor dev também era possível.

Então, aqui está o que eu fiz para otimizar meu processo

• Primeira rodada inicial de depuração remota, isso me permitiu ver o fluxo exato do código e os valores / estados exatos das variáveis.

• Planejando como e quais mudanças eu farei.

• Fazendo alterações e comparando as diferenças

• Armazenando em cache erros usando o linter ou compilando.

• Fornecendo o hotfix, substituindo os .classarquivos e reiniciando.

Às vezes, eu também incluía muitas instruções de log para verificar novamente o fluxo de código e verificar valores / estados. Isso me ajudou muito.

Também o uso de um IDE com boa complicação automática pode ajudar bastante na redução de erros de digitação.

Espero que isto ajude.