Texto escrito em 2014

Hoje passeando por antigos códigos meus percebi uma coisa: faz DEZ anos que programo em Groovy, e seis que criei o Grails Brasil. Uou! Tenho muitas lembranças legais deste período no qual trabalhei com aquela que, hoje posso dizer com  segurança, é minha linguagem favorita. Neste post conto o início desta história.

Culpa da classe java.math.BigDecimal!

Era 2004 e tudo começou por que sou um fervoroso inimigo da classe java.math.BigDecimal do Java. Se não a conhece, é a classe que usamos para lidar com números de alta precisão. Qual o problema com ela? Simples: imagine que eu precise implementar a fórmula de Bhaskara:

BigDecimal bhaskara(BigDecimal a, BigDecimal b, BigDecimal C) {
BigDecimal delta = b.multiply(b).subtract(new BigDecimal(4).multiply(a).multiply(c));
return b.multiply(new BigDecimal(-1)).subtract(Math.sqrt(delta)).divide(new BigDecimal(4).multiply(a).multiply(c));

}

Acho que este é o Bhaskara mesmo

Tirei parte da fórmula (e deve ter erro tá?) só para expor meu ponto. Eu queria usar a JVM, sabia do quão poderosa esta era e é. E eu tinha também uma imensa quantidade de código fonte Java que não queria jogar fora. Foi quando vi que existia uma linguagem chamada Groovy na qual eu podia escrever algo como no exemplo a seguir:

def bhaskara(a, b, c) {
-b + Math.sqrt( (b*b) - (4*a*c))
}

Me ganhou na hora. De repente eu podia escrever minhas aplicações matemáticas sem a maldita classe BigDecimal. E sabem o que era mais legal? Aquela função em Groovy me retornava um objeto do tipo... BigDecimal! Yeap: sentimento "troll master" me dominou.

Percebo que eu possuía... scripts!

Por um bom tempo Groovy era apenas a linguagem que eu usava para escrever minhas fórmulas: um motor matemático no máximo. Eu salvava as fórmulas em arquivos ou no banco de dados, meu sistema Java as carregava, passava alguns parâmetros para aquele código e na outra ponta vinha o resultado. Sabe aquele momento na vida em que você percebe que teve ouro o tempo inteiro diante de si e o ignorava? Foi o estalo.

Juro: não havia me passado pela cabeça que aquelas funções na realidade eram scripts! De repente acordei para o fato de que meus scripts podiam acessar meu código Java nativo, e meu código Java podia executar aqueles scripts e coisas boas poderiam surgir dali.

Se meu script acessa meu código Java dentro do meu projeto... por que não permitir que meus usuários possam estender meus sistemas? Assim eu trabalharia  menos pois fornecia apenas o framework básico e eles o "recheio" na forma dos scripts.

Percebo que meus scripts poderiam ser usados para criar minhas próprias... linguagens!

A possibilidade dos meus usuários fornecerem seus próprios scripts parecia maravilhosa, mas na prática eu acabava trabalhando muito mais, pois quem escrevia os scripts era... EU! Os usuários simplesmente não sabiam programar.

C++? Humpf!

Mas aí eu percebi que na linguagem havia alguns construtores que me permitiam criar algo que era quase como minha própria linguagem de programação. Anos depois fiquei sabendo que aquelas "quase linguagens de programação" tinham um nome técnico: Domain Specific Languages, as linguagens específicas de contexto (Martin Fowler tem inclusive um livro bem bacana sobre o assunto cuja leitura recomendo).

De repente meu sonho de ter meu próprio "K++" estava próximo de se tornar realidade. E sabem o que é mais legal? Aquelas DSLs que eu criava funcionavam: os usuários conseguiam digitar suas próprias fórmulas no sistema sem me chamar! Eu estava trabalhando... milímetros a menos.

Percebo que escrever aplicações web em Java era... um porre!

Meu framework web favorito por um tempo foi o JSF 1.2. Apesar de ter sido um projeto que fracassou em diversos aspectos (escrever componentes era horrível, desenvolvimento fora da web para PDAs e desktop nunca se realizou, as IDEs que nos permitiram programar apenas arrastando e soltando nunca funcionaram e mais alguns que não me lembro agora) eu gostava muito dele. Me sentia produtivo e diria que até mesmo mais inteligente que as outras pessoas.

Foi quando vi uma apresentação de um sujeito chamado "David Heineieneimengen Hanso" ou coisa similar fazendo uma demonstração de uma coisa chamada "Ruby on Rails". O vídeo ainda está disponível no YouTube e sugiro que você o assista pois aquele foi um momento histórico. Aqui o link: https://www.youtube.com/watch?v=Gzj723LkRJY

É David Heinemeier Hansson o nome, mas eu sempre vou dizer DHH 

Era um vídeo cheio de "Ops", "Uopa" e uma série de pequenos erros. Soavam engraçados em um primerio momento, mas sabem o que era chocante? De repente aquela minha sensação de que eu trabalhava de uma forma extremamente inteligente se transformou em vergonha. Eu trabalhava de uma forma muito, muito tosca perto do que aquele sujeito estrangeiro cujo nome eu mal conseguia pronunciar estava me mostrando.

Foi o melhor tapa na cara que levei na vida!

E aí eu tentei o Ruby on Rails e era muito lindo e... meu passado veio me importunar!

