Gostaria de fazer algumas perguntas sobre código sujo. Existem alguns iniciantes que codificaram em um projeto médio. O código é uma enorme bola de barro. Eles não são programadores avançados. Eles apenas sabem como usar o teclado um pouco sobre java. Eles apenas escreveram código com 12.000 linhas em sua classe principal, no entanto, 6.000 linhas pertencem ao próprio NetBeans.

Meu trabalho é analisar o código e sugerir uma boa maneira de manter o código. Minha idéia é descartar o projeto e iniciar um novo com a metodologia OOP. Recentemente, coletei algumas notas e idéias sobre o problema, neste site e em outros.

Agora, tenho as seguintes perguntas:

1. Devemos reparar o código e alterá-lo para um OOP? Agora estamos depurando.
2. O código não possui comentários, documentação, estilo particular de programação e assim por diante. Mudá-lo é realmente caro e demorado. O que podemos fazer sobre isso?
3. Como posso ensiná-los a seguir todas as regras (comentários, POO, boa qualidade de código etc.)?
4. O código está incorreto e propenso a erros. O que podemos fazer? Testando? Quase escrevemos dois ou três papéis A4 para correção, mas parece interminável.

Eu deveria dizer que sou novo com eles. Eu acho que violei as regras sobre adicionar pessoas muito tarde ao projeto também. Você acha que eu tenho que deixá-los?

Etapa 0: Faça backup no SCM

Porque, como sugerido por JBRWilkinson nos comentários, o controle de versão é sua primeira linha de defesa contra desastres (irreversíveis).

Também faça backup dos detalhes de configuração do software, procedimentos para criar entregas, etc.

Etapa 1: teste primeiro

Então comece escrevendo testes :

• pelo que funciona,
• e pelo que falha.

Não importa o que você decida fazer, você está coberto. Agora você pode:

• comece do zero e reescreva ,
• ou conserte .

Meu conselho seria iniciar a arquitetura geral do zero , mas extrair da bagunça as partes que validam os pontos de verificação e refatorá-las como achar melhor.

Etapa 2: verificar e monitorar

Configure um sistema de integração contínua (para complementar as etapas 0 e 1 ) E um sistema de inspeção contínua (para preparar a etapa 4 ).

Etapa 3: Ficar nos Ombros dos Gigantes

(como você sempre deveria ...)

• Refatorando para padrões
• Refatoração: melhore o design do código existente .
• Trabalhando efetivamente com o código herdado ( recomendado por Jason Baker )
• Refatoração

Etapa 4: limpar

Isso é desnecessário, mas em vez de analisar o código você mesmo, convém executar linters / analisadores estáticos e outras ferramentas na base de código quebrada para encontrar erros no design e na implementação.

Então, você também pode querer executar um formatador de código, que já ajudará um pouco na limpeza.

Etapa 5: Revisão

É fácil introduzir pequenos erros refatorando ou limpando as coisas. É preciso apenas uma seleção errada e um toque rápido em uma tecla, e você pode excluir algo bastante importante sem perceber a princípio. E às vezes o efeito aparecerá apenas meses depois. Obviamente, as etapas acima ajudam você a evitar isso (especialmente implementando um forte equipamento de teste), mas você nunca sabe o que pode e o que passará. Portanto, certifique-se de revisar suas refatorações por pelo menos um outro par dedicado de bolas de olho (e de preferência mais do que isso).

Etapa 6: teste seu processo de desenvolvimento para o futuro

Pegue todas as opções acima e torne-a parte inerente do seu processo de desenvolvimento usual, se já não estiver. Não deixe que isso aconteça novamente no seu relógio e trabalhe em conjunto com sua equipe para implementar salvaguardas em seu processo e aplicar isso (se isso for possível) em suas políticas. Faça da produção de Código Limpo uma prioridade.

Mas realmente, teste . Muito .

