Refatoração - Prática para Manter Qualidade

Terça-feira, 15 de julho de 2008 por Daniel Cukier

No nosso post anterior sobre XP falamos sobre as várias práticas que compõem a metodologia. Neste artigo abordaremos os detalhes da Refatoração. O termo “refatoração” vem do inglês “refactoring”, e surgiu nas comunidades de Smalltalk nos anos 80/90. Foi inserida na indústria por Kent Beck como prática XP. Tornou-se famosa com o livro “Refatoração - Aperfeiçoando o Projeto de Código Existente” escrito por Martin Fowler. Segundo o próprio M. Fowler define:

“Refatoração é uma técnica disciplinada para reestruturar um código fonte existente, alterando sua estrutura interna sem mudar o seu comportamento externo. Sua essência está em uma série de pequenas transformações que preservam comportamento. Cada transformação (chamada de refatoração) faz pouca coisa, mas uma sequência de pequenas transformações produz uma reestruturação significativa. Uma vez que cada refatoração é pequena, é mais improvável que algo dê errado. O sistema se mantém funcionando integralmente após cada refatoração, reduzindo as chances de o sistema sofrer um dano grave durante a reestruturação”

O objetivo de refatorar um código freqüentemente é manter o custo de manutenção constante ao longo do tempo. Refatorações trazem simplicidade, flexibilidade, clareza e algumas vezes desempenho ao código. Elas ajudam a manter a casa em ordem. Sem refatorações o código tende a ficar cada vez mais bagunçado e quanto maior a bagunça, mais difícil é de arrumar, ou seja, bagunça tende a gerar mais bagunça, até o limite em que o código fica ilegível. O custo de manutenção fica tão alto que a única solução é jogar tudo fora e começar do zero (isso é a última coisa que queremos num projeto de software, embora algumas vezes seja necessária).

Vale lembrar que cada refatoração é um passo trivial (ovo de colombo). O segredo está em conhecer com maestria o vocabulário das refatorações e saber aplicar cada uma delas no momento certo. Martin Fowler mantém um catálogo online de refatorações. Alguns exemplos de refatorações:

  • Mudar o nome de uma variável
  • Encapsular um código repetido num método
  • Remover um parâmetro não utilizado em um método
  • Generalizar um método (ex: raizQuadrada(float x) => raiz(float x, int indice))

Por onde começar?

Antes de começar a aplicar refatorações, é importante que seu código já tenha uma boa base de testes automatizados. Teste é uma outra importante prática da metodologia XP. Testes e refatorações são práticas irmãs. Uma refatoração pode ocasionalmente inserir um erro no sistema. Os testes ajudarão a detectar e corrigir esses erros.

Após aplicar uma refatoração você irá rodar todos os testes “apertando um botão” e terá como resultado uma luz verde (testes passaram) ou uma luz vermelha (testes não passaram).

Um pequeno exemplo

Vamos dar um pequeno exemplo de refatoração para tornar o conceito claro. Alguns outros exemplos podem ser obtidos nesses slides e no catálogo online do Martin Fowler.

O nome da refatoração que vamos usar é Substituir Variável Temporária por Busca. suponha que uma variável local está sendo usada para guardar o resultado de uma expressão. A idéia desta refatoração é trocar as referências a esta expressão por um método. Variáveis temporárias encorajam métodos longos (devido ao escopo). Com a refatoração, o código fica mais limpo e o método pode ser usado em outros locais.

Os passos para essa refatoração são:

  1. Encontre variáveis locais que são atribuídas uma única vez
  2. Declare temp como final
  3. Compile (para ter certeza)
  4. Extraia a expressão
  5. Compile e teste

Exemplo de código:

double getPreco() {
    int precoBase = _quantidade * _precoItem;
    double fatorDesconto;
    if (precoBase > 1000) fatorDesconto = 0.95;
    else fatorDesconto = 0.98;
    return precoBase * fatorDesconto;
}



double getPreco() {
    final int precoBase = _quantidade * _precoItem;
    final double fatorDesconto;
    if (precoBase > 1000) fatorDesconto = 0.95;
    else fatorDesconto = 0.98;
    return precoBase * fatorDesconto;
}



double getPreco() {
    final int precoBase = precoBase();
    final double fatorDesconto;
    if (precoBase > 1000) fatorDesconto = 0.95;
    else fatorDesconto = 0.98;
    return precoBase * fatorDesconto;
}

private int precoBase() {
    return _quantidade * _precoItem;
}



