Groovy em 2024 - onde aplicar e sua relevância hoje (há?)

Quatro anos atrás publicamos no blog da itexto nossa avaliação da linguagem Groovy, que você pode acessar neste link. Em 2024 (quase 2025), estas impressões se mantém? Como vemos a linguagem e parte do seu ecossistema hoje? Neste post reavaliamos nossa percepção.

Para tal, editei o texto original incluindo notas que batem o cenário de 2020 com o que temos hoje em novembro de 2024. Será que Groovy tem futuro hoje?

O que é Groovy?

Uma linguagem de programação desenvolvida e pensada para a plataforma Java. Por “plataforma Java”, entenda “executada pela e na JVM”. Mas o que “mais esta linguagem” pra JVM trás pro jogo?

Ter como alicerces a JVM e a linguagem Java

Groovy convive muito bem com código Java pré-existente. Você pode executar código Java a partir do Groovy e vice-versa. Groovy, assim como Java, gera bytecode que é executado pela JVM de forma indiscriminada.

Mas mais do que isto: Groovy respeita a estrutura de tipos e modelo de execução adotado pela linguagem Java, o que torna esta integração no nível mais baixo da linguagem (bytecode) um processo totalmente transparente.

Como nota histórica, a linguagem aparece pela primeira vez em um post do blog de James Strachan (seu criador) em 2003: o objetivo era ter uma linguagem dinâmica na plataforma Java que surgisse tendo a JVM em seu centro, ao contrário das linguagens Jython e JRuby que, na época, não tinham atingido com pleno sucesso este objetivo.

Surge assim Groovy: “uma linguagem dinâmica para a plataforma Java”, mas com um diferencial importantíssimo: sintaxe muito próxima à do Java, o que reduz significativamente a curva de aprendizado.

Uma linguagem dinâmica (mas só se você quiser)

É importante entender um dos principais fatores de venda do Groovy que é o fato desta ser “uma linguagem dinâmica”. Groovy é muito influenciado por Ruby e Python que também são linguagens dinâmicas.

Em essência uma linguagem dinâmica permite que você modifique o comportamento do seu código em tempo de execução. Soa estranho em um primeiro momento: se você já colocou seu código em produção, pra que incluir novos comportamentos neste? Qual o sentido?

A primeira forma como encontramos o aspecto dinâmico de linguagens diz respeito à tipagem. Uma linguagem possui tipagem dinâmica quando descobrimos seu tipo (inteiro, texto, booleano…) em tempo de execução e não de compilação.

Há aqui um tradeoff entre desempenho e produtividade. Não raro do ponto de vista do desenvolvedor o tipo não é tão importante quanto parece. Pense em uma hierarquia de classes na qual precisemos da existência de um conjunto de comportamentos (métodos). Em uma linguagem estática criamos uma hierarquia ou estrutura de interfaces que identifiquem estes comportamentos. Em uma linguagem dinâmica só precisamos que o método exista: é o que chamamos de duck typing.

Mas nem só de tipagem dinâmica vivem estas linguagens: você também pode incluir novos métodos e atributos em classes existentes ou mesmo interceptar a invocação de métodos usando recursos nativos da linguagem ao invés de frameworks como Spring ou AspectJ.

No frigir dos ovos, entretanto, é importante salientar que estes recursos são usados mais por quem desenvolve código de infraestrutura (frameworks) que a esmagadora maioria dos desenvolvedores.

Um aspecto importante a ser levado em consideração no caso do Groovy é que os aspectos dinâmicos da linguagem são opcionais: se quiser, você pode desenvolver com tipagem estática sem problema algum e com isto obter algum ganho de desempenho (não é tão significativo assim).

Um “Java++”?

Observamos em nosso time e de diversos clientes que a adoção do Groovy pode aumentar significativamente a produtividade da equipe devido aos pontos que trataremos aqui.

Uma consequência interessante de estarmos lidando com uma linguagem dinâmica é que a equipe responsável pelo desenvolvimento do Groovy acabou evoluindo a própria API do Java.

