Test Driven Development e Pair Programming [fechado]

StackOverflow https://stackoverflow.com/questions/882661

Pergunta

Eu estou em uma equipe onde eu estou tentando convencer meus colegas a adotar TDD (como eu tê-lo visto trabalhar na minha equipe anterior ea configuração é similar). Além disso, minha opinião pessoal é que, pelo menos no início, ele realmente ajuda se ambos TDD e programação em pares são feitas em conjunto. Dessa forma, dois inexperiente (em TDD) desenvolvedores podem ajudar uns aos outros, discutir que tipo de testes para escrever e fazer bom progresso.

Meu gerente, por outro lado, sente que, se introduzir duas novas práticas de desenvolvimento na equipe de uma vez, há uma boa chance de que ambos podem falhar. Então, ele quer ser um pouco mais conservador e introduzir qualquer um.

Como faço para convencê-lo de que ambos são complementares e não ortogonais. Ou estou errado?

Foi útil?

Solução

Eu não tenho certeza de que ter mais pessoas que não sabem o que estão fazendo em TDD vai ajudar. Ele vai descer rapidamente em ambos pesquisando o assunto, ou ambos você discutindo sobre exatamente o que TDD é / não é.

Eu acho que você seria melhor de conseguir alguém da equipe para se tornar o evangelista para uma determinada técnica (alguém vai e lê-se no TDD, alguém vai e lê-se na programação em pares) e tem aquelas pessoas, em seguida, promover e julgamento aquelas coisas. Sim, ambos podem acontecer ao mesmo tempo, mas eles não tem que ser usado em toda a equipe do projeto. Você poderia ter um pequeno grupo de sua equipe fazer a programação em pares e, em seguida, apresentar um relatório sobre as suas experiências.

Outras dicas

Par programação é eficaz quando aprender uma nova prática especialmente TDD

Assim, você pode ter ambos com um compromisso. Faça isso de forma ágil, de forma incremental. Assumir a programação em pares primeiro. É o mais fácil dos dois. Todas as práticas após a programação em pares se tornará muito mais fácil de aprender e será adotado pela equipe mais rapidamente e com maior consistentcy. A programação em pares é um dos primeiros, se não o primeiro treino engineerring que devem ser adoptadas. Certifique-se de que é feito de forma eficaz. Abaixo está uma descrição de como fazer a programação em pares.

programação emparelhado é uma das práticas mais potentes uma equipe de desenvolvimento pode usar no desenvolvimento de software. O emparelhamento ocorre com dois desenvolvedor ativamente desenvolver um cartão de história usando um único computador e teclado. Os gerentes temem que o uso de programação emparelhado vai dobrar seus custos de programação. À primeira vista, é compreensível que eles podem pensar que - depois de todos os desenvolvedores --Dois estão sendo convidados a trabalhar juntos na mesma tarefa. Na prática, no entanto, as equipas ágeis utilizando esta técnica de desenvolvimento descobriram que o ligeiro aumento de custos para o desenvolvimento inicial (15% de acordo com um estudo da Universidade de Utah) são mais do que compensado por uma redução nos defeitos, um teste mais curta e menos dispendiosa ciclo e menor necessidade de suporte de produção.

Embora possa parecer contra-intuitivo que ter programadores par e trabalhar em conjunto melhora a produtividade, há uma série de razões pelas quais esta técnica realmente funciona (Pense no velho ditado: "Duas cabeças pensam melhor que uma.") Aqui está o porquê:

  • Melhor qualidade - O emparelhamento incentiva revisão do código. Muitos erros pego como eles são digitados. programação emparelhado significa revisão de código contínuo feito por duas pessoas que estão comprometidos com a qualidade do código e estão trabalhando em conjunto para identificar e erros de correção em todos os momentos. Um estudo feito pela Universidade de Utah descobriram que o número final de defeitos encontrados em código foi reduzida em 15% em média para o código escrito por pares.
  • Menos tempo gasto "Stuck" - Programação é difícil. Muitas vezes os desenvolvedores se esforçam para encontrar uma solução e passar mais tempo do que deveriam "preso". Ter um parceiro para debater idéias com e concordar em procurar ajuda se necessário reduz a quantidade de tempo improdutivo gasto preso tentando encontrar uma solução.
  • Menos tempo gasto em Distrações -. Um desenvolvedor é o tempo gasto menos provável em chamadas pessoais de telefone ou navegar na web, ou férias de e-mail quando ele ou ela está trabalhando com um parceiro
  • duas perspectivas são aplicadas ao problema - Diferentes níveis de experiência, diferentes estilos de resolução de problemas, habilidades diferentes auxiliares tudo aumentar as chances de resolver um problema mais rápido. O estudo feito pela Universidade de Utah também identificou melhor design global e comprimento de código mais curto para o software escrito por pares.
  • Menos medo do desconhecido - Ao emparelhar com outro desenvolvedor é mais fácil de resolver um problema ou tentar obter uma alça sobre a nova tecnologia do que é quando se trabalha sozinho. Eles também ganham, ao longo do tempo, uma compreensão muito melhor de toda a aplicação. No final, o projeto acaba com várias pessoas entender cada peça do sistema como resultado de emparelhamento.
  • Menos provável construir no Âmbito - Muitas vezes os desenvolvedores de bom grado adicionar funcionalidade não abordados nos requisitos. Ao trabalhar com um par, o segundo desenvolvedor é mais propensos a manter seu / sua parceiro na tarefa.
  • Melhoria da Team Dynamics - Devido à abordagem emparelhado, as pessoas aprendem a trabalhar em conjunto. Eles falam com mais frequência e experimentar um melhor fluxo de informação. dinâmica da equipe melhorar como resultado. Na verdade, descobrimos que a melhor equipe edifício experiência em torno está a trabalhar em conjunto para software produzir o seu cliente está animado. ama a todos fazer parte de uma equipa de sucesso.
  • Eliminação de Silos de Knowledge - Domínio conhecimento, o conhecimento do código ou práticas são rapidamente propagado através do par de equipe e desenvolvedor uns com os outros em uma base de rotação
    • .

