Série Agile: Agilista

Olá pessoal,

Vou trazer pontos os quais acredito que todo Agilista tenha passado quando este começou a falar de Agile para alguém ou um team “No Agile here.”

Lets go..

O que todo Agilista sofre:

  • Vira motivo de risada: todos dão risada dele e dizem: “ele acha que a metodologia Agile é a bala de prata e vai mudar o mundo”. Na verdade o Agilista que deveria rir, porque ele conseguiu “mudar” e aqueles profissionais que são resistentes a qualquer tipo mudança estão com os dias contados :);
  • Ser ignorado: todo agilista é ignorado no início;
  • No bugs: associa que um agilista acredita que ao desenvolver um software usando metodologias não se cria bugs. Mas ninguém diz isso, porém acusação sobre o coitado do agislita é servera;

O que os demais acreditam:

  • Que a forma que tem usado até hoje é a correta, senão o projeto não existia, porém esquece que se existe até hoje talvez seja por consequência;
  • Que software sem bug tem algo de errado e que alguma das funcionalidades não foram implementadas, pois não é possível desenvolver software sem bug;
  • Aumentar a cobertura de unit tests depois do código já escrito é sinonimo de qualidade;

Bom vou ficando por aqui. E você já passou por isso ou algo pior? Comente… 

abracos, see ya!!

Série Agile:Qualidade Externa e Interna estimativas

Olá pessoal,

No post de hoje vou falar sobre qualidade externa e interna de quando vamos desenvolver um produto. Tá, não se preocupe porque vou explicar com mais detalhe durante o post, porém  responda a pergunta a seguir, se a resposta for sim, então já sabe o assunto que vamos tratar.

Algum cliente seu já pediu para você reduzir um pouco a sua estimativa para entregar alguma tarefa?

Se sua resposta foi sim, é disso que vamos falar:

como convencer o cliente que a qualidade não é negociável?

Lets go…

 

Starting

Como vocês, que tem acompanhado o blog e meu twitter, puderam ver, tenho me dedicado ao mundo Agile, mas o que vou falar aqui não está só ligado ao Agile, mas foi onde eu consegui perceber isso de forma mais face-to-face com o cliente e de certo modo foi onde houve menos questionamentos por parte dele e até uma aceitação de mudanças sem muita discussão. Eu sempre sofri com esse mal (desde da época de freelance), do cliente pedir para mudar uma estimativa, porém ele não queria mudar o escopo dele e sabemos que isso não é nada bom. Mas, como contornar a situação sem gastar muito tempo? Para isso é preciso ter duas coisas bem claras em mente:

  • Qualidade externa: aquilo que o cliente vê, tem acesso, que é o front-end, lentidão, etc.
  • Qualidade interna: aquilo que o cliente não tem acesso, tais como: refactoring, covertura de testes, code clear etc.

Quando o cliente pede para reduzirmos a estimativa ele está afetando a qualidade interna, algo como: “Sei que você tem a melhor equipe, com os melhores profissionais, será que não dá para fazer em 1 ou 2 dias a menos (isso aqui dá -16 hrs de trabalho, o que é muita coisa)?”

Normalmente não dá para mudar isso, pois nós sabemos do impacto. E como  resolver isso?

Resposta ao cliente

Podemos perguntar ao cliente se o escopo não pode ser alterado, que aquela parte onde temos as mensagens iterativas com o usuário não poderia ficar para o futuro e que por agora trataríamos com mensagens mais simples possível, por exemplo. Ou mudar o nível de importância, assim isso impactará em outras e saberemos o que deve ser entregue primeiro e isso forçará o product owner mover o backlog. Mas abrir mão da qualidade interna é algo que não deve ser feito, pois já sabemos dos problemas que vamos encontrar e o cliente não vai levar em conta essa redução de estimativa quando os problemas surgirem, principalmente se estes afetarem o “bolso dele”. Pense: “uma vez que se penetra que uma base de código se deteriore, é muito dificil recuperar a qualidade mais tarde”.

