Quando refatorar

Eu li a maioria dos livros sobre refatoração da Fowler e refatorei muitas aplicações no passado, grandes e pequenas.

Uma das coisas mais difíceis que eu ensino é "quando" refatorar. Costumo fazer isso com base em uma sensação de intestino que me serviu notavelmente bem no passado. No entanto, ao entrar em discussões com as pessoas sobre se um pedaço de código deve ser deixado sozinho ou refatorado no momento, é difícil manter a "verificação do intestino".

Sinto que deve haver abordagens mais rigorosas para isso, mas não tenho certeza do que sejam.

Entendo "cheiros de código", refatoração de vermelho-verde e outros pensamentos, mas muitas vezes sinto que o melhor momento para refatorar não é a primeira vez que você escreve o código, mas a segunda ou terceira vez que você está usando o código e percebe que é realmente um problema e está em uso real.

Refatorar quando o custo da refatoração for menor que o custo da não refatoração.

Meça "custo" da maneira que puder. Por exemplo, o código é tão mal implementado que erros triviais custam horas ou dias para serem corrigidos? A refatoração permitirá conquistar mais clientes, aumentar a capacidade ou melhorar o desempenho e, assim, tornar seus clientes existentes mais felizes?

1. A complexidade ciclomática da função é inferior a 5?
2. Você entendeu completamente o que era a complexidade ciclomática sem seguir esse link?
3. Você tem um teste automatizado ou um caso de teste documentado para todos os caminhos através da função?
4. Todos os casos de teste existentes são aprovados?
5. Você pode explicar a função e todos os seus casos extremos para mim em menos de 1 minuto?
6. Se não, que tal 5 minutos?
7. 10 minutos?
8. Existem menos de 100 linhas de código na função (incluindo comentários)?
9. Você consegue encontrar outros dois desenvolvedores que concordam que esse código está livre de erros apenas por inspeção visual?
10. Esta função é usada em apenas um lugar?
11. A função atende aos objetivos de desempenho (Tempo / Memória / CPU)?

Pontuação

Adicione as respostas "não" acima:

• 0-1 - Por que você pensaria em refatorar isso? Você provavelmente só quer renomear variáveis ​​porque não gosta da convenção de nomes do desenvolvedor anterior
• 2-5 - Isso pode precisar de alguns ajustes, mas eu não aguentaria um lançamento de produção para algo nesse intervalo
• 6-8 - OK, provavelmente precisamos corrigir isso ... É provável que continuemos revisando isso e / ou não sabemos o que está fazendo. Ainda em cima do muro, mas é altamente suspeito
• 9+ - Este é um excelente candidato para refatoração. (Observe que escrever casos de teste é uma forma de refatoração)

Quando seu intestino está lhe dizendo que você provavelmente deveria refatorar, é provável que seus instintos lhe digam um pouco tarde que você adia algo importante por muito tempo.

Entendo "cheiros de código", refatoração de vermelho-verde e outros pensamentos, mas muitas vezes sinto que o melhor momento para refatorar não é a primeira vez que você escreve o código, mas a segunda ou terceira vez que você está usando o código e percebe que é realmente um problema e está em uso real.

Existem efetivamente dois níveis para refatoração. O primeiro são os problemas óbvios que aparecem quando você codifica pela primeira vez. Essas são as pequenas otimizações que custam muito pouco para você fazer com antecedência. Coisas como manter seus métodos e classes pequenos e aderir a DRY e SRP. Então você tem o estágio adicional de lidar com grandes falhas em seu design, que podem não ser imediatamente aparentes até que seu código tenha algumas milhas abaixo. É desse segundo nível que você está falando e, para garantir que a refatoração posterior não seja muito dispendiosa, é necessário que você já tenha escrito seu código de forma que o esforço que você imagina mais tarde seja mais fácil e menos dispendioso, o que significa fazer uma refatoração precoce.

Como Jeff mencionou em sua resposta, "tempo é dinheiro" , principalmente em empresas onde a carga de trabalho é alta e os riscos ainda mais altos. O tempo gasto no início para garantir que o código esteja no seu melhor estado possível é economizado mais tarde, ao provocar o que deveria ter sido uma refatoração fácil acaba sendo uma operação importante.

Ao escrever um software, cada momento gasto para melhorar seu código antecipadamente economiza tempo mais tarde, quando você realmente precisa dele. Quanto mais cedo você refatorar, mais claras serão as alterações posteriores. É como fazer um adiantamento em dólares de hoje contra futuras dívidas técnicas, que estarão em dólares inflacionados amanhã.

