Blog da Thânia Clair

Como comentei em outros posts, estou estudando Groovy nas horas vagas e comecei a dar uma olhada no tão famoso Grails. Estranhei quando vi a estrutura de diretórios padrão. Er.. HmMmm… Será que só eu que notei que não é muito parecida com a do Rails?! o.Ô

Rails:

project
    + app
       + controller
       + helpers
       + models
       + views
           + layouts
    + config
    + db
    + doc
    + lib
    + log
    + public
    + script
    + test
    + tmp
    + vendor
README
Rakefile

Grails:

%PROJECT_HOME%
    + grails-app
       + conf                 ---> location of configuration artifacts like data sources
           + hibernate              ---> optional hibernate config
           + spring                 ---> optional spring config
       + controllers          ---> location of controller artifacts
       + domain               ---> location of domain classes
       + i18n                 ---> location of message bundles for i18n
       + services             ---> location of services
       + taglib               ---> location of tag libraries
       + util                 ---> location of special utility classes (e.g., codecs, etc.)
       + views                ---> location of views
           + layouts              ---> location of layouts
   + lib
   + scripts                  ---> scripts
   + src
       + groovy               ---> optional; location for Groovy source files
                                   (of types other than those in grails-app/*)
       + java                 ---> optional; location for Java source files
   + test                     ---> generated test classes
   + web-app
       + WEB-INF

:O

Sinceramente esta estrutura me lembra um pouco uma típica aplicação web para Java.

Enfim, preciso me aprofundar mais, mas achei estranho. Só espero que “Grails” não seja apenas um nome para vender, isto é, espero seja realmente um bom framework como o Rails.

:/

Depois de ter lido o post “Qual a performance de seu site no mundo todo? Teste e descubra”, no Informatiquez, descobri que o meu site anda razoavelmente bem em questão de desempenho e disponibilidade.

Clique na imagem abaixo e veja o relatório gerado pelo InternetSupervision:

Se você tem um blog, faça o teste também e analise os resultados. Acho que todos nós devemos ter um feedback de como anda o acesso ao nosso site. Vale a pena, galera!

Site: http://internetsupervision.com/

Obrigada pela dica, Douglas!

Em Groovy, para declarar uma lista é simples assim:

def lista = ["thania", "clair"]
println lista.get(0)
println lista.get(1)

Para definir um intervalo:

def intervalo=0..10
println intervalo.size()
println intervalo.get(5)

Para criar um mapa:

def mapa = ["chave":"valor", "chave2":"valor2"]
mapa["nova"]="novo valor"
println mapa["chave"]
println mapa["nova"]

lista e intervalo são instâncias de java.util.List. Definir o objeto como intervalo preenche a lista criada com os valores desejados (podem ser utilizados caracteres). A definição de um mapa parece com a de uma lista, exceto pelo fato de serem passados dados no formato [ <chave> : <valor> ].

As coleções em Groovy possuem métodos bastante úteis para closures:

def lista = ["a", "b", "c"]
lista.each
{
  elemento -> println elemento;
}

lista.eachWithIndex 
{ 
    elemento, indice ->
            println indice + "O elemento é = " + elemento;
}

O método each retorna como parâmetro para a closure todos os membros da coleção, na ordem.

Tudo isso me lembra muito Ruby, por isto é legal. Preciso descobrir ainda como anda a produtividade ao utilizar esta linguagem. Não sei ao certo se muitas aplicações vêm sendo desenvolvidas em Groovy e porque utilizá-la ao invés de Java ou Ruby. A verdade é que já li algo respeito, mas ainda não me convenceu. Espero que não seja apenas uma outra linguagem.

Uma closure em Groovy é um bloco de código ou um ponteiro de método. É um pedaço de código que é definido em um dado momento e executado em um ponto posterior.

Exemplo de closure em Groovy:

def clos = { println "hello! }

println "Executing the closure:"
clos()  //  Imprime: "hello!"

No exemplo acima, note que “hello!” é impresso quando a closure é chamada, não quando ela é definida.

Os parâmetros da closure são listados antes de “->”, exemplo:

def clos = { a, b -> print a+b }
clos( 5, 7 )  // Imprime: "12"

O token “->” é opcional e pode ser omitido se sua definição de closure tem menos do que dois parâmetros.

Existe ainda uma variável implícita denominada “it”. Ela tem um significado especial. Se você tem uma closure que tem apenas um único argumento, você pode omitir a definição de parâmetro da closure, assim:

def clos = { print it }
clos("hi there") // Imprime: "hi there"

Além disso, quando um método tem uma closure como último parâmetro, você pode definir a closure inline. Observe:

def list = ['a','b','c','d']
def newList = []

list.collect( newList ) {
      it.toUpperCase()
}
println newList           //  ["A", "B", "C", "D"]

Mas há outra forma de fazer isso. No exemplo abaixo, veja que o método collect aceita não só uma lista como também uma closure como parâmetro.

def list = ['a','b','c','d']
def newList = []

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

assert newList == ["A", "B", "C", "D"]

Enjoy!

Fonte: http://groovy.codehaus.org

Isto foi o que aconteceu hoje após eu ter acabado de iniciar o Windows:

E aí? Entre esperar alguns minutos pra reiniciar e reiniciar no momento, qual vc escolheria? E por que ele pergunta se eu desejo reiniciar se eu não tenho opção? O que aquele botão de “reiniciar depois” está fazendo ali desabilitado? Aff… Esse tipo de reuso de interface é pra acabar… Fala sério!

Hmpf! :/