Category Archives: Grails Brasil

Groovy/Grails, Spring e JavaScript Brasil por dentro – nossa arquitetura de comunidades

Cinco anos atrás escrevi este post descrevendo como era a arquitetura do Grails Brasil (hoje Groovy e Grails Brasil). As coisas caminharam bastante desde então: de um código fonte que tinha como objetivo atender um único site (Grails Brasil), pouco a pouco este evoluiu para que se tornasse uma solução capaz de atender qualquer comunidade.

Ao lançarmos o Spring Brasil demos o primeiro passo no que diz respeito a este objetivo: era essencialmente o código fonte do Grails Brasil com uma série de pequenas modificações (essencialmente a remoção de tudo o que era específico apenas daquele site). Já no caso do JavaScript Brasil demos o passo quase derradeiro: é o mesmo código fonte do Spring Brasil: todas as customizações (especialmente visuais), entretanto, passaram a ser o resultado de mudanças na configuração.

Acho que é interessante contar a história técnica por trás deste projeto (ela descreverá sua arquitetura). Curiosamente, não temos um nome para este código fonte: antes era “Grails Brasil”, hoje o chamamos de “Komunidade” ou o nome do site no qual estamos trabalhando.

A história

O início em PHP

A primeira versão do Grails Brasil veio em 2008 e era na realidade uma instalação do phpBB. Sim, você leu certo: o Grails Brasil era um site escrito em PHP. O criei para aprender Grails e o phpBB era uma solução muito interessante na época: fácil de instalar (fiz isto usando um assistente da Hostnet na hora do almoço) e manter. Além disto, era o que precisávamos na época: um fórum básico.

Esta solução nos atendeu bem por um ano ou dois. A hospedagem era relativamente barata, mas com o tempo foi ficando mais cara por dois motivos:

  • A comunidade cresceu bastante e sempre estávamos superando nosso limite de banda.
  • SPAM quase nos destruindo: gastava uma boa parte do meu dia apagando SPAM do site.

Em um primeiro momento fiz modificações no código do phpBB para reduzir estes problemas. Não tive bons resultados e por um tempo pensei seriamente em matar o projeto.

Segunda fase: primeira versão em Grails

Lá por 2008, 2009 tive meu primeiro contato com servidores cloud que passaram a se mostrar como uma alternativa bem mais viável (plano free tier da AWS pra ser mais preciso). Até então hospedagem Java era ou muito cara (pra mim) ou muito limitada (precisava enviar um WAR para o serviço que oferecia um Tomcat compartilhado, algo muito tosco).

Foi a oportunidade para poder finalmente ter a primeira versão em Grails do site. Dois objetivos me guiaram para esta mudança:

  • Meu custo com hospedagem deveria ser menor.
  • O problema do SPAM deveria ser definitivamente resolvido.

Foi escrita então esta primeira versão do site em Grails (versão 1.3.7, que foi usada até ano passado ou retrasado se não me engano – hoje usamos a versão 3.2.8). Dado que serviços como AWS costumam cobrar por processamento, foi o momento ideal para que eu pudesse otimizar ao máximo meu código (o que me levou a um conhecimento bem mais profundo da linguagem Groovy e da própria JVM).

E nisto foram tomadas uma série de decisões que são refletidas no código até hoje:

  • Dado que já existia uma base de posts vinda do phpBB, e este usa uma sintaxe chamada bbCode no armazenamento dos posts, a próxima versão do site deveria manter esta compatibilidade (até hoje usamos bbCode para escrever os posts).
  • As buscas não deveriam tocar o banco de dados: sendo assim adotamos o Lucene como nosso motor de indexação usado em todas as nossas consultas (já notou como são rápidas?).
  • Dado que meu objetivo era reduzir custos, e minha instância no free tier da AWS tinha 612 Mb de RAM, neste mesmo servidor deveriam ser executados o MySQL e o Tomcat. Logo o sistema poderia consumir, no máximo, 300 Mb de RAM (consome isto até hoje).
  • O site tinha de ser mais rápido que o phpBB (consegui, é ordens de magnitude mais rápido). Logo o que pudesse ser feito assincronamente deveria ser feito desta maneira (por isto e-mails não são enviados na hora, mas sim esporadicamente, assim como atualização de acessos e pontuação dos membros).
  • A esmagadora maioria dos acessos ao site são para simples consulta (10% se registram e menos ainda chegam a postar conteúdo), sendo assim SEO é prioridade (idem a busca).

