Como você lida com o código feio que você escreveu? [fechadas]

Então, seu cliente pede que você escreva algum código, e você também. Ele então muda as especificações sobre você, como esperado, e você implementa diligentemente os novos recursos dele como um bom rapaz. Exceto ... os novos recursos meio que entram em conflito com os antigos, então agora seu código está uma bagunça. Você realmente quer voltar e consertar, mas ele continua solicitando coisas novas e toda vez que você termina de limpar alguma coisa, acaba uma bagunça novamente.

O que você faz? Pare de ser um maníaco do TOC e apenas aceite que seu código vai acabar uma bagunça, não importa o que você faça, e continue insistindo nos recursos dessa monstruosidade? Salvar a limpeza para a versão 2?

Consiga outro emprego e deixe que outras pessoas lidem com ele. Muahahahhahahaa.

.....

Apenas brincando. :)

Mas com toda a seriedade: o preenchimento de estimativas é seu amigo. Geralmente faço uma estimativa realista decente e depois a dobro. Isso pode parecer excessivo, e às vezes é, mas é melhor superestimar um pouco e até parecer um pouco lento às vezes - do que deixar más impressões desativando o código do buggy e sempre exagerando suas estimativas. E, é claro, você incorre em dívidas técnicas ao deixar a base de código pirateada.

Outra dica (relacionada): sempre estime tarefas aparentemente minúsculas e sem esforço para um bloco de tamanho decente. Digamos, por exemplo - um item que você tem quase certeza de que será apenas uma alteração simples de uma linha e 30 segundos - dê 1 hora (ou talvez seja o menor intervalo de tempo no quadro de horários ou no sistema CR, por exemplo, 15 minutos / 0,25 horas) . E ofereça blocos de meio dia ou 1 dia para os itens um pouco maiores, mas ainda relativamente triviais.

A razão para isso é principalmente psicológica: acho que, se você adquire rapidamente o hábito de fazer pequenas alterações, o trabalho parece apressado e nunca acaba sentado, fazendo um balanço e refatorando coisas que precisam ser refatoradas. Além disso, em um nível prático: mudanças pequenas, mas não triviais, às vezes surgem, e você não quer estar constantemente se sentindo como se estivesse atrasado e apagando insetos. É parte integrante do motivo pelo qual as bases de código são invadidas com o tempo.

Por fim, lembre-se sempre de que as pessoas não precisam saber que você está preenchendo um pouco suas estimativas. Desde que você seja um desenvolvedor competente e comece a trabalhar em um ritmo decente, esse preenchimento não será perceptível. ou seja, não diga ao PHB "Minha estimativa inicial é que levará duas horas, mas me dê meio dia". Apenas diga a ele: "Acho que levará cerca de meio dia". e deixe lá.

Superestime deliberadamente o tempo necessário para seus próximos recursos. Use esse tempo extra para limpar.

Você nunca será capaz de justificar a manutenção, e o cliente precisa dela independentemente, portanto, dê a eles o remédio amargo (custos ligeiramente aumentados para os próximos recursos) para que eles possam melhorar.

Tente fazer um novo design adequado ao integrar novos recursos. Não há mais tarde. Sem o redesenho, você está constantemente adicionando cada vez mais atrito para novas alterações e novos recursos.

Em algum momento, você chegará a uma trituração, onde tudo parece levar séculos. A maioria das empresas provavelmente vai para a grande reescrita neste momento, versão 2. Ela tem uma economia muito ruim e é um bom momento para o seu cliente tentar uma outra parte do desenvolvimento, se sentir vontade.

O redesenho / refatoração adequados podem proteger o investimento de seus clientes e manter as coisas sustentáveis. Você precisa incorporar isso. Otimize para mudanças, viaje com pouca bagagem.

Com todos os comentários sobre superestimar, acho que há uma quantidade modesta de pontos (boas oportunidades) perdidos.

Não se trata de estimar o tempo necessário para fazer a alteração (apenas) e, em seguida, adicionar um pouco, trata-se de estimar o tempo necessário para modificar o código (refatorar!) Para chegar a um ponto em que a alteração possa ser feita com segurança e depois mudança (provavelmente um pouco munged juntos). Ok, isso equivale à mesma coisa ... mas não se trata de fingir, esticar ou superestimar, é simplesmente uma questão de dizer que, para fazer isso, primeiro preciso fazer isso e é quanto tempo levará no total. A chave aqui é que você trabalha naquelas partes do sistema das quais a mudança depende e não mais - se houver código horrível em outro lugar ... difícil, pegue-o quando estiver lá.

