Arquivo da categoria: Médio

Conheça Groovy e o lado Lean do Java

Salve Devs!

Hoje descobriremos como deixar nossa programação Java um pouco mais Lean (Enxuta).

lean

Você é daqueles que gosta de Java mesmo com toda a sua verbosidade ou daqueles que não gosta de Java graças a sua verbosidade? Resumindo … Você acha o Java verboso?

Se você respondeu SIM para alguma dessas questões, essa postagem foi feita para você!

A um tempo atrás montei uma apresentação falando um pouco sobre como Groovy tem trazido uma nova ropagem para a familia de frameworks que funcionam na JVM.

Conheça tecnologias como:

  • Grails
  • RatPack
  • Glide
  • Spock
  • GEB

Aproveita que é uma apresentação de leitura rápida, que foca no código e está cheio de imagens!

Link da apresentaçãohttp://slides.com/jonatasemidio/deck#/

leanjavaweb

Se você conhece mais alguma tecnologia com essa característica LEAN para a JVM deixe um comentário.

Até a próxima!

Anúncios

Groovy e o seu selo de NERD!

Você já brincou de [Pedra, Papel e Tesoura]? …

db2e_lizard_spock

Se sua infância foi normal, provavelmente a resposta será sim… No entanto, se você já jogou a sua versão extendida [Pedra, Papel, Tesoura, LAGARTO e SPOCK] não sei se podemos dizer o mesmo!

Para quem não sabe, estamos falando da versão criada por Sam Kass, que ganhou popularidade quando foi apresentado no The Big Bang Theory.

Pois bem, não estamos aqui para falar de seriados e sim de programação, programação com Groovy!
Há um tempo atrás, participei de um dojo de programação onde o problema a ser resolvido foi exatamente esse… Pouco tempo depois, só por curiosidade fui ver como Groovy poderia facilitar ou complicar na resolução deste problema.

Em um primeiro momento decidi programar normalmente (de uma maneira que um ser humano possa ler >> ler código)

def play(play1, play2){
    warning = {i, n -> (i + n) % 5}
    position = plays.indexOf(play1)
    play1 == play2 ? 'draw' : play2 in [plays[warning(position, 1)] , plays[warning(position, 3)]] ? 'play1' : 'play2'
}

Mas não demorou muito tempo para eu tentar incurtar isso, já que o objetivo também era ver maneiras diferentes de resolver o mesmo problema e o resultado foi segundo script:

Como podemos ver abaixo, usando os recursos nerds do Groovy, o mesmo algorítimo está com apenas 88 caracteres! Se é que podemos chamar isso de algorítimo!
p={p1,p2,c={a,b->l[(l.indexOf(a)+b)%5]}->p1==p2?'eq':p2 in [c(p1, 1),c(p1,3)]?'p1':'p2'}
Segue gist completo dos exemplos com seus respectivos testes:

OK OK!! Não é bonito, mas de vez em quando é legal dar uma descontraida!

Se ficou alguma dúvida ou se você sabe como deixar o código menor ainda, é só deixar um comentário.

Etiquetado

Descubra os novos métodos do Groovy para ordenação e remoção de duplicações

Professortocat_v2

No Groovy, nós podemos usar os métodos sort() e unique() para ordenar ou remover duplicações de nossas coleções. Esses métodos alteram a estrutura das próprias coleções utilizadas. Porém esses são os efeitos colaterais que queremos evitar. No entanto, os métodos sort e unique foram alterados para receber um parâmetro boleano para indicar se a coleção deve ser alterada ou se nós teremos uma nova coleção como resultado, deixando a coleção atual em seu estado original.

Desde a versão 2.4 do Groovy nós temos dois novos métodos que retornam por default uma nova coleção: toSorted e toUnique.

No exemplo abaixo, podemos ver esses métodos em ação:

Curiosidades:

