Quando é aceitável NÃO consertar janelas quebradas?

Em referência a janelas quebradas , há momentos em que é melhor deixar a refatoração para uma atividade futura?

Por exemplo, se um projeto para adicionar alguns novos recursos a um sistema interno existente for atribuído a uma equipe que não trabalhou com o sistema até agora e recebe um breve cronograma no qual trabalhar - pode ser sempre justificável adiar grandes refatorações para o código existente, a fim de cumprir o prazo nesse cenário?

A refatoração é - e deve ser - um processo contínuo. Não basta simplesmente atender aos requisitos com uma implementação testada e funcional que ainda está um pouco incompleta.

"Faça funcionar, depois faça funcionar melhor" .

Não me lembro onde li essa citação, mas essa é a chave para aplicar bem a refatoração, e considero pouco profissional fazer o contrário.

A refatoração contínua é como limpar os derramamentos durante o cozimento e limpar a louça após a refeição. A refatoração direcionada é como encontrar uma cozinha suja, mas ter apenas tempo para lavar um ou dois copos sujos. Você prefere viver com uma cozinha continuamente suja ou prefere manter as coisas limpas à medida que avança?

Você faz com que o código funcione e refatorá-lo para garantir que você tenha a melhor implementação possível. Se você estiver fazendo algo familiar, pode ser que você implemente o melhor código pela primeira vez, no entanto, demorará um momento para verificar novamente seu trabalho para ter certeza. Se parece que você pode melhorar seu código, tente refatorar para garantir que seu código seja no mínimo o mais enxuto e limpo possível. Isso significa que você está reduzindo o montante da dívida técnica que deixa para trás e facilita a leitura e a refatoração na próxima vez que o código precisar ser tratado. Esse é o valor principal por trás do mantra do TDD "Red-Green-Refactor", exceto que, no TDD, você refatora principalmente para remover a duplicação, vale a pena revisar também outros itens que podem ser refatorados, como classes grandes, métodos longos,

Se você se deparar com uma grande reformulação, talvez seja possível adiá-la por um tempo, principalmente se estiver com muito pouco tempo na sua programação. Porém, isso é fornecido desde que a funcionalidade do seu código não seja comprometida e também que a implementação continue atendendo aos requisitos. Esse tipo de situação deve ser uma ocorrência rara, e você pode ajudar a garantir que seja ainda mais raro se estiver refatorando continuamente à medida que avança. Ainda mais importante, porém, é que você não pode se arriscar a deixar suas grandes alterações por muito tempo; caso contrário, você acabará criando uma carga de trabalho ainda maior posteriormente, que pode ser muito mais dispendiosa para consertar ou pode resultar em um custo ainda mais caro. falha no projeto.

Tenho a impressão de que muitas pessoas tendem a confundir as definições de refatoração e reengenharia . Os dois termos descrevem estratégias para gerenciar situações muito diferentes. Se você deseja reprojetar, está assumindo o compromisso de fazer uma mudança drástica que alterará o comportamento de um sistema. Isso invalidará alguns testes e também exigirá novos testes. Ao refatorar, você garante que o sistema continue se comportando exatamenteda mesma forma que antes da alteração, no entanto, você também garante que seu código tenha longevidade e que será mais fácil manter com o tempo. Você não está "aprimorando" seu código, está comprometendo-se com um padrão profissional de código limpo que reduzirá o risco de falha e garantirá que seu código continue sendo um prazer trabalhar com ele e de um padrão profissional .

Voltando à analogia das janelas quebradas, se você quebrar a janela, deve repará-la imediatamente. Se você não percebeu que uma janela está quebrada, será necessário decidir o custo para você se deixar a janela quebrada. Agora, repita as duas frases anteriores, mas substitua Bug por window. Você acaba precisando de uma estratégia diferente. Se você criou um bug ao codificar, corrige-o imediatamente ou vê se as alterações exigirão um esforço de reengenharia e toma uma decisão comercial sobre quando será melhor resolver o problema. Para não refatorar para corrigir um problema, refatorar para garantir que seja mais fácil encontrar e corrigir problemas. Não me importo com o quão incrível você acha que seu código é, sistemas complexos sempre terão problemas que precisam ser tratados com o tempo. É disso que se trata a dívida técnica e por que a refatoração precisa ser um processo contínuo à medida que você implementa seu código , e não é deixada por um tempo arbitrário no futuro.