double getPreco() {
    final double fatorDesconto;
    if (precoBase() > 1000) fatorDesconto = 0.95;
    else fatorDesconto = 0.98;
    return precoBase() * fatorDesconto;
}

private int precoBase() {
    return _quantidade * _precoItem;
}



double getPreco() {
    final double fatorDesconto = fatorDesconto();
    return precoBase() * fatorDesconto;
}

private int fatorDesconto() {
    if (precoBase() > 1000)
    return 0.95;
    return 0.98;
}

private int precoBase() {
    return _quantidade * _precoItem;
}

double getPreco() {
    return precoBase() * fatorDesconto();
}



double getPreco() {
    return precoBase() * fatorDesconto();
}

private int fatorDesconto() {
    if (precoBase() > 1000)
    return 0.95;
    return 0.98;
}

private int precoBase() {
    return _quantidade * _precoItem;
}

double getPreco() {
    return precoBase() * fatorDesconto();
}


Conclusões

O uso de refatorações se torna mais e mais freqüente na medida em que o programador vai ficando mais experiente. As refatorações não devem ser usadas de qualquer modo, mas sim no momento certo e no lugar certo. Um bom programador surge só com muito trabalho e experiência. Qualquer um pode escrever código que o computador consegue entender. Bons programadores escrevem código que pessoas conseguem entender.

Uma boa dica de quando refatorar é ao identificar três repetições no código. Outro indício é quando você está tendo necessidade de escrever comentários para explicar o que um código faz. Algumas ferramentas como o Eclipse e o Visual Studio já possuem atalhos para as refatorações mais comuns como renomear método, extrair superclasse, introduzir objeto parâmetro. A experiência em refatorações trará grandes melhorias na qualidade do código de um programador. Em breve falaremos mais sobre Testes (automatizados), mais uma importante prática em que a Programação Extrema se baseia.

Fórmula ScrUM

Sexta-feira, 11 de julho de 2008 por Elson Barbosa

O Willi da SEA Tecnologia criou uma analogia genial: como uma corrida de Fórmula Um pode ser comparada a um projeto ágil. Vale a leitura:

http://blog.seatecnologia.com.br/articles/2008/07/11/formula-scrum

Estimativas ágeis

Sábado, 28 de junho de 2008 por Mauricio De Diana

Um post anterior falou sobre Scrum e as duas etapas do planejamento que ocorrem em todo sprint. Na primeira delas a equipe precisa estimar o esforço necessário para a realização das histórias, já na segunda, estimativas são feitas com foco nas tarefas. Esses são momentos do planejamento bastante delicados, a começar pelo próprio conceito de estimativa.

Muitos desenvolvedores detestam estimar pois às vezes eles são cobrados duramente pelas estimativas que fizeram. Alguns clientes e gerentes recebem mal a notícia de que “aquela tela de cadastro não vai ficar pronta até amanhã”. Isso normalmente acontece pois os desenvolvedores deram uma estimativa - algo como “acho que isso deve demorar 2 dias para fazer” - e, por falta de domínio em uma tecnologia ou algum mal entendido com relação ao negócio, não a cumpriram.

O erro conceitual aí é que não existe “não cumprir a estimativa”, já que uma estimativa é, por definição, um cálculo aproximado. É impossível dizer com exatidão qual o esforço envolvido em determinada atividade. E quanto mais genérica, abrangente e indefinida ela for, mais incerta será sua estimativa.

Metodologias ágeis não ignoram esse fato e por isso muitos autores sugerem diferenciar as estimativas de histórias (mais abrangentes) das de tarefas (mais específicas). Dado que histórias são breves descrições de coisas a serem feitas, a idéia é estimá-las em termos de tamanho, e não de tempo. Para isso, a primeira coisa a fazer é usar pontos de história como unidade de medida ao invés de horas. Como esse é um conceito artificial, um referencial é necessário.

Dessa forma, imagine que na primeira parte da reunião de planejamento o Product Owner apresente as seguintes histórias para a equipe:

  • Um usuário se cadastra na loja virtual passando suas informações pessoais básicas (nome, RG, endereço, etc).
  • Um usuário adiciona um produto a sua lista de desejos.
  • Um diretor tem à sua disposição um relatório com informações consolidadas mensalmente das vendas feitas pela loja virtual.