Um sistema com alta qualidade interna pode ainda ter baixa qualidade externa, porém um com baixa qualidade interna raramente terá uma qualidade externa alta, ou seja, não dá para construir algo bom se a base está pobre, então daí que dizemos que a qualidade interna simplesmente não é negociável.

Vou ficando por aqui. Espero que tenham gostado do post.

Abracos, see ya!

Lançamento livro: TDD na Prática

Olá Pessoal!
É com muita felicidade que venho compartilhar com vocês mais esse “filho”. Eu não sei nem por onde começar de fato. Mas que tal pelo inicio?
Bom, a seguir falo um pouco da história dele (como todo livro meu sempre tem uma história real por trás), porque escrevi, quem pode ler,  sorteio etc Vou buscar ser bem breve..
Lets go…
Agradecimentos
Fazer esta parte aqui nunca é fácil, pois são várias pessoas que contribuem para uma obra como esta: amigos, colegas de trabalho, familiares, amigo virtual, etc. E lembrar de cada um não é uma tarefa fácil. Sendo assim, estarei destacando aqueles que vieram em memória no momento que escrevo este trecho.  Aqueles que contribuíram e acabei esquecendo, peço que me perdoem.
Primeiro, não poderia esquecer o meu colega de trabalho Gustavo Knuppe. Apesar dele não saber que estava escrevendo este livro, foi responsável por muitas mudanças que fiz na forma de abordar o assunto de TDD, principalmente em um artigo, no qual Knuppe foi o revisor, e nesse processo sugiram várias e boas sugestões no artigo produzido que aproveitei para utilizar neste projeto.
Um amigo que não poderia deixar de fora é o Alberto Leal. Eu diria que meu contato com mundo Agile começou devido a uma apresentação sobre refactoring que o Leal fez em alguns minutos via MSN e depois desse dia fui me envolvendo mais e mais com a técnica e quando conheci TDD e liguei o passado com o presente vi que ter conhecido refactoring com o Alberto fez uma diferença grande. Obrigado meu amigo!
À minha namorada Ellis Ribeiro, que teve a paciência e dedicação em revisar a parte ortográfica e dar sugestões de melhoria na estrutura do livro 🙂
Como tudo começou… (Era uma vez….)
Bem, primeiro nunca imaginei que um dia eu escreveria um livro sobre TDD, independente de que foco este teria. Até porque eu não sabia nada do assunto até inicio de 2010, apenas ouvia. Tinha tentado usar algumas vezes antes e fracassei em todas elas. Nunca entendia de fato como fazer os unit tests, muito menos escreve-los primeiro, mas fiquei com aquilo na cabeça. Todos (Kent Beck, Martin Fowler, Guilherme Silveira, etc) falam e conseguem, daí eu me perguntava: “o que eu estou fazendo de errado? Não vou desistir de entender direito.”  Dai passou o tempo, tive que voltar a estudar devido a um projeto que precisei trabalhar em 2010 e tinha que escrever unit tests para as coisas darem certo e então fui estudando, começei a ler e pesquisar com mais detalhe. Lembro que o primeiro post que li sobre o assunto foi do Guilherme Chapiewski. Fui navegando para outros blogs, tentando entender a mecânica e praticar. Comecei a pegar o ritmo, mas confesso que naquele momento não sabia que eu fazia TDD na veia, era complicado, pra mim era código com um framework que eu testava o que escrevi. Mas cada vez que programava gostava do resultado, ficava viciado, daí decidi me aprofundar mais no assunto, e fui buscar referências “for dummy”, tanto em português quanto em inglês. Achei? Não, pois identifiquei os seguintes problemas nas obras publicadas sobre o assunto na época:
1. Era necessário ter uma certa experiência (nem que fosse muuuito básica) com a mecânica de unit test;
2. Os livros eram longos e poucos práticos para iniciantes, com exemplos esquisitos que ao término da leitura sentia falta de algo mais concreto para praticar e dizer: ‘entendi de fato com a mão na massa’. Enfim, faltava uma direção melhor para iniciantes.
E foi quando despertou de sair anotando tudo que ia aprendendo, tanto aquilo que deu certo quanto o que deu errado também. Meses depois (no final de 2010), por “ironia” do destino caiu no meu caminho o meu primeiro projeto, o qual usariamos TDD. Mesmo sendo pequeno ajudou muito, digo que foi onde tudo começou de fato, com erros e acertos, mas foi gratificante o resultado. Dai fui para um outro mais arrojado, de 1 ano, e TDD foi a base para podermos entregar o código com qualidade, menos bug, menor custo de manutenção e respeitando os prazos. Tudo isso me fez refletir. Um dia parei e olhei para tras e perguntei: “O que aprendi até hoje? Que tal criar um livro sobre o assunto? Aliás, usar minhas anotações, experiência adquirida, para ajudar quem está querendo entrar nesse mundo?” Observei nos fóruns e comunidades Java que muitos tinham vontade de aprender TDD, outros tinham tentado e fracassado, alguns nem sabiam por onde começar.
 Enfim, todos os problemas que passei eram bem recorrente para todo iniciante. E foi aí que nasceu o meu livro “TDD na Prática”. Essa é a história dele.
