A eficiência de custo relativa do desenvolvimento orientado a testes (aceitação)


15

Gostaria de saber qual é o impacto geral do planejamento de recursos em um projeto de software, onde os requisitos e o design do projeto são conduzidos por testes de aceitação automatizados e testes de unidade, em contraste com uma abordagem mais "tradicional" ao desenvolvimento de software.

insira a descrição da imagem aqui

Na sua experiência, qual é o efeito geral nos requisitos de recursos para a conclusão de um projeto de software no TDD, em oposição a metodologias de desenvolvimento mais "tradicionais"? Parece-me evidente que a qualidade aumentaria e a quantidade de incerteza diminui porque os testes são feitos anteriormente, mas exigir testes antecipados parece exigir mais horas do desenvolvedor para ser realizado. Quanto o esforço de desenvolvimento aumenta ou diminui de fato devido à eliminação antecipada de bugs?

Quanto mais esforço é necessário do cliente? Eles precisam mudar a maneira como se relacionam com o projeto, especialmente se forem usados ​​para grandes projetos de frente? O número de horas necessárias do cliente em geral aumenta ou diminui realmente?

Eu imagino que as estimativas de tempo seriam muito vagas em um processo iterativo de TDD no início de um projeto de TDD (já que não há Plano de Desenvolvimento de Software). Existe um ponto, digamos, 20% em um projeto, em que a confiança aumenta o suficiente para que uma estimativa de tempo e dinheiro mais ou menos estável possa eventualmente ser fornecida ao cliente?

Nota: Não estou procurando opiniões ou teorias subjetivas aqui, por isso não especule. Estou procurando mais pela experiência do mundo real em TDD.


Tenho certeza de que não há dados do mundo real. Você só obtém opiniões e teorias subjetivas baseadas na experiência do mundo real das pessoas.
Euphoric

1
@Euphoric: estou procurando observações objetivas e realidades baseadas na experiência do mundo real. Desculpe, não deixei isso claro. No entanto, não preciso de números concretos; Aceitarei impressões gerais como: "enquanto nosso tempo de desenvolvimento aumentou substancialmente, nossos custos de manutenção diminuíram porque o software era mais confiável e o cliente entendeu melhor o software porque participou do design durante todo o esforço de desenvolvimento".
Robert Harvey

2
Então, essa é uma pergunta baseada em opinião? Certamente soa como um #
29/07


@ BЈовић: Veja o último parágrafo no meu corpo da pergunta.
Robert Harvey

Respostas:


11

A primeira coisa que precisa ser declarada é que o TDD não aumenta necessariamente a qualidade do software (do ponto de vista do usuário). Não é uma bala de prata. Não é uma panacéia. Diminuir o número de bugs não é por isso que fazemos TDD.

O TDD é feito principalmente porque resulta em melhor código. Mais especificamente, o TDD resulta em um código que é mais fácil de alterar .

Se você deseja ou não usar o TDD, depende mais de seus objetivos para o projeto. Será um projeto de consultoria de curto prazo? Você é obrigado a apoiar o projeto após a entrada em operação? É um projeto trivial? A sobrecarga adicionada pode não valer a pena nesses casos.

No entanto, é minha experiência que a proposta de valor para TDD cresce exponencialmente à medida que o tempo e os recursos envolvidos em um projeto aumentam linearmente.

Bons testes de unidade oferecem as seguintes vantagens:

  1. Os testes de unidade alertam os desenvolvedores sobre efeitos colaterais não intencionais.
  2. Os testes de unidade permitem o rápido desenvolvimento de novas funcionalidades em sistemas antigos e maduros.
  3. Os testes de unidade fornecem aos novos desenvolvedores uma compreensão mais rápida e precisa do código.

Um efeito colateral do TDD pode ser menos erros, mas, infelizmente, é minha experiência que a maioria dos erros (principalmente os mais desagradáveis) geralmente são causados ​​por requisitos pouco claros ou claros ou não seriam necessariamente cobertos pela primeira rodada de testes de unidade.

Para resumir:

O desenvolvimento na versão 1 pode ser mais lento. O desenvolvimento na versão 2-10 será mais rápido.


1
Gosto da justaposição explícita de "código melhor" ser diferente de aumentar "a qualidade do software", ou seja, o que os programadores valorizam no código não é necessariamente o que o cliente deseja.