Num primeiro momento os desenvolvedores precisam escolher uma história que servirá como base para as estimativas de todas as outras. Normalmente escolhe-se uma história que seja pequena e dá-se um valor para ela que funcionará como referência. No caso das histórias acima, um desenvolvedor pode dizer “é bem fácil fazer um cadastro desses, já fiz muitos deles, essa história vale 1 ponto”. Será então a partir dessa que as outras serão estimadas. Um outro desenvolvedor diz “acho que a história da lista de desejos é 3 vezes maior” (ou seja, ela vale 3 pontos) e outro diz que “a história para o diretor então vale 8, pois teremos que processar muitos dados diferentes, e formatação de relatórios nunca é fácil”.

Alguém pode se perguntar pra que serve estimar histórias dessa forma se isso não vai dar nenhuma noção de prazo nem de quantidade de horas a serem trabalhadas no sprint. Na verdade a função disso é mensurar, mesmo que de uma forma imprecisa, a capacidade de produção de uma equipe em cada sprint. Imagine que a equipe citada decidiu implementar as três histórias no sprint, mas só teve tempo para acabar a primeira (1 ponto) e a última (8 pontos). Isso resulta na velocidade da equipe, que nesse caso foi de 9 pontos de história. A velocidade é usada para saber o tamanho do próximo Selected Product Backlog, ou seja, ela indica quantos pontos de história a equipe provavelmente será capaz de produzir no sprint seguinte.

Imagine agora que no sprint seguinte a equipe pegou os 9 pontos de história, mas acabou tudo antes do final do sprint. Como a equipe ainda não pode começar um novo sprint, pois no Scrum o tamanho dos sprints não pode ser alterado, a única opção para que os programadores não fiquem ociosos é “puxar” mais uma história que está no backlog. Se essa nova história estiver estimada em 5 pontos, por exemplo, e for de fato finalizada, a velocidade da equipe será então 14. Essa será então a quantidade de pontos a serem colocadas no Selected Product Backlog seguinte.

Esse processo de usar a velocidade de um sprint para definir a carga do seguinte cria um forte comprometimento da equipe com a entrega das histórias de um sprint, já que ela sabe que não será cobrada nem julgada por nada além do que já foi capaz de fazer. Por outro lado, os clientes se sentem seguros, pois sabem o que podem esperar da equipe. Ou seja, a medida de velocidade é um instrumento muito valioso no desenvolvimento de uma relação de confiança mútua entre programadores e clientes.

E quanto às estimativas de tarefas? Com relação à segunda parte do planejamento não há novidades: horas são uma boa unidade de medida. Primeiramente, porque é bastante razoável um programador dizer que gastará 3 horas para criar a página de cadastro, 1 hora para escrever a query que insere os dados do cliente no banco e mais 1 hora para escrever os testes de aceitação automatizados dessa história. Depois porque são as horas que dão a carga de trabalho do sprint, sendo usadas para o traçado do burndown e do burnup.

Em breve daremos algumas dicas sobre técnicas e formas de organizar o processo de estimativa. Até lá.

Webcast - Programação eXtrema (XP)

Terça-feira, 24 de junho de 2008 por Elson Barbosa

Essa semana teremos mais um webcast sobre Metodologias Ágeis, dessa vez com enfoque na Programação eXtrema (XP). Segue o post publicado no blog oficial da Locaweb:

No dia 27 de Junho, Sexta-feira, às 15h, faremos uma transmissão ao vivo sobre Programação eXtrema ou eXtreme Programming (XP).

O evento será apresentado por Daniel Cukier, líder de desenvolvimento de software na equipe de Telecom e autor do blog http://agileandart.blogspot.com, que falará sobre as principais vantagens dessa metodologia nas equipes de desenvolvimento de software.

A duração prevista é de 60 minutos e a participação é gratuita.

Para participar clique aqui, preencha o cadastro e faça a sua inscrição.

Se você já se cadastrou, clique na aba “Já sou cadastrado”, digite o seu e-mail e inscreva-se no evento.

Aproveite pois as vagas são limitadas!

Obs: o webcast é um projeto piloto da Locaweb e podem ocorrer instabilidades durante a sua apresentação.
Como sempre, sugestões são MUITO bem-vindas!

Programação eXtrema - eXtreme Programming ou simplesmente XP

Sexta-feira, 20 de junho de 2008 por Daniel Cukier

