Básico do Groovy para quem for aprender Grails

36 Comentários / Por /

Antes de começarmos a trabalhar diretamente com Grails, convém conhecer o básico do Groovy. Afinal de contas, é a linguagem por trás da ferramenta e, mais do que isto, trata-se também de uma linguagem muito interessante para se trabalhar (programadores Java podem ver varios detalhes da linguagem que realmente surpreendem).

O que é Groovy?

No site oficial da linguagem, Groovy é definido como uma “linguagem ágil e dinâmica para a plataforma Java com muitas ferramentas que são inspiradas em linguagens como Python, Ruby e Smalltalk, tornando-as disponíveis aos programadores Java, usando uma sintaxe próxima ao Java”. Se você já programa em Java, portanto, aprender Groovy não será uma tarefa de outro mundo: na realidade, a sintaxe do Groovy é práticamente a mesma que a do Java. A diferença está nos recursos adicionais que a linguagem oferece.

Antes de pormos a mão na massa, no entanto, devemos primeiro nos livrar dos preconceitos ligados ao Groovy, decorrentes da idéia de que trata-se apenas de “mais uma linguagem de script”. Sim: Groovy pode ser usada como uma linguagem de script (e funciona muito bem para este fim), porém também pode gerar código compilado em bytecode que, consequentemente, é integrado de forma transparente a código Java pré existente. Este é um dos pontos fortes da linguagem: código Java chama código Groovy (e vice versa) sem saber em qual linguagem o mesmo foi escrito. Aliás, esta é a tendência da plataforma Java agora: tornar-se mais popular por ser uma plataforma de execução do que uma linguagem de programação.

Sendo assim… os detalhes que importam:

Instalando o Groovy

Se você for usar Groovy apenas com Grails, que por sua vez já se encontra instalado em seu computador, não é necessário fazer nada, pois o Groovy já vêm embutido no Grails.

Caso contrário, a sua instalação é bastante simples. Basta baixar sua última versão em http://groovy.codehaus.org e descompactar o arquivo binário em um diretório de sua escolha. O único requisito para se usar o Groovy consiste na instalação do JDK 1.4 ou posterior. Em seguida, lembre-se de incluir o diretório bin da sua instalação do Groovy no path do seu sistema e também de possuir a veriável de ambiente JAVA_HOME definida em seu sistema.

Diferenças básicas entre código Java e Groovy

Como mencionado anteriormente, a sintaxe do Groovy não é muito diferente da que encontramos em Java. Os principais diferenciais consiste em:

ponto e vírgula opcional: se você for digitar apenas um comando em uma linha, não precisa digitar o ponto e vírgula. No caso de mais de um comando, no entanto, já é necessário.

Exemplo:


println "Sou um comando sem ponto e virgula. Não é legal?"

println "Eu já tenho ponto e virgula no final. Sou mais tradicional";

println "Mais de um"; println "comando"; println "na mesma"; println "linha.";

conceito de verdade: Groovy extende o conceito de verdadeiro com o qual estamos habituados a trabalhar em Java. Além do conceito tradicional, Groovy também considera verdadeiro qualquer valor que seja diferente de null, tal como nos exemplos abaixo:


String str = "Sou uma string não nula"
String strNula = null
if (str) {
  println "Eu com certeza serei impresso" 

} 

if (! strNula) {
   println "Eu vou ser impresso, pois meu teste consistiu em uma string nula negada!" 

}

“main opcional”: se estiver trabalhando com Groovy na forma de um script, pode considerar o seu arquivo de código fonte como um main. Tudo o que estiver fora das chaves será considerado código a ser executado, tal como no exemplo abaixo:


println "Veja, sou um script feito em Groovy"

boolean maiorQue(int a, int b) {

   return a < b

}

println "Reparou como eu simplesmente 'ignorei' a função maiorQue e continuei imprimindo?"

&#91;/code&#93;

Gerará a saida

&#91;code language='java'&#93;

Veja, sou um script feito em Groovy
Reparou como eu simplesmente 'ignorei' a função maiorQue e continuei imprimindo? 

&#91;/code&#93;

<strong>Tudo é considerado objeto:</strong> ao contrário do Java em que possuimos tipos primitivos e não primitivos, em Groovy tudo é considerado objeto. Sendo assim, os tipos primitivos do Java são convertidos para suas respectivas classes encapsuladoras de forma transparente para o programador, tal como no exemplo abaixo:

[code language='java']

int inteiro = 4;
print inteiro.toString() 

Uma maneira fácil de se habituar a este detalhe da linguagem consiste em compará-la com o autoboxing incluido na linguagem Java a partir da versão 5.

return opcional: a instrução return com a qual já estamos habituados a trabalhar em Java também existe em Groovy. Porém, é opcional. Dada uma função, o valor de retorno do último comando corresponde ao valor de retorno da mesma, tal como no exemplo abaixo:


boolean maiorQuetradicional(int a, int b) {

   // a maneira "tradicional" de se trabalhar com Java
   return a > b 

}

boolean maiorQueGroovy(int a, int b) {

      a > b // bem mais simples!

}

sobrescrita de operadores: tal como em C++, em Groovy você também pode sobrescrever os operadores básicos da linguagem, como ++, –, >, etc. (mais sobre isto mais tarde)

Groovy Beans

Groovy facilita muito a vida do desenvolvedor quando o assunto consiste em declaração de beans. Isto porque a linguagem já faz boa parte do trabalho para o desenvolvedor. Você não precisa ficar declarando métodos gets e sets: Groovy faz isto dinâmicamente para você!

Suponhamos que em Java, você precise implementar um bean tal como descrito abaixo:


class Pessoa {

    private String nome;
    private String sobrenome;

    public String getNome() {return this.nome;}
    public void setNome(String valor) {this.nome = valor;}

    public String getSobrenome() {return this.sobrenome;}
    public void setSobrenome(String valor) {this.sobrenome = valor;} 

}

Em Groovy, você poderia declarar o mesmo bean apenas com o código abaixo:


 

class Pessoa {

    String nome;
    String sobrenome;

}

 

Se o escopo de uma variável é indefinido, Groovy entende que deverá criar dinâmicamente os métodos get e set para cada um dos atributos da classe. Sendo assim, boa parte da sua digitação torna-se desnecessária!

Claro, se quiser pode sobrescrever um get e set para customizar sua classe, tal como no exemplo abaixo:

 


 

class Pessoa {

    String nome;
    String sobrenome;

    public String getNome() {

          return "Sempre me chamarei José!"

     }

}

 

Tipagem dinâmica

Em Groovy, o tipo das variáveis é definido opcionalmente. Se quiser, você pode defini-lo tal como faria em Java. Caso contrário, pode passar esta tarefa ao Groovy, que ele se vira pra você, tal como no exemplo abaixo:


def a, b
a = 5
b = 6
def c = a + b // C será igual a 11. 
d = c + a + b // D será igual a 22 

Para definir uma variável cujo tipo é indefinido, usa-se a seguinte sintaxe:

def [nome da variavel] [especificação do valor opcional] 

ou, se preferir, simplesmente

[nome da variavel] [especificação do valor opcional]

Groovy utiliza duck typing para definir os tipos das variáveis. O que é duck typing? Simplesmente isto:
se age como um pato, é um pato.

No caso do Groovy, se uma variável age como sendo de determinado tipo (um número, uma string, etc.), então Groovy irá definir o seu tipo dinâmicamente desta forma.

Strings

Groovy simplifica muito a nossa vida na hora de lidar com strings. As strings com as quais você está a lidar são as mesmas com as quais estava acostumado em Java, porém com alguns detalhes a mais:

Para começar, há três maneiras distintas de se declarar strings em Groovy: 

 

  • Áspas simples, como ‘sou uma string em aspas simples’
  • Áspas duplas, como em “sou uma string com a qual você já está habituado em Java” 
  • Áspas triplas, como em
    “”” sou uma maneira muito mais
        interessante de se lidar com strings que
        ocupem bem mais
        de uma linha”””

 

Há uma diferença entre o funcionamento destes três tipos de declaração: strings com áspas duplas e triplas permitem o acoplamento de strings, enquanto strings com áspas simples não. O que nos leva a mais uma útil novidade que Groovy nos trás:

Acoplamento de strings

Em Groovy, você pode incluir o conteúdo de uma variável ou o resultado de uma expressão dentro de uma string sem usar o operador + com o qual estamos acostumados (e irritados) em Java, tal como no exemplo abaixo:


int umInteiro = 5

String aspasDuplas = "Eu gosto do número ${umInteiro}"

