Alguém mais tem um problema de refatoração? [fechadas]

Parece que depois de escrever uma quantidade significativa de código, sinto-me ansioso como se não tivesse feito da melhor maneira possível, e acabo refatorando continuamente e gastando muito tempo no projeto, ou nunca obtendo feito às vezes. Isso já aconteceu com mais alguém e como você lida com isso?

Gosto desses momentos em que eles acontecem comigo.

O motivo: se eu não olhasse para o meu trabalho e pensasse que há algo que eu poderia ter feito melhor do que não estaria avançando como desenvolvedor. Portanto, quando ocorrerem esses momentos de iluminação, aceite-os e anote o que aprendeu. Considere seu cronograma para o projeto atual e, se possível, refatorar o código, se não for possível, pegue a lição e use-a em futuras implementações de projetos.

De qualquer forma, aprender com seus próprios erros é ótimo!

Aqui estão algumas regras para restringir essa atividade e torná-la mais produtiva:

• cronometrar, por exemplo, defina o temporizador para 25 minutos
• faça-o somente quando tiver uma cobertura de teste decente.
• tente tornar sua refatoração útil para o desenvolvimento dos próximos recursos

Parece que você sempre pode refatorar, não é? Tento limitar a refatoração apenas ao tentar resolver outros problemas. Por exemplo, refatorar quando você tiver um problema de desempenho e refatorar com ajuda para resolvê-lo - refatorar quando precisar adicionar novas funcionalidades e refatorar o ajudará a resolvê-lo

Para ser honesto, eu me preocuparia mais se você estivesse produzindo imensas resmas de código e achando que tudo é perfeito e não precisa de refatoração ...

Quando eu era mais jovem e inexperiente, era muito arrogante em relação à minha capacidade de programação e sempre tendia a imaginar que é possível projetar e planejar muito bem - e que, quando eu chegar ao estágio de implementação, eu simplesmente darei um jeito nisso ' Tudo será perfeito.

A realidade é quase o oposto. Alguns até dizem que, assim que você começar a codificar, você deverá estar no modo Manutenção. A idéia aqui é que o estágio "Implementação" do SDLC realmente não existe como tal, porque você nunca deve deixar de lado a correção de erros ou a refatoração e fingir que o código que você está produzindo é "fresco" e perfeito.

Tudo o que disse, acho que é possível chegar muito obsessivo sobre refatoração. Ainda não o vi ainda. E quanto mais experiência eu tiver, mais acho que seria bom se mais equipes de software se recusassem a trabalhar com prazos apertados e se endividar. Afinal, esse é o motivo mais comum pelo qual a refatoração é deixada de lado no mundo real.

Eu sugeriria não depender apenas do sentimento ou do cheiro do código.

Enumere claramente o que há de errado com o código e quais são as soluções. Sério, anote, porque você vai querer revisar a eficácia do refator contra isso.

Identifique maneiras de dividir o refator em pedaços possíveis e priorize-os. Tenha a disciplina para se concentrar apenas no escopo de cada bloco, evitando tangentes que possam prejudicar sua tarefa.

Além disso, identifique quais testes de unidade você pode escrever no código existente antes de continuar. Se já existem testes extensivos, isso é ótimo. A falta de testes de unidade representa uma grande oportunidade para fazer alguns.

Não há dúvida de que caí nessa armadilha, mas alguma refatoração é importante para o futuro suporte / depuração.

Ao escrever um trecho de código importante, fica muito fácil manter as linhas de código no método que está sendo gravado atualmente. Quando concluí um grande pedaço de código, coloco um comentário de revisão de código todo: Alguns dias depois, revisarei o código e refatorarei de acordo. Se eu tiver problemas para ler alguns dias depois, o que acontecerá em alguns meses ou até anos.

Caio nessa armadilha quando estou aprendendo um idioma ou uma tecnologia. Por exemplo, quando você aprende java pela primeira vez, imagine que você escreve um aplicativo Web com um servlet, pensando que é o caminho certo. Então você percebe que há jsp e pensa: oh, isso é novo, provavelmente o certo. Depois, no meio do caminho, você encontra Struts e talvez algumas coisas de EJB. Depois disso, você encontra spring (xml based) e depois encontra as anotações legais do @MVC, após as quais você acha tudo muito detalhado e fica estragado por escolha entre groovy / grails e scala / lift! Isso é perfeitamente adequado para projetos pessoais, já que o objetivo geralmente é aprender e não necessariamente atingir algum prazo.

Eu costumava ser super-refatorador no trabalho também. Mas, à medida que ganhei mais experiência, tornei-me mais seletivo sobre o que refatorarei. Acontece que, quando você sai de uma empresa, não leva o código com você, e geralmente outros engenheiros podem destruir o código quase mais rapidamente do que você pode corrigi-lo.

A regra de ouro que sigo é a seguinte: refatoro até que seja o mais otimizado possível naquele momento e depois não o refatoro a menos que as situações mudem, ou mais raramente se tiver uma inspiração sobre uma maneira nova e melhor de faça coisas (por exemplo, usando um novo recurso de idioma).

Por exemplo, uma vez tive que escrever um novo módulo de código para um aplicativo existente. Escrevi de uma certa maneira e, no dia seguinte, pensei mais e imaginei que poderia refatorá-lo e torná-lo mais abstrato, pois tínhamos certeza de que seria necessário estender o caminho para outros usos. Então, refatorei o código. Decidi que era um pouco genérico demais e consolidei algumas classes e interfaces que estavam basicamente fazendo a mesma coisa, usando Generics (C #) para obter a mesma funcionalidade. Neste ponto, eu provavelmente poderiarefatorar ainda mais para torná-lo ainda melhor, mas é "bom o suficiente" - o código está bem escrito, segue padrões de design e conceitos de engenharia adequados e é extensível. Eu o refatoraria apenas novamente se os requisitos me obrigassem a reavaliar o código ou se houvesse um recurso de idioma que pudesse tornar o código mais claro e / ou mais legível.