semana_groovy

Semana Groovy 15!

Grails Brasil 3.0 online!

No dia 19/9/2014 foi feita a primeira implantação da versão 3.0 do Grails Brasil. O foco deste novo release foi no visual e na responsividade do site, que agora está bem mais amigável.

Precisamos da sua ajuda nos fornecendo seu feedback a respeito. Maiores detalhes a respeito podem ser encontrados no blog /dev/Kico – http://www.itexto.net/devkico/?p=1981

E a coisa não parou ali: no dia 19 foi o release 3.0.0: hoje, dia 21, já estamos no release 3.0.3. Por que tantos releases neste curto espaço de tempo? Graças ao feedback da comunidade que foi extremamente rápido e muito, muito importante. Sendo assim, agradeço a todos aqueles que cooperaram (por e-mail, Google Talk, Skype, Facebook e tantos outros meios) e peço novamente para que me forneçam o máximo de feedback possível, ok?

Posts interessantes

Controle Transacional Declarativo com Spring: AOP ou @Transactional – EXCELENTE post no blog da Triad Works explicando as diferenças, vantagens e desvantagens entre os dois diferentes modos de se configurar transações com Spring: por XML ou anotações (leitura obrigatória) –  http://blog.triadworks.com.br/controle-transacional-declarativo-com-spring-aop-ou-transactional

Grails + sass + jade + handlebars + coffe – Ricardo Bocchi nos mostra como configurou seu projeto usando gulp para trabalhar com as tecnologias que dão nome ao post. Interessante, não conhecia o gulp, entrou pra minha lista de coisas a serem estudadas – http://ricardobocchi.blogspot.com.br/2014/09/grails-sass-jade-handlebars-coffe.html

Preview do Grails 3.0 – Os slides da apresentação do Grame Rocher sobre o que podemos esperar do Grails 3.0. É bastante animador! – https://speakerdeck.com/graemerocher/grails-3-preview

Apareceu uma solução bastante interessante sobre como lidar com datas em Grails no Grails Brasil – http://grailsbrasil.com.br/post/show/2774

Groovy Weekly #36 – Adivinhem quem aparece nela? :) – http://glaforge.appspot.com/article/groovy-weekly-36

Preview Spring Security Websocket & Sessions – Um post legal no site da Pivotal sobre como será o suporte a websockets a ser incluído no projeto Spring Security – http://spring.io/blog/2014/09/16/preview-spring-security-websocket-support-sessions

Apresentações

Curso de Grails, Aula 4, Configurando o projeto Grails para conexão com o MySQL – Leandro Guarino dá continuidade ao seu curso ensinando como configurar o acesso ao MySQL. – https://www.youtube.com/watch?v=vYACT_sxT-4&feature=youtu.be

Getting Started with Ratpack – Ratpack é um framewok no qual estou prestando bastante atenção e, na minha opinião, você também deveria. – https://www.youtube.com/watch?v=g0fX5yA-Xzg&feature=youtu.be

Posts clássicos (ouro!)

Descobri nesta semana um projeto no GitHub cujo objetivo é catalogar livros de programação que você pode ler e baixar gratuitamente de forma 100% legal, sem pirataria! Há livros sobre uma infinidade de linguagens: já teve curiosidade a respeito de linguagens exóticas ou pouco faladas como Forth ou Ada? E não se restringe a apenas livros sobre linguagens de programação: há também conteúdo sobre agilidade, arquitetura, carreira e muito, muito mais!

Aqui está o mapa da mina: https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md

(claro: há livros também sobre Groovy, Grails, Spring e muito Java!)

E a coisa pode melhorar: o link acima contém apenas livros em inglês. Há também uma versão do projeto só com material em português!

https://github.com/vhf/free-programming-books/blob/master/free-programming-books-pt_BR.md

Assine nossa newsletter!

Quer receber esta newsletter por e-mail no momento em que for publicada? Basta se inscrever preenchendo este formulário!

Grails Brasil 2.0

Grails Brasil ganha novo visual! (versão 3.0!)

Hoje é um dia muito importante para o Grails Brasil: foi feita a implantação do primeiro release da versão 3.0 do site. O foco foi no novo layout que, acredito, está BEM melhor agora.