String aspasTriplas = """Eu gosto muito do número ${umNumero}, 
                                      mas também curto o seu dobro: ${umNumero + umNumero}""" 

 

Como pode ser visto, a sintaxe é simples. Basta incluir em uma string dupla ou tripla os caracteres ‘${‘ seguidos de uma expressão ou valor e finalizá-lo com um ‘}’.

Closures

Closures é um tópico especial, razão pela qual você podera aprender mais sobre Grails neste link (ainda em produção).

Intervalos, hashes e coleções

Groovy inclui boa parte das Collections do Java na própria sintaxe da linguagem. Não é preciso referenciar o pacote java.util só para usar listas. Groovy já referencia este pacote automaticamente para você e ainda inclui algumas outras novidades tal como descrito abaixo:

Intervalos

Intervalos (no Groovy em Ação, são chamadas de escalas, porém acredito que o termo “intervalo” descreve melhor com o que estamos lidando) consistem em um recurso extremamente útil na linguagem. Você provávelmente é familiar ao senhor abaixo:


for (int i = 0; i < 10; i++) {
     bla bla bla 

}

&#91;/code&#93;

O que temos dentro do loop, na realidade é um intervalo, porém descrito de uma das maneiras mais horrorosas possíveis. A questão que fica agora é: como isto poderia ser melhorado? Veja o código abaixo:

&#91;code language='java'&#93;

for (a in 0..9) {

    bla bla bla

}

&#91;/code&#93;

Este <strong>0..9</strong> consiste em uma escala, que implementa a interface Collection do Java. Sendo assim, é mais do que sintaxe: é um objeto por si só. Declarar uma escala é bastante simples. Basta usar a sintaxe abaixo:

[limite inferior]..[limite superior]

".." consiste em um operador de precedência baixa, sendo assim é uma boa idéia sempre definir seus intervalos dentro de parênteses, tal como (0..9).

Se quiser, há também um outro operador que você pode usar ao definir escalas. O operador "..&lt;". Neste caso, estamos dizendo que o valor da direita não entra entre os valores da escala. O código em Java exposto no primeiro exemplo poderia portanto ser reescrito como

[code language='java']

for (a in 0..<10) {

   bla bla bla

}

&#91;/code&#93;

Como mencionei, intervalos são objetos. Sendo assim, há alguns métodos e funções que você pode chamar, tal como no exemplo abaixo:

&#91;code language='java'&#93;

(0..10).contains(4) // Verifica se o intervalo contém o valor 4

(0..10).each {elemento ->
          print elemento} // each executa uma closure (leia o tópico sobre closures para maiores detalhes) 

Escalas só aceitam números? Não. Basicamente, aceitam qualquer tipo de objeto pode ser usado desde que as duas condições abaixo sejam satisfeitas:

  • O tipo implementa próximo e anterior, ou seja, faz override dos operadores ++ e — (mais sobre sobrescrita de operadores aqui)
    (Groovy sobrescreve os operadores ++ e — em java.util.Date e alguns outros tipos básicos para você)
  • O tipo implementa a interface java.lang.Comparable

Listas

Uma lista é declarada em Groovy usando a seguinte sintaxe:

[ (uma série de objetos separdos por vígula) ].

Exemplo:


lista = ["uma", "lista", "de", "strings"]

/*

   Claro, você terá acesso também a todos os métodos da interface java.util.List

*/

lista.contains("uma")
lista.add("coisas da vida")
print "A lista possui ${lista.size()} itens!" 

E ainda há alguns operadores bem interessantes para se lidar com listas, tal como no exemplo abaixo:


lista = []
// Como incluir um novo item na lista?
lista += "primeiro item"
// Como incluir mais de um item?
lista += ["segundo", "terceiro", "quarto"]
// E como eu removo um item?
lista -= ["terceiro"] 

Resumindo: seu código ficará beeem mais fácil de ser compreendido.

Mapas (hashes)

Mapas em Groovy também estão embutidos direto na sintaxe da linguagem, tal como pode ser visto abaixo:


def mapa = ["a":1, "b":2, "c":3] // Definição do mapa
/*
     A sintaxe é simples: dentro dos colchetes, o elemento a esquerda do caractere ":" representa o índice, e o valor à direita, o valor
*/ 