Quem pode ler?
Essa é uma pergunta muito comum: “será que devo comprar?” Eu digo sempre o seguinte: compre o livro se você:
1. Conhece bem o básico do Java e Orientação a objetos. Olha o que eu estou falando, conhece bem JAVA e não JEE. Iniciantes ainda fazem confusão com as siglas do Java (não deveria, pois a primeira lição é saber as diferenças);
2. Sabe o que é unit tests ou tem ideia de para que serve;
3. Sabe a diferença entre unit test x Junit;
4. Quer de fato aprender TDD e saber que, no inicio, será um caminho duro, sofrido, pois não é só sentar na máquina e sair codificando. É uma forma diferente de pensar, codificar, resolver problemas, que no resultado final isso é transparente para quem olha sua aplicação e diz: “Essa eu digo 100% que foi feito com TDD, mas essa não”. A olho nú não é possível dizer isso.
5. Gosta de desafios e quebrar a cabeça;
Se você se encaixa nos pontos acima, pode adquirir um exemplar, caso contrário, eu diria que não compre :).
Como o livro está estruturado?
Bem, para quem conhece meus livros sabe que sou bem informal na escrita e gosto de dar a sensação ao leitor que estamos mais batendo um papo que lendo um livro em si. Com esse não será diferente, pois é meu jeito natural de escrever. Mas o que eu coloquei no livro?
Bom, quando começei a escrever a primeira pessoa que eu pude me espelhar era eu mesmo, aquele cara que não sabia:
  • – nada de TDD na prática, só ouvia falar;
  • – conceitos de Agile, muito abstrato ou quase nenhum;
  • – tanta sigla, termos TDD, Mocks, Mockito, Junit, refactoring que na prática, juntando tudo no “liquificador”, nunca sabia se o resultado final era de fato o esperado;
  • – e um cara que não sabia programar usando unit test; Alias, mal entendia uma classe que tinha métodos com as anotações @Test. Me perguntava “pra que realmente isso serve? como pode agregar valor na aplicação?” Só ouvia as pessoas falarem: “É bom”. “Funciona”. “Usa isso que vai ser show”, “Seus problemas acabaram, use unit test”. Mas no fundo não entendia como, e tive que aprender isso sozinho.