Como vocês vão reparar, alguns links não estão mais sendo expostos no menu principal: “vagas de trabalho” e “links”. Por que isto? A razão é simples: estou reformulando completamente esta parte do site, que vai ser ordens de magnitude melhor!

Como você pode nos ajudar

Com certeza há alguns bugs nesta nova versão. Caso encontre algum, por favor, me informem para que eu os vá corrigindo o mais rápido possível, ok? Ainda mais importante, preciso do seu feedback: diga-me tudo aquilo que você gosta e especialmente o que não gosta. Este feedback é fundamental para mim.

Enquanto isto, espero que goste do novo visual do Grails Brasil. :)

O link? http://www.grailsbrasil.com.br

Semana Groovy 14!

Grails Brasil com mais de 2000 membros!

Atingimos a marca de mais de 2000 membros esta semana ( http://grailsbrasil.com.br/grailsBrasil/info ). Vale à pena recordar alguns momentos:

Como é a arquitetura do Grails Brasil atual – http://www.itexto.net/devkico/?p=1097

Parte da história do Grails Brasil – http://www.itexto.net/devkico/?p=1907

O dia em que o Grails Brasil 2.0 foi pro ar – http://www.itexto.net/devkico/?p=965

O vídeo no qual apresentei o Grails Brasil 2.0 pela primeira vez – https://www.youtube.com/watch?v=hXSlPYqFCRM&list

E o futuro do Grails Brasil? –  http://grailsbrasil.com.br/post/show/2691

Posts

Integrando Groovy e Java – Escrevi este post no qual ensino como você pode fazer código Groovy falar com Java e vice-versa. Muitas dúvidas no Grails Brasil tem a forma “como uso [biblioteca Java x] com Groovy/Grails?”. Neste artigo respondo a esmagadora maioria destas. – http://www.itexto.net/devkico/?p=1957

An alternative pattern for creating custom Grails GSP tags – uma maneira alternativa para se criar tags em Grails – http://confusedbyearliererrors.com/creating-custom-gsp-tags/ . Como não é o padrão do framework, desrecomendo sua aplicação, mas citei aqui só para o caso de mais alguém ter lido o post.

Apresentações

E que tal algum material em português para variar? O Leandro Guarino ( https://www.youtube.com/channel/UC7Q_uLJ5hpA3NzlP7I4dGqQ ) começou a publicar algum material que é de interesse de todos nós:

Aula 1 – Curso de Grails – https://www.youtube.com/watch?v=61eUj2Li7hE

Aula 2 – Curso de Grails – Entendendo a estrutura do projeto – https://www.youtube.com/watch?v=jPaPow1F1iA

Gradle in the Enterprise at Linkedin – Como o Linkedin está adotando internamente o Gradle –  http://www.gradleware.com/conferences/gradle-summit-2014-video-gradle-enterprise-linkedin/

Groovy Intro – Uma introdução à linguagem que foi feita no evento Coding Serbia – http://www.java-tv.com/2014/08/28/groovy-introduction/

Lançamentos

Spring Boot 1.1.6 – https://spring.io/blog/2014/09/05/spring-boot-1-1-6-released

Swiss Knife – este é um lançamento importante: começam a aparecer ferramentas e frameworks para se desenvolver em Android com Groovy. Confira esta ferramenta! – https://github.com/Arasthel/SwissKnife

Plugins interessantes

Grails WSChat (Chat por websocket) – Permite a inclusão de um chat baseado em websocket em sua aplicação Grails – https://github.com/vahidhedayati/grails-wschat-plugin

Font Awesome Grails Plugin – No Twitter Bootstrap é usada uma fonte chamada “Awesome” (http://fortawesome.github.io/Font-Awesome/) que na realidade armazena uma série de ícones. Este plugin te permite acessar esta fonte como se fosse um resource do Grails – https://github.com/halfbaked/grails-font-awesome-resources

GroovyBlogs.org está sendo refeito!

GroovyBlogs é um site que acompanho há um bom tempo (desde que foi criado pra ser exato). Trata-se de um agregador de blogs que escrevam sobre Groovy, Grails e Spring (como esta newsletter). Uma boa notícia é que estão o remodelando completamente (está ficando bem melhor, diga-se de passagem) e em breve teremos acesso a uma nova versão!

Não conhece o site ainda? Não perca tempo e adicione-o nos seus bookmarks agora. – http://groovyblogs.org/

Posts clássicos

Na última edição da Semana Groovy voltou a seção Posts Clássicos na qual são expostos alguns links sobre a Ciência da Computação e sua história. Nesta edição a indicação é o Dicionário de Algoritmos e Estruturas de Dados do NIST (Instituto de Tecnologia e Padrões dos EUA (o “INMETRO” de lá)).

Para quem curte o assunto é um prato feito (e farto) – http://www.nist.gov/dads

De onde saiu o Google? Como curiosidade histórica, uma tese que sempre releio: “The Anatomy of a Large-Scale Hypertextual Search Engine”, de uns caras chamados Sergey Brin e Lawrence Page. Se você quer saber como foi implementado o Google em seus primórdios, esta é A fonte: http://infolab.stanford.edu/~backrub/google.html

Assine nossa newsletter!

Quer receber esta newsletter por e-mail no momento em que for publicada? Basta se inscrever preenchendo este formulário!

java_groovy

Integrando Groovy e Java

Groovy não deve ser visto como uma linguagem alternativa ao Java, mas sim complementar (e vice-versa). Mesmo em meus projetos Grails costumo ter partes escritas em Java (ou Clojure) por uma razão simples: é bom ter as ferramentas certas para cada tipo de problema, e se eu posso ter mais de uma e as domino, a pergunta que fica é: por que não?

Então neste post vou mostrar algumas maneiras que você pode integrar suas bases de código Groovy e Java para assim obter o melhor dos dois mundos. É importante ressaltar que aqui só vão ser expostas algumas das estratégias que costumo usar.

Java chamando Groovy

java_chama_groovy

Groovy como linguagem embarcada

Possivelmente esta é a estratégia mais comum: você já possuí um sistema escrito em Java e quer oferecer pontos de extensão para o usuário final sob a forma de scripts (que podem estar armazenados em um sistema de arquivos, banco de dados, nuvem ou qualquer outro local mágico de sua preferência). Assim seu trabalho como arquiteto/desenvolvedor diminui: você apenas fornece a estrutura básica sob a forma de um framework e os pontos de customização passam a ser feitos pelo próprio usuário final.

O fundamental

Como fazer? Já gravei agluns vídeos sobre isto pra você. O fundamental você pode ver abaixo:

Melhorando o desempenho

Mas esta é apenas a primeira parte do seu trabalho e o resultado vai ser um sistema razoavelmente lento. Como melhorar isto? Ensino no vídeo a seguir:

Sobre o vídeo acima, uma nota: hoje já tenho algumas técnicas que podem aumentar ainda mais a performance de scripts Groovy: em breve gravo um novo vídeo expondo como fazer isto (mas o acima resolve a maior parte dos seus problemas, se não todos).

Garantindo a segurança

Ter uma linguagem embarcada em seu sistema Java é muito bom, mas há um problema: segurança. Como evitar que código mal intencionado entre na sua vida? Imagine que seu usuário final escreva um script Groovy como o abaixo:


System.exit(1)

Ensino como resolver este problema em outro vídeo.

Usando bibliotecas escritas em Groovy já compiladas

Você quer adicionar ao seu projeto Java uma biblioteca ou framework escrito em Groovy. É bastante simples: basta que você adicione esta biblioteca e suas dependências ao classpath do seu projeto e os distribua junto com sua aplicação quando esta for compilada.

Uma nota importante deve ser feita: para evitar chateação, sempre inclua neste caso a biblioteca groovy-all. Esta vêm na distribuição oficial do Groovy e você pode referenciá-la em seu projeto Maven como no exemplo abaixo (basta mudar o número da versão para o que seja compatível com o seu projeto):

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>2.4.0-beta-3</version>
</dependency>

Esta dependência é importante pois já carrega o Groovy completo (o nome já entrega) e também as classes do GDK (Groovy Development Kit). Evite incluir apenas groovy-lang.

Código Groovy gera bytecode Java normal. Sendo assim, basta que suas classes Java usem as classes Groovy como se fossem… classes Java simples.

Usando código fonte Groovy usando Maven

maven-logo

Seu projeto está sendo escrito em Java e Groovy. Como você organiza seu projeto? Minha experiência principal é com Apache Maven, sendo assim aqui vou expor um exemplo bem rápido de como usar o plugin GMavenPlus.

Este plugin é uma reescrita do antigo GMaven com uma série de novos recursos. O uso é bastante simples: você só precisa incluir as pastas src/groovy e test/groovy para seu código Groovy, que vai ser compilado junto com o código Java.

Como usar o plugin? O caminho mais rápido e direto é você copiar os exemplos presentes neste link. Use o exemplo “joint compilation” que mostra como colocar em um mesmo projeto Maven Java e Groovy lado a lado.

E como seu código Java vai referenciar o Groovy? Exatamente como se fosse código Java convencional. :)

Groovy chamando Java

groovy_chama_java

Executando código Java compilado

Um dos principais pontos de venda do Groovy é justamente o fato de apresentar uma sintaxe próxima à do Java e também executar código Java de forma nativa. Lembre-se sempre desta regra:

Código Groovy vira bytecode Java padrão

Groovy pode executar qualquer código Java sem a necessidade de alteração. Basta que todas as dependências necessárias estejam no classpath do seu projeto. E como executá-lo? Exatamente como se fosse código Groovy. E sabe o que é bacana? Quando código Groovy executa código Java, Java vira Groovy!

Código Java que é essencialmente estático passa a ser dinâmico: você pode alterar os métodos presentes em código Java já compilado, por exemplo, exatamente como se fosse Groovy. Em 2009 escrevi alguma coisa a respeito, que você pode ler neste link.

Como Grails usa código Java?

Anos atrás escrevi um post sobre isto. Para ler, clique neste link.

Executando código fonte Java

Basta usar o GMavenPlus, exatamente como mostrei neste mesmo post. :)

Concluindo

Neste post expus algumas soluções de integração Groovy e Java. Há outras soluções (Gradle, por exemplo), mas como não tenho tanta experiências com estas, preferi não falar a respeito (no futuro aprendendo melhor provavelmente surgirá um post aqui).

Muitas dúvidas que vejo no Grails Brasil são do tipo: “como uso [sua biblioteca favorita Java] com Groovy/Grails”? Resposta simples: exatamente (ou quase em raríssimos casos) como faria se fosse em um projeto Java convencional!

Outro ponto importante: muitas pessoas me procuram dizendo que vão trocar Java por Groovy ou vice-versa: bobagem. Como disse no início deste post, o ganho na plataforma Java está no uso em conjunto de diversas linguagens. O uso exclusivo (só Java ou só Groovy) é tolo: pra que transformar o mundo em um prego?

semana_groovy

Semana Groovy 13!

Posts

O que há de novo na vesão 4.1 do Spring – Dado que nesta semana saiu a versão 4.1 do framework, é interessante que todos que trabalham com Grails conheçam as novidades. Segue o link para a seção presente na documentação oficial: http://docs.spring.io/spring/docs/4.1.0.RELEASE/spring-framework-reference/html/new-in-4.1.html

Groovy Markup Template – No Spring 4.1 há suporte para o Groovy Markup Template. Trata-se de um poderoso recurso do Groovy e que não é muito aproveitado pelos programadores. Que tal conhecer um pouquinho a respeito? http://groovy-lang.org/docs/groovy-2.3.6/html/documentation/markup-template-engine.html

Desenvolvendo aplicações Nativas Android com Groovy – Um passo a passo bem rápido que mostra quão simples é preparar seu ambiente de desenvolvimento para escrever aplicações Android com Groovy – http://www.objectpartners.com/2014/09/04/developing-native-android-app-using-groovy/

Por que sua empresa deve adotar Groovy? – Um post bem interessante que você pode usar para convencer o seu chefe. – http://www.objectpartners.com/2014/08/25/gr8conf-us-recap-why-your-company-should-adopt-groovy/

O post acima é o resumo de uma apresentação que vocês deviam assistir: https://www.youtube.com/watch?v=CvpxRoLEq7M

Existe código bonito? – Esta semana fiz esta pergunta em /dev/Kico no qual exponho meu próprio conceito de “código belo”. É uma discussão que acredito ser extremamente importante para todo desenvolvedor pois envolve o fator subjetivo por trás de todo desenvolvimento. – http://www.itexto.net/devkico/?p=1942

Apresentações

Groovy Puzzlers – Algumas armadilhas que a linguagem Groovy pode armar pra você se não ficar esperto. São expostos alguns pontos interessantes da linguagem. Vale muito à pena assistir: https://www.youtube.com/watch?v=k6vXQwxk7N8

Why your build matters – Uma apresentação que toda equipe deveria assistir: por que seu processo de build é importante? É o tipo de material que nos faz pensar o modo como lidamos com esta parte do processo que é tão negligenciada: o build. – https://www.youtube.com/watch?v=oF-gK-x8RGw

Lançamentos

Groovy 2.4 Beta 3 – http://glaforge.appspot.com/article/beta-3-for-groovy-2-4

Spring 4.1 GA – https://spring.io/blog/2014/09/04/spring-framework-4-1-ga-is-here (e também lançaram as versões 4.0.7 e 3.2.11 no mesmo dia!)

Vamos nos encontrar?

Algumas semanas atrás noticiei aqui a criação de um meetup só para programadores Groovy brasileiros. O objetivo é criar encontros nos quais possamos nos conhecer físicamente e, com isto, trocar idéias e experiências. Estamos pensando em planejar algo para os próximos meses.

Que tal se juntar a nós registrando-se em nossa página? http://www.meetup.com/groovybr/

Posts clássicos

Nesta edição da Semana Groovy voltei com a seção “posts clássicos” na qual coloco material sobre Ciência da Computação e sua história. Para que seja em grande estilo, que tal lidar com alguns problemas clássicos para desempoeirar aqueles seus livros de algoritmos e estruturas de dados? Começo com o clássico problema da mochila (knapsack problem).

O problema da mochila (Knapsack problem) – é um problema (talvez O) clássico de otimização. Imagine que você tem um saco com capacidade X, e precise enchê-lo com n itens, cada um com massa M e valor V. Como preenchê-lo de forma a maximizar o seu valor? Esta tese de Ph.D de David Pissinger mostra diversas variações do problema. http://www.diku.dk/~pisinger/95-1.pdf (leitura obrigatória)

Assine nossa newsletter!

Quer receber esta newsletter por e-mail no momento em que for publicada? Basta se inscrever preenchendo este formulário!

cubo_vazado

Existe código bonito?

Mudei tudo por que achei que estava muito feio

Inúmeras vezes ouvi esta frase para em seguida me questionar: o que é ser bonito? Em 2004 meu plano de vida era fazer mestrado na área de Estética (Filosofia, não Cosmética). Foi uma decisão que não se concretizou, mas o problema fundamental – a essência do belo – nunca me abandonou. Este é  mais um daqueles posts nos quais penso o modo  como usamos as palavras. :)