// Claro, todos os métodos da interface java.util.Map podem ser chamados aqui, tal como
println "Eis que nosso mapa possui ${mapa.size()}"
println "E o valor de c é... ${mapa.get("e")}"

Aliás, em Groovy, você pode passar mapas para construtores de classes também, já as populando, tal como no exemplo abaixo:


class Pessoa {

    String nome
    String descricao 

}

Pessoa pessoa = new Pessoa(nome:"Seu nome", descricao:"Um cara ai")

/*
    O que Groovy faz aqui: ele recebe um hashmap, percorre suas chaves, as compara com os atributos da classe e os preenche.
    Prático não acha?
    Em apenas uma linha você economiza n! 

*/

36 comentários em “Básico do Groovy para quem for aprender Grails”

  1. Raphael

    Bem legal esse apanhado geral de grails e groovy.

    Uma coisa basica legal e muito util que faltou mencionar foi metaprogramação (Expandos, metaClass, etc). São extremamente uteis na hora de fazer testes principalmente.

    Responder
  2. Mateus

    Gostei muito, porem eu como iniciante me encantei com o exemplo de lista, e gostaria de roda-lo para melhor enxergar e não consegui. uma dica seria completar todos os codigo a fim de faze-los funcionar. obrigado

    Responder
  3. Vinicius

    Olá, parabéns pela iniciativa, mas acredito que faltou um “hello world”, tipo como começar e rodar uma aplicação.

    Responder
  5. Bruno Dadalt Zambiazi

    Escrevo somente para parabenizá-lo pelas excelentes matérias. Foi a partir do artigo “O que é Grails e como ele salva a plataforma JEE” que comecei a estudar Grails e Groovy, e teu blog está sendo primordial para meu aprendizado. Parabéns!

    Um abraço

    Responder
    1. admin

      Que bom Bruno! Fico muito feliz com isto! Farei o possível para melhorar o máximo possível.

      Responder
  6. Leandro

    Caro Henrique,
    Tanto os seus blogs, quanto a comunidade Grails Brasil têm sido a base do meu trabalho de conclusão de curso.
    Em breve postarei na comunidade minha expereciencia.
    Meu muito Obrigado por sua dedicação em trazer o mundo Groovy para nós tupiniquins.

    Responder
  9. Yoshi

    Amigo, tenho estudado o Groovy e o Grails e me encantado e pensando seriamente em usar essa tecnologia do meu projeto de mestrado. Apenas uma coisa me intriga: porque essa tecnologia não emplaca? Já está aí há alguns anos e seu crescimento nem se compara com RoR… Qual sua opinião? Abraços.

    Responder
    1. admin

      Uai Yoshi,

      na realidade, emplaca sim. Groovy é usado a anos como linguagem embarcada em inúmeras aplicações Java.

      Além disto, temos visto também um crescimento significativo (principalmente a partir de 2009) de diversas aplicações desenvolvidas em Grails.

      Sugiro que você dê uma olhada nos cases de sucesso que se encontram no site oficial: http://grails.org

      Com relação ao RoR, bem: o pessoal do RoR sempre foi mais rockstar do que qualquer outro, acho que esta é a razão se formos comparar, mas olhando isoladamente, Groovy/Grails vão muito bem também!

      Responder
  10. Yoshi

    Olá, Henrique.

    Muito obrigado pela resposta, amigo :)

    Amigo, quanto a “emplacar”, talvez eu tenha me expressado mal… Quis dizer que não vejo “oba oba” sobre Groovy/Grails com vejo sobre RoR. Se eu for perguntar “quem conheçe RoR” para pessoas de mossa áreas, vários, talvez a maioria, responderão que sim. Já se a pergunta for sobre GG…

    Proferi uma palestra no Sun Tech Days daqui de Belém e quando perguntei aos quase 100 expectadores se alguém conhecia GG só 1 ou 2 levantaram a mão. Quando a mesma pergunta foi sobre RoR muitos levantaram.

    Na pesquisa mensal de popularidade de ling. de programação da TIOBE (http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html) Ruby está em 10º lugar com 2.653% já Groovy está em 47, com apenas 0.170%. Ou seja, segundo essa pesquisa, o Ruby é 15x mais conhecida que Groovy.

    Mas, independente sisso tudo, pretendo me tornar um “evangelista” Groovy/Grails aqui na região norte mas preciso estar preparado a responder perguntas como:
    1. Há IDE com “modo debug” para GG?
    2. Há comunidade grande o suficiente para que dúvidas sejam respondidas com pesquisas no google?
    3. Grails apresenta performance satisfatória para aplicações corporativas?
    4. Há como implementar “responsabilidades transverais” em Grails (como os Interceptors do Struts2)?
    5. Que servidores de aplicação posso usar para rodar aplicações Grails sem sustos?

    Poderia me ajudar com elas?

    Um forte abraço.

    Responder
    1. admin

      Oi Yoshi,

      bom: vamos lá

      Com relação à IDEs.
      1. Sim: há o Spring Tools que possibilita isto + alguns plugins para Eclipse (e o Netbeans também na próxima vesão)

      2. Grails Brasil! http://www.grailsbrasil.com Somos a maior comunidade do mundo em número de usuários e posts (não é legal?)

      3. A mesma performance que uma aplicação JEE convencional. Lembre-se: você está gerando uma aplicação JEE no final das contas. Código compilado em Groovy é um pouco mais lento, é verdade, porém a base do Grails é toda feita em Java, o que anula esta “perda”

      4. Sim

      5. Basicamente todos.

      Responder
  11. Silfar

    Simplesmente excelente, tenho procurado uma linguagem para desenvolvimento web a tempo, gostei do ruby e o rails nem precisa falar né.

    Mas confesso que estou encantado com o groovy e grails, acho que era a opção que eu esperava. Ainda mais que estou aprendendo java.

    Em relação a ser conhecido, eu também fiquei preocupado no inicio, mas tem duas coisas, como rails veio primeiro é natural que tome a dianteira, e apareceu mais porque pessoas conhecidas falaram bem dele. Muitas pessoas estavam cansadas do java, muitos doas railers hoje eram javeiros.

    Mas percebi que como grails roda dentro de java é uma questão de tempo para se tornar grande. O tb acho que atrapalhou foi a declaração de um dos criadores sobre SCALA.

    Mas vou apostar minhas fichas em java, groovy e grails.

    Abraçoss

    Responder
  12. Thiago Marinho

    Obrigado novamente Kicolobo!!

    seus posts esclarecedores são excelentes!!

    como o colega Yoshi!! se perguntar aqui em Campo Grande MS, quem conhece GG ninguém sabe que é um framework! agora se perguntar quem já ouviu falar em RoR! muita gente!! acredito que a expansão do Grails e Groovy seria eficiente se palestrassem mais sobre isso e realizasse mini-curso apresentando as sintaxes básicas!!

    vlw @tgmarinho

    Responder
    1. admin

      O problema com Ruby on Rails é que é o hype excessivo e com Grails a ausência de hype :)

      Responder
  13. Rafael

    Cara, estou iniciando a aprendizagem em Grails e estou mto feliz com a velocidade de aprendizagem e a facilidade de tudo.
    Parabens, você tem me ajudado muito neste novo caminho.

    A respeito da expansão do Rails e do Groovy/Grails vou dizer uma coisa.
    A maioria do pessoal que fala de Rails ouviu do mesmo em mini-cursos e palestras e somente depois procura na internet para se aprofundar, o que falta é isso.

    Tem cara que mal sabe escrever uma linha de código Rails, mas sobe num palco, conta a história e mostra meia duzia de código pronto comparando com Java e todo mundo sai babando (Aqui na minha região nas faculdades só se ensina Java).

    Acho que o Groovy/Grails tem uma comunidade grande o suficiente para organizar semanas durante o ano onde seus membros apresentarão a linguagem e o Framework em mini-cursos.

    A gente pode montar um Slide padrão com o principal e disponibilizar, com certeza todo mundo ganha com isso.

    A comunidade cresce e se fortalece, o palestrante do mini-curso ganha reconhecimento pela instituição e quem sabe até umas horas extra-curriculares e o publico conhece uma nova tecnologia emergente.

    Abraço a todos e parabéns pela qualidade do material.

    Responder
    1. admin

      Oi Rafael, fico muito feliz que tenha gostado cara.
      Isto me anima DEMAIS a continuar.

      Inclusive, estou com planos pra lançar em 2011 um “Guia itexto: Grails”, no mesmo formato do “Guia itexto: Spring”.

      Me procura depois por talk ou msn pra gente trocar idéia?
      loboweissmann@gmail.com ou kicolobo@itexto.net

      Grande abraço!

      Responder
  14. Téo

    Amigo,
    Muito bom este teu texto, me entusiasmou a avançar no estudo…
    Sobre o Guia itexto: Grails já saiu alguma coisa do forno?
    E a pergunta simples: Se o cara se apertar em algum ponto com groovy pode largar classes java sem drama? E pode largar uns jsp’s padrões também?
    Se for assim já vou me afundar em groovy para meu próximo projeto!

    Abração!

    Responder
    1. admin

      Oi Téo, fico feliz que tenha gostado.

      o guia itexto: Grails já tem bastante coisa no forno. Mas por enquanto, você pode contar com o http://guiagrails.itexto.com.br, que tá recebendo novidades a cada semana (vai ficar bem melhor que um “Guia itexto: Grails”)

      Grande abraço!

      E sim, eu já abandonei classes Java e JSP nunca mais! :D

      (mas eu gosto muito das classes Java também :D)

      Responder
      1. Téo

        Chê,
        Vou te ocupar mais um pouquinho…
        Até que ponto posso contar com o Grails para substituir minha camada de visualisação, numa aplicação que é JSP model1 ainda. Ou seja, onde jsps chamam beans que são populados com request.getParameter e as ações são chamadas dentro dos próprios jsps com scriptlets e javascript…
        Algo bem arcaico, mas que está funcionando.
        O chato seria refazer tudo de uma vez pois os sistema é imenso!

        Se quizer me manda um e-mail pvt que a gente discute melhor, pois quero migrar/melhorar mas não quero criar dramas, entendeu?
        Se tu puderes ajudar nisso eu agradeço, podemos fazer algum contrato para ter os serviços de vocês nesta etapa, com desenvolvimento de código e repasse de tecnologia… e-mail: teo@nuovonet.com

        Responder
        1. admin

          Neste caso Téo, eu não faria nada. Se a aplicação é grande, e já está funcionando legal, minha sugestão é que você mantenha a arquitetura corrente.

          No máximo, em manutenção, ir refatorando um módulo ou outro pra facilitar a sua vida, entende?

          Este negócio de trocar de arquitetura/framework em projeto já existente se enquadra no conjunto de situações nas quais “nada pode dar errado” :)

          Responder
          1. Téo

            É, realmente a ideia seria fazer módulo a módulo, porém o interessante seria a parte visual.
            E ficaria bem estranho ter alguns módulos com novas views e outros com as antigas ;-)

            Então a pergunta mais seria neste âmbito: até que ponto posso contar com Grails para substituir a camada de visualização apenas, sem ter que mexer no back-end?

            abraço!

  16. Marco Túlio

    Muito Bom. Estou muito interessado no groovy on grails, mas, depois da saída dele da ide NetBeans, parece que ele ficou meio morto. Eu não quero isso. gostaria que a comunidade crescesse na web, pois estou apostando na produtividade desta linguagem.

    Responder
    1. Kico (Henrique Lobo Weissmann)

      Estou escrevendo um livro sobre.
      Mas um livro bacana é o “Getting Started With Grails” que vocÊ consegue de graça no site da InfoQ americana.

      Responder
  18. Rodrigo Milaré

    Olá Henrique, parabens pelo post, e gostaria de agradecer por te-lo feito, pois não tem quase nenhum material sobre grails na internet além do site oficial que é um pouco confuso, principalmente pra alguem que nunca programou em java.
    Gostaria de saber como faço para seguir em ordem os posts sobre esse grails, porque quando pesquiso uma nova página sei se é continuação da outra que vi antes, tem como me dar uma dica?

    Responder
  19. Jeferson

    Trabalho com front end e agora quero migrar para back end(na verdade não é bem migrar, mas ser bom nas duas coisas).
    Sou estudante de ciência da computação 6º período e tenho 33 anos. Comecei carreia profissional tarde, pois fui seminarista queria ser padre fiquei 10 anos.
    Tentei aprender PHP e não curti assim como Java. Comecei olhar Ruby e Python e curti as duas. Comcei a estudar Python, mas sem muitas pessoas ao redor que curtam.
    Vi seu livro na casa do código e queria uma noção de direção.

    Responder

  20. Pingback: Testes automatizados com Framework Spock | Desenvolvendo no dia a dia

Deixe uma resposta

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.

Rolar para cima