E assim surgiu o Grails Brasil escrito em  Grails. Uma série de medidas foram tomadas para atingir estes objetivos, todas elas descritas neste antigo post (e as adotamos ainda hoje).

Terceira fase: Spring e JavaScript Brasil

Até 2015 o código do Grails Brasil se manteve essencialmente o mesmo, apenas com pequenas correções. A partir de 2016 começaram mudanças mais significativas.

A primeira delas dizia respeito à atualização do próprio Grails: passamos a usar a versão 3 e, pouco a pouco, fomos migrando até a versão 3.2.8, usada hoje. Por que levou tanto tempo para fazer este upgrade? A versão antiga me atendia muito bem. Uma boa decisão tomada lá atrás? Ter usado pouquíssimos plug-ins, o que tornou o upgrade muito fácil (em questão de horas estávamos na versão 3.0 do Grails). Além disto estava claro que precisávamos atualizar o código fonte para termos algo durável (Java 6??? Bora pro 8!).

Já fazia um tempo que queríamos criar novas comunidades, então era também a hora de podar o código fonte, removendo tudo aquilo que só fazia sentido no Grails Brasil do novo código. Foi ótimo por que conseguimos otimizar ainda mais o que já tínhamos.

(hoje como consequência temos duas bases de código: uma para o Grails Brasil, outra que atende as outras comunidades para que pudéssemos manter as funcionalidades para os membros atuais do site)

Novos objetivos arquiteturais

Modificações do site em tempo de execução

Ao lançar novas versões do site sempre havia momentos nos quais me deparava com pequenos problemas de layout, conteúdo textual ou JavaScript nos quais detectava problemas logo após ter implantado a solução. Aí era necessário gerar um novo WAR e realizar todo o processo de deploy.

Isto ocorria por que sempre havia um ou outro ponto de configuração que ficava no próprio código fonte (o próprio HTML gerado pelo site, por exemplo, pode ser visto desta forma). Hoje todas as configurações encontram-se externalizadas no banco de dados. Com isto, se queremos modificar, por exemplo, o rodapé do site após a versão ter ido pro ar, hoje é possível.

Erros de layout devido a problemas no CSS? Ok, podemos mudar também. Apenas a título de curiosidade, o JavaScript Brasil passou por umas 20 correções de layout de ontem até hoje (23/8/2017). Sabe quantos deploys foram feitos? 1.

Além disto o conteúdo que aparece nas laterais do site, rodapé e cabeçalho também podem ser modificados hoje com o site em execução, o que nos permite trocar anúncios de uma forma muito mais ágil.

Não só isto: configurações de tarefas agendadas, acesso às integrações essenciais (e-mail, redes sociais e no futuro até mesmo a conexão com o SGBD) são hoje trocadas a quente.

Criação rápida de novas comunidades com o mesmo código fonte

O objetivo é que o “Komunidade” seja como o WordPress. Você baixa a distribuição, configura o acesso ao banco de dados, escolhe um tema e voilá, tá criado um novo blog ou, em nosso caso, uma nova comunidade.

A versão atual é exatamente assim. Pegamos o código fonte, definimos a configuração de acesso ao banco de dados, geramos o WAR, criamos um tema, configuramos no banco de dados do projeto os detalhes da comunidade (seu nome, regras de conduta, quais links são expostos, aonde ficam nossos arquivos de template de e-mail e temas visuais e mais uma série de outros detalhes), instalamos no Tomcat e pronto: uma nova comunidade surge.