Uma vez que a equipe está confortável com o emparelhamento, em seguida, tomar em TDD. A destription seguinte:

Test-Driven Development (TDD) é uma prática de engenharia de desenvolvimento de software que consiste em breve explosão de desenvolvimento em que um novo caso de teste que cobre a melhoria desejada ou nova funcionalidade está escrito primeiro, depois o código de produção necessário para passar no teste é implementado, e, finalmente, o software é reformulado para acomodar mudanças. A disponibilidade de testes antes de desenvolvimento real garante feedback rápido após qualquer alteração. Praticantes enfatizam que o desenvolvimento orientado a testes é um método de concepção de software, não apenas um método de teste. desenvolvimento orientado a testes é uma prática poderosa e um dos principais contribuintes para a redução de defeitos encontrados mais tarde no ciclo de vida. A nova equipe é fortemente encorajado a par com um praticante de experiência TDD ou não receber TDD coaching.e

desenvolvimento orientado-teste exige que uma unidade de teste automatizado, requisitos do código que define, é escrito antes de cada aspecto do próprio código. Estes testes contêm afirmações que são verdadeiras ou falsas. A execução dos testes dá uma rápida confirmação de comportamento correcto como o código evolui e é reformulado. frameworks de testes baseados no conceito xUnit fornecer um mecanismo para criar e executar conjuntos de casos de teste automatizadas. Ciclo de Desenvolvimento Test-Driven:. A seqüência a seguir é baseado no livro de Desenvolvimento Teste-Driven por exemplo, que muitos consideram ser o texto de origem canónica sobre o conceito em sua forma moderna

  1. Escrever um teste. No desenvolvimento orientado a testes, cada novo cartão história começa com a escrita de um teste. Este teste irá falhar porque está escrito antes de o recurso foi implementado. A fim de escrever um teste, o desenvolvedor deve entender a especificação e os requisitos do recurso de forma clara. Isto pode ser conseguido através de História Cartões com critérios de aceitação para especificar quando os requisitos tem sido se encontram. Isso também poderia implicar uma invariante, ou modificação de um teste existente. Esta é uma característica diferenciadora do desenvolvimento orientado a testes contra escrever testes de unidade após o código está escrito:. Torna o foco desenvolvedor sobre os requisitos antes de escrever o código, uma diferença sutil, mas importante
  2. Executar todos os testes e ver se a nova falha. Isso valida que o equipamento de teste está a funcionar correctamente e que o novo teste não engano passar sem necessidade de qualquer novo código. O novo teste também deve falhar a razão para o esperado. Esta etapa testa o teste em si, negativa:. Que exclui a possibilidade de que o novo teste será sempre passar, e, portanto, ser inútil
  3. escrever algum código. O próximo passo é escrever algum código que fará com que o teste para passar. O novo código escrito nesta fase não será perfeito e pode, por exemplo, passar no teste de uma maneira deselegante. Isso é aceitável porque etapas posteriores irá melhorar e aprimorar-lo. É importante que o código escrito é projetado apenas para passar no teste; não mais (e, portanto, não testado) funcionalidade deve ser previsto e 'permitiu' em qualquer fase.
  4. Execute os testes automatizados e vê-los a ter sucesso. Se todos os casos de teste agora passar, o programador pode ter certeza que o código preenche todos os requisitos testados. Este é um bom ponto de que para começar a etapa final do ciclo.
    5. código
  5. Refactor. Agora, o código pode ser limpo, se necessário. Ao re-executar os casos de teste, o desenvolvedor pode ter certeza que a refatoração não é prejudicial qualquer funcionalidade existente. O conceito de eliminação de duplicações é um aspecto importante de qualquer projeto de software. Neste caso, no entanto, também se aplica à remoção de qualquer duplicação entre o código de teste eo código de produção-., Por exemplo, números mágicos ou cordas que foram repetidas em ambos, a fim de fazer o teste passar no passo 3

Repetir