Acabamos de ver a lista de usuários sendo criada com o asImmutable(), que transforma o objeto em outro imutável, ou seja, se tentarmos executar apenas um sort() ou um unique() receberemos uma exceção de método não suportado. Pois, como descrito no início dos post, estes métodos por default alterão o estado do objetos e isso não é possível nos imutáveis.

Se em nossa aplicação temos estruturas que não são alteradas no decorrer de seu ciclo de vida, é aconcelhavel que utilizemos estas estruturas como imutáveis para melhoria de performace.

Considerações

Estamos falando de casos em que estamos lidando com listas externas, que por algum motivo de performace ou segurança não podem ser alteradas ou ja vir ordenadas.

Em situações onde a nossa estrutura de dados tenha que estar sempre ordenada e sem repetições, é aconcelhado já cria-la como TreeSet(). TreeSet: É uma coleção que além de não permitir repetição graças ao Set, ela indiretamente implementa o SortedSet, ou seja, manterá a classe sempre ordenada.

Gostaria de agradecer mais uma vez ao Dev Hubert Klein Ikkink que tem contribuído bastante com a comunidade groovy com seus exemplos no Groovy Goodness.

Fonte original

Grep e a ciência por detrás do switch do Groovy

Salve Devs!

Esse post é uma continuação do SE AVENTURANDO NO SWITCH DO GROOVY que fala sobre os melhoramentos que o switch passou a ter no Groovy.

Conheça o grep! A inteligência por detrás do switch

heisencat

O grep é mais um dos métodos que são definidos no DefaultGroovyMethods.java. Onde este será inserido em tempo de execução em todas as Collections instanciadas do projeto em questão.

 

Indo um pouco mais fundo:

Este método utiliza o DefaultGroovyMethodsSupport.createSimilarCollection() para retornar a Collection mais especifica relacionada com o parâmetro de entrada (Ex: ArrayList ou LinkedList) e o BooleanReturningMethodInvoker.invoke() para definir se o parametro possui os critérios necessários para fazer parte do retorno.

 

Segue um exemplo de como o grep trabalha:

Veja em execução no GroovyConsole.

Lembrando que conforme descrito na documentação, o grep específico para collection só está disponível a partir da versão 2.0 do Groovy. Antes disso temos o grep mais genérico voltado para Objects.

Gostaria de agradecer mais uma vez ao Dev Hubert Klein Ikkink que tem contribuído bastante com a comunidade groovy com seus exemplos no Groovy Goodness.

Fonte original

 

 

O Jedi das Collections

Salve Devs!

octobiwan

Depois de quase 2 anos sem postar, tive que voltar depois de descobrir a existência do GroovyCollections disponível desde a versão 2.2 do groovy!

Ok! esse título ficou meio OVER, mas foi exatamente a impressão que tive assim que dei uma boa lida no código-fonte desse cara.

Além do código estar muito bem organizado e documentado, na própria descrição do método tem os exemplos de utilização. Que aqui entre nós … Nem todo mundo manja dos paranauês dos algorítimos e sabe de có o que é um transpose por exemplo.

Pois bem… Chega de blá blá blá e show me the code!
Vou destacar aqui os três métodos que mais me chamaram a atenção:

  • subsequence;
  • combitations;
  • transpose;
  1. Subsequence
    Como o nome já diz, esse cara é responsável por retornar todas as subsequencias não nulas de uma lista:
    Ex:

    subsequences([1, 2, 3]) => [[1, 2, 3], [1, 3], [2, 3], [1, 2], [1], [2], [3]]
  2. Combinations
    Já este é responsável por retornar todas as cominações de uma determinada coleção:
    Ex:

    combinations([[true, false], [true, false]]) => [[true, true], [false, true], [true, false], [false, false]]</pre>
    combinations([['a', 'b'],[1, 2, 3]]) => [['a', 1], ['b', 1], ['a', 2], ['b', 2], ['a', 3], ['b', 3]]

    Digo mais, se passarmos como parâmetro um item que não seja uma lista ele considera como uma lista de um item só:
    Ex:

    combinations([[1, 2], 'x']) => [[1, 'x'], [2, 'x']] 
  3. Transpose
    Por fim, o transpose é o que nos retorna a transposição de um array de list. “?”
    Segundo o Wikipedia: Em matemática, matriz transposta é a matriz que se obtém da troca de linhas por colunas de uma dada matriz. Desta forma, transpor uma matriz é a operação que leva na obtenção de sua transposta.
    Ex:

    transpose([['a', 'b'], [1, 2]]) => [['a', 1], ['b', 2]]</pre>
    transpose([['a', 'b', 'c']]) => [['a'], ['b'], ['c']]

 