1
Os testes de aceitação antecipada e os testes de unidade não devem esclarecer os requisitos?
Robert Harvey

@RobertHarvey Eles deveriam ser, mas não são necessariamente . Os testes de unidade e de aceitação refletirão a compreensão do desenvolvedor sobre os requisitos quando eles forem escritos. Os desenvolvedores podem ter desde um entendimento completo até o não entendimento dos requisitos quando começam a escrever o software. Essa parte da equação depende muito mais do cliente e do gerente de produto do que qualquer outra coisa. Teoricamente, os testes devem ajudar muito. Na prática, bem, "depende".
29413 Stephen

1
Devo esclarecer, estamos falando sobre TDD isoladamente aqui, não sobre uma implementação SCRUM que incorpora TDD. Isoladamente, o TDD tem tudo a ver com escrever testes, para que você escreva um código melhor e possa refatorar mais rápido e com segurança mais tarde.
29413 Stephen

1
@ Stephen: Talvez eu devesse ter deixado mais claro que estou falando sobre o sabor do TDD que incorpora testes de aceitação como parte do processo de coleta de requisitos. Eu adicionei um gráfico à pergunta para deixar isso mais claro.
Robert Harvey

6

Há um capítulo em Making Software about Test-Driven Development, que cita o artigo discutido aqui .

Os estudos de caso foram conduzidos com três equipes de desenvolvimento na Microsoft e uma na IBM que adotaram o TDD. Os resultados dos estudos de caso indicam que a densidade de defeitos de pré-liberação dos quatro produtos diminuiu entre 40% e 90% em relação a projetos semelhantes que não usavam a prática de TDD. Subjetivamente, as equipes experimentaram um aumento de 15 a 35% no tempo de desenvolvimento inicial após a adoção do TDD.

Se esses resultados são generalizáveis ​​para o seu caso, é claro que algo que os defensores do TDD argumentarão é óbvio e os detratores do TDD argumentam que é falso.


4
O problema desse estudo é que eles não testaram o código antes de adaptar o TDD. O TDD não é uma ferramenta mágica que diminui o número de defeitos em 40-90%, simplesmente adotando-o #
30713

1
@ BЈовић Eu não acho que eles reivindicam "mágica" em nenhum lugar desse jornal. Eles alegam que algumas equipes adotaram o TDD, outras não, receberam trabalho "semelhante" e algumas densidades de defeitos e tempos de desenvolvimento foram registrados. Se eles tivessem forçado as equipes não-TDD a escrever testes de unidade de qualquer maneira apenas para que todos tivessem testes de unidade, não seria um estudo ecologicamente válido.

Um estudo ecologicamente válido? Sorta depende do que você está medindo. Se você deseja saber se escrever seus testes antecipadamente é importante, todos precisam escrever testes de unidade, não apenas o grupo TDD.
Robert Harvey

1
@robert Harvey, é uma questão de confusão de variáveis, não de validade ecológica. Projetar um bom experimento envolve gradientes. Por exemplo, se o grupo de controle estivesse escrevendo testes de unidade post hoc, as pessoas argumentariam que o experimento era doentio porque o grupo de controle estava trabalhando de uma maneira incomum encontrada na natureza.

2
Felizmente eu não disse que eram.

5

Eu não tenho nenhum trabalho de pesquisa ou estatística para dar a você, mas relatarei minha experiência de trabalhar em uma equipe / organização que historicamente teve uma cobertura de teste de unidade de baixa a média e nenhum teste de ponta a ponta, e gradualmente movendo a barra para onde estamos agora, com uma abordagem mais ATDD (mas, ironicamente, não TDD tradicional).

Especificamente, é assim que os cronogramas do projeto costumavam se desenvolver (e ainda se desenrolam em outras equipes / produtos na mesma organização):

  • Até 4 semanas de análise e implementação
  • 2 semanas de teste de regressão, correção de bugs, estabilização e preparação de lançamentos
  • 1-2 semanas de correção de defeitos conhecidos
  • 2-3 semanas de problemas de limpeza de código e pós-produção (defeitos desconhecidos / interrupções não planejadas)

