Posts Tagged "java"
Desenvolvendo com Agilidade na Java Magazine
Java Magazine 68
É com grande satisfação que anuncio a publicação do artigo “Desenvolvendo com Agilidade” na revista Java Magazine Edição 68. Esta foi a primeira vez que escrevi um artigo para ser publicado em uma revista, e sem dúvida foi uma grande oportunidade que me trouxe excelentes experiências e maturidade. No artigo, procurei apresentar uma visão geral sobre o desenvolvimento ágil de software, sua origem, principais metodologias e práticas.
Espero que através de artigo mais pessoas entrem em contato com o desenvolvimento ágil e que tenham assim uma melhor experiência profissional. Escrevi sobre esse tema porque realmente acredito nele, e sei que pode trazer grandes benefícios ao dia-a-dia de muitas pessoas.
Críticas, sugestões e feedback serão sempre bem vindos.
Já nas bancas!
As Muvucas do Just Java 2008
Nos dias 10, 11 e 12 de Setembro estive no JustJava 2008. Este ano tive a oportunidade de participar da organização do evento junto com todo o pessoal do SouJava, foi uma ótima experiência.
Ajudei as organizar as tradicionais Muvucas. Para aquelas que ainda não as conhecem, Muvucas são pequenas reuniões de pessoas que discutem um determinado assunto. Os assuntos das Muvucas são sugeridos por congressistas durante o evento.
Fiquei no Hall com um FlipChart e um pincel atômico conversando com as pessoas e anotando suas sugestões e votações para escolha dos temas.
Votação para os temas das Muvucas
No primeiro foram realizadas as Muvucas:
1. “Java 7” com partipação do Michael “Mister M” Nascimento que contribui diretamente para o desenvolvimento do Java 7 (De forma especial na nova API de Datas).
2. “O que além do Java ME (Android, iPhone, etc…)” com participação do palestrante internacional Roger Brinkey e do Maricio “Maltron” Leal da Sun.
3. “Desenvolvimento Ágil” com participação do Daniel Wildt e do Giovanni Salvador.
E no Segundo dia, foram realizadas mais três:
1. “Caneta Livescribe Pulse”: O Dr. Spock da Global Code fez uma demonstração sobre a Pulse (uma caneta que roda Java) e falou sobre como desenvolver software para ela.
2. “Open Source no Setor Público, reutilizando código”: Com participação do Bruno Souza (JavaMan) e algumas pessoas do setor público.
3. “Desenvolvimento Ágil com Testes”: Com participação do Rodrigo Yoshima e do José Papo que são verdadeiros mestres no assunto, discutiu-se sobre a adoção de Agile nas empresas brasileiras, integração contínua, teste unitários, testes de aceitação, Scrum e XP.
Em suma, participar da organização do evento, foi uma excelente oportunidade de ampliar o networking e aprender, além de ter sido um grande desafio pessoal. As pessoas que participaram das Muvucas tiveram uma excelente oportunidade de conhecer novas pessoas, esclarecer dúvidas, e expor seus pontos de vista.
Gostaria de agradecer ao SouJava pela oportunidade, de forma especial ao Mauricio Leal, ao Bruno Souza, a Yara Senger, e todas as pessoas que fizeram desse evento um verdadeiro sucesso.
Espero você no JustJava 2009!!!
JUnit 4 em 60 Segundos
Esse artigo que foi escrito por Abdullah Çetin ÇAVDAR em inglês, apresenta de forma simples e rápida como utilizar a nova API do JUnit. Veja também o artigo original.
Brinquei um pouco com JUnit 4 esse final final de semana, e aqui vai uma pequena introdução:
@Test
Anote seus testes com @Test. Você não precisa mais usar o prefixo test nos métodos de testes, e além disso, sua classe também não precisa mais extender TestCase.
@Test public void addition() { assertEquals(12, simpleMath.add(7, 5)); } @Test public void subtraction() { assertEquals(9, simpleMath.substract(12, 3)); }
@Before e @After
Utilize as anottations @Before e @After para para “setup” e “tearDown” respectivamente. Eles serão executados antes e depois de cada um dos seus casos de testes.
@Before public void runBeforeEveryTest() { simpleMath = new SimpleMath(); } @After public void runAfterEveryTest() { simpleMath = null; }
Utilize as annotations @BeforeClass e @AfterClass para “setup” e “tearDown” a nível de classe. Pense neles como “setup” e “teardown” que são executados apenas uma vez. Eles são executados antes e depois dos testes.
@BeforeClass public static void runBeforeClass() { // executado uma vez antes de todos os testes serem executados } @AfterClass public static void runAfterClass() { // executado uma vez depois de todos os testes serem executados }
Tratamento de Exceptions
Utilize o parâmetro “expected” da annotation @Test para casos de uso que esperam exceptions. Escreva o nome da classe da Exception que deverá ser lançada.
@Test(expected = ArithmeticException.class) public void divisionWithException() { // divisao por zero simpleMath.divide(1, 0); }
@Ignore
Use a annotation @Ignore para testes que você queira ignorar. Você pode adicionar um parâmetro String que defina o motivo pelo qual você está ignorando o teste.
@Ignore("Não está pronto para ser executado") @Test public void multiplication() { assertEquals(15, simpleMath.multiply(3, 5)); }
Timeout
O parâmetro “timeout” define o tempo máximo em milisegundos. O teste falha caso o período seja excedido.
@Test(timeout = 1000) public void infinity() { while (true); }
New Assertions
Compare arrays com os novos métodos de asserção. Dois arrays são iguais quando tem o mesmo tamanho e cada elemento é igual ao correspondente no outro array.
//public static void assertEquals(Object[] expected, Object[] actual); //public static void assertEquals(String message, Object[] expected, Object[] actual); @Test public void listEquality() { List expected = new ArrayList(); expected.add(5); List actual = new ArrayList(); actual.add(5); assertEquals(expected, actual); }
JUnit4Adapter
Rode os testes do JUnit 4 no JUnit 3 com o Junit4Adapter.
public static junit.framework.Test suite() { return new JUnit4TestAdapter(SimpleMathTest.class); }
Boa Codificação!
The Developers Conference 2008
Complementando o que já falamos sobre o evento The Developers Conference (TDC) 2008 da Global Code, gostaria de expor com mais detalhes os assuntos que nos foram apresentados.
O Evento foi aberto na sexta-feira por uma apresentação do Burr Sutter (cuidado ao pronunciar) da JBoss sobre a JBoss Entrerpise SOA Plataform, Burr falou sobre Enterprise Service Bus (ESB), JBoss Rules (Drools) e Business Proccess Managment (BPM).
Burr Suter da JBoss
O Edgar Silva , também da JBoss, falou um pouco mais sobre SOA apresentando RestEasy e Drools e jBPM.
Pra mudar um pouco de assunto assisti a palestra do Renato Belia sobre persistencia com Java Persistence API (JPA).
O Vinícius Senger apresentou modularização e mundo OSGi de uma forma muito criativa, através de modelos criados no Google Sketchup. Comentou sobre as vantagens de se quebrar aplicações em partes menores, falou sobre como reduzir acomplamento e trabalhar com várias versões da mesma biblioteca em uma mesma JVM com as propostas das JSRs 291 e 297.
Vinícius Senger da Global Code
O palestrante internacional Reza Rahman da Tripod falou sobre as novidades que viram no Java Enterprise Edtion 6, como Profiles, EJB 3.1, Bean Validation (JSR 303), Web-beans (JSR 299) e JBoss Seam, JPA 2.0 (JSR 317), JAX-RS, JAX-WS, etc. Reza deixou bem claro que é muito importante que toda a comunidade Java participe com sugestões, codigo fonte e feedback. Achei muito util as novas annotations para agendamento de tarefas (@Schedule) no estilo Cron, as invocações assíncronas (@Asyncronous), os Singleton Beans Thread Safe, os wars simplicados, o web.xml opcional (graças as annotations), as novidades da Servlet 3.0 (JSR 315). Houve tradução simultanea para quem prefiriu ouvir a palestra em português.
Reza Rahman
Ed Burns, outro palestrante internacional, líder da especificação do JSF 2.0, que também esteve no Brasil no TDC 2007, fez uma apresentação muito parecida com a que havia feito no JavaOne em maio. Falou sobre as novidades que estão por vir no JSF 2.0, como melhor suporte a Facelets, Ajax, Annotation-Driven Features como @ResourceDependency, Data Validation (JSR 303), melhorias de performance, facilitadores para REST, Project Stages (como no Rails), e Convention over Configuration (CoC).
A Esquerda Reza Rahman e Ed Burns a Direita
Ed abriu o evento no sábado com uma palestra sobre seu novo livro “Secrets of the RockStar Programmers“. Foram apresentados trechos em áudio das entrevistas que foram feitas com grandes personalidades com mundo da tecnologia como James Gosling, o pai do Java, Rod Johnson, o criador do SpringFramwork, Adrian Colyer do AspectJ, os caras do JavaPosse, Andy Hurt, fundador da Agile Alliance e co-fundador do Pragmatic Programmers, entre outros.
O nosso querido Mister M também falou em sua palestra sobre as novidades do Java EE 6 e Java SE 7, comentou sobre o Swing Application Framework (JSR 296), Beans Binding (JSR 203) e NIO 2 (JSR 203). Apresentou com muita autoridade tudo sobre a Date and Time API (JSR 310), também, a final de contas, é ele quem põe a mão na massa…
Mister M
O Moacyr de Mello da IBM / Rational falou sobre a plataforma Jazz, e como modelar processos com a ferramenta, me pareceu algo muito interessante, porém confesso que ainda não consegui compreender bem como isso funciona… Achei muito interessante o template de Scrum.
Fomos almoçar em uma cantina bem tradicional proxima ao local do evento, feijoada excepcional!
Feijoada Ágil
E por falar em Scrum, falou-se muito sobre metodologias agéis no evento. A comunidade ágil estava em peso com seus representantes: Juan Bernabó da Teamware, Vinícius Teles da Improveit, Rodrigo Yoshima da Aspercom, Alexandra Magno da Caelum, o Heptaman da Heptagon, Jorge Diz da GlobalCode, André Piza da UOL, Enio Stein da Paggo, José Papo da FIAP, Manoel Pimentel da Visão Ágil, Felipe Rodrigues da Fratec entre muitos outros. Houve um debate sobre metologias ágeis em que dentre muitos assuntos discutiu-se sobre CMMi com Metologias Ágeis, a briga foi boa, dado que contavamos também com a presença do Marcos Dorça da Borland que defendeu o lado do CMMi.
Debate sobre metodologias Ágeis
O Vínicus Teles da Improvit gravou várias entrevistas ao longo do evento e as está disponiblizando aos pouquinhos no blog da Improvit, recomendo a todos que assitam, material de ótima qualidade, garanto!
A GlobalCode também disponibilizou os PDFs das apresentações no site deles e as fotos do evento estão no Picassa.
Gostaria de agradecer ao Vínicus Senger e a Yara Senger, a toda a equipe da Global Code, aos Javistas e Agilistas, e a todos que estiveram presentes e ajudaram para que este fabuloso evento pudesse ser realizado. Um grande abraço também para o Mauricio Leal, e ao todo o pessoal do SouJava, e ao Bruno e todo o pessoal do GUJavaSC, e é claro quero também agradeço a Bluesoft por me permitir e apoiar à participar do evento. Fica um abraço para o Bolha e para o Junião que estiveram lá comigo.
Fiquem ligados vem aí USCS.java, Sun Tech Days, Just Java 2008, Rails Submit Latin America, entre outros eventos que prometem dar mais ainda o que falar…
Grande Abraço,
André Faria
Test Driven Development
O contato com Scrum, XP e Agile em geral, me levaram à diversos conceitos que até então desconhecia, um dos quais resolvi me aprofundar foi TDD (Test Driven Devolpment), para isso li o livro ”Test-Driven Development by Example” escrito por Kent Beck. O Livro é muito esclarecedor e divertido de ler, apresenta diversos conceitos e técnicas através de exemplos de implementações de pequenas soluções.
TDD ou Desenvolvimento Dirigido por Testes, é uma técnica de desenvolvimento de software que consiste em pequenas iterações onde testes são escritos primeiro e o código produzido é somente o necessário para fazer o teste passar, e finalmente o código é refatorado para acomodar as mudanças. TDD proporciona feedback rápido depois de cada mudança. Não é considerado somente uma ténica de escrita de testes, mas uma técnica para design de software.
chemistry por tschoppi
TDD pode ser facilmente explicado em cinco simples passos:
- Adicione um teste rapidamente.
- Execute todos os testes e observe o novo teste falhar.
- Faça uma pequena mudança para fazer o teste passar .
- Execute todos os teste e observe que foram bem sucedidos.
- Refatore e remova o código duplicado.
Para melhor entender este ciclo de cinco fases, vamos constuir um pequeno programa Java para realizar um simples cálculo de potência. Para executar os testes precisamos de uma ferramenta de testes unitários, utilizaremos o JUnit.
O JUnit possui uma classes chamada TestCase, a qual nossa classe de teste deverá extender. Essa classe possui uma série de métodos que nos auxiliarão no processo de testes unitários, tais métodos fazem o teste falhar caso determinadas condições não sejam satisfeitas.
Ex: O método “AssertEquals(x,y)“ faz o teste falhar caso x seja direferente de y.
assertEquals(“TDD”,”DDD”); //Falha assertEquals(100, 100); //Passa
Começaremos então pelo teste:
public class CalculadoraTest extends TestCase { public void testCalcularOitoAoQuadrado(){ Calculadora calculadora = new Calculadora(); assertEquals(calculadora.calcularPotencia(8, 2), new BigDecimal(“64”)); } }
Se tentarmos executar nosso teste, o JUnit nos apresentará uma barra vemelha o que signfica que o teste falhou, e falhou porque a classe Calculadora e o método estático calcularPotencia ainda não existem. Vamos então criar a classe e o método para fazer o teste ao menos compilar.
public class Calculadora { public void calcularPotencia(Integer a, Integer b){ return null; } }
Nossa missão agora é fazer, rapidamente, o teste passar. Para isso vamos então retornar o valor que nosso primeiro teste espera, 64.
public class Calculadora { public void calcularPotencia(Integer a, Integer b){ return new BigDecimal(“64”); } }
Se executarmos o teste novamente o mesmo passará… Eu seu, eu sei, que isso pode parecer meio estranho no inicio, mas não se assuste, você se acostumará e entenderá melhor o que está por traz disso tudo com o tempo. Vamos adicionar mais um método de teste em nossas classe de testes
public void testCalcularDoisAoCubo(){ Calculadora calculadora = new Calculadora(); assertEquals(calculadora.calcularPotencia(2, 3), new BigDecimal(“8”)); }
E vamos fazer a alteração mais simples possível para fazer o teste passar:
public class Calculadora { public void calcularPotencia(Integer a, Integer b){ if (b == 2) return new BigDecimal(“64”); else return new BigDecimal("8"); } }
Agora que os dois testes estam passando, realizaremos o processo de refatoração para remover as constantes e a redundancia do código, assegurando que o teste continue passando.
public void calcularPotencia(Integer a, Integer b){ BigDecimal result = new BigDecimal(a); for (int I = 0; I < b; I++) { result = result.multipliedBy(BigDecimal.valueOf(a)); } return result; }
Pronto! Refatoramos nosso código removendo as constantes e se executarmos nossos testes verificaremos que este será bem sucedido! Este é o processo básico de TDD.
Ops!!! O que acontecerá se tentarmos executar o método executar uma potencia de um número elevado a zero? Problemas!!! Todo o número elevado a Zero é igual a 1 (Um), dessa forma devemos adicionar um novo teste que verifique se um número elevado a zero retorna 1, fazer o teste passar, refatorar e assegurar de que os outros testes continuem passando.
public void calcularPotencia(Integer a, Integer b){ if (b.equals(0)){ return BigDecimal.valueOf(1); } BigDecimal result = new BigDecimal(a); for (int I = 0; I < b; I++) { result = result.multipliedBy(BigDecimal.valueOf(a)); } return result; }
public void testTodoNumeroElevadoAZeroDeveRetornarUm(){ Calculadora calculadora = new Calculadora(); assertEquals(calculadora.calcularPortencia(21, 0), new BigDecimal(“1”)); assertEquals(calculadora.calcularPortencia(8, 0), new BigDecimal(“1”)); }
É isso pessoal! Parece simples, mas não é fácil. Depois muito treinamento e prática em diferentes cenários isso começa a ficar mais natural e você passa a enxergar mais claramente os benefício desta poderosa técnica. Estou a disposição para esclarecimento de dúvidas. Comentários são sempre muito bem vindos.