Voltando um pouco à pergunta original - depois de muitos anos, isso se resume a isso para mim, quando você implementa algo a menos que saiba (não acredite, não espere (suspeito?), Não pense, mas saiba ) que coisas adicionais são Também é necessário, então você deve fazer o que for necessário para implementar esse requisito e não mais da maneira mais arrumada e elegante possível.

Quando você implementa a próxima coisa - algum tempo depois -, você executa as etapas necessárias para levar a base de código (e o banco de dados e o que for) ao estado necessário para implementar essa funcionalidade da maneira mais arrumada e elegante possível. Essa refatoração é onde você lida com a bagunça que surge naturalmente à medida que o projeto evolui - e esperamos evitar criar mais bagunça (ou pelo menos manter o nível consistente).

Uma das áreas de discussão aqui é "Dívida técnica" - é como um cheque especial, você precisa pagá-lo e quanto mais tempo o deixar, mais juros (neste caso, tempo necessário para corrigir) você acumulará - o que lhe dará uma boa argumento para gastar parte do seu tempo minimizando a dívida técnica.

É também aqui que começam os testes de unidade e outros testes automatizados (se eu pudesse fazer o que digo, tenho certeza de que seria uma pessoa mais feliz!) Combinada com um servidor de compilação adequado (que pode executar pelo menos alguns dos seus testes). Combinados com esses - mas com valor em si mesmos - existem padrões como injeção de dependência e inversão de controle (nunca se sabe o quanto esses "são iguais"), porque facilitam a troca de canalizações e, portanto, lidam com as mudanças nos isolamento.

Por fim - lembre-se, se não estiver quebrado, não conserte. Organizar seu código exclusivamente para organizá-lo pode ser satisfatório, mas também é uma oportunidade de introduzir erros, embora possa ser doloroso se você não precisar alterá-lo e não estiver desenvolvendo, pode ser melhor deixar alguns caroços sozinho - a oportunidade de consertar ou substituir eventualmente chegará!

1) O controle adequado da mudança é seu amigo

Se o cliente alterar a especificação, isso é seu direito; no entanto, é uma alteração e ela precisa ser cobrada (ou custada de qualquer maneira que seja apropriada à estrutura / relacionamento do projeto).

A estimativa para essa mudança deve incluir o custo da refatoração necessária . O cliente pode se confundir com o que parece ser um custo alto, mas nesse momento você precisa explicar a ele que, como o código já está meio escrito, há elementos que precisam ser reescritos para garantir que sejam robustos e suportáveis ​​no futuro e que se isso não for feito, é provável que ele tenha problemas futuros com o suporte futuro ou as alterações se tornem ainda mais caras.

2) A refatoração deve ser realizada de modo a proporcionar um benefício genuíno a longo prazo ao cliente

Ao considerar a refatoração, você sempre deve considerar o que é realmente necessário e o que é importante e garantir que o trabalho de refatoração forneça uma genuína relação custo / benefício a longo prazo.

Afinal, devemos fazer essas coisas para que o código permaneça extensível e suportável a médio / longo prazo, para garantir que o investimento do cliente permaneça válido e não fora de qualquer unidade de perfeição teórica. O trabalho de refatoração (e as estimativas correspondentes) deve ser feito com esse escopo, e não apenas porque agora você acha que pode haver uma maneira um pouco melhor de fazê-lo.

Alguns programadores sugerem que uma maneira de controlar esse problema com os clientes é fazer com que o cliente assine e autorize a especificação inicial. ENTÃO, quando eles solicitam uma alteração de requisito que não esteja na especificação inicial, você diz a eles que precisa seguir o contrato e o cronograma do projeto para calcular custos adicionais e atrasos de tempo e, em seguida, fazer um anexo ao contrato. Aparentemente, ele faz maravilhas ao impedir que os clientes insistam em novos recursos (imprevisíveis).

Eu tenho o seguinte comentário em uma base de código em que estou trabalhando atualmente:

/*
 * Every time I see this function, I want to take a shower.
 */

Eu sei muito bem a situação que você está descrevendo. O que faço é tentar (o meu melhor) esperar até que as coisas se acalmem e qualquer tipo de 'creep' rasteje tudo o que vai fazer. Naquele momento, você provavelmente tem algo utilizável liberado e pode levar algum tempo para limpar as coisas e implementar as coisas de maneira um pouco diferente.