Como podemos incluir novos métodos em classes já existentes, Groovy acabou por adicionar uma pletora de novas funcionalidades na API padrão do Java, aumentando significativamente a produtividade do desenvolvedor. É o que chamamos de GDK (Groovy Development Kit). Observe os métodos incluídos na classe String, por exemplo: inúmeras funcionalidades que você sempre quis mas precisava antes de outras bibliotecas encontram-se ali.

Mas os ganhos não estão apenas no enriquecimento das bibliotecas padrão: a sintaxe também possui diversas melhorias. Como mencionado, você pode dar seus primeiros passos na linguagem usando o que já conhece do Java, mas pouco a pouco ir experimentando novas features, tais como:

• Sobrecarga de operadores.
• Operadores para lidar com Collections, tais como “[]” para lidar com listas ao invés da classe java.util.List (e implementações) e “[:]” para lidar com mapas ao invés de java.util.Map (e implementações).
• Interpolação de valores em strings.
• Uma sintaxe que pode ser muito mais limpa por remover atributos que poderiam ser opcionais (“;” ao final de cada comando quando há um único por linha, parênteses opcionais, expressão “return” opcional, método “main” opcional, e muitos outros).

E esta é uma lista bem pequena. Anos atrás (Windows Vista!) gravei um vídeo de quase uma hora só expondo estas funcionalidades que pode ser visto neste link: https://youtu.be/eEUKRhPoJAY

Com sua sintaxe menos burocrática e o enriquecimento da API padrão do Java, Groovy trás para o universo Java uma experiência muito próxima da que desenvolvedores Python e Ruby tem em seu dia a dia.

Indo além, acreditamos que temos aqui o que chamamos de “tecnologia ponte“: Groovy fornece aos menos experientes uma introdução suave a conceitos e bibliotecas mais complexas do ecossistema Java (incluindo Java EE).

Construa suas próprias linguagens (DSLs) com Groovy

A sintaxe do Groovy unida aos seus aspectos dinâmicos e a inclusão de funcionalidades como builders e outros o tornam a ferramenta ideal para a construção de linguagens específicas de contexto (DSLs – Domain Specific Language).

Há alguns projetos de sucesso hoje que são essencialmente DSLs escritas com Groovy, sendo o mais famoso provavelmente o Gradle, seguido do Spock.

DSLs são uma poderosa estratégia: permitem à equipe de desenvolvimento focar na construção de uma plataforma essencial que é enriquecida pelos seus usuários finais, responsáveis por implementar em uma linguagem próxima ao seu contexto regras de negócio que lhes atendam no dia a dia.

Em nossa experiência já implementamos, por exemplo, linguagens específicas de contexto para os setores de engenharia, e-commerce, comunicações e outros. Caso queira ler mais sobre Groovy para a construção de linguagens específicas de contexto, leia este link de sua documentação oficial ou leia este livro.

Aplicações

Groovy é uma linguagem de uso geral: pode portanto ser usada, em teoria, para qualquer coisa, entretanto há usos para os quais esta se mostra uma alternativa interessante, e são estas que traremos aqui. Naturalmente há outras, entretanto estes são os usos que consideramos mais populares.

Um problema que a linguagem enfrenta é o fato de na maior parte das vezes ter seu nome vinculado ao do framework Grails, o que limita bastante a sua percepção pelo público.

Complementando o Java

Como linguagem embarcada

É possível embarcar Groovy em projetos Java de uma forma relativamente simples, o que possibilita a construção de plataformas que possam ser estendidas em tempo de execução por seus usuários através da inclusão, edição e remoção de scripts Groovy a serem executados por esta.

Em uma plataforma de vendas, por exemplo, é possível termos scripts que validem promoções em tempo de execução, podemos pensar também em fórmulas e cálculos definidos pelo usuário, algoritmos de processamento sinais e muitas outras funcionalidades cujo conhecimento está nas mãos dos usuários e não da equipe de desenvolvimento. Uma opção muito mais fácil de ser implantada que a adoção de motores de regras complexos como Drools, por exemplo.

A equipe de desenvolvimento passa portanto aqui a atuar como responsável pela evolução de uma plataforma a ser enriquecida por seus usuários finais, sem a necessidade de realizar complexos procedimentos de manutenção de código e implantação. Bateu aquela curiosidade pra saber como isto pode ser feito? Aqui segue um vídeo em que explico como proceder: https://youtu.be/_njSd-efuCo