Então o livro segue uma ordem que, a depender em que nível você está, pode ir lendo sequencialmente. Eu diria que se é bem iniciante mesmo, vá na ordem sequencial, mas se você já sabe mocks, usar o JUnit, etc, pode pular alguns e ir para o qual lhe interessa de imediato.
Coloquei exercícios para serem feitos com o objetivo de forçar o leitor a exercitar o que aprendeu sobre TDD de formas diferentes. Vamos começando em um nível com a minha ajuda, mas depois deixo você ir sozinho, tomando suas decisões de quais testes escrever. Isso ajuda a ganhar confiança naquilo que está fazendo, o que no inicio com TDD todos se sentem desconfortável, inseguros e se perguntando: “será que estou fazendo a coisa certa? É isso mesmo?”. Enfim, espere exercícios um pouco diferentes do que você está acostumado a fazer no dia-dia. Também compartilho com o leitor como eu faço TDD e a gente vai vendo o que da certo e não da. Em alguns exercícios há respostas, para depois o leitor comparar e ver como resolvi. Não quer dizer que o seu tem que ser igual ao meu, cada um resolve de uma forma. O objetivo é que você tenha feito realizando os testes primeiro. Mas há outros que não temos a resposta. Fiz esses para que você possa olhar para o problema e garantir que atendeu ao requisito, ou seja, resolveu de fato usando TDD sem ter outra solução para preparar. Isso ajuda a ter mais confiança no que você entrega, já que todo “TDDista” sempre vai ouvir a seguinte frase: “Isso não funciona”, “Isso é coisa de nerd”. “Só funciona no mundo do Kent Beck e Martin Fowler”. Mas acostume-se com esses e outros comentários, faz parte do dia a dia, e o melhor de tudo: não se irrite. Há um capítulo que explico o Junit, Mocks, refactoring, falo rapidamente sobre Agile e Scrum.
Onde adquirir um exemplar?
Acredito que, dentro de uma semana no máximo, o livro estará disponível nas melhores livrarias, como: Saraiva, Cultura, Fnac, etc. E nas lojas virtuais: livrosdeprogramacao.com, submarino.com.br, americanas.com.br  etc.
No site da editora você pode comprar: www.lcm.com.br.
Formato do livro:
O livro será disponibilizado no formato impresso (R$ 36,80) e e-book(R$ 27,80). A versão ebook só será vendida pelo site da editora.
SlideShare
Disponibilizei no slideshare alguns capítulos do livro.
Sorteio
Você tem até 02/12/2012 para realizar o seu cadastro. No dia 03/12/2012 divulgarei o resultado.
Regras:
  • – Não é permitido realizar 2 cadastros. E-mails duplicados e a pessoa não estará mais participando do sorteio. Então façam apenas 1 cadastro por e-mail. Lembrando que deve ser um e-mail válido, pois o contato para confirmação dos dados será feito pelo e-mail cadastrado, e o ganhador tem até 48hrs para responder, a partir da data de recebimento. Caso contrário, um novo sorteio será feito;
  • – O livro será enviado para o endereço informado no cadastro. Então coloque o endereço completo + ponto de referência.
Atualização: 
O ganhador poderá escolher se deseja a versão impressa ou e-book.
Resultado
O ganhador foi: Rafael Oliveira
note: Um e-mail foi enviado para o ganhador o mesmo tem até 48hrs para confirmar o recebimento e dados de entrega. Caso não seja respondido em 48hrs a partir da data de envio, um novo sorteio será realizado. 
 Bom, vou ficando por aqui.
Demorou, mas chegou. 🙂
See ya!!

IcreScrum tools para Team Agile

opa! Pessoal,

O post de hoje é para quem teve dificuldade de rodar o IceScrum localmente em ambiente Linux. Ahh, você sabe o que é iceScrum? Se não sabe, fique tranquilo que irei explicar.

Lets go…

IceScrum