Código é arte ou apenas desejamos que seja?

Quando uso termos como “belo”  ou “feio” falamos sobre o que agrada ou não. O que é o (des)agradável? Esta é a questão fundamental da Estética, e há uma área de imensa subjetividade neste território: como o assunto é software, uma armadilha se arma diante de nós.

O que é arte? Quando a questão estética emerge a primeira coisa que pensamos é em arte pois é a maneira mais direta em que a questão estética se manifesta. Pensamos em pinturas, esculturas, filmes, poemas, músicas…  No livro “Arte é o que eu e você chamamos Arte” do Frederico Morais há 801 definições para o termo “Arte”. Com tantas definições, podemos pensar em alguns aspectos que sempre aparecem:

  • Há a criação de um produto: pintura, escultura, música… código?
  • Há uma atividade artesanal.
  • Há criatividade de alguma forma (bastante polêmico este ponto)
  • Há uma pessoa que gera o produto, o “artista”

E ao pensarmos no artista, nos vêm diversas imagens à cabeça: um pintor, escultor, músico, cantor, ator, escritor e tantas outras atividades que pensamos estar diretamente relacionadas à criação. São aquelas pessoas que acabam se tornando de uma forma ou outra nossos ídolos. Talvez por isto haja este esforço em tentar aproximar código de arte: queremos ser ídolos também.