Isso parece uma sobrecarga ridícula, mas na verdade é muito comum, mas geralmente é mascarada em muitas organizações por um controle de qualidade ausente ou ineficaz. Temos bons testadores e uma cultura de testes intensivos; portanto, esses problemas são detectados precocemente e corrigidos com antecedência (na maioria das vezes), em vez de serem permitidos a execução lenta ao longo de muitos meses / anos. O custo de manutenção de 55% a 65% é menor do que a norma geralmente aceita de 80% do tempo gasto na depuração - o que parece razoável, porque tivemos alguns testes de unidade e equipes multifuncionais (incluindo o controle de qualidade).

Durante o primeiro lançamento de nosso produto mais recente pela nossa equipe, começamos a adaptar os testes de aceitação, mas eles não eram muito bons e ainda tínhamos que confiar em muitos testes manuais. O lançamento foi um pouco menos doloroso do que outros, em parte devido à IMO, devido aos nossos testes de aceitação aleatórios e também devido à nossa cobertura muito alta de testes unitários em relação a outros projetos. Ainda assim, passamos quase duas semanas em regressão / estabilização e duas semanas em questões de pós-produção.

Por outro lado, todos os lançamentos desde o lançamento inicial tiveram critérios de aceitação e testes de aceitação, e nossas iterações atuais são assim:

  • 8 dias de análise e implementação
  • 2 dias de estabilização
  • 0-2 dias combinados de suporte e limpeza de pós-produção

Em outras palavras, progredimos de 55 a 65% para a manutenção de 20 a 30%. Mesma equipe, mesmo produto, a principal diferença é a melhoria progressiva e a racionalização de nossos testes de aceitação.

O custo de manutenção é de 3 a 5 dias para um analista de controle de qualidade e de 1 a 2 dias para um desenvolvedor. Nossa equipe tem 4 desenvolvedores e 2 analistas de controle de qualidade, então (sem contar UX, gerenciamento de projetos etc.), isso é um máximo de 7 dias / homem em 60, o que aumentarei até uma sobrecarga de implementação de 15% apenas para continuar o lado seguro.

Gastamos 15% de cada período de lançamento desenvolvendo testes de aceitação automatizados e, no processo, podemos cortar 70% de cada lançamento fazendo testes de regressão e corrigindo erros de pré-produção e pós-produção.

Você deve ter notado que a segunda linha do tempo é muito mais precisa e também muito mais curta que a primeira. Isso foi possível graças aos critérios de aceitação iniciais e aos testes de aceitação, porque simplifica enormemente a "definição de concluído" e nos permite estar muito mais confiantes na estabilidade de uma versão. Até agora, nenhuma outra equipe teve êxito com um cronograma de lançamento quinzenal, exceto talvez ao fazer lançamentos de manutenção razoavelmente triviais (somente correção de bugs, etc.).

Outro efeito colateral interessante é que conseguimos adaptar nossa programação de lançamentos às necessidades dos negócios. Uma vez, tivemos que prolongá-lo para cerca de três semanas para coincidir com outro lançamento, e conseguimos fazê-lo enquanto fornecíamos mais funcionalidades, mas sem gastar tempo extra em testes ou estabilização. Em outra ocasião, tivemos que reduzi-lo para cerca de 1 ½ semanas, devido a feriados e conflitos de recursos; tivemos que trabalhar menos com desenvolvedores, mas, como esperado, pudemos gastar correspondentemente menos tempo em testes e estabilização sem introduzir novos defeitos.

Portanto, na minha experiência, os testes de aceitação, especialmente quando realizados muito cedo em um projeto ou sprint, e quando bem mantidos com os critérios de aceitação elaborados pelo Dono do produto, são um dos melhores investimentos que você pode fazer. Diferentemente do TDD tradicional, que outras pessoas apontam corretamente, está mais focado na criação de código testável do que no código sem defeitos - o ATDD realmente ajuda a detectar defeitos muito mais rapidamente; é o equivalente organizacional de ter um exército de testadores fazendo um teste de regressão completo todos os dias, mas muito mais barato.

A ATDD o ajudará em projetos de longo prazo realizados no estilo RUP ou (ugh) Waterfall, projetos com duração de 3 meses ou mais? Eu acho que o júri ainda não participou. Na minha experiência, os riscos maiores e mais feios em projetos de longo prazo são prazos irrealistas e requisitos variáveis. Prazos irreais farão com que as pessoas tomem atalhos, incluindo atalhos de teste, e alterações significativas nos requisitos provavelmente invalidarão um grande número de testes, exigindo que sejam reescritos e potencialmente aumentem a sobrecarga da implementação.

