Danilo Sato

Qual a melhor forma de medir o sucesso de uma equipe? Os Métodos Ágeis promovem um processo empírico para desenvolvimento de software, baseado na colaboração e no feedback trazido por ciclos curtos de inspeção e adaptação. Encontrar maneiras eficazes de avaliar o processo e a equipe não é uma tarefa simples. O senso comum leva à decomposição e à proliferação de diversas métricas baseadas na premissa de que se cada parte do processo for otimizada, os resultados do processo como um todo serão otimizados também. Quando critiquei o modelo hierárquico do IO-Map, minha preocupação era justamente essa. Ao tentar micro-otimizar partes de um sistema por meio de diversas métricas, o objetivo verdadeiro se perde em meio a tantos outros substitutos e a equipe perde sua capacidade de tomar decisões num nível mais macro.




Um outro problema com métricas bastante conhecido (o Vinícius comenta sobre isso em um dos seus podcasts) é que as pessoas geralmente se comportam de acordo com a forma que são avaliadas. Robert Ausin, no livro Measuring and Managing Performance in Organizations, discute os problemas da avaliação de desempenho baseada em métricas e destaca que sua principal vantagem (“Você tem o que você mede”) é também sua principal desvantagem (“Você tem exatamente o que você mede, e nada mais”). Métricas manipuláveis serão manipuladas. Esse é o lado triste da história.




Por isso queria aproveitar esse post curto para discutir uma classificação interessante, que pode te ajudar a refletir quando estiver pensando em utilizar uma nova métrica.

Métricas Organizacionais

Também conhecidas como “métricas de avaliação” na abordagem Lean. São as métricas que medem o sistema como um todo, no nível mais alto. Elas medem o quanto de valor seu processo consegue entregar. A abordagem Lean sugere uma prática conhecida como Measure Up, onde você usa uma medida de avaliação que foge do controle de qualquer sub-parte do processo, incentivando a colaboração entre os indivíduos de diferentes equipes e evitando a micro-otimização. Essas métricas-chave devem ser geralmente escolhidas pelo cliente ou quem quer que espera extrair algum valor do sistema. Como consequência dessa prática, você acaba ficando com um número muito menor de métricas. Recentemente apresentei na XP@Rio alguns exemplos de métricas organizacionais:

• Cycle Time: métrica Lean mais conhecida que mede o tempo médio para que seu processo atenda uma nova requisição. Essa métrica geralmente surge depois que a equipe entende seu Value Stream Map e o conceito importante é que ela começa a contar com o cliente e só termina quando o cliente é atendido.
• Métricas Financeiras: o investimento de muitos projetos de software é justificado com base na melhoria de alguma métrica financeira. Essa métrica pode ser o Retorno de Investimento (ROI), Net Present Value (NPV), uma matriz de lucros e perdas ou coisas desse tipo. Como uma equipe consegue melhorar esses números de outra forma que não seja entregando o software?
• Satisfação do Cliente: Se você está preocupado em entregar valor para seu cliente, o quão satisfeito ele está? Uma métrica sugerida pela Mary e pelo Tom para medir isso é o Net Promoter Score, uma medida simples que verifica se seus clientes recomendariam seu produto para outro cliente.

Métricas de Acompanhamento

Também conhecidas como “métricas de diagnóstico”, “indicadores” ou “métricas informativas”. Elas são medidas internas da equipe que auxiliam na melhoria do processo, através dos ciclos de inspeção e adaptação. Essas métricas agregam dados, mas não os associam com nenhum indivíduo, assim como não devem ser atreladas ao valor que está sendo entregue. Seu ciclo de vida também é geralmente mais curto. Uma vez que o processo evoluiu, elas se tornam desnecessárias e devem ser descartadas. Novas métricas de acompanhamento deverão surgir conforme a equipe avança e o ciclo continua, em busca da melhoria contínua.

Um exemplo amplamente utilizado desse tipo de métrica é a velocidade. Espera-se que, após um certo tempo, a velocidade do time se estabilize (se nenhum fator externo acontecer, como mudança de membros da equipe ou mudança da linguagem de programação). Uma vez que a velocidade se torna “conhecida”, a equipe geralmente não precisa mais medí-la.

Como esse tipo de métrica surge em diferentes contextos e problemas, podemos pensar em diversos outros exemplos. Supondo que a equipe está tentando melhorar nas práticas de teste, pode utilizar a cobertura de código como métrica de acompanhamento. Se querem melhorar a integração contínua, podem medir o tempo entre commits, ou o número de linhas alteradas em cada commit. E por aí vai…

Propaganda Descarada

Aproveitando o assunto (que oportuno!), vou fazer uma propaganda descarada da defesa da minha dissertação de mestrado, na próxima sexta-feira. As informações para quem estiver interessado em assitir são:

Título: “Uso Eficaz de Métricas em Métodos Ágeis de Desenvolvimento de Software”

Orientador: Alfredo Goldman

Local: Instituto de Matemática e Estatística (IME/USP)

Sala: 256 Bloco A

Data: 29 de Junho de 2007

Horário: 9:30hs

No último dia da conferência, um tutorial pela manhã e um workshop de tarde. Alguns dos temas do dia foram: barreiras invisíveis, teoria das restrições e área de trabalho informativa.

How to Overcome Invisible Barriers – Christoph Steindl e Christian Federspiel

Esse tutorial da parte da manhã foi o mais fraquinho dos que participei. Apesar disso, pude aproveitar algumas das idéias apresentadas e acho que elas podem trazer valor na hora de discutir um problema invisível. Como o Tom de Marco disse: “Não importa qual o problema, é sempre um problema com pessoas”. Algumas das ferramentas apresentadas e exercitadas ao longo da sessão foram:

• 5 Por Quês?: Essa é uma excelente ferramenta que a Toyota usa quando precisa encontrar a verdadeira causa de um problema. Corrigir sintomas não curam a causa, então ao perguntar o “Por Quê?” do “Por Quê?”, você quase sempre chega na raíz. Essa ferramenta eu já conhecia e posso dizer que ajuda muito.
• Diagrama de Resolução de Conflitos (Conflict Resolution Diagram ou CRD): Uma forma de estruturar um conflito de idéias entre membros da equipe e explorar as suposições que estão por trás daquilo. Apesar de não ter gostado muito da forma como o modelo te obriga a preencher alguns poucos quadradinhos, tirei duas idéias boas do exercício: ele te força a pensar no objetivo em comum por trás das suposições dos pontos de vista opostos e ele te força a usar palavras extremas e exageradas ao defender as diferentes suposições. Com isso, você acaba chegando em frases do tipo: “Tecnologias tradicionais NUNCA são arriscadas”, “A ÚNICA forma de motivar os desenvolvedores é utilizando tecnologias de ponta” ou “As novas tecnologias são SEMPRE o MAIOR risco”.
• Mapa de Objetivos Intermediários (Intermediate Objective Map ou IO-Map): Uma árvore para estruturar os fatores críticos de sucesso e as condições necessárias para atingir um objetivo (raíz da árvore). Acredito que é fácil utilizar essa ferramenta do jeito errado (quebrando o objetivo em diversos fatores de sucesso e sub-otimizar as partes ao invés do todo), no entanto tirei uma lição do exercício prático: mesmo não sendo muito eficaz, ela te força a pensar sobre o objetivo e a expressar essas idéias, levando a um maior entendimento a respeito do objetivo (ou mesmo encontrando um objetivo melhor).

Além dessas ferramentas, o palestrante comentou rapidamente sobre outras (nem vale a pena citar, pois achei muito complicado e estranho) e sobre a Teoria das Restrições, que é uma boa forma de tratar um problema sistêmico (ao invés de otimizar partes, você precisa focar na sua maior restrição). Eu já conhecia um pouco sobre a Teoria das Restrições e acho que ela é muito alinhada com os valores Lean.

Reface Your Team Space – Patrick Kua

Um workshop excelente do Patrick Kua, da Thoughtworks de Londres. Em uma atividade interativa e criativa, discutimos em equipes diversas formas de exibir informações no espaço de trabalho. Como podem ver pelas fotos, passamos boa parte do tempo rabiscando e discutindo várias formas de tornar o progresso visível e ajudar a equipe a entender o andamento do projeto (tanto da iteração atual quanto do projeto como um todo).

Na segunda parte do workshop, sentamos em uma espécie de “mesa-redonda” (sem a mesa no meio) e discutimos diversas práticas e ferramentas que utilizamos em projetos passados. Levantando idéias que deram certo e outras que não deram certo, aprendi bastante com a experiência das outras pessoas. Algumas das coisas que compartilhei que as pessoas gostaram:

• Retrospectivas fora do ambiente de trabalho: quando a retrospectiva é feita no mesmo (ou próximo do) ambiente de trabalho, eles tendem a se concentrar menos, pois estão no seu habitat natural. Ao invés de rearranjar ou refatorar o ambiente para diversos propósitos, as vezes é melhor trocar de ambiente. Essa técnica funcionou muito bem para mim.
• Humorômetro: já utilizei essa técnica em diversos projetos e todo mundo parece gostar e adotar. A idéia é japonesa, e se chama Niko-niko calendar. Cada membro da equipe tem uma linha num calendário e, ao final do dia, cola um adesivo colorido ou desenha um smiley que representa seu humor naquele dia. Esse indicador geralmente não serve para a comunicação com gerentes ou pessoas externas (Não é para virar algo do tipo: “Em média, o Fulano é mais triste que o Siclano”), mas sim como um fator de motivação dentro da equipe. As pessoas tendem a soltar a criatividade e eu diria que 99% dos projetos que começaram a usar decidiram continuar com essa prática.
• Combinados ao invés de regras: essa foi uma idéia que o Cícero, da Paggo, compartilhou com a gente na última palestra no IME. Ao invés de definir regras para a equipe, ele define “combinados” pois é algo que as pessoas concordam em seguir e soa menos como uma imposição. E outra coisa: quando você combina alguma coisa, sua responsabilidade em cumprir o combinado é muito maior do que quando quebra uma regra alheia.

E agumas coisas legais que aproveitei e vou testar:

• Mantra do dia: a equipe tem uma pilha de “mantras” e a cada dia, na reunião em pé, uma é escolhida e compartilhada na área de trabalho.
• Diferentes materiais: estou trazendo comigo post-its em forma de setinhas que são muito legais. Além disso, conheci uma folha de papel com estática (não sei o nome certo) que gruda na parede e serve como quadro branco improvisado. Infelizmente não sei se vou conseguir achar um desses no Brasil. Outra idéia boa de material é usar uma espécie de cera (ou massinha) para grudar os cartões na parede.
• Sinais sonoros: quando o build quebra, ao invés de mandar e-mail (que na minha experiência não é uma boa mídia, pois as pessoas ignoram depois de um tempo) ou usar uma lava-lamp (que é legal, mas hardware X10 no Brasil é muito caro), usar algum sinal sonoro para avisar que tem algo errado. Pensei na trilha do plantão da globo, pois essa é uma música que sempre me assustou e me fez prestar atenção. :-)
• Tokens: além do token da reunião em pé e da integração, que já utilizei em algumas ocasiões, conheci outros tipos de tokens: um peixe, para quando alguém começa a desviar do assunto você arremessar e “pescá-lo” de volta; um timer de tomate (aqueles de cozinheiro), para usar como estimativa e para servir como cronômetro e focar o trabalho durante um certo período de tempo (olha que divertido: “Essa história eu estimo em 4 tomates”).
• Sino da História: um sino que é tocado sempre que um par termina uma história. Numa equipe grande isso pode ser uma boa forma de mostrar que as coisas estão andando.
• Nariz de Palhaço: esse pode ser um pouco ofensivo, mas se o seu build estiver quebrando frequentemente, considere premiar alguém com um desses. :-)