Levou algo em torno de umas 4 horas para termos uma primeira versão aceitável do JavaScript Brasil (e nós nem sequer tocamos no código fonte do projeto).

Tornar a abertura do código fonte algo viável

Este tem sido o objetivo já faz algum tempo. Infelizmente ainda há informações no código fonte atual que não devem ser publicadas. Este é o principal motivo por que ainda não existe um repositório no GitHub com o código do Komunidade.

Mas posso dizer que o último release não deu mais um passo nesta direção, mas sim um salto quântico. A esmagadora maioria das informações que mencionei acima não existe mais. O objetivo agora é tornar este código fonte o mais fácil possível de ser mantido E entendido por novos colaboradores.

Mais do que tornar o código fonte mais legível, temos de ter uma distribuição do “Komiunidade” que possa ser usada também por não programadores. Algo como o WordPress.

(diga-se de passagem, uma pessoa que não sabe programar é que fez o tema do JavaScript Brasil, absolutamente sozinha)

Também falta melhorar a documentação do projeto: código Grails é muito fácil de ser entendido, mas não é o suficiente (nunca acreditei naquele papo de “meu código é minha documentação”).

Então, aos que sempre me pedem acesso ao código fonte o que posso dizer neste momento é isto: será eventualmente aberto, mas de uma forma correta e em grande estilo, não por pressão.

O futuro

Lá em cima mencionei que hoje temos duas bases de código: “Grails Brasil” e “Komunidade”, certo? Isto é temporário pois o objetivo é ter apenas uma. Mas como fazer isto se no código do Grails Basil há tanta coisa que só faz sentido nele?

Já estou trabalhando em uma arquitetura de plug-ins para este projeto (WordPress sempre é  inspiração). Sendo assim, tudo aquilo que era específico do Grails Brasil será transformado em um pequeno módulo, que possa ser instalado em uma instância do “Komunidade”.

Com isto é possível ter seções distintas em instalações separadas do Komunidade. É possível, por exemplo, termos uma seção em uma instalação do site que seja na realidade um plug-in. O core será bastante diminuto, e a seu redor os plug-ins orbitarão: tal como ocorre no Eclipse, Netbeans e, claro, no WordPress também.

No que diz respeito ao frontend, ainda temos receio a respeito de uma grande mudança, tal como a adoção de um framework JavaScript ainda tenho algum receio pois um dos nossos objetivos é ter código duradouro e, sinceramente, ainda hoje não vi soluções que tenham passado no teste do tempo (com exceção do jQuery talvez).

E enquanto isto vamos evoluindo pouco a pouco o código que temos. Esta é a história do projeto até agora, grandes novidades virão em breve como sempre. Espero que tenham gostado.

E se inscrevam no Spring Brasil e JavaScript Brasil, pois o principal objetivo por trás dos dois projetos é criar discussões bem acaloradas sobre estes temas!

Spring Brasil no ar, Grails Brasil e o poder das comunidades

Ontem colocamos no ar o Spring Brasil, que é um portal/fórum voltado para a comunidade de desenvolvedores que trabalham com o framework e todas as tecnologias relacionadas. O objetivo é em parte o mesmo que me motivou 9 anos atrás a criar o Grails Brasil: ajudar a divulgar estas tecnologias e aprender mais a respeito no processo.

Mas há uma diferença: Spring, ao contrário do Grails naquela época (e mesmo hoje) não precisa de gente que o divulgue pois já é há um bom tempo (mais de uma década provavelmente) o framework mais popular entre desenvolvedores Java. Então: pra quê este esforço?

Por que comunidades importam

Por um tempo pensei que o Stack Overflow fosse matar todos os fórums voltados a desenvolvimento da internet. Em parte matou, entretanto, apesar do sucesso estrondoso eu, pelo menos, nunca criei elos com outros participantes do site tais como os que criei no GUJ ou Grails Brasil.