Portanto, em suma, a resposta que, em momentos raros, é aceitável adiar grandes alterações no código para estabelecer um prazo, no entanto, não deve ser considerada uma prática normal tratar a refatoração como um exercício independente do seu trabalho diário de implementação e certamente nunca usado como desculpa por equipes não familiarizadas com a base de código como uma opção para evitar garantir que sua implementação seja tão enxuta e limpa quanto possível, de acordo com as circunstâncias.

Alguns desenvolvedores dizem que estão "consertando janelas quebradas" quando estão "reorganizando as espreguiçadeiras no Titanic". O código de refatoração que funciona, mas ofende seu olfato, é relativamente fácil. Se você acha que continua voltando a esse tipo de tarefa em vez de adicionar novos recursos aos usuários ou tornar o aplicativo mais utilizável para eles (otimização significa tornar o aplicativo mais rápido é bom aqui, otimização significa tornar o código mais legível) diferente), então talvez você esteja arrumando demais. Não porque arrumar é ruim, mas porque a empresa está pagando pelo desenvolvimento para desenvolver algo. Eles não querem uma solução frágil, difícil de ler e mal arquitetada, com certeza, mas também não querem uma meia solução polida e bonita.

Organize quando você precisar fazer algo simples "seguir em frente", ou quando estiver esperando por outra equipe para lhe dizer se o seu problema é realmente culpa deles ou quando você estiver aguardando uma decisão. Haverá muitas oportunidades. Se você tiver a chance de mover o aplicativo inteiro para a frente, leve-o, a menos que esteja começando a sentir que tudo se tornou frágil. Provavelmente não. Você terá a chance de refatorar - não precisa se preocupar com isso.

Para voltar à segunda metade da sua pergunta, um sprint para adicionar recursos em uma linha do tempo curta, seria errado dizer "e não faremos nenhuma refatoração, não há tempo". Também seria errado dizer "sei que já faz 6 semanas e parece exatamente o mesmo para os usuários, mas essas janelas quebradas realmente precisam ser consertadas". Encaixe a refatoração nas lacunas que ocorrem em qualquer projeto. Não se refugie em arrumar às custas de atingir a meta do projeto.

Do ponto de vista comercial, a refatoração é um investimento especulativo - investindo tempo e esforço (dinheiro) agora, na esperança de economizar mais tempo e esforço (dinheiro) em algum momento no futuro.

Sem entrar no debate sobre quanto o esforço para refatorar economizará no futuro (isso depende de muitas variáveis ​​para que seja uma discussão significativa aqui), fica claro que é hora de refatorar quando o "valor presente líquido" do custo que sai excede o custo de fazer agora.

Isso é fácil, exceto que você não tem idéia de quanto custará o furture. Você também precisa considerar todas as idéias normais de planejamento financeiro, como retorno do investimento, gerenciamento de riscos (valor da marca, responsabilidade legal, risco segurável versus risco não segurável), custo operacional etc.

Na maioria dos casos, é melhor decidir quando refatorar para as pessoas que administram o negócio. Apesar do que muitos pôsteres deste fórum expressam, os gerentes geralmente sabem mais sobre o gerenciamento de negócios do que os programadores. Eles têm uma imagem maior em mente que inclui maximizar o retorno ao acionista. É raro que consertar coisas que não estejam quebradas contribui para isso, o código não é exceção.

Edit: Eu li um artigo interessante sobre agendas de manutenção em infraestrutura crítica. A essência é que o movimento está longe da manutenção de rotina (refator) para reparar quando necessário (consertar bugs). A principal diferença são os níveis de monitoramento - por exemplo, uma usina nuclear monitora em grandes detalhes e corrige quando "quebrada", mas muito antes da falha. O que foi encontrado é que a fixação em um esquema de manutenção não custa apenas mais, mas é menos confiável devido a interrupções causadas pelo programa de manutenção. Uma idéia semelhante é necessária para o software - refatorar os bits que estão prestes a quebrar - que você só pode saber por medição.

É aceitável quando o dano ao negócio, corrigindo-o, é maior do que não corrigi-lo.

As situações em que isso ocorre podem ser:

• onde um prazo ou oportunidade de negócio pode ser perdida devido ao tempo necessário para corrigir
• onde um trecho de código está (genuinamente) programado para ser retirado em uma escala de tempo muito curta, portanto, quase não há benefício em refatorá-lo.