Conforme visto acima, o código fonte desta classe está no repositório do groovy-core no github;

Se você não quiser, não precisa futucar o código fonte, pois temos sua API;

Caso você goste de mais detalhes a webingenia tem uma documentação bem detalhada com os exemplos e gráficos;

Pontos negativos
Com certeza devem ter mais, mas um ponto negativo assim como boa parte das classes em java rsrs é que alguns métodos já estão depreciados.

Fiquem livres para comentar, criticar e divulgar.
Espero que tenham gostado e até o próximo post!

Reutilização com Grails Validators

Salve Groovistas!!

É sempre bom descobrir recursos que podem tornar o nosso código mais reutilizável.
Logo, hoje focaremos nos famosos validators do grails.

Sabemos que todas as classes que implementam o @Validatable possuem uma closure estática de nome constraints que pode empacotar algumas regras comumente ligadas ao domínio em questão, facilitando muito na hora de verificar a integridade dessas informações antes de tentar persistir o mesmo.

Depois de muito tempo criando e alterando constraints, eu comecei a ficar incomodado com tanta repetição de código e decidi averiguar a possibilidade de tornar o meu código um pouco mais reutilizável. Foi ai que encontrei três maneiras de reutilizar os validadores do grails.

Podemos separar os validadores reutilizáveis em três categorias:
Empacotados
Globais
Formulário de CommandObject

1 – Empacotados:
Neste caso não é preciso muito conhecimento em grails, pois estamos apenas utilizando orientação a objetos.

Onde pegamos o que se repete e separamos em uma classe, sendo que a única novidade é a maneira que chamamos esse código.

// É sempre bom descobrir recursos que podem tornar nosso projeto mais reutilizável.
class Validators {

    static final confirmPasswordValidator = { value, command ->
        if (command.password != command.confirmPassword) {
            return 'command.confirmPassword.error.mismatch'
        }
    }

    static def requiresAtleastOne =  {val, obj->
        if(!val?.size()){
            return "default.requires.atleast.one"
        }
    }
}
class MyDomain {
        static constraints = {
              items(validator: requiresAtleastOne)
        }
}

Primeiro criamos a classe que ira empacotar as nossas validações, para logo em seguida criar as nossas validações como closures estáticas com seus parâmetros de entrada, lógica de verificação e mensagem de erro para o retorno caso seja necessário.
Para que essa classe seja utilizada como validação, precisamos apenas chama-la de dentro da constraints de nossa classe em questão seguindo a seguinte convenção <atributo_da_classe_local>(<classe_de_validacao>:<closure_de_validacao>). Simples assim.

2 – Globais:
Também podemos reaproveitar nossas validações utilizando o “Global Constraints”
Este é um recurso que precisa ser configurado de dentro do grails-app/conf/Config.groovy. Definindo validações genéricas que serão seguidas por todos os nossos domínios.

//Tambem podemos reaproveitar nossas validações com o "Global Constraints ".

//Podemos aplicar este recurso de dentro do grails-app/conf/Config.groovy
//Definindo validações para todos os domínios
grails.gorm.default.constraints = {
    '*'(nullable: true, size: 1..20)
}

// Ou até até criando diferentes validações globais
grails.gorm.default.constraints = {
    myShared(nullable: true, size: 1..20)
}

//Que pode ser chamadas da seguinte forma
class User {
    static constraints = {
        login(shared: "myShared")
    }
}