Começando com outro novo teste, o ciclo é então repetido para empurrar para a frente a funcionalidade. O tamanho dos passos pode ser tão pequeno como o desenvolvedor gosta, ou ficar maior se ele / ela se sente mais confiante. Se o código escrito para satisfazer um teste não rapidamente fazê-lo, então o passo-size pode ter sido muito grande, e talvez os passos testáveis ??menores deve ser usado em seu lugar. Ao usar bibliotecas externas É importante não fazer incrementos que são tão pequenos quanto a ser efetivamente apenas testando a própria biblioteca, a menos que haja alguma razão para acreditar que a biblioteca é buggy ou não é suficientemente completo de recursos para atender a todas as necessidades do principal do programa que está sendo escrito.

Estilo de desenvolvimento Há vários aspectos para usar o desenvolvimento orientado a testes, por exemplo, os princípios de "Keep It Simple, Stupid" (KISS) e "yagni" (YAGNI). Ao se concentrar em escrever apenas o código necessário para passar por testes, os projetos podem ser mais limpo e mais clara do que é frequentemente alcançado por outros métodos. desenvolvimento orientado a testes exige que o programador primeiro falhar os casos de teste. A idéia é garantir que o teste realmente funciona e pode pegar um erro. Uma vez que este é mostrado, o ciclo normal terá início. Este foi cunhado o "Mantra Test-Driven Development", conhecida como / refactor vermelho / verde, onde vermelho significa falhar e verde é passagem. desenvolvimento orientado a testes constantemente repete os passos de adicionar casos de teste que falham, passando-os, e refatoração. Receber os resultados do teste esperados em cada fase reforça modelo mental do programador do código, aumenta a confiança ea produtividade aumenta

Você está absolutamente correto que par-programação irá ajudar imensamente quando aprender algo novo. Concordo com você que você deve empurrar com força para fazer as duas coisas.

Talvez a melhor maneira de colocá-lo para o seu gerente não é sugerir que você está pedindo para introduzir essas duas coisas novas ao mesmo tempo. Em vez disso, sugerem que você sente a maneira mais eficiente para começar a implementar TDD é, e ainda obter o trabalho feito, é tomar apenas dois desenvolvedores como a "equipe de investigação TDD" e tê-los trabalhar juntos para obter as ferramentas adequadas definidas, aprender a técnicas, testá-las e descobrir o que você precisa fazer para aplicá-los em seu ambiente. Uma vez que você tem que trabalhar, e tem duas pessoas que têm um pouco de experiência com ele, então eles têm que se separaram e cada sentar-se com outro desenvolvedor por alguns dias para trazer esse outro desenvolvedor até a velocidade sobre as novas técnicas. Repita até que todos os desenvolvedores aprenderam TDD.

Você não convencer. Diga-lhe as razões você acha que ambos trabalham juntos, talvez apresentar alguns dados que confirma isso, e deixá-lo decidir. Se você precisa convencer a todos que é uma boa idéia, eu estou apostando que ninguém vai levar a ele muito bem. oposição Natual.

Pessoalmente eu encontrei a programação em pares funciona melhor com um experiente e um inexperiente.

Ou seja, eu apontaria para uma diferença na habilidade / exp de programadores ao invés de tentar corresponder uniformemente qualificado.

os mais experientes fica mais fora do que de explicação e sendo forçado a pensamentos estrutura enquanto o inexperiente fica chance de ideias salto e pegar 'melhores práticas'.

como para TDD, eu sou um grande fã. Novamente exp ajuda o inexperiente porque ajuda realmente trazer para fora o ponto do teste. Ou seja, você não quer testar absolutamente tudo ... ele adiciona foco. Muitas vezes acho que as pessoas estão escrevendo testes sem foco sobre o que eles estão tentando alcançar.

Os testes unitários são essenciais imo ... afinal, alguns funcionários não vai estar lá dentro de 2 anos. Como você pode alterar o código existente, se não há nada para verificar a sua função contra?

Bem, dependendo do gerente, você pode apontar para alguns argumentos na literatura XP que estas práticas são interdependentes. Por exemplo, se você não tem testes de unidade sólida, não refatorar impiedosamente.

Eu sugiro que você abordá-lo de forma incremental, em que o emparelhamento seria apenas para o propósito de descobrir o TDD, como qualquer esforço de colaboração em um novo problema difícil, não que "todo o desenvolvimento da produção será feito em pares."

Enquanto uma prática não exige que o outro, há um 'sorrateira' maneira de introduzir tanto um pouco de cada vez.

Comece com o objetivo de implementar TDD usando um dos frameworks xUnit disponíveis. Encontrar um colega de trabalho compatível e perguntar se por cerca de uma hora por dia eles estariam dispostos a trabalhar com você. "Shawn, estou tentando esta nova ferramenta, você iria me ajudar a ter certeza que eu estou fazendo certo?" funciona muito bem.

Depois de um par de dias com Shawn, repita com Susan ...

Faça-o de qualquer maneira. Se as capturas gerente você emparelhamento, dizer as palavras mágicas "Code Review"
Assunção: Obviamente, o par deve ser disciplinado / focado código de trabalho suficiente e produzir no final da sessão

Escrever alguns testes que chamar a atenção para os erros existentes na base de código - em seguida, mostrar-lhes a seu chefe, eu acho que ele pode de repente concordam TDD é uma boa idéia

!
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top