E essas situações ocorrem - as situações comerciais costumam estabelecer prazos artificiais que precisam ser cumpridos quando a oportunidade de negociá-los se esgotar e requisitos que têm um componente temporal - por exemplo, uma mudança na legislação ou regras tributárias que entram em vigor. uma data específica - existe.

O truque é identificar essas situações e avaliá-las adequadamente. O código que está programado para ser aposentado geralmente permanecerá por anos. Os prazos artificiais podem precisar ser cumpridos, mas geralmente podem ser cumpridos de maneiras diferentes (por exemplo, o software pode ser apresentado, demonstrado e "lançado" em uma determinada data, sem que a versão final seja necessariamente finalizada mais tarde).

Quando apresentado a esse tipo de coisa, você precisa abordá-lo com a mente aberta, mas sempre perguntar: é o que parece? As premissas envolvidas são realistas? Existe outra maneira de atingir a meta sem enviar código abaixo do padrão? Se não houver, como melhor uso o tempo disponível?

E se não houver alternativa sempre boa, mas quando vamos resolver isso?

Porque deveria quase, quase, quase sempre ser quando , não se .

Se os gerentes decidirem que desejam acumular dívida técnica . Essa é uma decisão justa a ser tomada, se alguém, por exemplo, deseja apenas um protótipo antecipado para alguns clientes iniciais, para obter feedback antecipado.

Você pode pensar nisso da mesma maneira que pedir crédito. É aceitável pedir dinheiro emprestado para investir no X no curto prazo e pagar a longo prazo? Não existe uma resposta definitiva, ela pode ser do melhor interesse da organização (por exemplo, para atender às expectativas atuais do cliente) ou pode ser um desastre se for realizada de forma irresponsável.

Tudo se resume a prioridades, e a gerência deve estar ciente de que, embora a prioridade número um seja fazer com que o "código funcione", implemente novos recursos e atenda às expectativas do cliente, toda vez que você deixa janelas quebradas, torna a prioridade número um mais lenta , mais difícil e exigindo mais investimento em recursos. Além disso, 99% das vezes não é possível parar de desenvolver novos recursos e concentrar todos os esforços na "correção da base de código".

Concluindo, sim, às vezes é aceitável deixar janelas quebradas, assim como é aceitável pedir um empréstimo ... lembre-se de que você realmente precisa pagar por isso no futuro. E no futuro, o tempo para fazê-lo provavelmente não será muito maior do que o tempo que você tem agora.

Normalmente, quando você puder, deve corrigi-lo. Isso evitará o possível tempo gasto em manutenção. No entanto, algumas práticas bárbaras não-ágeis tendem a deixar o status quo enquanto durar. Alguns gerentes têm medo dos "efeitos imprevistos" da mudança.

Minha opinião é deixá-lo apenas se estiver funcionando como deveria (apenas quebrado pela otimização, mas não pela funcionalidade) e você não terá tempo para testá-lo, se fizer alguma refatoração. No entanto, observe que ele deve ser corrigido mais tarde, o mais rápido possível.

Se estiver quebrado pela funcionalidade e os novos recursos dependerem dele, seria melhor corrigi-lo o mais rápido possível.

A maioria dos programadores está no negócio de ganhar dinheiro para seu empregador. Então, quando a refatoração deve acontecer: quando você ganha dinheiro com firmeza. Refatoração é o tempo gasto não gasto em outros projetos e o tempo economizado no futuro nesse projeto.

Se vale a pena, depende principalmente do seu gerente.

Os programadores devem informar ao lado da empresa a extensão da dívida técnica, para que possam tomar uma decisão informada. Se a necessidade de chegar ao mercado mais cedo supera o risco do seu código, você não tem muita escolha. A falta de fluxo de caixa superará muitas decisões técnicas.

Para colocar alguns dos problemas em uma perspectiva não técnica, aponte o tempo estendido para corrigir bugs e adicionar novos recursos. Se a gerência possui um plano de vendas e marketing, eles podem entender isso. Eles odeiam ter que dizer aos clientes que essas coisas levarão mais tempo.

Se você está pensando em expandir sua equipe, talvez seja um bom momento para contratar um desenvolvedor júnior. A cobertura do teste será um grande salvador neste caso. Eles aprenderão mais fazendo do que lendo a documentação.

pode ser justificável adiar grandes refatorações para o código existente, a fim de cumprir o prazo nesse cenário?

• Se algo está quebrado, provavelmente não. Você não vai dirigir um carro com freios parcialmente trabalhando, não é? (A menos que o risco de não chegar a algum lugar a tempo seja maior do que o risco de travar por causa dos freios com defeito.) Longe da solução ideal, mas infelizmente isso acontece.