A Programação Extrema é uma das metodologias ágeis mais conhecidas. Foi criada por Kent Beck e ganhou notoriedade a partir da OOPLSA 2000 (a maior conferência internacional de Orientação a Objetos). A primeira reação a XP foi bem controversa. Alguns amaram (normalmente os programadores), outros odiaram. Em XP, o bom programador se sente mais livre para fazer o que faria se não existissem regras. Ao mesmo tempo, XP obriga o “mau” programador a se comportar de forma similar ao bom.

A Programação Extrema é baseada em cinco valores, alguns princípios e várias práticas. Ela se destina a times de até dez programadores, projetos de curto e médio prazo.

Os cinco valores de XP são:

  1. Comunicação – para um projeto de sucesso é necessária muita interação entre os membros da equipe, programadores, cliente, treinador. Para desenvolver um produto, o time precisa ter muita qualidade nos canais de comunicação. Conversas cara-a-cara são sempre melhores do que telefonemas, e-mails, cartas ou fax.
  2. Feedback as respostas às decisões tomadas devem ser rápidas e visíveis. Todos devem ter, o tempo todo, consciência do que está acontecendo.
  3. Coragem – alterar um código em produção, sem causar bugs, com agilidade, exige muita coragem e responsabilidade.
  4. Simplicidade – para atender rapidamente às necessidades do cliente, quase sempre um dos valores mais importantes é simplicidade. Normalmente o que o cliente quer é muito mais simples do que aquilo que os programadores constróem.
  5. Respeito – todos têm sua importância dentro da equipe e devem ser respeitados e valorizados. Isso mantém o trabalho energizado.

XP, valores, princípios e práticas

Em XP existem quatro papéis principais:

  • Programadores - foco central da metodologia, sem hierarquia.
  • Treinador (ou coach) - pessoa com mais experiência no time, responsável por lembrar os outros das regras do jogo (que são as práticas e os valores de XP). O treinador não precisa necessariamente ser o melhor programador da equipe e sim o que mais entende da metodologia XP.
  • Acompanhador (ou tracker) - responsável por trazer para o time dados, gráficos, informações que mostrem o andamento do projeto e ajudem a equipe a tomar decisões de implementação, arquitetura e design. Algumas vezes o próprio coach faz papel de tracker. Outras o time escolhe sozinho quem exercerá este papel.
  • Cliente – em XP o cliente faz parte da equipe. Deve estar sempre presente e pronto para responder às dúvidas dos programadores.

Práticas de XP

A parte principal da metodologia são as Práticas. Para descrevê-las precisaremos de alguns posts. Existem vários livros que falam das práticas de XP e podem ajudar o leitor a obter maiores detalhes. Os principais são os escritos pelo próprio criador da metodologia (Extreme Programming Explained: Embrace Change). Neste post faremos um breve resumo das práticas e em breve entraremos nos detalhes de algumas delas.

  • Planejamento - assim como no Scrum, existe uma fase de planejamento, quando desenvolvedores e cliente se encontram para priorizar e estimar histórias.
  • Fases Pequenas - cada fase é chamada de iteração (Sprint no Scrum). Elas devem durar no máximo 30 dias, mas o ideal é que seja 15 ou até 7 dias.
  • Design Simples - seguindo o valor simplicidade, os projetos devem ser simples e atender a cada passo somente o que foi pedido. Nada de matar formigas com canhão!
  • Testes - todo desenvolvimento inclui testes. Kent Beck diz que código sem teste não existe. Os testes devem ser escritos de preferência antes do desenvolvimento (TDD - test driven development) e sempre devem rodar de forma automatizada.
  • Refatoração - é um conjunto de técnicas para modificar o código do sistema sem alterar nenhuma funcionalidade. O objetivo é simplificar, melhorar o design, limpar, enfim, deixar o código mais fácil de entender e dar manutenção.
  • Programação Pareada - em XP dois programadores sentam juntos no mesmo computador e programam juntos. Enquanto um programador digita, o outro observa, pensa em melhorias, alternativas. Falaremos mais sobre a programação em pares e seus benefícios
  • Propriedade Coletiva - O código fonte não pertence a um único programador. Todos da equipe são responsáveis. Todos alteram código de todos (mas sempre rodando os testes para se certificar que nada foi quebrado)
  • Integração Contínua - depois de testada, cada nova funcionalidade deve ser imediatamente sincronizada entre todos os desenvolvedores. Quanto mais freqüente for essa integração, menores são as chances de conflitos de arquivos que vários programadores alteram simultaneamente
  • Semana de 40 horas - programar é uma atividade intensa e que não rende se o programador não estiver descansado e disposto. Por isso, 40 horas de trabalho por semana é essencial para a saúde do time.
  • Cliente Sempre Presente - o cliente não é alguém de fora, mas sim um membro da equipe. Ele deve estar sempre disponível e pronto para atender às dúvidas dos desenvolvedores.
  • Padronizações - se todo o time seguir padrões pré-acordados de codificação, mais fácil será manter e entender o que já está feito. O uso de padrões é uma das formas de reforçar o valor comunicação.