De qualquer forma, a refatoração não deve ser uma tarefa que você adia até um futuro misterioso, quando o software já está completo e estável, pois aumenta seus riscos mais tarde, quando as apostas são muito maiores e o produto muito mais difícil de mudar. A refatoração deve fazer parte de suas atividades diárias, e essa é a essência da filosofia Red-Green-Refactor que você mencionou.

Acho que sua pergunta pode ser respondida de maneira diferente por cada desenvolvedor e até pelo gerenciamento responsável pela programação.

Minha preferência pessoal é que, sempre que aprendo algo novo ou aprimoro minhas melhores práticas, refatoro o código que posso - gosto de manter meu código no padrão assim que aprendo qual o melhor padrão a ser usado nessa situação. Eu estou autorizado a fazer isso porque é uma empresa menor que usa o mesmo software por longos períodos de tempo.

Em uma empresa maior de desenvolvimento de software, onde tempo é dinheiro, pode ser apenas começar a projetar com as melhores práticas que você aprendeu a partir deste ponto; não se preocupe em refatorar até a versão 2 desse software específico?

Sinto que ensinar quando refatorar realmente depende da empresa em que você está atualmente.

"Quando refatorar?"

Resposta curta: toda vez que você encontra um código que cheira mal ou pode ser melhorado ( Regra dos escoteiros )

Na prática, isso acontece:

• Se você pratica o TDD, sistematicamente durante a etapa Refatorar do ciclo do TDD, ou seja, quando o teste estiver verde e antes de começar a escrever um novo teste.
• Como resultado de uma revisão de código
• Ao assumir o código legado
• Ao consumir código que parece desajeitado
• etc.

Quando eu aprendi sobre refatoração, meu mentor me disse: "Faça isso duas vezes, segure o nariz. Faça isso três vezes. Refatorar". (Obrigado, Josh!) Para ser específico, o que ele estava dizendo era que, quando você está prestes a escrever o mesmo bloco de código pela terceira vez (ou mesmo um padrão de código semelhante), é a hora de refatorar. Eu segui isso nos últimos 10 anos e achei que era uma regra prática bastante sólida.

O uso do Eclipse, ou IDE semelhante, com forte suporte à refatoração, reduz o esforço para fazer a refatoração. O suporte ao IDE aumenta a probabilidade de você refatorar assim que clicar na "terceira vez" (ou ver a necessidade), em vez de vê-lo como um esforço adicional.

Além disso - o TDD também é uma grande ajuda, pois você pode continuar executando seus testes como refatorador e saber que não quebrou nada.

Refatorar por sua definição é um processo. Isso implica que você não deve se esforçar para encontrar tempo livre para executar a tarefa de rafactoring; em vez disso, deve refatorar o tempo todo ao encontrar um código de código que poderia ser melhor escrito.

Pessoalmente, gosto de escrever protótipos evolutivos, dizendo de maneira mais simples: código que simplesmente funciona e depois refatorá-los até que atendam aos padrões de codificação esperados. Outro bom exemplo é adicionar funcionalidade adicional e refatorar o código existente para permitir sua reutilização.

Nos meus 20 anos de programação, aqui está a única regra prática em que realmente vi trabalho, no qual as pessoas podem se apegar e os gerentes dão tempo. (Refatorar é como fazer dieta: claro, "calorias in / calorias fora" é a fórmula para perder peso, mas isso não se traduz em uma dieta que as pessoas cumpram.) E assim:

Refatore continuamente enquanto trabalha. Use o Test Driven Development para ter vários ciclos de refator vermelho-verde ao longo do dia. Refatorar apenas as partes do código que você tocou.

Depois de ter mais certeza de si mesmo, você pode variar deste regime.

Eu acho que depende das demandas do proprietário do projeto e do cara que responde pela qualidade do código. Você simplesmente não pode decidir sozinho, quando o dinheiro de outra pessoa está em questão.

Por razões técnicas, existem várias.

• Se você tiver um bug no código, isso significa que este local é mal compreendido e é MUITO provável que mais erros possam estar ocultos aqui e certamente haverá grandes problemas com qualquer tentativa de desenvolver as partes conectadas do código. Portanto, este local deve ser verificado quanto à possível refatoração.
• Outro motivo é quando você adiciona ou altera um recurso e o código antigo é muito inconveniente para alterar / adicionar e as alterações / adições posteriores são altamente possíveis. Claro, você deve equilibrar o custo.
• Talvez o motivo mais sério seja quando você está alterando o código e ele não pode ser testado.