Na discussão, surgiram assuntos relacionados ao espaço físico da equipe. Uma idéia interessante foi a existência de um espaço coletivo, onde a equipe pareia, e um espaço privatido onde cada um pode fazer coisas pessoais e falar no celular. O Kent Beck descreve um ambiente assim no segundo livro de XP. Outra idéia foi utilizar as janelas para colar post-its ou cartões. Eu já testei e é uma boa forma de ganhar espaço quando o número de quadro brancos é restrito. Só não deixe os post-its colados por muito tempo (mais que 10 minutos) pois eles tendem a cair. A gravidade atrapalha. :-)

Por fim, uma pequena discussão sobre a eficácia das informações visuais espalhadas pela área de trabalho: se alguém não está mais olhando alguma coisa (ou atualizando), se você tem muitas coisas espalhadas ou muitas informações, geralmente é um bom sinal para refatorar seu espaço de trabalho. As reuniões de retrospectivas são um bom momento para discutir coisas desse tipo e descobrir o que está sendo realmente útil e o que é apenas “barulho visual”.

Conclusões e Próximos Passos

Essa conferência foi muito proveitosa. Pelo fato de ser bem menor que a Agile (esse ano foram aproximadamente 200 participantes), tive a oportunidade de ficar muito mais perto de pessoas importantes como Kent Beck, Joshua Kerievsky, Mary e Tom Poppendieck, dentre outros. Além disso, conheci muitas pessoas da comunidade XP na Europa e tive a chance de compartilhar experiências e aprender bastante. Esse tipo de evento é sempre empolgante e estimulante, pois saímos com diversas idéias novas. Espero poder compartilhar algumas dessas idéias com a comunidade ágil do Brasil e volto no final de semana com vontade de fazer um monte de coisas novas por aí. Me aguardem… :-)

Conforme eu havia previsto, hoje teria menos coisas para escrever. Como houve manifestações a favor dos meus relatos, vou tentar compensar esse post mais “magro” com mais fotos. Mas isso não significa que pouca coisa aconteceu. Pelo contrário, muita coisa interessante aconteceu: 2 tutorias excelentes, almoço com a Mary e Agile Café. Pena que está acabando…

Thinking, Refining, and Communicating the Business Perspective with Executable Documents – Rick Mugridge e David Hussman

Pela manhã, decidi participar do tutorial sobre Documentos Executáveis com o David Hussman (Agile Coach) e o Rick Mugridge, co-autor do famoso livro sobre FIT, apesar de ter participado de uma sessão sobre o framework na Agile 2006. O interessante foi que a ênfase da apresentação foi muito além da ferramenta FIT/FitNesse/FitLibrary. O conceito da documentação executável como elemento de comunicação com os clientes e como forma de definir os cenários de aceitação de uma história vai muito além da ferramenta. Documentos Executáveis são aqueles que não são escritos uma vez só; aqueles que não tendem a ser esquecidos ou a crescer infinitamente; aqueles que ajudam as pessoas a pensar e colaborar; aqueles que ajudam as pessoas a comunicar o que o produto realmente faz.

Algo que gostei muito, e que não tinha visto de forma formalizada antes, foi a prática conhecida como Story-Test Driven Development (STDD ou Desenvolvimento Dirigido por Testes de Histórias), onde antes de fazer TDD, a equipe de programadores, analistas, testers e clientes colabora para definir os critérios de aceitação da história antes mesmo de começar a desenvolver. Como a Mary disse no seu tutorial, por que uma equipe de desenvolvedores deve começar a trabalhar numa história sem saber o que deve fazer? Segunda ela, na empresa do Jeff Sutherland (criador do Scrum e CTO da PatientKeeper) os desenvolvedores não podem colocar a mão numa história se ela não é “testável”. Se o cliente não consegue (ou não se importa em) sentar com a equipe para definir exatamente o que espera do software desenvolvido, não tem sentido começar a programar. Qual o valor esperado?

Segundo os palestrantes, o caminho para chegar a uma documentação executável passa por diversas etapas:

• Personas: Para quem não conhece, é uma prática criada por Alan Cooper para descrever os usuários do sistema de forma mais humana. Ao invés de usar “homens-palito” (ou seja lá como chamam esses bonequinhos), uma persona tem nome, foto (ou caricatura), interesses pessoais e valores que espera extrair do produto. No artigo que vou apresentar semana que vem na WDRA (em Porto de Galinhas!), apresento de forma breve essa prática que é muito eficiente (e divertida).
• Histórias: Partindo das personas, você consegue enxergar diversos objetivos e tarefas que um usuário irá realizar no seu sistema. Fica bem mais fácil escrever histórias a partir dessas tarefas.
• Testes de Histórias (Story-Tests): Uma vez que temos histórias, é hora de colaborar com o cliente para entender o que eles realmente querem. Dessa conversa devem surgir os testes de histórias (ou testes de aceitação, como o Kent Beck definiu em XP).
• Cenários, tabelas/fixtures (no caso do FIT), APIs, etc: No momento que a equipe entende a real necessidade do cliente (que pode mudar com o tempo, mas isso é normal), precisam garantir que aquilo seja armazenado de forma executável e que sirva como ferramenta para informar o desenvolvedor quando uma história está quase pronta (“quase” pois o seu conceito de “pronta” pode – e deve – ir mais além da codificação/teste).
• Documentos Executáveis: Só depois de tudo isso você é capaz de construir uma documentação executável. Essa documentação serve como registro de como o sistema deve funcionar e, quando o cliente mudar de idéia ou quiser discutir algo em particular, ela pode ser alterada/testada em ciclos curtos de feedback para garantir que o sistema se adapta às novas necessidades.

