É significativamente mais caro corrigir um erro no final do projeto?

Em um post de Andrew Hay , o seguinte axioma foi colocado:

Custa significativamente mais para corrigir um bug no final do projeto do que para corrigir o mesmo bug no início do projeto.

No entanto, isso não parece certo, especialmente depois de ler uma postagem no blog Less Wrong , e os dados que eu vi para fazer backup são extremamente antigos.

Esse axioma ainda está correto hoje?

Os únicos dados concretos que eu já vi são Boehm e Papaccio, Entendendo e controlando os custos de software .

Isso remonta a 1988 e foi um estudo de cerca de 80 projetos de software. Eles concluíram que uma decisão tomada com antecedência e corrigida com atraso poderia custar 50-200 vezes o que teria se tivesse sido corrigida com antecedência. Mas o tipo de decisão inicial que eles estão falando é em qual SO executar e em qual idioma e banco de dados usar.

Portanto, esses números podem ser exagerados em relação ao desenvolvimento de software atual. No entanto, agora temos muita experiência em campo e sabemos instintivamente que isso ainda é válido até certo ponto.

Extremamente, sabemos que se uma falha nos requisitos for detectada pouco antes de iniciarmos a produção, isso causa muito retrabalho e atrasa ou até o projeto do projeto, onde, se ele foi detectado antes de qualquer trabalho, teria ficado bem.

Edit: Doc Brown faz um bom ponto em seu comentário.

A pesquisa de Boehm foi realizada em projetos COBOL e FORTRAN em uma época em que os tempos de compilação e execução eram ridiculamente lentos. Comecei minha carreira no início dos anos 90 no COBOL e o ciclo de compilação e teste demorava tanto que valeu a pena o esforço de testar o código antes de passar pelo ciclo (ou pelo menos durante a fase de compilação, apenas no caso você pode pegar algo e cancelá-lo mais cedo, economizando uma hora ou mais).

Por sua vez, nossos chefes riam de nossas reclamações porque não faz muito tempo, eles tinham que carregar uma caixa de cartões perfurados escolhidos a mão para a sala do servidor e deixá-la lá por um dia.

Então era definitivamente mais verdadeiro do que é agora.

E, no entanto, muito recentemente, vi blogs reutilizando a visualização deste problema por Steve McConnell ( ref . Datada de 1996) como se esse gráfico fosse realmente baseado em números concretos. Não é. É uma visualização, para explicar seu argumento simplesmente.

Penso que a premissa de Morendil, no artigo citado pelo OP, é boa. A ciência que temos sobre esse assunto é pobre e desatualizada e, no entanto, tratada como cânone. Mas também acho que se mantém bem e soa verdadeiro, porque sabemos por experiência amarga que ainda é verdade, pelo menos até certo ponto. E acho que seu dramático fraseado de "disciplina doente" não lhe favorece.

Embora eu não esteja ciente de dados concretos ou outras evidências para apoiar essa afirmação, no mínimo , acho que é bom senso.

Pense dessa maneira. Se você possui um sistema complexo com subsistemas interdependentes (como a maioria dos aplicativos não triviais), pense em problemas indiretos que podem resultar de alterações feitas em qualquer um dos sistemas. Se subsistemas são provou ser correta (via testes de unidade e afins) e fixa cedo, o número de bugs que irá ser causado devido a knock-ons só são mitigados simplesmente através da fixação antecipada.

Além disso, se você estiver corrigindo bugs cedo, a implementação ainda estará fresca na mente do desenvolvedor. Dependendo da duração de qualquer projeto, se você estiver corrigindo erros no final, o desenvolvedor precisará dedicar um tempo para descobrir o que eles escreveram e (talvez) como os subsistemas dos quais seu código depende funcionam. Tempo gasto re-aprendendo isso = $.

Duvido que seja possível encontrar uma maneira cientificamente rígida de medir isso - existem muitos outros fatores envolvidos, e não há dois projetos comparáveis ​​o suficiente para servir como mais do que estudos de caso. O pensamento lógico deve levá-lo a um longo caminho. Alguns argumentos:

• A quantidade total de código em um projeto tende a crescer no final. Quanto mais você esperar para corrigir um bug, maior será a base de código em que você precisará tocar.
• A qualidade do novo código adicionado a um projeto diminui no final, pelo menos se houver pressão (o que geralmente é um dado): um prazo iminente faz com que as pessoas joguem as melhores práticas ao mar apenas para enviar a tempo. Isso significa que, quanto mais tarde você corrige um bug, mais código ruim é necessário analisar.
• Embora a duplicação de código geralmente seja desaprovada, isso acontece o tempo todo e, como é fácil copiar e colar, mas difícil re-mesclar seções de código duplicadas, a quantidade de código uma vez copiado e colado geralmente aumenta ao longo da vida útil de um projeto. Um código mais copiado e colado significa uma chance maior de que seu bug seja duplicado e precise ser encontrado e corrigido várias vezes (e consequentemente, uma chance maior de que algumas de suas ocorrências passem despercebidas).
• Corrigir um bug é uma alteração em uma base de código; você espera melhorar as coisas, mas uma mudança sempre traz um risco. Uma mudança que causa sérios problemas em um projeto que deve demorar meses deve deixar bastante espaço para o gerenciamento de danos, mas dois dias antes do envio, você terá sérios problemas.
• Quanto mais tempo o bug existir, maior será a probabilidade de que outras partes do aplicativo comecem a se comportar mal. Então, quando você o corrige, repentinamente libera vários bugs secundários no código que não esperam que sua função realmente forneça os resultados documentados corretos.

Isso é algo básico aceito pela engenharia de sistemas - e se aplica a qualquer forma de desenvolvimento técnico (seja a construção de pontes, mísseis, navios de guerra ou software).

Essencialmente, o custo das coisas sobe aproximadamente uma ordem de magnitude à medida que você avança nos estágios de desenvolvimento.

Algo que custa US $ 10 para corrigir no momento de conceber a idéia ...

Vai custar cerca de US $ 100 se você precisar fazer uma atualização da especificação ....

Ou custa cerca de US $ 1.000 se algo foi implementado e você precisa fazer alterações nesse ponto (e atualizar as especificações, obter as aprovações e assim por diante), mas não passou por algum tipo de teste formal de aceitação / venda

Ou custa cerca de US $ 10000 se algo foi implementado e aceito pelo cliente, e você precisa fazer alterações nesse ponto (e atualizar as especificações, obter as aprovações, testar novamente e executar novamente a aceitação e qualificação do cliente, etc.)

E o custo após a implantação / implantação / colocação em serviço é ainda mais uma vez.

Existem muitos exemplos e é fácil compreendê-los: um sistema bancário com uma alteração séria de escopo feita após a utilização de 25.000 funcionários, custará um pacote em um tempo de treinamento ... antes mesmo de considerar o escopo, a codificação, o teste, a regressão, etc etc etc

Obviamente, sua milhagem variará: os custos e os impactos da alteração do site de comércio eletrônico de aquecimento de meias eletrônicas de Fred Nurke são um pouco diferentes dos custos da alteração de software em um computador de controle de vôo de uma aeronave.

Como não tenho acesso a dados ou fatos concretos, só posso oferecer observações anedóticas recolhidas dos meus últimos 20 anos em TI.

Acredito que exista uma grande diferença entre a maneira como a maioria dos desenvolvedores cria software hoje em comparação com 20 anos atrás. Com o movimento Agile ganhando tanto impulso, principalmente nos últimos 5 a 6 anos, vi uma mudança real de atitudes no local de trabalho. Tanto é assim que a qualidade do que fazemos parece crescer aos trancos e barrancos a cada ano, e a cada projeto à medida que aplicamos as lições que aprendemos de um projeto para outro. Os processos mais enxutos, combinados com o foco no desenvolvimento do primeiro teste, passaram de muito controversos a comuns. Tanto é assim que, para entrar em muitas empresas hoje, se você não se sentir confortável com o Agile, terá sorte se elas não lhe mostrarem a porta.

Então, que impacto isso teve? Antes de tudo, notei que os problemas costumam ser identificados muito mais cedo. Frequentemente, se o problema não parecer muito grande, às vezes ele pode ser suspenso indefinidamente. Em um raro punhado de casos, vi bugs que eram considerados triviais se tornarem problemas sérios quando abordados mais tarde, pois se torna aparente uma questão fundamental que não foi considerada na época. Às vezes, isso pode levar a um ciclo de correção prolongado, e isso pode custar um certo grau, mas esse custo geralmente é medido menos em termos de recursos e, mais frequentemente, em termos do impacto no relacionamento entre cliente e desenvolvedor. Os clientes estão se acostumando com essa maneira de pensar ágil, que gera resultados muito mais rapidamente do que nos velhos tempos, com sprints de desenvolvimento altamente iterativos e rápida recuperação entre solicitações e implementação, eles esperam muito de nós. E, no que diz respeito aos bugs reais, o tempo para consertar um bug diminui com mais frequência devido à existência de um conjunto sólido de testes para dar suporte às mudanças e à capacidade de criar novos testes para fornecer informações e soluções. para os problemas relatados.

