Já faz um bom tempo que eu mudei o meu ciclo de desenvolvimento com testes do Red, Green, Refactor (ciclo tradicional de TDD) para algo um pouco diferente.

O que aconteceu foi que eu tinha muito problema para pensar nas unidades pequenas sem ter as unidades grandes. Ah? Basicamente eu não consigo pensar em como implementar sem estar resolvendo o problema.

Confuso ainda, certo?

Bom, digamos que eu queira implementar algo que transforme um html em uma árvore (basicamente, parsear html). Eu não consigo pensar em como eu faria para parsear a tag. Apenas consigo pensar em como funcionaria para o html. Algo como:


HtmlParseado html = new HtmlParser().
                  parse("<html><title>Conteudo</title></html>");

Somente no momento em que estou dentro do método parse que eu consigo pensar em como descobrir quais são as tags. Por que isso? Por causa da abstração.

No código acima não faz o menor sentido pensar nas tags, apenas no html completo. Dentro do método parse começa a fazer sentido procurar pelas tags.

Então o que tenho feito? Eu crio um ou mais testes que sobre a funcionalidade inteira (no caso, o que o parse deve fazer com o html).
Algo como:


@Test
public void testaQueOParserFunciona(){
  HtmlParseado html = new HtmlParser().
                 parse("<html><title>Conteudo</title></html>");
  Assert.assertEquals("html", html.getFirstChild().getTagName());
  ...
}

O problema é que esse teste é muito grande para guiar o desenvolvimento. O que eu faço então? Parto para o problema menor que é o reconhecimento de tags.

Como nesse ponto eu já consigo imaginar mais ou menos o que quero que aconteça, consigo criar os testes para fazer o reconhecimento de tags.
Mas durante todo esse tempo, o meu teste do ponto mais alto da abstração continua sem passar. Isso quebra com o RGR, mas me ajuda muito com o desenvolvimento da interface de uso.

Talvez eu tenha perdido um pouco na qualidade do código usando essa abordagem top-down, mas ganho bastante em termos de usabilidade desse código. Isso me força a pensar em primeiro lugar em como vai ser usada a funcionalidade final e não nos menores constituintes dela.

Outra coisa que esses testes me ajudam muito é a saber quando eu terminei a funcionalidade mais complexa.

O que acham disso? Já fizeram (ou fazem) algo semelhante?

Posts Relacionados:

  • Guia Latex - Parte IV: Estética (imagens e coloração)
  • “Free Software Song” de Stallman faz ações da Microsoft caírem
  • Sincronizando o Address Book do seu mac com os Contatos do Gmail
  • Tabelas assimétricas no LaTeX
  • Autores
    • The Red, Green, Refactor? by VidaGeek.net, unless otherwise expressly stated, is licensed under a Creative Commons Atribuição-Uso Não-Comercial-Compartilhamento pela mesma Licença 2.5 Brasil License.

    Acompanhe-nos por RSS, por Email ou via Twitter.
    Veja como ter um desconto no Dreamhost: um excelente servidor web.