3 – Formulário de CommandObject:
Por último, temos o importForm muito utilizado em projetos que seguem o conceito de command object.

Neste caso temos duas classes de cara, o nosso domínio e o seu respectivo Command Object. Praticamente replicamos o constraints do Domain no Command Object, mas seus problemas acabaram!!!!

Com o importForm, no lugar de reescrevermos todas as validações do Domain, nós precisamos apenas escrever importForm . Mais simples impossível!

Segue um exemplo mostrando sua utilização e praticidade:

//Outro recurso que chamou bastante minha atenção foi o importForm.
//Este é um recurso muito utilizado para replicar as validações do domínio para o seu command object.

//Digamos que em nosso projeto tenhamos o seguinte domínio:
class User {
    String firstName
    String lastName
    String passwordHash
    static constraints = {
        firstName blank: false, nullable: false
        lastName blank: false, nullable: false
        passwordHash blank: false, nullable: false
    }
}

//Podemos com o importForm replicar as validações do domínio para o nosso command:
class UserCommand {
    String firstName
    String lastName
    String password
    String confirmPassword
    static constraints = {
        importFrom User

        password blank: false, nullable: false
        confirmPassword blank: false, nullable: false
    }
}

Se você conhece outra maneira de reaproveitar seus validadores não deixe de compartilhar. Comente no post.

Transformando métodos complexos em closures

Salve Groovystas,

Peço desculpas pelo tempo sem posts. Espero que isso não se repita… pois tenho bastante coisa para escrever e com isso pretendo criar a rotina de postar semanalmente.

Em alguns momentos nos deparamos com métodos que devido sua complexidade são difíceis de refatorar.
Recentemente, passei pelo seguinte problema de desempenho:
No sistema existe um método complexo que precisava ser chamado de dentro de um loop e isso sobrecarregava o processamento da funcionalidade em questão.
Devido à urgência desta tarefa, o melhor recurso encontrado neste momento foi a utilização do “memoize()”.
Este é um resumo sobre memoize para facilitar o entendimento:

//Problema: Quando temos um loop e dentro dele temos uma determinada
//lógica que precisará ser executada em todas as iterações;
(1..10).each{println  "este numero é ${it+5*(10-1)}"}

//Solução: Podemos otimizar nosso código inserindo nossa lógica dentro
//de uma closure, onde ao final desta chamamos o método memoize().
c = {println "este numero é ${it+5*(10-1)}"}.memoize()

//Por fim, chamamos esta closure de dentro do loop para que apenas a primeira
//interação seja 100% processada, pois nas próximas a parte repetida desta
//logica ficará em cache apenas sofrendo alteração de parâmetro.
(1..10).each(c)

Esse foi apenas um resumo, um exemplo rápido para não jogarmos termos novos sem explicação no post, mas em breve pretendo escrever exclusivamente sobre esse recurso que já me salvou varias vezes.

Mas, para nossa infelicidade, esta complexidade estava dentro de um método. Logo este precisou virar uma closure.

Imagine que estamos lidando com um método que é frequentemente alterado, como um cálculo de tarifa ou algo parecido e que é chamado por varias outras classes. Nesta situação, se alterássemos este método para uma closure, isso implicaria em um preenchimento desnecessário da PermGem, sem contar que iriamos inserir o memoize(), que seria um recurso desnecessário para a maioria dos casos. Logo estaríamos concertando de um lado para provavelmente estragar de outro.

Chega de revira volta!!! Vamos para o Show me the code!

Neste caso podemos utilizar “reference.&”, que recupera toda a lógica de um determinado método e a transforma em uma closure.

class SizeFilter {
    Integer limit
    boolean filter (String value) {
        return value.length() <= limit
    }
}

SizeFilter six = new SizeFilter(limit:6) //#1 Construtor

SizeFilter five = new SizeFilter(limit:5) //#1 Chamada

Closure smallerSix = six.&filter //#2 Associando o método à closure