Portanto, no geral, parece que o esforço geral para corrigir erros foi, na maioria dos casos, reduzido se houver um conjunto robusto de testes e procedimentos para garantir que o teste continue sendo o foco do que o desenvolvedor faz, mas o custo real em alguns aspectos, mudou em parte, pelo menos da implementação, para outras áreas do negócio, porque, em alguns aspectos, o foco também mudou da oferta e demanda puras para o gerenciamento de relacionamentos.

Outra coisa que se tornou aparente é que nossos instintos intestinais de alguns anos atrás, que sugeriam que ser ágil reduziria nossos ciclos de manutenção, foram provados, tanto em certo quanto em errado. Bem no sentido de que testes sólidos tornaram mais fácil depurar e corrigir nosso código em grande parte e reduzir em geral o número de bugs lançados no código de produção, e errados no sentido de que agora estamos trabalhando mais para evitar a necessidade de manter o código legado, refatorando constantemente o código e aprimorando a arquitetura, para que fique cada vez mais raro o desenvolvimento de novos produtos completamente do zero.

Então, no final, o que isso significa com relação à pergunta do OP? Bem, isso significa que a resposta realmente não é tão cortante e seca quanto pensávamos que fosse. 15 anos atrás, eu provavelmente teria respondido a pergunta como um Sim, mas agora sinto que é mais realista dizer que é realmente muito difícil medir empiricamente, porque a natureza do que fazemos para desenvolver software mudou muito desde quando começamos a nos perguntar a pergunta do OP naquela época. De certa forma, quanto mais avançamos nossas técnicas e habilidades como indústria, mais a questão cresce de um sim definitivo, a um ponto em que suspeito que em um curto número de anos estaremos dizendo que isso não importa quando corrigimos bugs, porque nossos testes e processos serão muito mais robustos, que o tempo das correções será menos orientado pelos esforços para salvar nossos orçamentos e mais por prioridades para satisfazer as necessidades de nossos clientes, e o custo relativo tornam-se virtualmente sem sentido contextualmente.

Mas, como eu disse, isso não é uma evidência suportada por dados, apenas minhas observações dos últimos anos e meu intestino me dizendo que haverá mais sabedoria inovadora por vir que melhorará a maneira como fazemos as coisas.

Os bugs iniciais se propagam para outras partes do sistema; portanto, quando você corrige o bug, pode ser forçado a reescrever algumas partes do sistema que dependiam do próprio bug.

Além disso, com o tempo, você descobrirá como algumas partes do programa são construídas e precisará se lembrar. É uma forma de dívida técnica (se você apressar o projeto no estágio inicial, terá problemas para finalizá-lo devido aos atalhos que tomou).

É simples assim e não há nada a provar.

Acho que você está tentando apressar o projeto o mais rápido possível para apresentar uma solução funcional para seu funcionário. A boa notícia é que você a obterá muito rapidamente; a má notícia é que provavelmente nunca a terminará sem reescrever completamente se você continuar escrevendo porcaria o mais rápido possível e planejar consertar tudo em alguns meses. Você provavelmente nem será capaz de refatorar isso.

Bem, provavelmente não posso lhe dar a prova definitiva que você está pedindo, mas posso relatar um incidente bastante recente do meu trabalho.

Adicionamos um recurso que fornecia recursos de gerenciamento de fluxo de trabalho ao nosso produto. Itens típicos do BDUF, especificações assinadas e aprovadas pelo cliente. Implementado para especificação. Reclamações desde o primeiro dia na implantação.

Não tínhamos feito uma explicação real sobre usabilidade com o cliente, apenas aceitamos a palavra deles para o que eles queriam. Resultado: centenas de horas de retrabalho - a análise, o design, a implementação e o controle de qualidade tiveram que ser refeitos. Tudo porque a especificação perdeu casos de uso específicos. Um erro na especificação, se você preferir.

Já vi coisas semelhantes em trabalhos anteriores, quando alguém da cadeia faz suposições diferentes das suposições do usuário final. Os erros de codificação direta são relativamente fáceis de lidar, se detectados perto de quando ocorrem, mas os erros de design podem matar sistemas inteiros.

Se você corrigir o bug após o lançamento, terá o custo de encontrá-lo e corrigi-lo - o que pode ou não levar mais tempo / custo para ser feito após o lançamento. No entanto, você tem uma rodada de testes de integração, testes de regressão, testes de UA, atividades de lançamento etc. que precisarão ser contabilizados. A menos que a correção do bug ocorra com várias outras correções ou uma atualização de versão, você terá despesas adicionais com as atividades de teste e liberação que seriam evitadas com a inclusão da correção na liberação inicial - porque esses custos seriam compartilhados por várias correções / atualizações / recursos.

Considere também o custo que o bug causará em uso, se for apenas cosmético, provavelmente não importa, mas um bug de função ou desempenho pode criar um custo com atividades de suporte ou produtividade reduzida ou cálculos incorretos.

