O mercado reclama cada vez mais de dificuldades típicas enfrentadas por uma equipe de desenvolvimento de software. Os métodos ágeis tentam, então, resolver diversos desses problemas através de práticas que favorecem o produto final e os problemas que o cliente deseja resolver.

Dos próprios princípios ágeis: "Atenção contínua a excelência técnica e bom design engrandecem a agilidade."

Neste curso prático de 20h voltado para desenvolvedores ágeis, apresentaremos práticas de desenvolvimento de software comprovadamente eficazes, sempre sob a ótica dos métodos ágeis. É um curso baseado na experiência real dos instrutores da Caelum com XP e Práticas Ágeis desde 2005 em equipes locais e remotas, em projetos internos, em clientes, consultorias e projetos open source.

As práticas reconhecidas do XP e algumas outras são abordadas durante esse curso, fazendo com que o desenvolvedor trabalhe o tempo todo em equipe para vivenciar os problemas do dia a dia de um projeto. Entre os assuntos, abordamos testes automatizados, design patterns, refatoração, processos de build, integração contínua, deploy contínuo, programação pareada e o uso de controle de versão. A valorização do código e do produto final a ser entregue ao cliente será frisada durante todo o curso, bem como as vantagens da entrega de um produto funcional ao fim de cada iteração.

Esse curso faz parte da Formação Ágil junto com o curso PM-83. Curso novo, primeira turma em Dezembro/2010.

Pré-requisitos: Cursos FJ-11 e FJ-21 ou: Java, Orientação a Objetos, Collections, JSP, JSTL básico, MVC, Hibernate/JPA, patterns DAO e Factory. Desejável noções básicas de metodologias ágeis.

Posts relacionados no blog

O medo de se adaptar

1. Problema: código desconhecido
2. Problema: entregas demoradas
3. Outros problemas
4. Enfrentando o medo com práticas ágeis

Controle de versão

1. Problema: o medo de remover código
2. Solução: Controle de versão
3. Métodos não utilizados
4. Em casa: treinando usar auxílio da IDE
5. Problema: imprevistos
6. Solução: Controle de versão com Git
7. Exercício: Mexendo com o git
8. O que vem de brinde?
9. Para saber mais: Outros sistemas de controle de versão
10. Criando um projeto usando git
11. Exercício: iniciando um novo repositório
12. Trabalhando com Branches
13. Exercícios
14. Para saber mais: hooks

Conhecendo o sistema

1. Problema: Primeiro contato com o sistema
2. Exercício: Primeiro contato com o sistema
3. O código fonte
4. O medo de quebrar algo
5. Programação pareada
6. Exercício: exercitando coragem

Bugs e testes

1. Problema: o bug
2. Exercício: identificando um bug em cenário complexo
3. Resolvendo bugs
4. Replique o problema, então corrija
5. Exercício: resolvendo bugs para que não voltem
6. Presença de testes vs. segurança
7. Exercício: eliminando testes duplicados
8. Testes como documentação

Qualidade do código

1. Problema: o único que entende sai de férias
2. Solução: dividir mais o conhecimento
3. O ambiente de trabalho
4. Exercício: troca de informações
5. Refatoração
6. Exercício
7. Desenvolvimento incremental
8. Qualidade do código é importante! Mas como medir?
9. Refatorando e testando código legado

Parar, pensar e adaptar

1. O que desejamos desenvolver?
2. Fugindo do design antecipado
3. Escrevendo testes antes
4. Teste primeiro, codifique depois
5. Faça funcionar e, então, melhore
6. Um passo de cada vez
7. Mudanças simples x Soluções simples
8. Exercicios: TDD

E se eu falhar? Integrando continuamente

1. Problema: ::merge hell:: (merges infernais)
2. Integração contínua
3. Solução: Build automatizado com Ant e Ivy
4. Dependências com Ivy
5. Build contínuo com o Hudson
6. Exercicio: instalando e configurando o Hudson
7. Para saber mais: MAVEN

Release e entrega

1. Problema: não funciona em produção
2. Acelerando o processo de deploy
3. Solução: homologação contínua
4. Exercício: Deploy para homologação
5. Exercício: Deploy para produção
6. Problema: só entrego a cada 6 meses
7. Releases curtos e frequentes
8. Solução: deploy e entrega contínua
9. Build pipeline
10. Funcionalides e branches

Testes de aceitação

1. Na minha máquina funciona!
2. Exercício: uma nova feature
3. Mas não era bem isso
4. Problema: definição ambígua
5. Solução: definindo um critério de aceitação
6. Transformando critérios em testes
7. Exercícios

Apêndice - Acompanhamento do projeto

1. Quanto estamos desenvolvendo?
2. Release vs. Iteração
3. Techtalks e Brownbags
4. Em busca de uma métrica
5. Exercício