Pessoalmente, eu não iniciaria esse projeto até ter uma cópia do Working Effective with Legacy Code à mão. Sério, ele foi escrito exatamente para esse tipo de coisa. Está cheio de estratégias para lidar com códigos complicados e entra em muito mais detalhes do que posso lhe dar aqui.

Eu estive lá várias vezes. Minha regra é: se o software não for trivial (mais de 1 semana de trabalho para o recurso que você possui) e funcionar, mantenha-o e continue com a refatoração incremental.

Se o software realmente não funcionar (número muito alto de bugs, requisitos pouco claros etc.), é melhor reescrevê-lo do zero. O mesmo se for bem pequeno.

O ponto da refatoração (como no livro de Fowler e no de Kerievsky, http://www.industriallogic.com/xp/refactoring/ ) é que ele mantém o sistema funcionando, talvez a refatoração demore duas vezes, mas os riscos são zero.

Reescrever do zero pode apresentar muitos riscos, desde requisitos de mal-entendidos até implementação incorreta (afinal a maioria da equipe será a mesma).

Na verdade, vi um procedimento complexo sendo reescrito do zero duas vezes e ainda não funcionando conforme o esperado.

Eu o reescreveria completamente. Às vezes é impossível reparar esse código. Outra opção é fazê-lo funcionar, sem adicionar novos recursos. Para ensinar a equipe a escrever um bom código (bem projetado, documentado e com testes), deixe-os corrigir o código que você possui agora. Permita a todos que corrijam bugs / revisem o código de outros desenvolvedores, não da parte dela. Após algumas tentativas, eles entenderão que é quase impossível revisar / corrigir esses códigos.

Adicionar pessoas a projetos atrasados ​​ajuda muito raramente. Geralmente ele quebra os prazos. Você deve fazer todo o possível para concluir o projeto com sucesso e depois pensar em sair.

Meu conselho será não descartar completamente o código inteiro. Esse é o problema da vida cotidiana, que toda equipe de desenvolvimento enfrenta. Ataque uma parte do código de cada vez. Corrija, limpe e documente. E depois vá para a outra parte. O principal é sempre manter algum código transportável à mão. Reescrever todo o código do zero levará a quantidade de tempo gasto até agora e não haverá garantia de que será melhor do que o atual.
Mas também as pessoas devem evitar escrever o código dessa maneira. Passe mais algum tempo nas revisões de código. Adapte-se a algum estilo de codificação uniforme. Discuta o design primeiro e depois escreva o código. Coisas simples assim farão grandes mudanças.

Bom blog dizendo por que o Netscape está solto

Se funcionar, refatorar. Existem ferramentas para ajudá-lo a fazer isso. Se não funcionar, use o comando de aprimoramento de código mágico, ou seja, deltreeno Windows resp. rm -rfno Linux.

Devemos reparar o código e alterá-lo para um OOP? Agora estamos depurando. [... contém erros, nenhuma documentação ...]

Eu estive lá, você tem minhas simpatias. Eu até escrevi um artigo sobre isso que pode ajudá-lo a ter alguma perspectiva. Mas em suma:

Se o código contiver muita duplicação, você deve reescrever. Se não houver uma estrutura discernível (sem interfaces claras, espaguete), a refatoração falhará e você provavelmente deverá reescrever.

Como posso ensiná-los a seguir todas as regras?

Comece explicando por que eles podem querer fazer isso, mostrando a eles o que podem ganhar com isso pessoalmente. Quando eles concordarem com isso e estiverem dispostos a aprender, comece a ensiná-los a usar shuhari .

Minha sugestão é uma combinação das respostas de @ duros e @Manoj R.

Comece do zero, lembrando-se de criar um bom código / OOP / comentado / etc, desta vez, consulte / copie e cole a partir do seu código antigo. À medida que você encontrar as partes ruins do seu código antigo, reescreva / refatore-as.

Se seus desenvolvedores não são bem treinados, acho bom enviá-los para os cursos. É importante para a reciclagem regular no setor de TI em rápida mudança