O fórum ainda é vital, principalmente os quebra-paus

O foco no Stack Overflow e sites de Q&A é outro: resolver problemas de forma direta e não discutir. Por isto tantas perguntas que acho extremamente relevantes são travadas por moderadores (como esta). Isto sempre me incomodou (e muito). É a limitação do formato “Q&A”. Você está lá para ter uma solução do problema, não necessariamente para refletir a respeito e, mais importante, se aprofundar nele, e por isto, confesso, sempre desprezei o formato e não o segui no Grails Brasil, tal como tentaram fazer no GUJ.

Acredito no poder da discórdia. Pode não parecer, mas minha discussão favorita no Grails Brasil, sabe qual é? Esta: “Grails é horrível“. Seria fácil como mantenedor do site apagar o post, bloquear os membros (bloqueei um sujeito que fez flood, mas só por isto) e censurar o conteúdo dizendo se tratar de uma briga tola.

(não gosto daqueles que concordam com tudo e confesso curtir ver o circo pegando fogo)

Entretanto, se você ler a discussão inteira irá notar que aprendemos muito nela. É por isto que no Grails Brasil (e agora também no Spring Brasil) não temos moderadores no fórum. Confesso que não gosto desta figura: cria duas classes de pessoas quando deveria haver só uma: o participante que quer aprender ou ajudar os outros.

(há moderadores no Grails Brasil e Spring Brasil: eles cuidam apenas da aprovação de notícias para evitar spam, mas nunca houve uma notícia que não tivesse sido aceita nestes 9 anos)

E o mais interessante destas longas conversas é que elas costumam criar elos. Muitos dos clientes da itexto hoje surgiram destas discussões no GUJ e Grails Brasil. Sendo assim, não há como negar o aspecto socializador da coisa.

E os trolls?

E os trolls, como lidar com eles? Bom, nestes 38 anos algo que aprendi foi que você tem das pessoas o que espera delas. Se criarmos uma comunidade esperando o pior dos outros, teremos isto como retorno. Se é uma comunidade, pessoas normais se auto gerenciam, não precisam de tutores.

E se o troll aparecer? Ah, aí a gente lida com ele, mas existem mecanismos no próprio fórum que o evitam. Quer um exemplo? A impossibilidade de editar perguntas ou respostas que muitos reclamaram comigo nestes anos (talvez mude um pouco, mas muito pouco, em um futuro próximo). Por que você não pode editar ou excluir este conteúdo? Simples: para garantir a honestidade intelectual do diálogo.

Nestes 9 anos de Grails Brasil, quantos trolls tivemos? Um. Talvez por a comunidade ser muito menor que as demais, entretanto, creio que o mesmo se repetirá no Spring Brasil ou qualquer outra comunidade que venhamos a lançar no futuro.

Por que boa parte do ecossistema Spring é desconhecida

Esta é outra boa razão: o Spring Framework (e agora o Spring Boot) são muito bem conhecidos na nossa comunidade. Entretanto, conversando com o pessoal observo que, tirando estes projetos, o único conhecido de fato é o Spring Security.

E há uma enorme quantidade de projetos que podemos discutir e nos aprofundar nesta comunidade: basta ver a página dos projetos no spring.io. Então há muito o que aprender, e isto me empolga bastante!

Coisas que estão por vir

 

No sábado colocamos no ar o primeiro release do Spring Brasil que contém as mesmas funcionalidades presentes no Grails Brasil (é o mesmo código fonte, porém com algumas melhorias). Em um futuro próximo queremos melhorar incluindo algumas novidades:

  • Publicação de vagas de emprego
  • Melhoria no portólio pessoal dos membros para que possam expor seus trabalhos e currículo
  • Divulgação de eventos
  • Criação de uma nova newsletter, tal como a Semana Groovy
  • E, claro, o que for sugerido pelos membros da comunidade

Eventualmente todas estas mudanças irão voltar para o Groovy e Grails Brasil pois, como disse, é o mesmo código-fonte.