Tenho certeza de que o ATDD tem uma recompensa fantástica para os modelos Agile, ou para equipes que não são oficialmente Agile, mas têm agendas de lançamento muito frequentes. Eu nunca tentei em um projeto de longo prazo, principalmente porque nunca estive em uma organização ou sequer ouvi falar em fazê-lo nesse tipo de projeto; portanto, insira o aviso padrão aqui. YMMV e tudo isso.

PS No nosso caso, não é necessário nenhum esforço extra do "cliente", mas temos um Dono do produto em tempo integral dedicado que realmente escreve os critérios de aceitação. Se você está no ramo de "consultoria", suspeito que pode ser muito mais difícil fazer com que os usuários finais escrevam critérios úteis de aceitação. Um Dono / Gerente de Produto parece ser um elemento essencial para fazer o ATDD e, embora eu possa mais uma vez falar apenas da minha própria experiência, nunca ouvi falar do ATDD ser praticado com sucesso sem que alguém cumpra esse papel.


Isso é muito útil, obrigado. Não me ocorreu que o ATTD possa mudar o caráter do esforço do TDD, mas faz sentido, especialmente quando você ouve sobre pessoas capazes de produzir software bem escrito e relativamente livre de erros, dentro do prazo e do orçamento, sem erros. utilizando necessariamente testes de unidade extensivamente.
Robert Harvey

@RobertHarvey: Devo esclarecer - ainda criamos testes de unidade, mas não como parte de um processo TDD. Normalmente, os testes de aceitação vêm primeiro ou em paralelo com o desenvolvimento inicial, depois o código é concluído, depois os testes de unidade e a refatoração. Às vezes, pensei que o TDD ajudaria certos desenvolvedores a escrever um código melhor, mas ainda não posso fazer o backup. Embora eu possa falar por mim mesmo - muitas vezes pego muitos bugs e falhas de design no meu próprio código simplesmente durante o processo de escrever os testes de unidade.
Aaronaught

1

Requisitos de Recursos

Na sua experiência, qual é o efeito geral nos requisitos de recursos para a conclusão de um projeto de software no TDD, em oposição a metodologias de desenvolvimento mais "tradicionais"?

Na minha experiência, o custo de exigir testes iniciais é imediatamente atenuado, definindo um critério de aceitação claro antecipadamente e depois escrevendo para o teste. Além de mitigar o custo dos testes iniciais, também achei que geralmente acelera o desenvolvimento geral. Embora essas melhorias na velocidade possam ser eliminadas por uma definição deficiente do projeto ou pela alteração de requisitos. No entanto, ainda somos capazes de responder muito bem a esses tipos de mudanças sem impacto grave. O ATDD também reduz significativamente o esforço do desenvolvedor na verificação do comportamento correto do sistema por meio de seu conjunto de testes automatizados nos seguintes casos:

  • grandes refatores
  • atualizações de plataforma / pacote
  • migração de plataforma
  • atualizações de ferramentas

Isso pressupõe uma equipe familiarizada com o processo e as práticas envolvidas.

Envolvimento do cliente

Quanto mais esforço é necessário do cliente?

Eles precisam estar muito mais envolvidos de forma contínua. Vi uma enorme redução no investimento antecipado, mas uma demanda muito maior em andamento. Não medi, mas tenho certeza de que é um investimento de tempo maior para o cliente.

No entanto, eu descobri que o relacionamento com o cliente melhora bastante após cinco demonstrações, nas quais eles vêem seu software lentamente tomar forma. O comprometimento de tempo do cliente diminui um pouco ao longo do tempo, à medida que um relacionamento é desenvolvido, todos se acostumam ao processo e às expectativas envolvidas.

Estimativa do Projeto

Eu imagino que as estimativas de tempo seriam muito vagas em um processo iterativo de TDD no início de um projeto de TDD (já que não há Plano de Desenvolvimento de Software).

Descobri que geralmente é uma questão de quão bem definida é a solicitação e se o (s) líder (es) técnico (is) é (s) capaz (s) de cardar (incluindo a estimativa do cartão) o projeto. Supondo que o projeto seja bem elaborado e você tenha uma média de velocidade razoável e desvio padrão, descobrimos que é fácil obter uma estimativa decente. Obviamente, quanto maior o projeto, maior a incerteza, razão pela qual eu geralmente divido um projeto grande em um projeto pequeno, com a promessa de continuar mais tarde. Isso é muito mais fácil quando você estabelece um relacionamento com o cliente.