Como ferramenta de automatização/integração com scripts

Código Groovy pode ser executado sob a forma de scripts. E dado que o acesso a código Java é direto, abrem-se aqui possibilidades de automatização bastante interessantes.

É possível, por exemplo, incluir suas bibliotecas de negócio (arquivos JAR) ou de infraestrutura (como frameworks de persistência ou biblitoecas utilitárias) no classpath dos seus scripts e executar nativamente as funcionalidades ali implementadas.

Um uso muito comum é a execução de tarefas agendadas de manutenção como, por exemplo, usando as regras de negócio distribuídas como arquivos JAR, invalidar registros, executar relatórios, etc através de agendamentos simples de sistema operacional (CRON).

Você pode, por exemplo, tirando proveito das melhorias introduzidas pelo GDK inclusive executar ações como raspagem de dados, implementação de crawlers, processamento em massa de dados e muitas outras atividades que normalmente são implementadas como scripts simples.

Desenvolvimento web

Desenvolvimento web com Groovy vai muito além do Grails . Sou obrigado a citá-lo, mas é fundamental que você saiba que há várias outras alternativas que também são de altíssima produtividade:

• Grails – de longe a opção mais popular da linguagem, sendo fortemente inspirado em Ruby on Rails – https://grails.org
• Micronaut – desenvolvido pela equipe que desenvolveu o Grails, uma solução interessantíssima para o desenvolvimento de microserviços. – https://micronaut.io
• Spring Boot – é possível com pouquíssimo código Groovy escrever microserviços com este framework, sabia?
• Ratpack – uma opção extremamente produtiva para a escrita de aplicações web no estilo de microserviços – https://ratpack.io/
• Groovy Servlets – quer um desenvolvimento mais raíz? Que tal implementar seus próprios servlets com o mínimo de código? Aprenda mais aqui.

Desenvolvimento desktop

Quem disse que o desenvolvimento desktop acabou? Groovy é uma opção muito interessante nesta área. Duas alternativas bastante interessantes:

Griffon

Pense no Griffon como se fosse um Grails/Ruby on Rails/Django para o desenvolvimento desktop. Os mesmos princípios de convenção sobre configuração e não se repita (DRY – Don’t Repeat Yourself) se aplicam aqui.

Saiba mais neste link.

Swing Builder

Em sua biblioteca padrão Groovy trás um recurso muito interessante que é o Swing Builder. Com ele é possível desenvolver aplicações desktop na plataforma Java usando um ambiente que desenvolvedores JavaFX (especialmente em sua primeira versão) acharão bastante familiar 😉

Adoção e futuro

Uso no mercado

Por muitos anos Groovy foi a segunda linguagem mais popular na plataforma Java (atrás do próprio Java). Com a adoção do Kotlin no desenvolvimento Android a situação mudou e esta não é mais a realidade.

Em 2020 Groovy estava no top 10 global do índice TIOBE. Hoje não está nem no top 50. Em nossa experiência seu uso principal hoje é como a linguagem adotada pelo framework Grails.

É importante no entanto levar em consideração que o índice TIOBE só leva em consideração o que se escreve sobre uma linguagem, não seu uso real. Sendo assim não há como se ter hoje uma medida precisa sobre sua adoção em sistemas pré-existentes (legados). Pessoalmente acredito que o TIOBE deva ser visto como um "índice de hype".

Há muito hype que deve ser filtrado, o que realmente interessa são outras métricas em relação ao futuro do projeto:

• Atividade do repositório: bastante ativa como pode ser vista no Github.
• Frequência na liberação de releases: há pelo menos uns dois ou três por ano, tal como pode ser visto neste link.
• Adoção em outros projetos: tais como pode ser visto neste (Awesome Opensource) e neste link (Github). Repare que não são muitos, apesar de haver alguns de grande relevância.
• Comunidade – a comunidade Slack do Groovy é bastante ativa e há muita movimentação no StackOverflow também, como pode ser visto aqui. Entretanto é importante salientar que temos aqui comunidades difusas, dado que estas se distribuem entre os diferentes projetos que se baseiam na linguagem (Gradle, Grails, Jenkins, etc.).
• Adoção pelo mercado e maturidade: Groovy surge em 2003, já tem 21 anos de idade e adoção nos mais variados cenários.
• Livros publicados a respeito: há muito material publicado a respeito, o que pode ser verificado, por exemplo, no site da Amazon ou na documentação oficial da linguagem.

