Formação Ágil

Curso Práticas ágeis de desenvolvimento de Software em Java

Sobre o curso PM-87

O mercado reclama cada vez mais de dificuldades típicas enfrentadas por uma equipe de desenvolvimento de software. Os métodos ágeis tentam 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 há mais de 8 anos em projetos internos, em clientes, consultorias e projetos open source.

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.

Essa é a versão em Java do curso. Temos também a versão em .NET.

Veja também a ementa detalhada do curso.

Pré-requisitos

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.

20horas aula

A opinião de quem fez

Quando a escola é boa, o aluno retorna. Retornarei.

Carlos Eduardo Sant'Ana

Curso muito bom! Apostei no curso saindo de Salvador para fazê-lo em São Paulo e estou contente com a qualidade. Parabéns ao time Caelum.

Leandro Alves – Salvador/BA

Excelente treinamento. Conteúdo bem elaborado e coerente com o dia a dia. Recomendo.

Phelipe Buratto, SBCampos - SP

Próximas turmas

DataPeríodoCidadeComentário
03/11 a 07/11Manhã (9h às 13h)Brasília
24/11 a 28/11Noturno (19h às 23h)São Paulo
19/01 a 23/01Noturno (19h às 23h)São Paulo
26/01 a 30/01Noturno (18h às 22h)Rio de Janeiro - Centro Inscrições abertas.

Não achou a turma ideal pra você? Entre em contato e consulte outras turmas e horários.

Fale com a gente.

Dúvidas, reservas ou um papo com um instrutor?

Conteúdo detalhado

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. Problema: imprevistos
  5. Solução: controle de versão com Git
  6. Exercício: Mexendo com o Git
  7. O que vem de brinde?
  8. Para saber mais: outros sistemas de controle de versão
  9. Criando um projeto usando Git
  10. Exercício: iniciando um novo repositório
  11. Trabalhando com Branches
  12. Juntando commits de outra branch
  13. Exercícios: usando branches
  14. Contribuindo com projetos open source no Github
  15. Solução: Fork/Pull Requests
  16. Para saber mais: hooks
  17. Alguns comandos úteis do Git

Conhecendo o sistema

  1. Problema: primeiro contato com o sistema
  2. Exercício: Conhecendo 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. Solução: testes automatizados
  5. JUnit
  6. Replique o problema, então corrija
  7. Exercício: Resolvendo bugs para que não voltem
  8. Presença de testes vs. segurança
  9. Exercício: Eliminando testes duplicados
  10. 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ícios: Melhorando o código com refatorações
  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. TDD
  8. Mudanças simples x Soluções simples
  9. Exercícios: TDD

E se eu falhar? Integrando continuamente

  1. Problema: ::merge hell:: (merges infernais)
  2. Integração contínua
  3. Solução: build automatizado
  4. Build contínuo com o Jenkins
  5. Exercicio: Instalando e configurando o Jenkins

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. Funcionalidades e branches

Testes de aceitação

  1. Na minha máquina funciona!
  2. Mas não era bem isso
  3. Problema: definição ambígua
  4. Solução: definindo um critério de aceitação
  5. Transformando critérios em testes
  6. Criando testes de aceitação com Selenium WebDriver
  7. O Padrão Page Object
  8. Behaviour Driven Development (BDD)
  9. Exercícios: Testes de aceitação com Selenium WebDriver

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

Apêndice - Testes em cenários difíceis

  1. Quando testar é difícil ou lento
  2. Simulando comportamentos com Mocks
  3. Testando DAOs
  4. Exercícios: Testando a DAO
  5. Para saber mais: Evoluindo o Banco de Dados com Migrations
  6. Para saber mais: Pirâmide de Testes


* Os apêndices listados são conteúdos adicionais que não fazem parte do curso regular.