Um bate-papo sobre TDD

6.657 visualizações

Publicada em

Apresentação sobre TDD e design, feita no DNAD 2010.

Publicada em: Tecnologia, Turismo
0 comentários
2 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

Sem downloads
Visualizações
Visualizações totais
6.657
No SlideShare
0
A partir de incorporações
0
Número de incorporações
4.692
Ações
Compartilhamentos
0
Downloads
72
Comentários
0
Gostaram
2
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide


  • quem aqui faz tdd? quem aqui nao faz tdd?
  • pratica de desenvolvimento de software popularizada pelo kent beck em 2001
    a mecânica é simples: você deve escrever um teste antes de escrever o código de produção
  • muitas!
    diferentes perspectivas
  • testes automatizados são bons! queremos isso!
  • refatorar com testes automatizados é muito fácil e seguro!
    medo ao refatorar sem isso!
  • tem teste no nome...
    muitas definições confusas...
  • provando por teoria dos conjuntos.. eles não tem nada em comum a não ser os testes de unidade! nenhum livro de TDD fala sobre elas!
    - vc pensa em muitas outras coisas quando quer testar!

  • isso mesmo! parece maluquisse?
  • e pensar eh bom! :)
  • só de escrever três linhas de código, eu penso sobre um monte de coisa...
  • o teste é o primeiro cliente
    - muitas vezes você está mudando um código que nem existe ainda!
  • TDD é uma das práticas que te dão feedback mais rápido sobre o seu código!
    - só perde pra programação pareada!!
  • TDD diz explicitamente que você deve fazer sempre o mais simples possível. Se seguirmos isso, teremos código simples, que é legal! :)
  • o que vocês gostariam de por numa classe dessa?
  • grande parte da simplicidade eh baseado nisso! chega de adivinhação! o programador só escreve o que realmente precisa!
  • mas daqui a pouco eu critico a maneira que as pessoas entendem isso!
  • claro que não né! nao existe bala de prata!
  • tdd não vai resolver seus problemas de design!
  • - vai escrever um código que seja fácil de testar...
    - existe uma sintonia muito grande entre código fácil de testar, e código de alta qualidade
  • pq isso acontece? pq você começa a receber as dependências da classe, geralmente pelo construtor! se vc não faz isso, você não consegue testar!
    - uncle bob diz que gerenciar dependencias eh a parte mais complicada do desenv de sw
  • você escreve classes mais fáceis de serem usadas.. os comportamentos são mais fáceis de serem invocados, você não quer perder tempo configurando o objeto pra usar e etc!
  • se você pergunta pra todo mundo qual a vantagem de TDD, todo mundo diz: é receber as dependências pelo construtor! agora fica fácil injetar qualquer coisa lá!

  • ele evidencia os problemas do seu design
  • eh você, programador, que resolve o problema!
  • se você conseguir ver o problema, já é meio caminho andado!!
    ver é a parte mais difícil !
  • a maioria deles você percebe basicamente quando está difícil testar! eu, preguicoso, nao quero escrever muito código no meu teste, nao quero pensar muito ali... se eu tenho que pensar muito, algo tá errado!
  • uma God Class é uma classe que é acoplada com outras 20 classes... ela conhece um monte de classes, geralmente coordena trabalhos, mas não tem inteligência nenhuma...

  • explica o código
  • veja que a classe CounterPartyFinder é usada apenas pela MessageUnpacker... Pq não passar a dependência pra ela?
  • Agora podemos ver que essa regra de negócio pode ser encapsulada dentro de outro objeto menor e mais específico, com um nome que faça sentido ao domínio...
  • yay!
  • TDD tem tudo a ver com dependências! eu jah falei que ajuda a pensar melhor nelas? pois é...
  • softwares de gente grande são gigantes e vai ser inevitável acoplar classe com classe...
    a diferença é que TDD faz com que você acople de uma maneira diferente..
  • classes estaveis sao classes que tem menos chance de mudar! imagina uma interface com 10 classes que a implementa? você nunca vai mudá-la, certo?
    agora imagina depender de uma classe chamada DriverDaEpson? a chance de mudar é grande, concorda? Porque você não liga de acoplar com IList?
  • logo, queremos acoplar com classes mais estáveis do que a classe cliente. Devemos ir sempre em direção à estabilidade. TDD ajuda nisso, já que você pensa melhor na interface que você precisa depender, e isso geralmente produz interfaces/classes mais estáveis.
  • você começa a observar diferentes tipos de dependências
    - dependencies, notifications e adjustments
  • dependencies você deve tomar cuidado! elas são imprescindiveis pro seu sistema! então tente ao maximo acoplar com classes estáveis!
    - notifications de alguma forma podem ser removidas do código, e extraídas, como no exemplo...
  • parecem notifiers, não?
  • lembra do SRP?
  • refatorado para observer... agora quem quiser ser notificado sobre a geracao da nota, torna-se um observer, e será notificado assim que a nota for gerada... isso desacopla o GeradorDeNotaFiscal do resto do processo, e permite que evolua de maneira mais fácil!
  • se vc sente necessidade de testar um método privado, é pq provavelmente essa classe não está coesa! ela tem coisa demais, e vc sente necessidade de testar essas responsabilidades separadas.
  • você começa a extrair esses comportamentos e colocar em classes menores e mais coesas!!
  • é mais fácil compor comportamentos do que criar uma classe com todos os comportamentos
  • imagina agora para escrever todos os testes.. era complicado! precisávamos extrair o comportamento para algum lugar...
    - outro exemplo: criar filtros... se tal campo foi postado, então adicione isso na condição, e por aí vai...
  • a primeira refatoracao eh levar cada filtro para uma classe especifica (depois pode ter uma factory para montar os filtros)...
    veja que ficou facil customizar o comportamento de um filtro, além de ser muito mais fácil testar: agora o número de combinações para cada um deles é muito menor!
  • classes pequenas sao mais simples!
  • a ideia é dar passos de bebê em direção à solução mais simples
  • - a ideia de ficar retornando constantes e acrescentando um monte de if é besteira!
    - o proprio kent beck diz que nao faz assim
  • - o objetivo principal é a solução mais simples e não a mudança mais simples!
  • implementação você refatora mais fácil ! design é difícil refatorar!
    - ao implementar uma funcionalidade, você deve refatorar o código (e o design) para permitir que essa funcionalidade seja adicionada da maneira mais fácil possível.
  • - acoplamento muito forte
    - nao dá pra substituir sem mágica!
    - quero evoluir sem precisar mexer em código que já existe (OCP)
  • - deve-se tomar cuidado para não deixar o conceito vazar da classe
  • veja a API do asp.net mvc! Precisa mockar muita coisa para testar o HttpRequest
  • - deve-se pensar na melhor abstração
    - lei de demeter
  • - Tell, Don’t Ask
  • ajuda a entender o requisito melhor, e isso gera código mais perto do domínio
    - levantado como uma das partes mais benéficas do processo pelas pessoas no encontro ágil
  • classes que você não consegue dar um bom nome tem algo errado... talvez o conceito não esteja muito claro!
  • ouça eles! eles tem muito a dizer!



  • ×