No Brasil, entretanto, não observamos toda esta animação. Em 2024 tiramos do ar o Grails Brasil, por exemplo, por que simplesmente não havia mais interação no fórum. Quando percebemos que algo como duas a três perguntas novas POR ANO surgiram, vimos que era a hora de aposentar o projeto.

Se popularidade é um fator para a escolha de uma tecnologia, então Groovy não deve estar no seu radar. Infelizmente.

Dificuldades na adoção em equipes

Em nossa experiência encontramos alguns fatores que devem ser levados em consideração caso seu time opte pro adotar Groovy como linguagem de programação. É muito importante levar estes pontos em consideração caso esteja considerando adotar esta tecnologia.

Cuidado com o primeiro contato

A principal dificuldade na adoção do Groovy é o modo como profissionais tem o primeiro contato com a linguagem, normalmente a partir de um framework (Grails). Um comportamento muito similar que observamos com a linguagem Ruby em relação ao Ruby on Rails (e poderíamos também mencionar Python com Django).

Muitas vezes o desenvolvedor se limita ao que é apresentado pelo framework, acabando por não se aprofundar na linguagem e, com isto, usando apenas uma pequena parte do que esta tem a oferecer.

Vícios do Java

Groovy oferece uma sintaxe que é muito próxima à do Java. A vantagem desta abordagem é que a curva de aprendizado é realmente muito pequena para quem já conhece a linguagem, entretanto há um perigo aqui.

A escrita de código Groovy muito similar ao do Java deve ocorrer somente nos primeiros contatos com a linguagem. Com o passar do tempo a equipe deve ser incentivada a escrever código que seja o mais próximo possível do estilo Groovy para que possa tirar máximo proveito do que esta tem a oferecer e, também, evitar uma série de problemas difíceis de serem detectados se lermos código Groovy como se fosse Java.

Caso enfrente este problema, recomendamos que os dois textos a seguir sejam divulgados para o time:

• Guia de estilo da linguagem – mostra os padrões adotados na escrita de código Groovy
• Diferenças em relação ao Java

Dinamismo

O dinamismo da linguagem também pode ser considerado uma dificuldade por equipes habituadas a trabalhar com linguagens estáticas. Essencialmente vemos aqui estas equipes tendo o mesmo tipo de dificuldade com outras linguagens, tais como Ruby ou Python, o que talvez justifique, nos mesmos times, o sucesso de linguagens como TypeScript.

É muito importante que a equipe esteja consciente do significado de uma linguagem dinâmica para que possa tirar máximo proveito do que esta tem a oferecer, caso contrário há o risco real de comportamentos esperados da linguagem serem mal interpretados como defeitos e não como o que realmente são: funcionalidades.

Ferramental

Após tantos anos no mercado é natural que tenha surgido todo um ferramental que rodeia a linguagem. Seguem algumas ferramentas que consideramos essenciais para a adoção e aprendizado da tecnologia.

SDKMan

Hoje a principal ferramenta para se instalar o Groovy e qualquer outra ferramenta do ecossistema Java é o SDKMan, que nos permite gerenciar diferentes versões das principais ferramentas do ecossistema Java.

Maiores detalhes sobre o SDKMan podem ser obtidas em seu site oficial. Caso queira se aprofundar no assunto, recomendo que leia nosso guia do SDKMan.

IDEs e editores de texto

O fato de Groovy ser uma linguagem dinâmica torna o desenvolvimento de IDEs uma tarefa mais difícil se comparado às linguagens estáticas. Felizmente existem boas opções no mercado que podem ser adotadas:

• Intellij IDEA – a melhor IDE para se trabalhar com Groovy e Grails se você tiver uma licença para a versão paga.
• Eclipse Groovy Development Tools – a instalação pode ser um pouco mais complicada, mas oferece o essencial para quem está habituado a trabalhar com Eclipse. Praticamente abandonado hoje.
• Visual Studio Code – apesar de não oferecer recursos avançados como “code complete”, já possui plugins que permitem a refatoração de código e, ao que tudo indica, é questão de tempo até que alternativas melhores apareçam no editor. Ainda é muito ruim.