E nove anos depois…

Nove anos depois vamos fomentar mais comunidades, primeiro com o Spring Brasil, depois com outras que sabemos ser importantes na comunidade de desenvolvimento nacional.

Conto com a participação de vocês nesta nova jornada: espero fazer um número de amigos e parceiros tão grande quanto foi realizado com o Grails Brasil.

Link para a comunidade: http://www.springbrasil.com.br

Para se registrar, acesse este link: http://springbrasil.com.br/membro/registro . É possível se conectar usando Facebook (mais redes sociais estão a caminho), sendo assim o processo de entrada fica muito mais fácil (algo que devia ter feito no Grails Brasil anos atrás).

Conto com vocês!

Semana Groovy 35!

Esta foi uma semana bem corrida para mim, o que não quer dizer que não haja alguns links que eu venha a compartilhar com vocês sobre as tecnologias que curtimos.

E… nesta sexta-feira irei apresentar um caso muito interessante sobre sistemas legados na QCon Rio usando algumas das tecnologias que falamos aqui. http://qconrio.com/speaker/henrique-lobo-weissmann

Duas excelentes notícias para quem trabalha com Grails!

Até este momento não estava recomendando o Grails 3.x para meus clientes. Isto está prestes a mudar devido a dois acontecimentos importantes:

O primeiro é que finalmente temos uma versão do plug-in Spring Security para o Grails 3:  http://grailsbrasil.com.br/noticia/show/277

Algo que ainda não havia notado no Grails 3.0.4. O suporte ao scaffolding dinâmico voltou! – https://github.com/grails/grails-core/issues?q=milestone%3Agrails-3.0.4

Um projeto muito legal open source feito em Grails

O Bruno Bemfica me mostrou um projeto muito bacana chamado Streama: um gerenciador de vídeos e streaming cuja leitura do código fonte é bastante interessante. Interessado? Dá uma olhada neste link: http://dularion.github.io/streama/

Links da semana

Um recurso muito bacana do Groovy e sobre o qual pouco se fala a respeito: o trampoline – https://wakeupcode.wordpress.com/2015/08/18/groovy-functional-sugar-trampoline/

Uma introdução bem bacana ao RatPack – http://kyleboon.org/blog/2015/08/05/zero-to-ratpack/

Ferramenta legal da semana: Jenv (talvez um GVM++)