No final, o grupo se dividiu e a discussão continuou entre os mais interessados no nível mais técnico (discutindo o FIT/FitNesse em particular) e os mais interessados no nível mais amplo. Fiquei um pouco em cada discussão.

From User Story to User Interface – Jeff Patton

Na parte da tarde participei de mais um excelente tutorial com o Jeff Patton, da Thoughtworks. Material impecável, slides e timing muito bons, didática excelente e exercícios práticos divertidos e instrutivos. E, claro, um assunto muito interessante: como o design de usabilidade (por aqui mais conhecidos como Interaction Design) e o design de interfaces gráficas se encaixam no mundo ágil?

Quem vive no mundo do design de interfaces e da usabilidade tem uma propensão a trabalhar com BDUF (Big Design Up-Front). O que geralmente se diz é que você precisa ter uma idéia de todas as possíveis formas de interação e atividades que um (ou vários) usuário(s) terão com o sistema antes de projetar a melhor interface e o melhor design gráfco. Nós do mundo ágil sabemos que BDUF não funciona muito bem. Num dos relatos de experiência apresentados anteriormente, Robert Beedle mostrou um estudo empírico qualitativo mostrando que, em geral, a maioria das atividades de definição de interface tendem a acontecer no início dos projetos mesmo. Ele mostrou quatro abordagens diferentes:

• Fazer todas as atividades de design da interface antes de começar a desenvolver
• Fazer ambas as atividades em paralelo, de forma iterativa
• Fazer ambas as atividades em paralelo, porém trabalhando no design de interface uma iteração na frente (de forma que a equipe de desenvolvimento trabalha sempre em cima do que a equipe de interface desenvolveu na iteração anterior)
• Começar somente com atividades de design da interface e, gradualmente, inserir atividades de desenvolvimento. Conforme as iterações vão passando, a quantidade de trabalho de desenvolvimento vai aumentando enquanto de design diminui, até o momento em que só é preciso desenvolver. Algo como aqueles gráficos de baleia do RUP.

No tutorial, Jeff apresentou o modelo em camadas proposto por James Garrett para descrever os diferentes elementos da Experiência do Usuário:

• Superfície: interface gráfica, com cores e elementos gráficos do design.
• Esqueleto: uma espécie de “wireframe” de como os elementos estão estruturados na interface.
• Estrutura: como os elementos da interface estão conectados para formar um todo.
• Escopo: uma lista de tarefas que um usuário tipicamente irá realizar através da interface.
• Estratégia: os objetivos por trás das tarefas que serão realizadas na interface.

Apresentou também as diferentes formas de representar os usuários (Atores, Papel, Perfil ou Persona) e as diferentes formas de capturar e representar as interações do usuário com o sistema, como: Use cases, Histórias, Workflows, Cenários e Modelo de Tarefas. Durante o resto do tutorial, nos organizamos em grupos e realizamos diversas atividades para produzir e validar um protótipo em papel: partimos de uma história e definimos um simples cenário de uso, descrevendo as interações entre o usuário e o sistema (num formato de Use case essencial). A partir disso, definimos os diversos componentes que fariam parte da interface gráfica para que o cenário fosse atendido.

Depois veio a parte divertida: começamos a desenhar e recortar os diversos componentes e “montar” a interface em papel, usando canetinhas, papel, transparências, cola pritt e liquid paper.

Por fim, vimos como funciona um teste de usabilidade num protótipo de papel e como, depois de poucas iterações, conseguimos diminuir o número de erros de usabilidade. Para isso, cada um tinha um papel (role, para não confundir): o “facilitador” apresentava nossa proposta e era o único que podia conversar com o usuário-final (num estilo narrador de esporte). Outra pessoa faz o papel de “computador” e fica trocando os papéis/botões/transparências conforme o usuário-final interage com o protótipo. Além do “usuário-final” (que eram duas pessoas vindas de uma outra equipe), alguém precisa fazer o papel de “observador” e ficar tomando nota dos problemas encontrados durante o teste.

Foi uma experiência valiosíssima (o melhor tutorial até agora na conferência) e aprendi bastante sobre como integrar o mundo do design com o mundo de desenvolvimento. Nós sempre aprendemos bastante quando passamos por problemas parecidos. O Jeff está fazendo um trabalho excelente para juntar essas duas comunidades. Para quem se interessar, vale a pena conferir as suas idéias.

Discussões em Geral

Não bastassem os ótimos tutoriais, aind tive o privilégio de ser convidado para almoçar com a Mary e com o Tom para discutir várias coisas. Uma das discussões foi a respeito da velocidade, e expressei minha opinião (e a da Mary) na XP@Rio. Não vou me repetir por aqui. Se alguém se interessar, é só seguir o link. :-)

Como comentei, as pessoas que não estão participando de workshops ou tutoriais geralmente se reúnem nas mesas de fora do hotel para discutir assuntos ágeis, no que foi batizado como Agile Café. Dei uma passada no final do dia, mas já estava cansado e resolvi voltar pro hotel para descansar. Por hoje é só, pessoal. Amanhã é dia de mais um tutorial e um workshop. Arrivederci!

Muitas coisas aconteceram no último dia da main track: painel de discussão sobre certificações, artigos científicos, painel de discussão sobre “melhores práticas”, DSLs e keynote do Kent Beck. No terceiro dia de conferência diversos tópicos foram abordados e, daqui pra frente, participarei apenas de tutoriais e workshops, então espero que a densidade dos posts diminua :-)