Por exemplo:

Os "sprints" da minha equipe duram uma semana e temos uma média de rodadas e um padrão. desvio das últimas 14 semanas. Se o projeto é de 120 pontos, temos uma média de 25 e um valor padrão. desvio de 6 e estimar a conclusão de um projeto é:

Project Total / (Mean Velocity - (2 * Std. Deviation) = 95% Time Estimate
120           / (25            - (2 * 6             ) = 9.2 weeks

Nós usamos o 2 Std. Regra geral de desvio para nossa estimativa de confiança de 95%. Na prática, geralmente concluímos o projeto no primeiro padrão. desvio, mas acima da nossa média. Isso geralmente ocorre devido a aprimoramentos, alterações etc.


Então, basicamente, o que você está dizendo é que o TDD melhora o esforço de desenvolvimento, incentivando as partes interessadas a fazerem o que deveriam fazer de qualquer maneira, como fornecer requisitos claros e acionáveis ​​e critérios de aceitação.
9788 Robert Harvey

1
Bem, não é só isso. À medida que o projeto avança, o aumento da participação permite uma melhor conversa entre os desenvolvedores e as partes interessadas. Ele permite coisas como desenvolvedores que oferecem alternativas menos dispendiosas à medida que o entendimento do que as partes interessadas desejam é aprimorado. Ele permite que as partes interessadas alterem os requisitos mais cedo, pois percebem que as coisas estão faltando ou não funcionarão sem uma resposta tão antagônica do dev; e sem muitas das expectativas irracionais que geralmente vêm das partes interessadas.
dietbuddha

-1

exigir testes antecipadamente parece exigir mais horas do desenvolvedor para ser realizado. Quanto o esforço de desenvolvimento aumenta ou diminui de fato devido à eliminação antecipada de bugs?

Na verdade, isso não é verdade. Se seus desenvolvedores estão escrevendo testes de unidade (e deveriam), o tempo deve ser aproximadamente o mesmo ou melhor. Eu disse melhor, já que seu código será completamente testado e eles terão que escrever apenas o código para atender aos requisitos.

O problema com os desenvolvedores é que eles tendem a implementar coisas que não são necessárias para tornar o software o mais genérico possível.

Quanto mais esforço é necessário do cliente? Eles precisam mudar a maneira como se relacionam com o projeto, especialmente se forem usados ​​para grandes projetos de frente? O número de horas necessárias do cliente em geral aumenta ou diminui realmente?

Isso não deveria importar. Quem faz os requisitos deve fazê-lo da melhor maneira possível.

Se você desenvolve uma maneira ágil de desenvolvimento, isso não significa um grande design antecipadamente. Porém, quanto melhores forem os requisitos, a arquitetura e o design - a qualidade do código aumentará e o tempo para concluir o software diminuirá.

Portanto, se eles gostam de fazer BDUF, deixe-os fazer. Isso tornará sua vida mais fácil como desenvolvedor.


1
Pelo que entendi, TDD e BDUF geralmente não são compatíveis entre si.
Robert Harvey

3
O BDUF geralmente não é compatível com quaisquer boas práticas de gerenciamento de desenvolvimento. Mas seria possível fazer um projeto BDUF de forma TDD. O TDD é uma técnica para criar software de melhor qualidade, enquanto o BDUF é uma técnica para obter requisitos. Uma técnica ruim, mas ainda assim uma técnica.
29413 Stephen

@RobertHarvey Certo, mas se eles querem fazer o BDUF - a escolha é deles. Se você realmente está agilizando, está livre para melhorar o design e ainda fazer TDD.
BЈовић

então você diz que, se eu escrever teste de unidade, meu código será completamente testado e se todos os testes forem aprovados, isso significa que o software está livre de bugs (ou pelo menos melhor). Então, eu só preciso testar todos os métodos do meu software, por exemplo "função testSqr () {int a = 3; assertTrue (mySqr (a) == 9);} função mySqr (int a) {return 9;}"
Dainius

@ Dainius Não, leia novamente. 100% de cobertura de código não está livre de bugs. Sim, você precisa testar todos os métodos. Obviamente, o acesso à base de dados de teste de unidade, a GUI etc. não faz sentido. Os testes de unidade não são para aqueles.
BЈовић
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.