No entanto, se você estiver falando sobre refazer o código de trabalho, considere o seguinte:

• Se dependesse de nossos desenvolvedores seniores ou diretor técnico, nunca lançaríamos nenhum software. Nós sempre re-fatoramos e lutamos pelo perfeccionismo.

• Se a re-fatoração tiver um impacto negativo na lucratividade dos negócios, ela deverá ser remarcada.

• Se sua empresa prometeu entregar determinadas funcionalidades em uma determinada data, você deveria refatorar mais tarde. Pense na caridade do Red Nose Day - todos os anos, eles podem coletar doações por um período de 24 ou 48 horas. Não há como eles redefinirem sua base de código se acham que isso pode impedi-los de receber doações nesse intervalo de tempo. Além disso, se houver uma janela quebrada, mas isso não afetará a capacidade de receber doações, é bem provável que eles optem por não fatorar novamente.

• Você sempre encontrará uma maneira melhor de fazer alguma coisa. É um processo natural e é muito importante poder traçar uma linha.

Em resposta à sua pergunta sobre refatoração, eu diria "sim". Como alguém apontou nas respostas acima, a refatoração é um processo em andamento e, algumas vezes, há decisões táticas e de negócios que substituem a necessidade de reescrever o código que já está funcionando (embora talvez de uma maneira klugey).

Sobre "janelas quebradas": ouvi esse termo pela primeira vez no contexto de desenvolvimento de software, há cerca de 10 anos. Mas naquela época, era usado para descrever a permissão de testes de unidade quebrados . Isso descrevia o cenário em que as pessoas têm a tentação de não consertar testes de unidade quebrados, porque parece mais conveniente apenas lembrar quais testes são "aceitáveis ​​para falhar", em vez de consertar os testes quebrados (que foram validamente quebrados devido a interface ou requisitos alterações, por exemplo).

Penso que aplicar a metáfora da janela quebrada a testes de unidade quebrados é mais adequado e mais descritivo do perigo de permitir "janelas quebradas" na vizinhança do software. Na minha opinião, se você estivesse falando de testes de unidade quebrados (como janelas quebradas), a resposta seria que nunca está tudo bem. (Na medida em que podemos dizer nunca ...)

Se estiver realmente quebrado, deve ser corrigido.

Mas está realmente quebrado? Tem certeza de que não está apenas equiparando "não bonito" a quebrado?

Você precisa aplicar um cálculo de "valor irrecuperável" antes de redefinir o código de trabalho porque não gosta do estilo ou porque acha que isso causará problemas no futuro.

Para refazer o código que você escreveu na semana passada, o custo irrecuperável é o tempo que você gastou para codificá-lo na semana passada, não vale a pena se preocupar em saber se o código é substancialmente aprimorado.

Re-fatoração de código que passou por teste de unidade. Agora você não precisa apenas reescrever, é necessário redefinir e reexecutar todos os testes realizados até agora, isso está começando a parecer caro.

Re-fatoração de código que foi para produção. Ainda mais testes a serem feitos, além de uma implementação para os usuários e o risco de entregar algo que não funciona tão bem quanto a versão antiga. Você precisa justificar isso e limpá-lo com o grande chefe antes de prosseguir.

Re-fatorar código que entrou em produção por um tempo e passou por várias versões e correções de bugs. A menos que você saiba que o software vai parar de funcionar, nem vá lá!

Foi minha experiência que o prazo final é a coisa mais importante para os negócios. Realmente depende de quem usará seu aplicativo. No meu caso, era para o software do sistema operacional para celulares ... prazos perdidos significavam metas de vendas perdidas e acertos nos preços das ações.

Nos deparamos com muitos momentos do WTF quando analisamos o código que herdamos e claramente precisávamos ser alterados. No entanto, como esse código funcionou 'quase' (a assincronicidade é pouco compreendida), não havia incentivo para a gerência permitir a refatoração enquanto havia compromissos pendentes a serem cumpridos. Não foi até que um inseto fosse visto "em estado selvagem" que poderíamos mudar qualquer coisa, mesmo que pudéssemos quebrá-lo facilmente através de casos obscuros. Uma vez refatorei aproximadamente 10 mil linhas de código no meu tempo e acabei tendo que jogá-lo fora. O tempo necessário para testes e outras revisões etc. não poderia ser justificado.