Painel de Discussão sobre Certificação

 

Certificação no mundo ágil é um assunto que está na moda. A Agile Alliance anunciou recentemente sua posição sobre o assunto; Scott Ambler colocou sua opinião a favor num artigo da DDJ; além disso, muitos debates vêm acontecendo nas diversas listas de discussão, como scrumdevelopment@Yahoo, extremeprogramming@Yahoo e na nossa XP@Rio. A opinião dos participantes do painel estava dividida entre:

 

• Contra: Joshua Kerievsky e David Hussman
• A Favor: Jeff Patton e Boris Gloger
• Em cima do muro: Rachel Davis, representando a Agile Alliance

Uma das grandes discussões girou em torno do Certified Scrum Master. Joshua e David argumentaram que é um excelente treinamento (eu concordo), porém dá um título muito poderoso (para o observador desatento) para um curso de 2 dias sem uma prova no final. Em outras palavras, empresas procuram SCMs sem saber o que eles tiveram que fazer para se tornar um (está escrito na descrição do curso na Scrum Alliance). Do outro lado o Boris argumentou que, apesar de ser sim uma ferramenta de marketing (muito eficiente, por sinal), foi um programa que propiciou a criação de uma enorme comunidade interessada no Scrum e que, de uma forma ou de outra, contribuiu para o aumento na adoção dos Métodos Ágeis na indústria. Sobre esse tópico, estou um pouco mais pendente pro lado contra (apesar de ser um SCM) devido à fragilidade da nossa indústria. Infelizmente as empresas buscam profissionais certificados sem saber o que os torna certificados. Apesar disso, concordo com o argumento do Boris de que a formação de uma comunidade é importante. Acredito que uma estratégia de longo prazo para popularização dos Métodos Ágeis não deve ser tão ambiciosa a ponto de querer atingir quantidade e qualidade ao mesmo tempo. Olhando por esse lado, acredito que é mais fácil (e natural) conseguir a quantidade antes da qualidade. Por isso, acho que os treinamentos de SCM são importantes.

Dentre outras discussões sobre o tema, surgiu a idéia de ter uma “certificação” ágil mais parecida com o que fazemos na universidade: um curso muito mais longo, muito mais abrangente e que fornece uma base comum de conhecimento para que o aluno possa evoluir. Quando um aluno se forma na graduação, não espera-se que ele saia totalmente proficiente. Existe um consenso de que a experiência trará benefícios. Gostei dessa idéia de uma “faculdade ágil”. :-)

Outro ponto interessante da discussão foi a separação entre habilidade e certificação (ou treinamento). Ter uma certificação ou participar de um treinamento não é garantia de que o participante irá adquirir a habilidade necessária. Isso pareceu ser consenso. O único ponto do Joshua foi que ele prefere chamar isso de treinamento ao invés de certificação, pois é mais realista. Por outro lado, o Boris argumentou que qualquer programa de certificação gera um mercado mais atraente para empresas.

Outros assuntos interessantes foram abordados na discussão, mas esse espaço é muito curto (e minhas anotações muito sucintas) para expor de forma adequada. Acho que a discussão está boa e deve continuar…

Artigos Científicos

 

Após o debate, houve uma sessão de apresentação de artigos científicos, dentre eles o meu. Confesso que fiquei um pouco nervoso por ter que apresentar em inglês e um pouco mais nervoso quando vi o Kent Beck na platéia. Mas isso passou assim que comecei a falar (como costumava acontecer quando tinha que tocar piano na frente dos outros.. he he) e acho que correu tudo bem. Após a sessão fui conversar com o Kent Beck (sobre outro assunto) e ele me disse que gostou da minha apresentação, o que me deixou muito orgulhoso :-)

 

Dentre os outros papers apresentados, teve um que não gostei (nem o Boris.. he he) sobre um meta-modelo para modelar e medir a eficácia de processos ágeis. O exemplo usado foi o Scrum e me pareceu uma tentativa de fazer um framework-de-processos(RUP)-ágil-genérico, onde outras metodologias ágeis poderiam ser “instanciadas”. Enfim, não deu pra entender muito bem a motivação para usar aquilo (e eu também tenho um certo preconceito quando começam a falar de processos com caixinhas parecidas com UML, setinhas e coisas <<entre símbolos estranhos>>).

 

Por outro lado, os outros dois papers foram bem mais interessantes. O primeiro foi sobre o FitClipse, um plugin do Eclipse para execução e edição de testes de aceitação do FIT. Ele roda em cima do FitNesse e permite a distinção entre testes que falham por motivos aceitáveis (ainda não foram implementados) ou por motivos inaceitáveis (já foram verde e ficaram vermelho depois de um tempo), além de mostrar uns gráficos bonitinhos. O outro foi sobre o EzUnit, uma extensão do JUnit que permite a identificação mais precisa de qual pedaço de código pode ter causado uma falha. O framework permite a definição do(s) método testado(s) (Method Under Test ou MUT) com anotações (isso achei estranho) ou, para quem é preguiçoso como eu, escreve as anotações através de análise estática e dinâmica do código. Gostei da idéia, mas não tanto dessa parte das anotações/análise estática. Concordo com o comentário do Kent Beck no final de que a análise dinâmica, associada aos deltas das mudanças efetuadas mais recentemente, dão uma informação muito boa sobre onde uma possível falha pode estar localizada. Além disso, linguagens dinâmicas não permitem análise estática de qualquer forma. Acho/espero que no futuro vamos usar testes unitários como “compiladores” e ferramentas como essa podem facilitar a vida.

 

Painel de Discussão sobre “Melhores Práticas em Software”

 