Bom, venho há algum tempo buscando ferramentas open-source eficiente para usar nos meus projetos Agile, tentei de cara ScrumWorks, porém a limitação deles para nro de usuário e feature para a versão free foram pontos que fizeram eu buscar uma nova ferramenta mais completa(claro, sem deixar de ser open-source). Daí, fui apresentado ao IceScrum através do Google, e vou lá fazer uns nos testes, e não é que a ferramenta foi aprovada? Pois, eh bem completa com relação à outras que fingem ser free, mas só com meia-duzia de feature, no máximo. A seguir falo um pouco sobre IcreScrum:

  •  100% plataforma web;
  • leve e rápido;
  • roda tranquilão no Chrome;
  • Bons conceitos de usabilidade ;
  • boa organização;
  • baixa curva de aprendizagem;
  • instalação (execução na verdade) rápida e fácil;
  • diversos tipos de chart;
  •  controle das atividades por horas ou pontos;
  • no dashboard temos todas as informações que precisamos;
  • podemos usar post it para user stories (achei bem legal);

O que sentir falta?

  • definir deadline  ou horas para uma task;(pelo menos achei, onde fechar uma task, ou definir quando ela deve ser concluída)
  • add uma task à um Sprint deveria ser mais fácil de encontrar e adicionar.

Ainda estou testando a ferramenta para conhecer melhor, mas já adotei para um projeto e quero ver  se ela vai atender aos principios de um projeto Agile. No link a seguir temos os screensshots da ferramenta:

http://www.icescrum.org/screenshots/

Rodando o IceScrum Localmente ambiente Linux

  1. faça o download da ferramenta na versão bundle: http://www.icescrum.org/en/download-en/
  2. descompacte o arquivo
  3. abra  o terminal e navegue até a pasta bundle que foi descompactada
  4. digite: sudo chmod u+x *.sh  na raiz da pasta bundle
  5. Agora vá na server/bin e faça o mesmo
  6. Em seguida retorne para raiz, ou seja, pasta bundle
  7. e execute: sudo ./start.sh
  8. Algumas mensagens  de config são printada, é o esperado;
  9. abra o browser, por default o icrescrum roda: http://localhost:8080/icescrum
  10. Para entrar, faça um pequeno registro, que também já cria o usuario admin
  11. Pronto, done! Agora é só criar os projetos e  enjoy

 Note: Detalhe importante, para rodar o IceScrum é requerido ter o TomCat 6  ou later instalado, para este post usei o Tomcat 7.

Vou ficando por aqui, espero que tenham gostado do post.

see ya! Guys

abraços,

Scrum:Definindo as estórias para o Sprint Backlog


olá Pessoal,

Demorei um pouco, pois os ultimos dias tem sido corrido, mas está aqui mais um post da série Scrum, hoje vou apresentar como é que a equipe define quais estórias estarão no Sprint Backlog do Sprint que inicia amanhã. Vimos em um dos post anteriores que o PO é um cara importante no planejamento do Sprint. Então chegou a hora de discutir de como tirar as coisas que estão no Product Backlog e trazer para nossa “mesa”. Antes de começar o post queria compartilhar com vocês um vídeo muito interessante desenvolvido pela FIAP. Não é fazer propaganda da instituição, pelo contrário o vídeo foi feito com objetivo informativo sobre o mercado de TI. Vejam:


Lets go

Como a equipe define as estórias que vão para um Sprint?

Essa é uma pergunta clássica. Eu já ouvir alguns comentários que talvez o PO ou SM deveria fazer isso. Eu acho que se Scrum fosse um framework que funcionasse com base em quem tem o nível mais alto(para não dizer função) é quem define as coisas, talvez faria sentido. Mas, como não é assim, o conceito de time, equipe, pessoas etc, é de fato mais importante que os papeis apenas. Enfim, apesar do PO ter escrito toda história e em alguns casos ser o responsável pelo investimento no projeto, com Scrum isso não dar o direito de dizer: “a estória já está escrita, priorizada e o escopo é aquele. Se não entendeu algum ponto, por favor, deixe me saber, mas não vou mudar o escopo, porque eu quero assim”. Não é bem por ai. A questão é quem tem a bola da vez aqui é o time, ou seja, todos estão envolvidos e não apenas o PO. Não é porque ele é dono do produto que tudo vai acontecer como ele deseja sem questionamentos. Se temos um problema como esse é sinal que seu cliente não entendeu como Scrum funciona e ai é um outro problema que precisa ser tratado antes de pensar quando vai acontecer a reunião de planejamento.Eu diria que até antes do cliente apresentar o produto, ele já deveria saber o porque vai rodar Scrum e saber que as coisas funciona em um trabalho de equipe e cada um tem suas responsabilidade e limitações. Se isso não está claro para o seu cliente, não inicie nada, do contrário terá problemas e discussões que talvez não compense. Agora vamos ignorar o cenário anterior, trouxe apenas fazer uma citação do mundo real :). Então, Camilo como escolher a estória que vai para o Sprint Backlog?