Pergunte à Intel quanto custa o Pentium Bug, o Ariane 5 Rocket é outro bom exemplo. Esses bugs foram corrigidos no final do projeto. Eu trabalhei em um sistema em que uma "tentativa" de uma liberação de software tem um orçamento de 6 dígitos. Nesses casos extremos, é fácil ver o custo. Em outros casos (a maioria?), O custo fica oculto pelo barulho, mas ainda existe.

Não há dúvida de que os bugs custam dinheiro enquanto existem. Um item, relatórios de defeitos, leva tempo para compilar, triar e fechar como dup, tempo é dinheiro - portanto, um bug aberto cria custos contínuos. portanto, deve ser que adiar a correção de custos custa mais do que corrigi-los antes.

Se um bug escapa à natureza, o custo dá um salto passo a passo ...... "O final do projeto" é anterior ou posterior ao lançamento do software?

Certa vez, li um artigo que tinha dois pontos interessantes (infelizmente as referências que eu tinha se foram há muito tempo, então terei que postular aqui). O primeiro ponto que eles enfatizaram foi que cerca de 50% de todos os erros foram introduzidos na especificação de requisitos e que cerca de 90% de todos os erros foram encontrados durante os testes do UAT ou do sistema.

O segundo ponto que eles tinham era que, para cada fase do modelo V, o custo aumentava 10 vezes. Se o fator está correto ou não, acho irrelevante, mas os erros mais caros ocorrem quando o design é baseado em uma suposição incorreta. Isso leva a uma enorme quantidade de reescritas. Todo o código que funciona por causa dessa suposição, mas falha quando a suposição correta é aplicada, terá que ser reescrita.

Eu experimentei que todo o modelo de domínio precisava ser reescrito por causa de uma suposição incorreta nas especificações de requisitos. Se um bug desse tipo for detectado cedo, ou seja, ao revisar as especificações de requisitos, o custo é muito baixo. Nesse caso em particular, seriam necessárias dez linhas de texto. No caso em que é encontrado durante o UAT (como foi), o custo é substancial (no exemplo dado, o custo do projeto foi aumentado em 50%)

Sem dados estatísticos, mas experiência pessoal:

O código de controle do motor de foguete em que eu estava trabalhando tinha uma linha parecida powerCutoff = someCondition && debugOptions.cutoffIsAllowed;. A opção padrão não era permitida. A compilação 'final' deveria remover todas as opções de depuração, portanto a linha foi modificada para powerCutoff = someCondition;.

Você capturou o bug durante a revisão de código? Nós não. A primeira vez que a condição do gatilho ocorreu no teste, causando um corte inesperado, foi apenas alguns meses antes do primeiro vôo.

Esse bug teria custado menos de uma hora se tivesse sido detectado durante a revisão. Pode custar um dia ou dois se for capturado durante a integração, causando uma única repetição de teste. Se ele foi capturado durante a qualificação formal, poderia custar uma semana ou duas, causando um reinício completo da série de testes com uma nova compilação.

Como foi, o custo aumentou. Primeiro, projetamos e executamos testes para determinar se a unidade de vôo poderia acionar a condição. Depois que foi determinada como uma possibilidade real, houve um custo para a engenharia, o gerenciamento e a análise do cliente da melhor correção, liberando a nova compilação, criando e executando um novo plano de teste de regressão, teste do sistema em várias unidades e simuladores. Ao todo, custam milhares, senão dezenas de milhares de horas-homem. Além dos 15 minutos originais para fazer a alteração correta do código.

Infelizmente, como muitas coisas, depende.

Se uma mensagem de diálogo estiver incorreta, pode ser 'trivial' para corrigir (atualizar string, reconstruir / empacotar, reimplementar). Ou, se um layout precisar de atualização, uma modificação em um arquivo .css pode ser suficiente.

Se o erro é que a saída de um método crítico com mais de 100 especificações e provas de página está incorreta, a investigação em si pode levar horas ou dias. É a isso que o velho 'axioma' se refere e o que, entre outras coisas, o TDD e o ágil estão tentando evitar (falhe cedo e claramente, faça um progresso incremental seguro, yada).

Da minha experiência recente com equipes de vários scrum em um único projeto, os 'bugs' geralmente são problemas de mesclagem / integração que aparecem apenas no final de um lançamento, à medida que as ramificações de recursos são promovidas para estáveis. Estes são os piores, pois os conflitos geralmente exigem suporte cruzado das equipes enquanto as equipes estão com pressa para concluir seus próprios objetivos, mas não sei se são mais caras que outros bugs, pois ocorrem quando ocorrem: no final o lançamento, mas o mais cedo possível. É isso que os torna os piores.