Antes de mais nada, uma colocação da Mary: “Não existe uma MELHOR prática”. A partir do momento que consideramos algo como o melhor, deixamos de pensar em formas de melhorar, afinal de contas já temos O MELHOR. Muito bem colocado e os presentes no painel concordaram: Giancarlo Succi, Jutta Eckstein, Robert Beedle e Yael Dubinsky.

 

Os “painelistas” (como se escreve isso em português?) mostraram uma preocupação na definição e escolha de práticas muito técnicas. A agilidade propõe aspectos humanos que dificilmente são expressados em práticas específicas. Por outro lado, medir e avaliar a adoção de princípios e valores é complicado. Robert Beedle defendeu o ponto de que a prática mais importante é a colaboração. Ela inclui os valores humanos e dirige o resto do processo na direção certa. Segundo ele, sua primeira impressão sobre XP foi positiva pois servia como uma ferramenta cognitiva para compartilhamento de conhecimento que, mesmo sem saber explicar muito bem como, fazia com que as coisas certas acontecessem. Em outras palavras, se você seguisse as práticas (e suas sinergias e valores embutidos), você seria capaz de dirigir a produção do software certo, ao contrário da abordagem da engenharia de software tradicional que busca a forma certa de produzir software. Produzir certo vs. Produzir o software certo. Conceitos bem diferentes.

 

Por fim, houve uma discussão sobre como medir o sucesso nos projetos. O Giancarlo defendeu o ponto de que é preciso utilizar métricas e objetivos claros para avaliação do sucesso. Num debate sobre o valor de métricas quantitativas e qualitativas, Robert Beedle disse que para medir o lado humano dos Métodos Ágeis, métricas qualitativas são a única solução. Por outro lado, Giancarlo disse que é mais fácil entender dados quantitativos, apesar de serem facilmente manipuláveis ou mal-interpretados.

 

Birds of a Feather: Domain Specific Languages – Emily Bache

 

Apesar de não constar na programação oficial, a Emily havia mandado uma proposta de workshop que foi recusada e, mesmo assim, decidiu fazer uma sessão aberta para interessados em discutir DSLs. Eu achei muito louvável a atitude e, como não programaram nenhum Open Space na conferência desse ano, também demonstrou o poder da comunidade em adaptar o programa e compartilhar conhecimentos.

 

Nesse workshop, discutimos o conceito de uma DSL que, para minha surpresa, não era consenso. Eu ainda não tive muitas experiências utilizando uma DSL numa situação onde precisei de verdade, a não ser na definição de testes de aceitação. Porém, como disse para os participantes, já houve momentos na minha carreira (antes de saber o que era XP) onde consigo ver uma DSL ajudando a diminuir a distância entre especialistas e programadores. Após diversas discussões surgiram alguns aspectos do que seria uma DSL:

 

• Uma DSL deve maximizar a densidade semântica: em outras palavras, dependendo do público-alvo (os especialistas no domínio), usar muitos parênteses e símbolos de programação podem atrapalhar a legibilidade (particularmente em DSLs internas).
• Uma DSL deve ser executável: isso inclui a habilidade de edição e execução na frente do especialista do domínio, trazendo feedback imediato.
• Deve ser fácil e rápido alterar uma DSL: em outras palavras, o especialista de domínio deve ser praticamente capaz de escrever na DSL (ler é mais fácil que escrever).

Ainda no tópico da densidade semântica, houve uma pequena discussão sobre se uma DSL deve ou não ser obrigatoriamente legível para o cliente (ao invés do programador). Nesse caso, o rake não seria uma DSL.

Keynote de encerramento: Ease at Work – Kent Beck

 

Para não tornar um post longo ainda mais longo, não vou me estender muito sobre esse keynote. Kent Beck é O CARA. E dessa vez, ao invés de falar sobre aspectos técnicos, metodologias ou empresas, ele deu uma palestra quase como psicólogo (tudo bem que a esposa dele é psicóloga), para tentar fazer-nos refletir sobre nosso papel como programadores e como encaramos nosso trabalho. Em outras palavras, como fazer com que possamos nos sentir bem com nossas qualidades e defeitos?; como conviver e aceitar que não estaremos sempre no auge ou na lama?; como sair do trabalho com a consciência tranquila de que demos nosso melhor?; Como sustentar mudanças?; Como sermos mais responsáveis e transparentes no trabalho?

 

Como disse, espero que o post de amanhã seja mais resumido pois também cansa escrever esses relatos… brincadeira :-)

 

Lean, velocidade, Ferrari e computadores quânticos foram alguns dos temas do meu segundo dia na XP2007: uma palestra pela manhã, a main track começando durante a tarde e muitas coisas interessantes acontecendo.

Lean Software Development – Mary e Tom Poppendieck

Minha programação do dia era assistir outra palestra, sobre Anti-Padrões em Métodos Ágeis, porém o palestrante não conseguiu chegar a tempo em Como. Isso não é um grande problema para alguém ágil, afinal um plano é apenas um plano, certo? Fui então assistir o tutorial excelente sobre Lean Software Development. Apesar de já ter participado da sessão dos mesmos autores na Agile 2006, pude vivenciar na prática a construção e a análise de um Value Stream Map, uma ferramenta muito boa para encontrar desperdícios em um processo.

Um dos tópicos interessantes discutido no tutorial foi levantado por alguém da platéia e se encaixa perfeitamente numa das recentes discussões na XP@Rio: “O que levar em consideração no cálculo da velocidade?”. Assim como eu disse, a Mary argumentou que a velocidade é uma medida de capacidade (eu chamei de cadência) e, portanto, todo tempo que é gasto durante a iteração deve ser levado em consideração: seja com design, teste, desenvolvimento, integração ou tirando dúvida com o cliente. A velocidade é uma medida da capacidade da equipe para entregar software funcionando no final da iteração (ou release). No contexto Lean, ela serve como ferramenta para cortar desperdícios. Se sua “lista de coisas a fazer” é maior que sua capacidade de entrega, então você pode estar desperdiçando tempo gerenciando coisas com baixa prioridade. O conselho da Mary é que essa lista não tenha mais trabalho do que a equipe consegue entregar nas próximas 2 ou 3 iterações.