Por sentimento ou instinto. É isso mesmo não há mágica nem ferramenta que vai ti dizer: “pega a história X, e sim a equipe que vai contribuir para isso”. Normalmente o ScrumMaster pergunta para equipe se a estória que está no top da lista(aquela que tem mais importância para o PO) dar para entregar naquela Sprint. Aquelas que ficarem com dúvidas e incertezas da entrega fica de fora (com o aval e negociação com PO) do Sprint.

A seguir temos um exemplo, pratico de um Product Backlog:

Imagem do livro Scrum and XP from the Trenches

Note: Claro, que vamos seguir sempre a ordem de importância definidas pelo PO e não pegar as estórias aleatórias.

Vamos supor que o PO não gostou porque a história D está fora, já que a velocidade da equipe só permite entregar até a C. O que fazer?

Primeiro: O PO não pode obrigar à equipe pegar(de novo, para você não esquecer). Então ele tem duas opções:

  1. é alterar o escopo, possivelmente quebrando e o time re-estimar e ver se é possível.

  2. ele mudaria a ordem de prioridade levando a estória para acima do C, daí o team é obrigado a pegar. Porém, a estória C ficaria de fora. Mas, o framework Scrum não diz que temos que pegar a estória com maior prioridade?

Sim. Pegamos a estória que está no topo da pilha do product backlog, mas ao olhar ela identificamos que é grande demais e não cabe dentro do Sprint de duas semanas, ou seja, é pouco tempo para muita coisa(escopo grande) em uma única estória. Lembre-se, as estórias deve ser do tipo INVEST.

  • Independente: a estória não pode ficar bloqueada durante a implementação, ela precisa ter vida por si só;
  • Negociável:uma estória precisa ter um escopo que pode ser alterado sem perder toda a essência do que se pretende e algumas coisas podem ser postergadas para um dos próximos Sprint tranquilamente.
  • Valioso: deve agregar valor ao produto, ter um valor de importância dentro do produto
  • Estimável: se não conseguimos estimar com base no que está escrito para estória, é porque temos alguma problema no que ela se propõe atingir. Então precisamos ver com o PO o que ele está querendo dizer;
  • Small: não precisa ter todas as funcionalidade em única estória, sendo assim pode ser pequena para que fique dentro do Sprint.
  • Testável: toda estória precisa ter uma forma de validar se ela foi implementada corretamente. Então os critérios de aceitação devem existir, para que podemos nos certificar que fizemos algo de acordo com o esperado.

Então era isso pessoal que eu tinha para apresentar para vocês quando estiverem pegando as estórias do Product Backlog e trazendo para o Sprint Backlog. Não se esqueçam que a responsabilidade de analisar e estimar uma estória é da equipe.
O que foi escrito pelo PO para estória é o que ele desejaria(nem sempre querer é poder) de ver pronto, mas nem sempre é possível, pois há vários fatores que contribuem para isso tais como: velocidade da equipe, nível técnico, interrupções etc. Não é uma tarefa fácil, mas com uma boa comunicação entre a equipe e o PO, sempre terminamos no contexto ideal.

Vou ficando por aqui espero que tenham gostado.

Abraços, see ya!!