def words = ['long string', 'medium', 'short', 'tiny']

assert 'medium' == words.find (smallerSix) //#3 Chamando a closure

assert 'short' == words.find (five.&filter) //#4 Passando a closure diretamente

Lembrando que os recursos fornecidos, raramente são para todas as situações. Logo, nada como uma boa análise antes de sairmos codificando.

Por fim, algo que chamou muito minha atenção, foi o fato de o “reference.&” também trabalhar em cima do polimorfismo conforme exemplo abaixo:

class MultiMethodSample{
    int mysterMethod(String value){
        return value.length()
    }
    int mysterMethod(List list){
        return list.size()
    }
    int mysterMethod(int x, int y){
        return x+y
    }
}

MultiMethodSample instance = new MultiMethodSample()
Closure multi = instance.&mysterMethod

assert 10 == multi ('string arg')
assert 3  == multi (['list', 'of', 'values'])
assert 14 == multi (6, 8)

Como podemos notar, o processamento da closure muda quando alteramos os parâmetros.

Espero ter ajudado com a dica e até os próximos posts.

Método X Closure: Isso o método não faz – Parte 2

Agora que já conhecemos o funcionamento básico das closures e vimos que elas podem ser entendidas como métodos, não porque são as mesmas coisas e sim pelo fato de as closures encapsularem também as características de um método.

Veremos neste post, em detalhes, qual a real diferença das closures com os métodos.

Devemos tomar muito cuidado ao utilizar as closures, diferente dos seus primos métodos, cada closure criada se transforma em um .class e ninguém quer deixar a memória da JVM de barriga cheia sem necessidade.

Voltando ao mundo de desenvolvimento ágil…
O simples fato de poder não declarar parâmetros quando só existe um já é um ponto positivo. “Em minha opinião, é claro!”.

As funcionalidades quadrado a seguir fazem a mesma coisa:

public int quadrado(int a){
    return a**2;
}

quadrado = { it**2 }

Como vimos no post anterior, a closure é um bloco de código encapsulado em um objeto e esta lógica pode até ser passada por parâmetro.

Um dos meus exemplos favoritos do groovy in action é a transformação de uma função em closure para poder ter sua lógica passada por parâmetro.

class MethodClosureSample{
    int limit
    MethodClosureSample(int limit){
        this.limit = limit
    }
    boolean validate(String value){
    return value.length() <= limit
    }
}

MethodClosureSample first = new MethodClosureSample(6)

// recurso ‘.&’ retornara não o valor mas a lógica contida no método
Closure firstClosure = first.&validate

def words = ['long string', 'medium', 'short', 'tiny']

println words.find(firstClosure) //Imprime:  medium

Definição:
MethodClosureSample: É uma classe que por definição recebe em seu construtor um numero que será utilizado para validar em um determinado método.

validate: É um método que recebe uma String e verifica se o tamanho da mesma é menor ou igual ao valor informado na criação do MethodClosureSample.

Instanciamos a MethodClosureSample.

Agora que vem a mágica. Utilizamos o “.&” para no lugar de executar o método e retornar o seu valor, nós retornamos a lógica atribuída a este método.

Criamos a closure firstClosure  que nada mais é que a lógica do validate da classe first.

Agora que temos a nossa closure que começaremos a diversão:

Começamos criando uma lista de palavras e em seguida chamando dessa lista a closure find (find – é uma closure que recebe outra que retorne boolean por parâmetro iterando na lista e retornando o 1º elemento true de acordo com a closure parâmetro).

println words.find(firstClosure) // que por sua vez retorna:  ‘medium’

Pronto: Aqui nós temos o find iterando a lista e verificando o resultado da atribuição do item iterado a closure parâmetro.

Por fim. Já sabemos o que é closure e conhecemos alguns de seus recursos que se encontram fora do escopo dos métodos tradicionais.

No próximo post veremos alguns testes de desempenho e seus resultados, sem falar em como melhorar o desempenho das closures em loops.