Se a sua capacidade de entrega (velocidade) é a segunda seta, não faz sentido querer entregar (ou gerenciar) a primeira seta. Ao final do tutorial, fui falar com ela sobre nossa discussão e eis o que ela me disse:

• Sim, bugs definitivamente devem ser contados na velocidade pois impactam a capacidade de entrega freqüente de software.
• Defeitos não devem ser tolerados. Um processo que permite defeitos é um processo defeituoso. Se você chegar em qualquer linha de produção (manufacturing) e disser isso, eles irão concordar facilmente. No mundo do software isso ainda não aconteceu.

Dentre outros tópicos interessantes que foram levantados no tutorial, destaco mais um: a importância de Respeitar as Pessoas. O Teste de Litmus deve dar uma boa idéia sobre a motivação de seus funcionários: “Quando alguém está chateado com alguma coisa no trabalho, ele reclama, ignora ou tenta arrumar?”. Ainda nessa discussão, Mary falou sobre o papel dos padrões numa empresa Lean: “Padrões são feitos para serem questionados. Servem apenas como base para mudanças”. Na sua empresa, padrões são impostos ou desafiados? (não responda se não quiser – ou não puder) :-)

Keynote: The grand-prix starts at 2 o'clock – A race to race software development eXPerience – Piergiorgio Grossi

No keynote de abertura, o CTO da Ferrari (sim, a equipe de corrida na Fórmula 1) apresentou como eles usam XP para gerenciar seus (diversos) projetos. Apresentaram algumas coisas interessantes como a urgência das coisas (mudança é uma constante. A cada corrida os clientes mudam suas prioridades), a dificuldade de determinar os testes de aceitação (o cliente nem sempre sabe exatamente o que quer. Ex: “Nosso software de estratégia de corrida deve levar em conta a nova regra e devemos usar os 2 tipos de pneu durante a corrida”) e os desafios de lidar com um número pequeno de programadores e diversos projetos (segundo eles, uma taxa de 1:5).

Artigos, Painel de Discussão e Outras Coisas Mais…

O resto da tarde foi bem variado. Assisti algumas apresentações de artigos publicados (para ter uma idéia do tempo disponível e para me preparar para apresentar o meu amanhã). Outra parte interessante foi um painel de discussão aberto, no estilo fishbowl. Para quem não conhece, é um estilo de discussão onde as pessoas levantam tópicos e um moderador escolhe o primeiro a ser discutido. Quem estiver interessado em discutir vai ao centro (daí o termo “aquário”) e discute. Qualquer um pode entrar ou sair em qualquer tópico. Após um tempo pré-determinado, o moderador pergunta se a platéia quer continuar a discutir o mesmo tema ou trocar (cada um tem um post-it vermelho e um verde para votar). Nessa discussão aberta surgiram alguns tópicos interessantes:

• Agilidade e valor de negócio: cheguei um pouco no meio da discussão, mas uma frase impactante veio do Joshua Kerievsky: “Agile is Dead”. Mais sobre o assunto daqui a pouco.
• O futuro ágil?: Acreditam que deve continuar existindo, assim como muitas coisas “velhas” ainda existem, como Cobol, sistemas legados, etc. Alguém levantou uma preocupação do Ken Schwaber em 2002 sobre o perigo das abordagens ágeis se tornarem tão rígidas, estruturadas e burocráticas como aconteceu com outras coisas.
• Como sustentar as mudanças propostas pelos Métodos Ágeis?: Citaram novamente a importância da motivação, contando a história dos trabalhadores quebrando pedras (não consegui achar uma boa referência, vou deixar a história nos comentários). Comentaram também sobre o perigo da desvalorização dos coaches e das empresas que deixam as práticas ágeis degradarem com o passar do tempo.

Por fim, foi proposto um novo formato de discussão: um “Agile Café” (ou, como alguns preferiram: “Agile Bar”). As pessoas sentam nas mesas do lado de fora do hotel para discutir qualquer assunto relacionado ao mundo ágil e quem estiver interessado pode se juntar e debater o assunto em questão. Se ninguém estiver discutindo, você pode sentar e esperar alguém aparecer para discutir o assunto que desejar. Logo após o fim da conferência, já fui participar de um e aproveitei bastante. Dentre algumas das discussões que tivemos, destaco:

• Agilidade não existe: existem diferentes “sabores” de metodologias. Você sempre discute com base nos sabores que conhece (ou experimentou). Como uma coisa que não existe pode viver (ou morrer)? :-)
• Evolução e Computadores Quânticos: apresentei a idéia do Dick Gabriel sobre design evolutivo (aquele que um humano não consegue explicar ou entender), seus paralelos com a biologia, algoritmos genéticos e tudo mais. Uma idéia interessante (viagem) que surgiu da discussão foi a utilização de TDD para definir o comportamento esperado do sistema e deixar que um algoritmo genético evolua uma solução aceitável. Claro que para evitar a explosão combinatória precisaríamos de computação quântica, mas não sabemos o que o futuro nos prepara. :-)

Mais um dia produtivo na Itália com muitas idéias e pessoas interessantes. Volto com mais novidades/relatos amanhã (ou hoje, se conseguir conexão no fim do dia).

Apesar de ler e concordar com o Thiago que esse tipo de post não é o ideal, meu blog se encaixa nessa categoria a maioria das vezes, portanto por que não continuar mais um pouco? :-) Prometo tentar melhorar depois dessa série. Além disso, sei que algumas pessoas vão se beneficiar desses relatos (me incluo nessa lista, pois esse tipo de registro já me foi útil em outras ocasiões e agora eu terei que escrever um relatório de qualquer jeito). Então, aproveitem os meus comentários sobre a XP 2007, diretamente de Como, na Itália.