Algum tempo atrás falei aqui sobre o GVM (http://www.itexto.net/devkico/?p=2259) que é uma excelente ferramenta para se gerenciar diferentes versões de ferramentas que pertençam ao ecossistema Groovy.

Uma limitação do GVM, no entanto, é que ele não te ajuda a gerenciar diferentes versões do JDK. Então encontrei uma ferramenta muito interessante que nos permite gerenciar tanto versões de diversos componentes do ecossistema Groovy (incluindo Grails) e também do Java (JDKs, Maven, inúmeros frameworks e muito mais). Se chama Jenv.

Mais detalhes sobre esta importante ferramenta (que já está substituindo o GVM para mim) neste link: http://jenv.mvnsearch.org/

Semana Groovy 34 – Túnel do tempo!

Estamos entrando em uma fase temática da Semana Groovy, sendo assim o tema de hoje é história. Vou compartilhar alguns links históricos sobre desenvolvimento com vocês além de, claro, os agora tradicionais links da semana.

No treinamento que estamos ministrando na itexto para desenvolvedores independentes um aluno me perguntou o que deveria estudar após dominar completamente as tecnologias que ensinamos. Minha resposta? História.

Nada melhor que um bom conhecimento histórico pra que você entenda de verdade por que as tecnologias que usamos possuem seu aspecto atual. Sendo assim, vamos lá!

Guia dos perplexos

Sem dúvida o projeto que mais gostei este ano foi o Guia dos Perplexos do Rene de Paula Jr. Para comemorar os vinte anos de Internet no Brasil, Rene entrevistou diversas pessoas com quem trabalhou durante este período.

É um retrato fascinante da história neste período e expõe muito bem o que rolou e aonde estamos hoje. São dezenas de entrevistas gravadas nos últimos dois meses (eu acho). Um trabalho realmente incrível: vale cada segundo assistido!

Segue o link: http://guiadosperplexos.tv/

No site é dito que foi terminada a primeira temporada. Torço para que a segunda venha logo!

NerdTV

O trabalho do Rene de Paula me lembrou muito algo que o Robert Cringely fez quase dez anos atrás chamado NerdTV. A diferença é o cenário: enquanto Cringely fala sobre o Vale do Silício, Rene de Paula fala sobre o Brasil.

Link para o NerdTV: http://www.pbs.org/cringely/nerdtv/

Links históricos sobre Groovy, Grails e Spring

Groovy é apresentado ao mundo por seu criador, James Strachan – http://radio-weblogs.com/0112098/2003/08/29.html

Por que Grails não se chama “Groovy on Rails” – http://grails.1312388.n4.nabble.com/Groovy-on-Rails-is-no-more-kind-of-td1313422.html

Primeiro post do Grails Brasil – http://grailsbrasil.com.br/post/show/2

O dia em que a SpringSource comprou a G2One (desenvolvedora original do Grails) – http://www.infoq.com/news/2008/11/springsource-g2one

E aí a SpringSource foi comprada pela VMWare! – http://colinharrington.net/blog/2009/08/vmware-acquiring-springsource-which-acquired-g2one/

Foi quando a VMWare resolveu criar uma empresa chamada Pivotal para explorar o ecossistema Spring, Groovy e Grails – https://gigaom.com/2012/07/16/vmware-plans-cloud-spin-out-to-keep-up-with-microsoft-amazon-and-google/

Então, em janeiro de 2015 a Pivotal decide parar de financiar os projetos Groovy e Grails. Seria o fim? – http://blog.pivotal.io/pivotal/news-2/groovy-2-4-and-grails-3-0-to-be-last-major-releases-under-pivotal-sponsorship

Na época havia dito que não era motivo para se preocupar, lembra? – http://www.itexto.net/devkico/?p=2116

E então, mais tarde neste ano, duas novidades interessantes que comprovaram o que disse:

Em março o projeto Groovy foi para a Apache e desde então vêm caminhando super bem! – http://glaforge.appspot.com/article/groovy-projects-intends-to-join-the-apache-software-foundation

E a OCI se tornou a principal financiadora do projeto Grails – http://www.infoworld.com/article/2909679/java/grails-web-framework-finds-home-at-object-computing.html

E que tal ver o nascimento do Spring? Ele vai aparecer pela primeira vez neste livro (ainda um clássico) do Rod Johnson – http://www.amazon.com/Expert-One-One-Development-without/dp/0764558315

E o artigo que realmente apresenta o Spring ao mundo? – http://www.theserverside.com/news/1364527/Introduction-to-the-Spring-Framework

E finalmente, os links da semana :)

Como integrar sua aplicação com o serviço S3 da AWS – http://www.tothenew.com/blog/integrating-amazon-s3-in-grails-application/

Awesome Groovy! – Uma lista muito bem feita contendo um monte de bibliotecas, frameworks e ferramentas para você usar com Groovy. Muito bacana! – https://github.com/kdabir/awesome-groovy

Como usar Groovy com Spring – https://www.accelebrate.com/blog/have-a-groovy-spring/

Migrando um projeto Grails da versão 1.3.7 para a 2.4.4 – exposto em detalhes. Excelente leitura! – https://dzone.com/articles/check-out-the-new-json-p-11-early-draft

Um comparativo entre Groovy e Scala (não gosto deste tipo de post, mas este aqui é particularmente interessante) – https://www.linkedin.com/pulse/scala-vs-groovy-functional-programming-showdown-owen-rubel