Post anterior: https://santograils.wordpress.com/2012/07/20/metodo-x-closure-entendendo-as-closures-no-groovy-parte-1/

Por: Jonatas Emidio

Método X Closure: Entendendo as Closures no Groovy – Parte 1

Uma das coisas que mais tem me chamado a atenção no groovy é o seu suporte à closures. Logo passei a utiliza-las no lugar dos métodos, já que a principio a função era a mesma. No entanto me surgiu uma dúvida… Será que eu ganho ou perco desempenho utilizando-as na aplicação?
Iniciei as consultas no google e não tive muito sucesso, em seguida postei minha duvida no grails brasil e pouco depois já tinham várias respostas. Percebi que o conteúdo que estava sendo gerado era muito rico e tive a ideia de compilar todas essas informações em um post de fácil entendimento.
Pois bem, para começar “métodos e closures” podem até trazer o mesmo resultado, mas eles não são a mesma coisa.
Este artigo será dividido em 3 posts, pois o mesmo possui bastante conteúdo.

  1. Entendendo as Closures no Groovy;
  2. Método X Closure;
  3. Teste de desempenho com Closures e Métodos;

Entendendo as Closures no Groovy

Segundo o Livro Groovy in action: closures são importantes, muito importantes, são de longe um dos recursos mais importantes do groovy.

Closure é um bloco de codígo encapsulado em um objeto. Definição tambem do Groovy in action.

Para os que estão acostumados com desenvolvimento java e já teve a oportunidade de escrever uma closure ,deve ter notado que seu fluxo lógico é diferente do tradicional, mas assim que nos acostumamos com o seu estilo de escrita os algoritmos fluem como água.
Um simples exemplo de closure utilizado na documentação do groovy é o seguinte:

def clos = { print “Hello”}
// - clos2: Onde a closure recebera algum valor na sua chamada e imprimirá o mesmo.
def clos2 = {print it}.
clos2(‘Hello’) /*Onde o mesmo imprime Hello*/

Também da documentação do groovy, temos dois exemplos bem interessantes de closures para listas.
Suponha que você precise varrer uma determinada lista e aplicar alguma lógica em cada item antes de inseri-los em outra lista.

Pois bem… Temos basicamente duas formas simples de fazer isso no groovy.
1 – Podemos utilizar o collect aplicando a logica para cada item iterado:

def list = ['a','e','i''o','u']
def newList = []

list.collect( newList ) { it.toUpperCase() }

Definição: Foi criada uma lista com as vogais e uma lista vazia que receberá o maiúsculo de cada vogal.
Neste caso o collect é utilizado para aplicar a logica ao it (variável default no groovy para closures com apenas um parâmetro – neste caso uma outra lista) e inseri-lo na lista passada por parâmetro.
Logo no final teremos a seguinte lista [“A”, “E”, “I”, “O”, “U”]

2 – Digamos que a logica a ser aplicada a cada item é um pouco mais complicada, também podemos encapsula-la em outra closure.

def list = ['a','e','i','o','u']
def newList = []

def closAux = { it.toUpperCase() }
list.collect( newList, closAux)

Definição: Neste caso estamos trabalhando com a mesma lógica, mas aqui podemos aproveitar a segunda closure para encapsular uma lógica mais complexa a ser atribuída a cada atributo da lista iterada.
Aqui, temos uma nova closure criada que atribui uma lógica (no it) para no final retorna-lo.
Logo em seguida podemos chamar o collect passando a nova lista e a closure. Pronto, a logica da closure passada por parâmetro será utilizada para cada item iterado da lista e atribuindo a nova lista.

Por fim. É claro que não paramos por aqui. Closures no groovy pode se transformar em um mundo quando utilizamos a boa e velha lógica de programação em conjunto com os conceitos da linguagem.

Lembrando que este post foi só um esclarecimento de closure para dar continuidade nos próximos posts.

Por: Jonatas Emidio

Etiquetado