Você não pode correr por aí limpando muitas pequenas bagunças repetidamente. Isso apenas triplica o seu trabalho e a frustração. Espere que ele se torne maior, mas dificilmente se mexa, e então você pode fazer algo a respeito.

Minha preferência é evitar essa situação em primeiro lugar.

Tudo depende de como você lê as especificações. É fácil pensar nelas como tábuas de pedra, mas, na realidade, a maioria das especificações muda. Ao criar seu código, analise a probabilidade de alteração de cada parte da especificação. Com o tempo, você ficará muito bom em prever isso.

Tendo entrado na bagunça, a experiência e o julgamento são muito importantes. Você está escrevendo novos bugs por causa desse código de espaguete? está demorando mais para implementar? isso apontaria para fazer um refator tático.

para o futuro, parece que você precisa trabalhar em parceria com seu cliente. Dizendo a eles: "veja que este produto está se expandindo significativamente além das especificações originais. Embora o design original tenha sido bom para esse nível, expandi-lo na direção X e nas direções Y, você precisa de alguma reestruturação no design" bem administrado, e você poderá obter cliente a pagar por isso.

Carregue por hora e, se ele quiser mudanças, diga que está bem, mas incorpore o tempo necessário para escrever um bom código na equação. Lembre-se também de que escrever código mais limpo compensa a longo prazo quando você precisar mantê-lo. Economizar tempo agora pode custar mais tarde.

Eu acho que escrever software precisa andar de mãos dadas com as necessidades da empresa. Se for um projeto descartável (como um protótipo que precisa ser construído em uma semana, com novas entradas chegando todos os dias), não há necessidade de se preocupar com a manutenção do código e outras coisas - o tempo é crucial e você só precisa empurre seu código para fora da porta o mais rápido possível.

Mas se você estiver escrevendo um aplicativo de longo prazo, faz sentido considerar tudo isso, porque há um impacto considerável em quanto tempo leva para criar novos recursos, corrigir erros existentes, integrar-se a outros aplicativos e outras coisas - e isso se traduz em impacto nos negócios (devido a mais tempo necessário posteriormente e mais custo).

Portanto, é melhor sensibilizar o tomador de decisão para os custos reais de não refatorar o código sempre que necessário - na minha experiência, se o custo e o impacto no tempo de ambas as opções forem explicados em termos mensuráveis ​​ao proprietário da decisão, a decisão poderá ser uma acéfalo. Não espere que as pessoas lhe digam 'sim, vá em frente, escreva um código bonito, mesmo que demore o dobro do tempo e não me dê nenhum benefício extra'. Simplesmente não funciona assim.

Faça parte do seu processo, eu chamo de "refatoração extrema" e será grande! ;) Faça as coisas rapidamente e quando forem adicionados novos recursos suficientes que contenham tecido cicatricial, refatore-o. Pergunte-se continuamente "Agora, se eu tivesse começado do zero, como eu teria feito isso"

As pessoas que pensam que podem projetar e pensar em tudo no início estão se enganando, você (e seu cliente) sempre aprende as coisas à medida que avança. Use essas lições.

Como você é um bom programador, poderá refatorar rapidamente e, à medida que o faz continuamente, o código começará a ter sua "forma adequada", o que significa que se tornará mais flexível com menos dependências.

Os clientes podem ficar ofendidos se soubessem que você estava "desperdiçando tempo" reformulando as coisas, para que elas não ajudem a perguntar / contar e serem realmente rápidas.

O código desenvolvido dessa maneira economizará muito tempo no final e tornará cada vez mais fácil adicionar novos recursos.

Eu diria também que uma das maiores razões para um código incorreto é o medo que alguns programadores têm de fazer uma refatoração estrutural maior, e quanto mais você esperar, pior fica.

Confie em um poder superior

Não quero dizer rezar. Quero dizer, verifique se há um cara de negócios (ou seja, gerente de projeto ou equivalente) que você possa colocar como preenchimento entre você e o cliente. Se o cliente estiver exigindo demais, deixe o profissional de negócios colocar o pé no chão e estar pronto para exercer o "é factível, mas não tenho certeza se isso se encaixa no escopo da especificação, consulte [profissional de negócios]".

Em um fluxo normal de projeto, a especificação geral deve ser congelada antes que ocorra um desenvolvimento sério.

