(Nota do editor: Ainda na série “try a little help from my friends”, a contribuição do nosso amigo Wilson Freitas)
Desde que comecei a trabalhar com linguagens fortemente tipadas, passei a tratar tipagem estática como um dogma. Simplemente não fazia sentido usar uma linguagem que não verificasse os tipos em tempo de compilação. Com o tempo algumas linguagens começaram a despontar na mídia: Ruby e Python são duas que despertaram minha curiosidade. Mas a enorme inércia de anos e anos trabalhando na plataforma Java tratou de matar minha vontade de aprender (mais) uma linguagem de programação.
Quando falo de anos trabalhando com Java, não estou me referindo apenas à linguagem, mas a todo o mundaréu de frameworks e especificações tais como Hibernate, Struts, Spring, Jakarta*, EJB, JNDI, JMS, e mais trocentas mil coisas que não cabem neste post. É muito difícil para um profissional abrir mão de toda essa parafernália que gastou anos aprendendo pra começar a trabalhar com uma linguagem completamente nova, tendo que descobrir como fazer aquelas coisas que em Java estão “na ponta da língua”.
Então, um belo dia eu vi um artigo qualquer sobre uma tal de Groovy. A princípio achei que era mais uma linguagem: “putz, pra que o povo inventa tanta linguagem!”, mas algumas coisas me chamaram a atenção:
- Assim como Ruby, Groovy é uma linguagem dinâmica que permite malabarismos impensáveis em Java.
- Groovy tem um interpretador que gera Java byte code sob demanda, que em seguida é executado por uma JVM comum, o que permite criar scripts que podem ser executados diretamente na linha de comando.
- Groovy é um “sabor” de Java. A sintaxe é muito parecida, o que a torna muito fácil para quem já está acostumado com o velho Java.
- Como no final das contas tudo é byte code, classes Java podem ser instanciadas em código Groovy e vice versa, ou seja, todos os milhares de trecos que já foram escritos em Java podem ser usados dentro de código Groovy.
Estas características do Groovy me convenceram que valia a pena estudar a linguagem, que vem sendo a minha porta de entrada para o paradigma de linguagens dinâmicas. Ainda não estou usando o Groovy no desenvolvimento em si, mas como uma ferramenta de apoio a algumas tarefas do dia a dia, como processamento de arquivos em lote por exemplo.
Não vou alongar este post enumerando as features do Groovy, mesmo porque elas podem ser facilmente encontradas no site oficial, vou me limitar a mostrar dois trechos de código, um em Groovy e outro em Java, que executam a mesma tarefa, que é aplicar um filtro uma lista de mapas, gerando uma segunda lista com os itens filtrados.
código JAVA
import java.util.*;
public class ExemploJava {
public static void main(String[] args) {
new ExemploJava().rodarExemplo();
}
public void rodarExemplo(){
List<Map<String, Object>> personagensLost =
new ArrayList<Map<String,Object>>();
personagensLost.add(obterPersonagem("Kate", 28));
personagensLost.add(obterPersonagem("Jack", 38));
personagensLost.add(obterPersonagem("Desmond", 39));
personagensLost.add(obterPersonagem("Hurley", 27));
personagensLost.add(obterPersonagem("Locke", 50));
personagensLost.add(obterPersonagem("Walt", 12));
List<Map<String, Object>> personagensFitrados =
new ArrayList<Map<String,Object>>();
for (Map<String, Object> personagem : personagensLost) {
Integer idade = (Integer)personagem.get("idade");
if(idade >= 20 && idade <= 30){
personagensFitrados.add(personagem);
System.out.println(String.format(
"Personagem [%s] filtrado",
personagem.get("nome")));
}
}
}
private Map<String, Object> obterPersonagem(String nome, Integer idade) {
Map<String, Object> mapa = new HashMap<String, Object>();
mapa.put("nome", nome);
mapa.put("idade", idade);
return mapa;
}
}
e o código equivalente Groovy
def personagensLost = [
[nome:"Kate", idade:28]
,[nome:"Jack", idade:38]
,[nome:"Desmond", idade:39]
,[nome:"Hurley", idade:27]
,[nome:"Locke", idade:50]
,[nome:"Walt", idade:12]
]
def personagensFiltrados =
personagensLost.findAll{ (20..30).contains(it.idade) }
personagensFiltrados.each {
println "Personagem [${it.nome}] filtrado"
}
Ao comparar as duas versões desse programa, o que mais me chama a atenção não é a diferença de linhas de código, mas sim a clareza do Groovy em comparação com o Java. O fato de listas e mapas serem construções nativas da linguagem tornam as tarefas relacionadas a estas estruturas de dados muito mais simples, e o código mais inteligível.
Obviamente eu poderia usar uma lib como commons collections para filtrar os elementos da lista na versão Java, mas minha idéia aqui é comparar as linguagens usando apenas as APIs comuns, incluídas com o development kit padrão. Eu inclusive criei um método privado para reduzir o volume de código Java, mas mesmo assim, a diferença de linhas de código é grande. Não significa que isso vai ocorrer para todos os casos, nem significa que Groovy Rocks e Java Sucks. O que quero mostrar é que o Groovy é uma ferramenta extremamente útil para profissionais proficientes em Java que querem enveredar pelo mundo das linguagens dinâmicas, sem ter que abrir mão do SimpleDateFormat quando ele for necessário.
Wilson Freitas é arquiteto de sistemas com 12 anos de experiência em desenvolvimento de software. Atualmente trabalha na Vetta Technologies. Bacharel em Ciência da Computação pela UFBA.
Loading ...