São muitas práticas! Para colocá-las em produção é preciso paciência e conhecimento. O ideal é começar com 2 ou 3 delas e ir inserindo lentamente as outras, sentindo as dificuldades, refletindo e avaliando as mudanças. Muitas das práticas só serão aprendidas na prática (ha ha! por isso chamam práticas). Aos poucos falaremos mais sobre cada uma delas e daremos dicas de como podem ser aplicadas em conjunto. O mais legal é que as práticas se sustentam: uma ajuda a outra a tornar o projeto mais eficiente e ágil.

Dia 26/junho às 15h farei uma palestra online sobre XP. O endereço para quem quiser se inscrever é:
http://www.locawebcast.com.br/webcast.aspx

Escrevendo boas histórias de usuário

Sexta-feira, 13 de junho de 2008 por Mauricio De Diana

O que é e para que servem histórias de usuário foi explicado em um post anterior. Mas faltou comentar sobre como se escreve uma boa história. Segundo Mike Cohn, autor de User Stories Applied, uma história bem escrita obedece as características do acrônimo INVEST - Independente, Negociável, Valiosa para o cliente ou usuário, Estimável, Pequena (Small em inglês) e Testável.

Independente

  • Um usuário da loja virtual consulta um produto por palavra-chave.
  • Um usuário da loja virtual consulta um produto por categoria.

Essas histórias podem apresentar um problema no momento da estimativa. Ambas provavelmente usam a mesma infra-estrutura da aplicação (o código que faz uma busca no banco de dados, por exemplo), tendo como única diferença o critério da busca. Dessa forma os desenvolvedores vão dizer que a estimativa vai mudar dependendo da ordem em que as histórias serão implementadas, ou seja, depois de implementada a primeira busca, a segunda será mais fácil. Esse tipo de situação prejudica bastante o planejamento e o desenvolvimento dos sprints, já que passa a haver a necessidade de se controlar essas dependências.

Seria melhor se essas histórias fossem combinadas ou se a parte comum entre elas fosse colocada em outra história. Nesse caso os desenvolvedores poderiam alegar que feita a busca por um critério a outra seria tão fácil que nem compensaria manter duas histórias separadas:

  • Um usuário da loja virtual consulta um produto por palavra-chave ou por categoria.

Ou então, caso eles considerassem que vale a pena ter duas histórias, elas poderiam ser:

  • Um usuário da loja virtual consulta um produto por um critério qualquer (palavra-chave ou categoria).
  • Um usuário da loja virtual consulta um produto por um segundo critério (palavra-chave ou categoria).

Negociável

  • Um usuário da loja virtual opta por embrulhar um ou mais dos itens comprados para presente, escolhendo se o papel é azul ou vermelho. Ele também opta por enviar um cartão, que pode ter uma mensagem padrão ou personalizada, sendo que ele paga R$ 0,10 a mais nesse caso.

Essa é uma história com detalhes demais. Um dos problemas de se ter um excesso de detalhes na história é que ela não é uma especificação de requisitos, mas sim uma promessa de conversa futura entre desenvolvedores e clientes. Aí existe o risco de os desenvolvedores acharem que têm todas as informações de que necessitam e não conversar com o cliente. Além disso, parece que essa história pode ser dividida.

Mas o maior problema desse nível de detalhe é que a história deixa de ser negociável, o que é importante para se garantir que a equipe sempre entregue algo de valor para o cliente ao final de um sprint. O ideal é que histórias tenham escopo variável, para que, conversando, cliente e equipe cheguem a um acordo do quão “profundamente” ela será implementada. Assim, a história poderia ser melhor escrita:

  • Um usuário da loja virtual opta por embrulhar itens comprados para presente, escolhendo o papel e a mensagem do cartão.
  • Um usuário da loja virtual que opte por enviar um cartão com mensagem personalizada paga um adicional por isso.