O melhor livro que conheço sobre História da Arte

O melhor livro que conheço sobre História da Arte

Esta visão do artista, no entanto, é preponderantemente a que temos formada no século XX (e final do XIX). Dado que há um trabalho artesanal, há um outro tipo de artista que poucas vezes vejo ser mencionado: o relojoeiro (ou engenheiro, mas vou focar no relojoeiro). Este, para mim, é aquele que mais se aproxima do programador/desenvolvedor (ou o nome da moda que você quiser).

Excelente livro de Frederico Morais sobre a definição de arte

801 definições de arte que Frederico Morais compilou

A imagem do relojoeiro não soa excitante o suficiente para muitos, talvez por isto não se fale tanto a seu respeito como um artista, mas gosto dela pois me trás aquilo que agrada tanto quem compra meu software como quem o manipula: o objeto complexo, artesanal, preciso, difícil de ser feito e que requer paciência infinita. A mesma coisa se aplica à pintura, mas com uma diferença: o relógio precisa atender à risca o requisito de mostrar o tempo com precisão. Há subjetividade, mas o aspecto objetivo grita mais.

(o aspecto pintor é também fundamental. Recomendo a leitura do texto Hackers and Painters de Paul Graham : http://www.paulgraham.com/hpt html)

Aqui está como tornar a coisa um pouco mais excitante para vocês: já ouviu falar em Jaquet Droz? No vídeo abaixo você pode ver um dos seus trabalhos. Mais de 6000 partes interagindo entre si, programaticamente, em 1774. Muito similar ao que você faz hoje com seu código.

Então, sim: há um aspecto artístico no código. É uma atividade criativa (com limitações que falarei a seguir), há um produto (o software), é artesanal (sempre é diferente) e uma pessoa, o “artista” está por trás daquela criação. Mas o que torna o código belo?

O que torna o código belo?

Após anos lendo sobre Estética fica claro para mim o que é belo (sou arrogante). Segue a definição Kiconiana Espartana de belo:

Belo é aquilo que atende a um ou mais requisitos de alguém e com isto o agrada.

Ok, então qual a definição Kiconiana de código bonito?

Código bonito é aquele que funciona e sua equipe consegue entender

O requisito a ser atendido é funcionar: quando faz exatamente aquilo que foi proposto. Neste ponto o código é quase bonito. Se funcionar consumindo o mínimo de recursos computacionais e executando da forma mais rápida possível sem incluir bugs, tá bonitinho (feio arrumadinho).

O alguém é sua equipe. A coisa vai ser bonita mesmo apenas quando sua equipe (não só você)  conseguir entender claramente o funcionamento da sua criatura. Aqui entra o limite criativo do código: se for inteligível por apenas um, estamos lidando com um risco, e não um produto. Risco por que você não terá outra pessoa capaz de evoluir aquele objeto com a saída do seu criador.

Se houver uma discussão em sua equipe do tipo: “olha: eu faço de uma maneira e você de outra, gosto não se discute”, já sabe: a situação foi pro pior lado possível do problema estético que é o estritamente subjetivo. Seu objetivo que é criar um objeto com finalidade bem definida se perdeu, e seu código, por mais belo que cada tolo acredite ser, para o resto da equipe não passa de uma horrorosa aberração.

Sendo assim, você só pode dizer que “mudou a coisa toda por que tava achando muito feia” quando os requisitos acima tiverem sido satisfeitos. Na realidade, você sequer pode dizer “eu acho”, pois o bom profissional (de software) não “acha”, ele é pago para oferecer seu parecer técnico e soluções acerca dos problemas que enfrenta.

PS: dicas de leitura

Este assunto é um ramo extenso da Estética: a “beleza das máquinas”. Você vai encontrar muitos livros bacanas a respeito, mas neste post vou indicar apenas dois.

a_beleza_das_maquinas

“A Beleza das Máquinas” de David Gelernter: é sobre de que maneira o conceito de belo se manifesta em produtos industrais. Você irá ver exemplos que vão do telefone ao desktop do Macintosh. Leitura excelente.

cultura_da_interface

“Cultura da Interface”, de Steven Johnson: uma leitura excelente sobre o modo como elementos culturais e estéticos se manifestam na interface dos sistemas que usamos.