Peter Ledbrook compartilha suas primeiras impressões a respeito do Grails 3.0. Considere leitura obrigatória caso esteja pensando em atualizar suas aplicações para esta versão – http://blog.cacoethes.co.uk/groovyandgrails/exploring-grails-3

Quais plug-ins estão na fila para serem atualizados para a versão 3 do Grails? – https://github.com/grails/grails-core/wiki/Grails-3-Priority-Upgrade-Plugins

Apresentação útil: GVM: The Groovy Environment Manager – interessantíssimo para aqueles que estão interessados na ferramenta. Vale cada segundo! – https://www.youtube.com/watch?v=i6WOnN8uJdM

Lançamentos

Spring Batch 3.0.5 – http://spring.io/blog/2015/08/10/spring-batch-3-0-5-release-is-now-available

Spring Boot 1.3.0 M3 – http://spring.io/blog/2015/08/11/spring-boot-1-3-0-m3-available-now

Spring Roo 1.3.2 RC1 – http://spring.io/blog/2015/08/11/spring-roo-1-3-2-rc1-maintenance-release-now-available

Semana Groovy 33 – Blogs sobre Groovy, Grails e Spring!

Blogs sobre Groovy, Grails e Spring

Há blogs muito bons em português sobre Groovy e Grails: que tal você os adicionar aos seus favoritos?

Domine o Spring – https://domineospring.wordpress.com/

Emilio’s Blog – http://emilio2hd.com.br/

Portal Willcrisis – http://www.willcrisis.com/site/

Santo Grails – http://santograils.org/

Vai de Grails – http://vaidegrails.com/

/dev/Kico – http://devkico.itexto.com.br