Assim, caso os desenvolvedores percebam que não vão conseguir entregar a história completa, podem sugerir para o cliente que a escolha de mensagens personalizadas não seja implementada. Nesse caso, o cliente cria outra história para o futuro:

  • Um usuário da loja virtual escolhe entre a mensagem padrão ou uma mensagem personalizada quando decidir embrulhar um item para presente.

Valiosa para o cliente ou usuário

  • O sistema suporta no máximo 50 conexões simultâneas com o banco de dados.

O problema que essa história apresenta é o de não ter valor para o cliente, já que ele não tem como priorizá-la com relação às outras - tente imaginar a dificuldade que ele teria ao tentar comparar essa com as apresentadas nos tópicos anteriores. Ela poderia ser re-escrita de forma que ele possa entender melhor do que ela se trata e quais as conseqüências para o seu negócio:

  • 50 usuários fazem compras na loja virtual simultaneamente.

Um outro item a considerar é que histórias podem ser valiosas tanto para o cliente quanto para o usuário final. O último exemplo tem valor para o cliente, que é quem paga pelo projeto e que quer que muitos usuários consigam utilizar o seu site simultaneamente, pois isso significa um lucro maior para ele. Mas as outras histórias citadas nesse post, começadas por “Um usuário …”, possuem valor direto para o comprador de produtos pelo site.

Estimável

  • Um usuário da loja virtual recebe um e-mail caso a operadora de cartão crédito recuse o pagamento.
  • Um usuário da loja virtual vê no máximo 10 resultados de uma consulta por página.

Fazer a estimativa para o primeiro caso é fácil: se os desenvolvedores não sabem como operadoras de cartão crédito funcionam, ou seja, não entendem do domínio, eles simplesmente perguntam para o cliente, que deve estar presente na reunião de planejamento e deve saber responder à pergunta.

Já o segundo caso é mais complicado: se nenhum dos desenvolvedores implementou paginação em uma aplicação web eles não têm como estimar e também não têm para quem perguntar. Nesse caso a história não deve entrar no sprint sendo planejado, mas sim uma outra que representa o que Extreme Programming chama de spike: uma mistura de estudo e testes com a tecnologia para entender como se faz alguma coisa. Com esse conhecimento será possível estimar melhor a história para o sprint seguinte.

Um outro motivo que pode dificultar o processo de estimar uma história é o seu tamanho, o que está relacionado ao próximo tópico.

Pequenas (Small, em inglês)

  • Um usuário da loja virtual compra produtos.

O exemplo acima é o que se costuma chamar de épico, que nada mais que uma história grande demais. Histórias assim dificultam muito o processo todo, desde as estimativas até a criação de tarefas para a sua implementação. Em um caso como esse não há muita opção que não dividir a história em outras.

Normalmente uma história é considerada grande por ter trabalho demais envolvido. Nesse caso, o próprio cliente ajuda a equipe a dividir a história. A história acima poderia ser transformada em:

  • Um usuário da loja virtual adiciona itens ao carrinho de compras.
  • Um usuário da loja virtual fecha o pedido.
  • Um usuário da loja virtual calcula o frete da sua compra.
  • Um usuário da loja virtual escolhe a opção de pagamento.
  • Um usuário da loja virtual adiciona os seus dados cadastrais ao site.
  • etc.

Raramente uma história é considerada pequena demais, mas isso pode ocorrer. Nesses casos, é uma boa idéia agrupar várias dessas histórias em uma única. Um exemplo de situação em que isso pode ocorrer é um grupo de melhorias relativas a texto e cores em algumas páginas do site.

Testável

  • Um usuário da loja virtual espera muito pouco para ir de uma página a outra.

Essa é uma história que não tem como ser testada e, portanto, o cliente não tem como dizer se a solução dada pelos desenvolvedores é satisfatória. Além disso, testes automatizados são importantíssimos. Se a história for escrita dessa forma isso nunca acontecerá. Dessa forma, ela precisa ser mais objetiva:

  • Um usuário da loja virtual espera no máximo 7 segundos para ver uma página após tomar uma ação no site.

Essas são características que quando presentes nas histórias tornam muito mais simples as estimativas e o planejamento. Mas para funcionar de fato, tanto desenvolvedores quanto cliente devem conhecê-las e se preocupar com elas. Para isso, uma sugestão: uma apresentação rápida para todos os envolvidos antes de começar um projeto mostrando o que é necessário para se escrever boas histórias.

Webcast - Metodologias Ágeis e Scrum

Quinta-feira, 12 de junho de 2008 por Elson Barbosa

Repassando o post publicado no blog oficial da Locaweb:

Na próxima Sexta-feira, 13 de Junho às 15h, faremos uma transmissão ao vivo sobre a utilização de Metodologias Ágeis e Scrum no desenvolvimento de Software.

A duração prevista é de 60 minutos e a participação é gratuita.
Para participar clique aqui, preencha o cadastro e faça a sua inscrição.

Se você já se cadastrou, clique na aba “Já sou cadastrado“, digite o seu e-mail e inscreva-se no evento.

As vagas são limitadas!

O evento será apresentado por Elson Barbosa, Gerente de Projetos, que destacará os principais benefícios destas metodologias nas equipes de desenvolvimento.

Obs: o webcast é um projeto piloto da Locaweb e podem ocorrer instabilidades durante a sua apresentação.

Como sempre, sugestões são MUITO bem-vindas!

Qual é a taxa de sucesso das metodologias ágeis?

Sexta-feira, 6 de junho de 2008 por Joca

Talvez você esteja curioso: afinal essas tais de “metologias ágeis de desenvolvimento” funcionam mesmo? Existe alguma pesquisa falando da taxa de sucesso de adoção dessas metodologias? InfoQ.com, uma comunidade online independente focada em mudanças e inovações em desenvolvimento de software, publicou recentemente os resultados da versão de 2008 da Pesquisa de Adoção Ágil.

Essa pesquisa foi feita em 642 empresas e mostra que a taxa de adoção de metodologias ágeis é de 69%. Há vários outros dados interessantes como tamanho dos sprints, escalabilidade e se todos os desenvolvedores ficam no mesmo lugar.

Contudo, um dado que me chamou a atenção é a efetividade das metodologias ágeis se comparadas aos métodos tradicionais de desenvolvimento:

Fator Melhorou Não mudou Piorou
Produtividade 82% 13% 5%
Qualidade 77% 14% 9%
Satisfação 78% 15% 7%
Custo 37% 40% 23%

Os resultados acima mostram que vale a pena investir em metodologias ágeis. Todos sairão ganhando!

Discurso de elevador - explicando metodologias ágeis

Segunda-feira, 2 de junho de 2008 por Joca

Agora que já sabemos o que são as metodologias e vamos começar a aprender seus detalhes, pode acontecer de sermos pegos de surpresa pelo nosso chefe, ou mesmo por um cliente, nos perguntando “mas o que são essas tais de metodologias ágeis que vocês tanto falam?”.

No blog da Agile Chronicles eles nos oferecem um discurso de elevador para ajudar a responder. Suponha que você esteja pegando um elevador e tenha que explicar para alguém durante essa viagem de elevador o que são as metodologias ágeis. Deve dar uns 30 segundos para toda a explicação.

Então aqui vai:

Metodologias Ágeis de Desenvolvimento são basicamente 3 coisas:

  1. um conjunto de melhores práticas de engenharia de software que permitem a entrega de software de alta qualidade;
  2. um processo de gestão de projetos que encorajam avaliação e adaptação frequente;
  3. uma filosofia de liderança que encoraja o trabalho em equipe e a responsabilidade do time.

O sucesso na economia atual requer que respondamos sempre prontamente às mudanças de mercado. Os processo ágeis permitem que nossas equipes atendam às demandas de nossos clientes, demandas essas que sempre sofrem mudanças, ao mesmo tempo que cria um ambiente onde os melhores desenvolvedores querem trabalhar.

Histórias de usuário

Quinta-feira, 29 de maio de 2008 por Mauricio De Diana

Uma questão fundamental no desenvolvimento de software é a forma pela qual os clientes dizem para os desenvolvedores o que eles esperam que seja feito. Uma cena clássica e bastante inconveniente é aquela em que os desenvolvedores apresentam para o cliente o que fizeram e o cliente diz que não era bem aquilo o que ele tinha em mente. Muitos tentam evitar essas situações através da criação de especificações de requisitos antes de se começar o desenvolvimento. Nesses casos, é responsabilidade do cliente escrever nos mínimos detalhes tudo o que ele espera da aplicação antes de os desenvolvedores começarem a trabalhar. Se depois ele mudar de idéia, bem… isso é problema dele.

Essa forma de organizar a comunicação entre cliente e desenvolvedores apresenta alguns problemas óbvios. Primeiro, nem sempre o cliente sabe exatamente o que quer. Depois, é comum que, após ter visto algo que foi desenvolvido, ele tenha novas idéias de coisas a serem feitas ou alteradas. E o principal é que é praticamente impossível colocar no papel com clareza e exatidão, em português, as características de um software. Normalmente os desenvolvedores consideram essa situação irritante e desagradável, o que de fato não deveria ocorrer, já que isso não só é natural, como no final a única coisa que deveria interessar é ter um cliente satisfeito.