Muitos clientes continuarão a buscar mudanças / aprimoramentos / aprimoramentos enquanto você permitir. Muitos abusam dessa capacidade ao máximo, porque isso faz com que eles sintam que estão aproveitando ao máximo seu dinheiro (mesmo que isso sabote seu projeto).

Tenha uma pessoa dedicada a aperfeiçoar e congelar a especificação desde o início e aplicá-la mais tarde.

Não há nada errado em fazer um pouco mais por um pouco de bom karma com o cliente, mas esteja pronto para adiar para um poder mais alto quando ficar fora de controle. Se a especificação exigir uma quantidade ridícula de alterações, talvez seja hora de voltar ao ciclo comercial e reavaliar o contrato e / ou adicionar adições ao contrato (com compensação monetária justa).

O fato de você estar tendo esse problema tem pouco a ver com a maneira como você codifica. É um sinal de que seu gerente de projeto está subutilizado no projeto (seja sua culpa, culpa dele ou ambos).

Como outros já disseram em muitas respostas, também é necessário adicionar um buffer de tempo para contingências em qualquer projeto, mas determinar isso deve ser decidido a portas fechadas antes que a especificação seja congelada e entregue ao cliente pelo PM.

O design inicial adequado não pode ajudar a evitar o problema. E é quase impossível (ou muito, muito difícil) considerar todos os futuros requisitos "talvez". Então, depois de algum tempo, o Big Re-factoring chegará. E a melhor solução é reescrever tudo.

Em poucas palavras: em vez de colocar uma torre na Ferrari vermelha, reconsidere os requisitos e construa um tanque.

Matá-lo com fogo.

Aka refatorá-lo o mais rápido possível: por exemplo, quando um código feio vem da corrida para um prazo, eu refatoraria após o prazo porque você não pode (ou não deveria pelo menos) adicionar mais recursos até que o código existente possa ser mantido, caso contrário tornará muito mais difícil depurar códigos futuros.

Escreva testes de unidade para seus projetos que testam o estado atual e refatore quando tiver tempo, para evitar que o projeto seja interrompido enquanto você tenta limpá-lo.

Resposta mais simples. Eu pararia de codificar qualquer tipo, até que ele tenha uma especificação final para exatamente o que ele / ela quer a partir de agora.

Em seguida, eles precisam priorizar essa lista de recursos, etc., para confirmar quais itens devem ter agora e quais podem ser feitos posteriormente ...

Usando suas experiências para determinar qual é o tempo / custo de cada recurso e, em seguida, diga a eles, se eles querem isso, levará x quantidade de tempo e dinheiro.

Você está lidando com o grande crime de escopo de recursos, e eles continuarão adicionando recursos sem parar, até que nada seja feito ou feito tão mal.

Diga a eles que, depois de ter uma lista final, fará modificações futuras, como preferirem, mas precisará se concentrar nos 15/20 principais que eles devem ter no momento.

Depois, com base no tempo de conclusão, diga a eles que, após o lançamento, você estará aberto para discutir / debater a próxima versão.

Uma vez tomada a decisão final sobre o que deve ser feito para a versão atual, todas as discussões / idéias / sugestões devem ser interrompidas 100%.

Se ele receber as idéias sem parar, peça que as anote, na lista de recursos da próxima versão, e permita que você se concentre em fornecer os recursos mais importantes que eles desejam no momento.

Se eles continuarem a desperdiçar seu tempo, continue mudando de idéia. Então eu simplesmente pararia de trabalhar no projeto e trabalhar em outros projetos, até que eles finalizem suas decisões.

É difícil de fazer, mas a fluência no escopo dos recursos é tão destrutiva quanto ao tempo, energia, motivação e pensamento claro.

De uma perspectiva completa do projeto:

Aprenda com o código com sua equipe, veja o que pode ser refatorado e reutilizado na próxima vez e depois tome uma cerveja.

De uma perspectiva em desenvolvimento:

Pacientemente, explique por que o desenvolvimento parou e explique por que ele não pode continuar até que todas as especificações estejam na mesa e entendidas. Então, vá tomar uma cerveja.

De uma perspectiva de planejamento:

Solicite todas as especificações antecipadamente e trabalhe com todos para ter um entendimento claro do caminho do desenvolvimento. Envolva o cliente / partes interessadas o mais próximo possível para garantir que todos estejam na mesma página. Mais tarde naquela noite, pegue cervejas para todos. Amanhã, inicie o projeto.