E também não dá pra não citar o /dev/All (http://www.devall.com.br) aonde sempre aparece conteúdo sobre estes assuntos. :)

Links

Contribuindo para projetos abertos no GitHub – descobri este excelente post no /dev/All (http://www.devall.com.br), no qual o Gildásio Júnior nos mostra como proceder quando queremos contribuir para projetos open source hospedados no GitHub. Uma excelente leitura! – https://gjuniioor.wordpress.com/2015/07/30/contribuindo-para-projetos-abertos-no-github/

O que nos aguarda no Spring Framework 4.3 e 5.0? – https://spring.io/blog/2015/08/03/coming-up-in-2016-spring-framework-4-3-5-0

Making Java Testing Groovy – Um excelente post mostrando por que Groovy é uma linguagem fantástica para testadores que precisem lidar com Java (ou linguagens que vão ser executadas sobre a JVM) – Vale cada segundo esta leitura! – http://www.thattestingguy.com/making-java-testing-groovy/

Como usar o GVM no Windows – escrevi um rápido tutorial ensinando a usar o GVM no Windows – http://www.itexto.net/devkico/?p=2259

Uma crítica muito bem escrita ao padrão REST

Há posts que você lê e sabe que nasceram clássicos. Este tem grande probabilidade de entrar nesta categoria: “RESTful Considered Harmful”. Vivemos em uma época na qual ao pensarmos em APIs e integração imediatamente nos vêm à mente a implementação de uma arquitetura REST. Será que é sempre o caso? Quais os lados negativos e limitações desta abordagem? Considere leitura obrigatória! https://dzone.com/articles/restful-considered-harmful

Dica de projeto – Spring Session

Já viu o Spring Session? Trata-se de um projeto muito interessante desenvolvido pela Pivotal que é inteiramente focado na gestão de sessões em aplicações web. Com ele é possível, por exemplo, implementar sessões clusterizadas, multi-browser, por websocket e mais algumas coisas bastante interessantes.

O link para o site oficial do projeto é este: http://projects.spring.io/spring-session/

Dois posts de pessoas que estão descobrindo Groovy!

Feedback Leitura – Groovy recipes – Guilherme Costa escreve suas impressões sobre o livro e a linguagem – http://imguilherme.com/2015/08/04/feedback-leitura-groovy-recipes/

Groovy: uma jornada inesperada – Fernando Franzini se apaixona por Groovy (o entendo perfeitamente!) – https://fernandofranzini.wordpress.com/2015/08/03/groovy-uma-jornada-inesperada/

Lançamentos

Spring 4.2 GA – https://spring.io/blog/2015/07/31/spring-framework-4-2-goes-ga

Spring Statemachine 1.0-M3  – Um projeto bem interessante da Pivotal que desconhecia. Vale à pena dar uma estudada nesta criatura, especialmente se você for implementar workflows distribuídos –  http://spring.io/blog/2015/08/04/spring-statemachine-1-0-0-m3-released

Spring Session 1.0.2 – http://spring.io/blog/2015/08/03/spring-session-1-0-2-released

Dica de leitura – Guia de expressões regulares

Não há muito para onde fugir das expressões regulares. É uma daquelas ferramentas que você é obrigado a conhecer. Então nada melhor que um livro pra te ajudar nisto, certo?

“Expressões Regulares – Guia de Consulta rápida”, de Aurélio Jargas, trata-se da edição integral que o autor torna disponível gratuitamente em seu site. Uma mão (ou melhor, DUAS) na roda! – http://aurelio.net/regex/guia/

Semana Groovy 32!

Mais uma edição da Semana Groovy com alguns links e notícias que chamaram minha atenção nos últimos dias.

Neste dia 8 de agosto começam as aulas da primeira turma de Grails no projeto Formação itexto! E que tal uma notícia ainda melhor? Estamos preparando o material para um novo treinamento que deverá ser lançado mês que vêm. Acredito que vocês irão gostar, pois é um assunto que muitos pedem maiores detalhes a respeito (manterei o mistério por enquanto). Você pode acompanhar o que estamos fazendo emhttp://formacao.itexto.com.br

Observem algo interessante nesta edição da Semana Groovy: a maior parte dos links está em português!

Links da semana

No blog do Emílio há três posts muito bons ensinando a configurar o Grails com uma infraestrutura que envolve o Sonar, Jenkins e Artifactory. São ferramentas essenciais para todo desenvolvedor (Grails ou não). Seguem os links!

Parte 1 – http://emilio2hd.com.br/artifactory-jenkins-grails-sonar-parte-1/

Parte 2 – http://emilio2hd.com.br/artifactory-jenkins-grails-sonar-parte-2/

Parte 3 – http://emilio2hd.com.br/artifactory-jenkins-grails-sonar-parte-3/

Configurando o Spring Security em uma aplicação Java EE com JPA – Post bem prático do blog Domine o Spring – https://domineospring.wordpress.com/2015/07/27/spring-security-spring-jpa-e-o-javaee/

Problemas com o recarregamento dinâmico de classes no Grails? Talvez o problema esteja relacionado com o nome do diretório no qual seu projeto se encontre (caracteres de espaço podem ser a causa). Link interessante que apareceu no Grails Brasil e que recomendo a leitura: http://peedeebeesblog.blogspot.com.br/2015/07/grails-auto-class-reloading-broken-but.html

Container-less: usar ou não um servidor de aplicação? – post interessante publicado no site O Tapioca. Dado que o Grails 3 nos oferece este recurso, assim como o Spring Boot, é uma leitura bastante interessante para se levantar a discussão –http://www.otapioca.com.br/2015/07/container-less-usar-ou-nao-um-servidor-de-aplicacao/

Lançamentos

Grails 3.0.4 – https://github.com/grails/grails-core/releases/tag/v3.0.4

Grails 2.5.1 – https://github.com/grails/grails-core/releases/tag/v2.5.1  (ainda a versão que recomendo a meus clientes)

Dica: documentando seus projetos Grails!

Um recurso que vejo poucas pessoas usando no Grails são os recursos oferecidos pelo framework na geração de documentação. Sabia disto? Se não, recomendo que você leia esta seção da documentação (repetição inevitável!) do framework:http://grails.github.io/grails-doc/2.5.1/guide/conf.html#docengine