A solução encontrada pelas metodologias ágeis para resolver esse problema é bastante simples, como está explícito no manifesto ágil: “colaboração com o cliente ao invés de negociação de contratos”. E a especificação de requisitos detalhadas nada mais é do que um contrato. Mas então qual é a sugestão para entender e desenvolver o que o cliente quer?

A “ferramenta” leva um nome bem simples: histórias de usuário. Uma história de usuário nada mais é que uma ou duas frases, escrita pelo cliente na sua linguagem, sobre algo que a aplicação deve fazer. Histórias possíveis para uma loja virtual seriam “Um usuário possui um carrinho de compras no qual ele adiciona produtos que quer comprar”, “Um usuário faz o pagamento com cartão de crédito ou boleto bancário”, “Um usuário lê comentários feitos por outros sobre os produtos da loja” e “Um usuário recebe um e-mail de confirmação de compra quando efetua um pagamento”. Qual a quantidade máxima de itens no carrinho de compras? Quais são os cartões de crédito aceitos? Qual o conteúdo do e-mail de confirmação? Essas definições, que seriam obrigatórias em uma especificação de requisitos formal, não fazem parte da história. Isso porque costuma-se dizer que uma história nada mais é que “uma promessa de uma conversa futura entre cliente e desenvolvedores”.

Normalmente um cliente escreve as histórias e as apresenta na reunião de planejamento de release (aguarde um post sobre o assunto em breve) e novamente na primeira parte da reunião de planejamento do sprint no qual ela será desenvolvida. É nesse momento que os desenvolvedores começam a fazer as perguntas para o cliente para entender melhor do que a história se trata. E essas perguntas não param no planejamento. Mesmo durante o sprint os desenvolvedores devem voltar ao cliente e pedir mais detalhes de qualquer dúvida que tenham, daí a importância de haver um cliente o mais ativo e acessível possível.

Outra função fundamental da história é guiar os testes de aceitação. Esses testes não dizem respeito ao funcionamento interno da aplicação, mas sim às funcionalidades implementadas, já que seu objetivo é ajudar o cliente a validar se o trabalho desenvolvido está de acordo com o que havia sido pedido. Para o cliente não interessa se a comunicação com o banco de dados está correta ou se a integração entre duas classes foi bem sucedida, mesmo porque na maioria das vezes ele não entende de nada disso. Para ele o que importa é confirmar que a aplicação sendo desenvolvida está de acordo com o que ele espera ter em produção no futuro. E a história é importante nesse processo pois dúvidas surgirão e serão debatidas com o cliente no momento em que os desenvolvedores (ou o time de QA) tiverem que escrever os testes de aceitação baseados nela, o que por sua vez guiará o desenvolvimento correto.

Até o momento falamos de dois dos 3 C’s das histórias: conversa e confirmação. O terceiro C é o cartão. A idéia é usar papel e caneta, as ferramentas mais simples possíveis, para se gerenciar as histórias. As histórias estarem em cartões tem várias vantagens. Primeiro, o espaço para escrever é limitado e ninguém vai tentar colocar detalhes em excesso nela, aumentando as chances de “pularem” a conversa. Depois, é interessante no planejamento de release (que pode ter algo em torno de 80 histórias para uma pequena aplicação) poder manipular fisicamente as histórias, agrupando-as, empilhando-as, espalhando-as na mesa, fazendo anotações nelas, etc.

Além disso os cartões também são bons no que diz respeito a feedback visual, com muitas equipes usando os próprios cartões como ferramentas de controle durante o desenvolvimento. Eles ficam pregados em quadros e são movidos de acordo com seu status “não iniciado”, “em andamento” e “pronto”, por exemplo. Olhar para o quadro é uma maneira intuitiva e eficiente de se saber como anda um projeto, é fácil perceber em que categoria os cartões estão se acumulando.

No fim, o conceito de histórias de usuário nada mais é que uma forma de forçar e simplificar a comunicação entre clientes e desenvolvedores, utilizando a linguagem do próprio cliente para guiar o desenvolvimento, estimulando assim a colaboração entre todos os envolvidos, o que certamente é a melhor maneira de se atingir o fim comum.