É possível ter acesso a mais opções na documentação oficial da linguagem neste link, entretanto é importante ter em mente que as opções sempre são bem mais limitadas, devido à natureza da linguagem, que aquelas que temos com linguagens de tipagem estática como Java ou Kotlin.

REPL

Pelo fato da linguagem poder ser executada como scripts, esta oferece opções interessantes de interfaces REPL (Read Eval Process Loop), tal como o IRB do Ruby ou o interpretador do Python. Dentre estas, destacamos:

• Groovy Web Console – que permite experimentar código Groovy na web sem a necessidade de tê-lo instalado localmente.
• Groovy Console – interface desktop provida pela instalação padrão da linguagem (comando groovyConsole) que permite editar e executar pequenos scripts (inclusive depurá-los).

Ambas as ferramentas são bastante úteis no dia a dia em momentos nos quais é necessário avaliar possibilidades da linguagem e, principalmente, no aprendizado da mesma.

Para saber mais

O objetivo deste post é apresentar, do ponto de vista gerencial, uma tecnologia que pode agregar valor a seus projetos e que dominamos na itexto.

Caso deseje se aprofundar no assunto, segue uma pequena lista de recursos:

• Site oficial do projeto Groovy – https://groovy-lang.org
• Canais de suporte oficial a Groovy – http://groovy-lang.org/support.html
• Meu livro de Grails (trata de Grails 2.5, bem ultrapassado), que contém uma introdução à linguagem Groovy – https://www.casadocodigo.com.br/products/livro-grails
• Meu canal no YouTube no qual há diversos vídeos sobre o assunto – https://youtube.com/kicolobo

Em 2024...

Amaria dizer que em 2024 temos uma linguagem vibrante com um ecossistema em constante crescimento, mas isto não refletiria a realidade.

O maior evento mundial de Groovy não existe mais (Gr8 Conference), Grails Brasil saiu do ar, e pouco se escreve sobre a linguagem hoje. É interessante observar o gráfico do Groovy trends de 2004 até hoje sobre a linguagem no mundo:

A situação é um pouco melhor no Brasil (acredito que eu tenha grande parte da "culpa" por ter sido a pessoa que mais escreveu em português sobre o assunto):

De qualquer modo, não está mais no foco, não há mais hype. Comparando o interesse em relação ao Kotlin, aqui no Brasil, a situação fica ainda mais clara:

Especialmente após Kotlin ter sido adotado como linguagem padrão para o desenvolvimento de aplicações Android (oportunidade IMENSA perdida pelo Groovy, que começou algo nesta direção mas simplesmente desistiu).

No entanto, nem tudo está perdido e a linguagem está longe de ter morrido. Ainda é desenvolvida, e novos recursos ainda são incluídos nela a cada novo release, apesar de não ter visto nada de revolucionário ou que chamasse minha atenção ao longo dos últimos 5 anos pelo menos.

Hoje vejo dois usos importantes para a linguagem:

• Grails - que apesar de não ser tão falado hoje, ainda é o framework mais produtivo que conheço se você precisa implementar CRUDs auto gerados ou mesmo aplicações web mais complexas
• Como linguagem embarcada - especialmente se você implementar uma DSL com Groovy. O poder que esta técnica pode oferecer aos seus usuários finais é algo que não pode ser subestimado.

Ainda é uma linguagem produtiva? Sim.

O problema é que tem um "departamento de comunicação" péssimo!

Groovy tem futuro? Tem, há muito código legado escrito na linguagem e Grails continua a evoluir. No entanto acredito que a relevância da linguagem está em risco pois hoje, na nossa experiência, está totalmente atrelada à do Grails, e não na criação de novos projetos que gerem ânimo na comunidade.

Sendo assim só recomendo a adoção do Groovy hoje para os dois usos que mencionei acima. Daqui a alguns anos revejo este post: se ele for curto, nem precisa ler inteiro para saber a conclusão.