Selling: How to Effectively Communicate the Value of Agility? – Joshua Kerievsky

Quem nunca teve problemas “vendendo” ou apresentando algumas das práticas ágeis para outras pessoas? Na AgilCoop eu me vi nessa situação diversas vezes: “Programação Pareada? Metade da Produtividade?”, “Parar para escrever testes e refatorar? Não posso parar, preciso entregar novas funcionalidades!”, e por aí vai. Por causa dessas e outras pré-concepções (não estou dizendo preconceito, muitas vezes eles são infudados), muitas pessoas resistem a mudanças.

No tutorial, Joshua, fundador da Industrial Logic e escritor do ótimo livro Refactoring to Patterns (que, por sinal, estou lendo agora), nos fez passar pela experiência da mudança através de uma pequena simulação, mostrando como mudar é anti-natural para as pessoas e como geralmente associamos mudança com a perda de alguma coisa (ao invés de ganho). Uma das discussões foi sobre a curva de mudanças de Virginia Satir, que diz que toda mudança leva um tempo para surtir efeito, passando por uma fase de caos antes de atingir um novo patamar, melhor que o anterior:

Através de algumas histórias sobre vendas bem e mal sucedidas, ele apresentou algumas das características de uma boa venda:

• Venda apenas o necessário: Isso inclui conhecer muito bem o problema e o contexto do seu cliente. Muitas vezes a solução para um problema pode ser obtida com custo reduzido se o verdadeiro problema é identificado. Quando a única ferramenta disponível é um martelo, todos os problemas se parecem com um prego.
• Venda riscos: ao invés de enfatizar os benefícios de uma prática ou outra, discuta com os interessados quais os riscos associados a não implementá-las.
• Compartilhe experiências: um gerente ou executivo não vai entender os benefícios dos testes automatizados, pois essa não é a linguagem que ele entende. Procure compartilhar vídeos, fotos e experiências de equipes que obtiveram sucesso, para que ele vivencie os benefícios.

Diversos outros assuntos e histórias foram compartilhados nesse tutorial, além de algumas boas recomendações de leitura: Selling the Invisible e The Secrets of Consultancy (esse eu já ouvi falar muito bem em diversos outros lugares).

Coder's Dojo: Acceptance-Test Driven Development in Python – Emily Bache and Geoff Bache

Nessa apresentação, em formato de Dojo, resolvemos parte de um problema do Ruby Quiz (Texas Hold'em) em Python, usando uma variação um pouco diferente de TDD, escrevendo os testes de aceitação antes. Nesse caso, o teste de aceitação final seria a saída esperada do programa, conforme a página de descrição no Ruby Quiz. Ao partir de cenários mais simplificados (porém ainda de aceitação) e utilizando o TextTest como ferramenta de teste, resolvemos parte do problema (infelizmente, o problema era grande demais para o tempo disponível). Algumas das minhas impressões da experiência:

• Como o exercício era relativamente simples comparado a um cenário real, os testes de aceitação, que escrevíamos incrementalmente, eram muito parecidos com testes de unidade. Apesar disso, os exemplos ainda estavam na “linguagem de negócio” do poker. Isso pode ter confundido um pouco algumas pessoas da platéia que não tinham experiência com TDD.
• Para quem tem experiência com TDD os passos pareciam um pouco grandes demais, apesar de ainda pequenos. Muitas vezes precisamos implementar muita coisa para fazer um teste de aceitação passar. Uma discussão interessante que tive depois da sessão, com o Emmanuel Gallot (fundador do Dojo de Paris, o mais antigo Dojo em funcionamento) e os apresentadores, percebemos que existem duas abordagens para aplicar TDD: enquanto alguns preferem escrever diversos testes de aceitação para “pedir” por uma implementação, outros preferem quebrar as necessidades que vão surgindo ao longo do caminho, e aplicar TDD separadamente para cada parte antes de integrar tudo no cenário de aceitação inicial. A primeira abordagem tem a vantagem de conectar toda funcionalidade com um teste de aceitação, enquanto a segunda acaba gerando diversos passos intermediários que, em muitas situações, são mais fáceis de acompanhar e fazem o design surgir da necessidade. Eu me identifiquei mais com a segunda abordagem, apesar de entender que é possível seguir outro caminho.
• O TextTest é uma ferramenta de teste em Python baseada na comparação de texto ou, em outras palavras, um teste baseado em diffs da saída do programa. Eu não conhecia a ferramenta e achei interessante duas práticas aplicadas pelos apresentadores (que estavam seguindo a primeira das abordagens que apresentei acima): em primeiro lugar, a ferramenta permite salvar a saída esperada de acordo com o que aconteceu (resultado da execução do teste). Isso permite que você diga que o resultado do teste que acabou de falhar, na verdade está correto. A princípio, isso me pareceu “roubar”, mas como a abordagem deles era diferente, permitiu que eles convivessem com a implementação atual, podendo refatorar no verde (no final da sessão, algumas pessoas disseram preferir uma cor amarela para essa situação. Eu concordo). A segunda prática é a utilização de logs nos cenários de teste. Como a ferramenta se baseia na saída de texto do programa, os apresentadores puderam testar passos intermediários com logs que “explicam” o que o programa está fazendo. Eu pessoalmente batizei a técnica de printf-debugging automatizado :-)

Bom, por hoje foi isso. Continuo com os relatos com o passar da semana. Se estiverem interessados em fazer alguma pergunta para alguém importante aqui na conferência, deixem um comentário que eu tentarei entrar em contato. Alguns dos nomes que podem interessar estão disponíveis no website da Conferência.