E puxa vida, o tal do Ruby on Rails era muito lindo! Eu estava criando aqueles projetos com uma velocidade incrível: pegava meu banco de dados, criava algumas classes, iniciava o scaffolding e boom: lá estavam minhas páginas!

Me lembro também de ter comprado um livro excelente, de um sujeito chamado Fábio Akita, o "Repensando a web com Rails". Foi uma experiência muito bacana porque eu lia o livro, experimentava no meu PC, ia progredindo, as aplicações crescendo e de repente eu achava Java um porre e o JSF a coisa mais entediante do universo. (ah... a arrogância...)

Foi quando na empresa em que trabalhava desenvolvi um projeto no qual precisava usar uma boa quantidade de código que eu já tinha implementado e funcionava perfeitamente bem em... Java.  Virei para os meus colegas e disse: "ah, basta que a gente reescreva tudo em Ruby que é uma linguagem super massa!".

Ainda me lembro da assustadora sensação de voar sobre minha casa graças ao "amistoso impulso" dado pelos meus colegas de trabalho, aqueles "preguiçosos que não queriam reescrever todo o seu código em uma linguagem mais massa que a deles". :)

Tem um tal de Groovy on Rails que parece massa...

Voltar para o JSF 1.2 foi muito triste. Era como se em um dia eu estivesse no paraíso e no seguinte estivesse... escrevendo componentes em JSF 1.2. Até me inspirou a escrever um texto sobre o assunto um tempo depois, só que não sobre o JSF, mas sim sobre "cavernas". :)

Mas eu ouvia falar de algo chamado Groovy on Rails que ainda não tinha atingido a versão 1.0 mas que me possibilitava ter o mesmo estilo de desenvolvimento que o pessoal do Ruby on Rails tinha. E com uma vantagem: eu podia reaproveitar todo o meu código Java nativo e ainda ter uma performance muito superior, pois estava usando a JVM e todos aqueles servidores de aplicação que me pareciam tão fantásticos na época!

Os primeiros projetos foram sucesso absoluto e nós pudemos usar todo aquele nosso código legado. O passado deixou de ser um problema e se tornou um aliado. E ainda melhor: eu não estava programando apenas em Java, mas em Groovy e tinha todos aqueles tesouros que havia descoberto com o tempo. Foi lindo.

Mas só eu usava aquele negócio e aquela solidão me incomodava muito... e se eu buscasse por gente que também usasse aquilo?

Só nossa equipe usava Groovy e Grails. Na realidade, na nossa equipe só eu usava Grails, pois os outros tinham medo de chegar perto daquela "coisa que ninguém usava". E no GUJ não via o pessoal falar a respeito.

Primeiro logo do Grails Brasil

E eu ganhava extremamente mal,  mas na Hostnet tinha um plano de PHP que custava na época algo em torno de R$ 24,90 por mês no qual havia alguns assistentes que permitiam aos clientes instalar sistemas PHP de forma muito simples e rápida. Um destes assistentes era para o phpBB, que é um excelente motor de fórum feito em... PHP.

Na época eu conhecia bem PHP:  juntei a fome com a vontade de comer e, naquele dia 15 de fevereiro de 2008, no intervalo do almoço (terminei o dia com fome), assinei o plano, executei o assistente, customizei o phpBB, registrei o domínio grailsbrasil.com e tempos depois o grailsbrasil.com.br. Tudo em 40 minutos. Nascia ali o Grails Brasil pois eu queria conhecer mais pessoas que também usassem Grails e falassem português.

Na primeira semana havia 20 membros, no primeiro mês 50. Foi um choque para mim. Não esperava que o Grails Brasil iria durar mais que seis meses (na realidade, eu nem sabia se teria dinheiro para pagar as coisas depois daquele período).

E hoje, bem...

A maior parte das pessoas me conhecem por causa do Grails. Publiquei um monte de artigos sobre, criei este blog, Grails Brasil saiu do phpBB e hoje é 100% escrito em Grails (uso a versão 1.3.9 até hoje!), publiquei um livro sobre Spring e estou lutando para terminar o meu livro sobre Grails (cuja idéia para escrevê-lo surgiu lá pelos idos de 2009, 2010) e cujo resultado final, espero, vai alegar muita gente nos próximos meses (eu sei que estou atrasadíssimo).

Grails Brasil tá chegando perto dos 2000 membros e eu continuo usando estas tecnologias diariamente. As vi evoluir, Groovy deixou de ser uma lesma e hoje tem performance próxima à do Java, mais e mais pessoas programam em Groovy e Grails aqui no Brasil , uma porrada de empregos foi criada graças a estas tecnologias, muita gente veio para o Java graças ao Groovy e outra penca para o Java EE graças ao Grails.

Acho esta uma história bacana, e ainda ocultei aqui diversos detalhes que dariam um livro. Conheci muitas pessoas interessantes e fiz excelentes amizades. E sinceramente? Pra uns vai soar estranho, mas me vejo programando em Groovy daqui a dez anos: talvez não como linguagem principal (sei lá o que vai surgir), mas com certeza como aquela que me quebra diversos galhos diários.

Aviso: momento cafona a seguir

Não é exagero dizer que Groovy e Grails fazem parte da minha família.

PS:

E eu ainda nem cheguei no primeiro quarto da história. Coisas boas virão neste ano e no próximo. :)