You are currently browsing the archives for the ruby category


Sua gem funciona bem com JRuby?

Acabei de ler no post Notícias do Front #5 do Fábio Akita uma notícias que me deixou muito feliz:

is it jruby? – recentemente a Brightbox lançou o site is it ruby 1.9?, onde a comunidade poderia testar gems e dizer nesse site se ela é ou não compatível, em seus testes, com o ruby 1.9. Agora foi lançado mais uma com o mesmo objetivo mas desta vez para avaliar a compatibilidade de gems com o jruby. Mais e mais a comunidade está se conscientizando que as gems precisam receber mais tratamento para ficarem compatíveis com múltiplas virtual machines. Isso é muito bom e espero que todos colaborem.

Isto porque sou usuário de JRuby e volta e meia tenho problema com alguma gem que não funciona com ele, por conta de extensões nativas em C.

Então, por caridade, quando fizer uma gem, veja se ela funciona bem com JRuby também. :)

Ruby + Rails no mundo Real 2009: Como foi?

Ontem aconteceu aqui em São Paulo o primeiro evento do GURU-SP, com co-participação da Tempo Real Eventos. Eu estive por lá e vou dizer - sob a minha ótica, claro - como é que foi.

Preço

O preço foi bem razoável para quem comprou antecipadamente, R$ 69,00; mas um pouco carinho para quem comprou na hora, R$ 129,00.

Local

O local, em geral, foi bom. Perto do metrô, pra quem foi de condução; estacionamento a R$ 10,00, pra quem foi de carro; opções de almoço perto não faltaram; o auditório acomodou todo mundo; o ar condicionado estava na medida certa; e o coffe-break, apesar de bem simples, também atendeu. No entanto não havia WI-FI. Isso foi realmente decepcionante, porque evento de programação, sem WI-FI pra galera que levou note, é russo.

Palestras

As palestras, sinceramente, me decepcionaram um pouco. Achei que foram muito introdutórias, muito superficiais. O que salvou o dia dos mais experiêntes foi a palestra do Fábio Kung e a do Caffo. Mas, sei lá, talvez tenha sido a estratégia do evento.

O track foi o seguinte:

1. Vinícius Baggio Fuentes: Criando um Instant Messenger usando Rails

XMPP é uma de minha áreas de interesse, então, estava realmente interessado nessa palestra.

O conteúdo estava legal, eu gostei do formato como a palestra foi estruturada, no entanto, acho que o Vinícius estava um pouco inseguro; e isso acabou atrapalhou um pouco em alguns momentos.

2. Hugo Lima Borges: Ruby, Rails e empreendedorismo

Esse é um assunto que tem sido muito recorrente em eventos de Ruby on Rails,  o que, com toda certeza, é um ponto muito positivo. Eu não me lembro de ter visto este tema rolar em eventos de Java, por exemplo. Mas a palestra, em si, achei meio frustrante pela superficialidade como o assunto foi abordado.

(Aliás, Hugo, você já empreendeu seu próprio negócio? Se sim, queria trocar umas figurinhas com você.)

3. Marcelo Castellani: Ruby no desktop

Não era para ser “Integrando Ruby e Java para facilitar a vida”?

Achei legal os comparativos e as dicas de quais toolkits funcionam melhor em cada SO, mas acho que faltou uma porção caprichada de código ao vivo. Código só no slide é um pouco chato. O legal é ver o código no slide, mas rodando no terminal também. Fica a dica.

4. Rodrigo Franco: Outsorcing, ou como trabalhar para empresas gringas

Para quem não sabe, esse cara é o Caffo, fundador da lista Rails-BR, que além de ser veiaco de Rails, também é muito experiente no que se propos a palestrar. Ele trabalhar com outsourcing, se não estou enganado, desde 2004.

Sua palestra foi muito, muito, interessante e todo mundo ficou muito intere$$ado mesmo. :)

A grande dia foi: Quer ser um pinguim com colar de ouro? oDesk.

Mas para isso, antes de mais nada, tenha uma conta ativa no GitHub; um blog que apenas copia notícias de outras fontes, mas que fala do que você pensa e sabe; uma página de portifólio e depoimentos também vai muito bem (segundo o Caffo, é indisponsável).

5. Mauricio Leal: GlassFish on Rails: Escalabilidade e Confiabilidade

Tema interessantíssimo para mim, uma palestra que eu estava realmente ansioso para ver. Acho que foi a que mais me decepcionou.

O Mauricio tem uma boa desenvolvura como palestrante, domina a oratória, mas sua palestra foi mais marketing - a Sun apoia Ruby, Rails e Open Source! - do que uma palestra técnica sobre o GlassFish. Como o próprio Fábio Kung, convidado pelo Mauricio, disse: O GlassFish é muito bom, mas o modo que a Sun tem o vendido à comunidade Ruby tem sido bem desadequada.

6. Carlos Brando: Só imaturos não testam

O Carlos é um cara que fala bem, sabe se expressar e sua palestra foi legal. Foi mais voltada a iniciantes em testes, mas bem legal. Na minha opinião, da próxima vez ele poderia abordar tópicos mais avançados de testes, cenários mais elaborados, etc.

Mas no geral, a palestra foi boa. Rolou até um marketzinho do Remarkable.

7. Willian Molinari: O que é e como funciona o RubyLearning

O RubyLearning é um site bem legal mesmo, ótimo não só pra quem está começando, mas para quem já tem algum conhecimento. Mas uma mini palestra para falar dele, não sei, não achei muito legal não. Acho que um post do tipo FAQ no RubyInside e no GURU-SP seria um apoio muito mais eficiente ao ótimo trabalho que o pessoal do RubyLearning tem feito.

Não posso deixar de dizer que o Willian, apesar de parecer bem jovem, soube conduzir muito bem a apresentação.

8. Fábio Kung: Ruby, muito mais do que reflexivo!

Palestra excepcional. O Kung realmente é um ótimo palestrante - instrutor da Caelum, não podia ser diferente.

A palestra dele abordou temas high level de metaprogramação com Ruby. ParseTree, Flog, roodi, Heckle e Ruby2Ruby foram alguns dos mandraques que ele nos apresentou. Foi o momento hacker do dia.

Ah! Além das ferramentas apresentadas, como o Carlos Brando, ele também fez marketing do seu projeto Rfactor.

Conclusão

Valeu a pena participar do evento, trocar idéia com os camaradas e tudo mais. Apesar dos pontos negativos, o resultado final é que o evento foi legal; e os pontos negativos ficam como um toque, para que o próximo evento seja ainda melhor.

Nos vemos no próximo evento!

Sparrow, um cliente JMS baseado em JRuby

Mês passado comecei a tocar um projeto na CVC Turismo que, entre outras coisas, envolve troca mensagens assíncronas usando JMS. Esse trabalho foi está sendo tão divertido que me inspirou a escrever um post sobre Message-Driven Beans e Transações; e mais recentemente, a começar um novo projeto pessoal.

Sparrow é um cliente JMS implementado sobre JRuby e distribuido como uma Rubygem – hospedada no Github,  é claro. Ele é uma boa opção para quem precisa integrar sistemas Ruby com servidores de aplicações Java EE, provedores de mensageria JMS.

É pá, pum! Quer ver?

require 'rubygems'
require 'sparrow'

# Configuração que tem que ser feita uma única vez
jms_client = Sparrow::JMS::Connection::Client.new do |props|
  props.client_jar_file         = '/oc4j_extended_101330/j2ee/home/oc4jclient.jar'
  props.initial_context_factory = 'oracle.j2ee.naming.ApplicationClientInitialContextFactory'
  props.provider_url            = 'ormi://localhost:23791'
  props.security_principal      = 'oc4jadmin'
  props.security_credentials    = 'welcome'
end

jms_client.enable_connection_factories(
    :queue_connection_factory => 'jms/MyQueueCF'
  )

jms_client.enable_queues(
    :my_queue => 'jms/MyQueue'
  )

# Envio
jms_client.queue_sender(:my_queue).send_text_message('sparrow rocks!') do |msg|
  msg.set_string_property('recipient', 'sparrow-example')
end

# Recebimento
jms_client.queue_receiver(:my_queue).receive_message(
    :timeout  => 5000,
    :selector => "recipient = 'sparrow-example'"
  ) do |msg|

  puts msg.is_text_message?    # true
  puts msg.text                # sparrow rocks!
end

Fácil, não? :)

Se você quiser saber mais sobre o projeto, testá-lo, critica-lo, ou algo assim, por favor, não fique acanhado fique à vontade. E se não for pedir demais, deixe um comentário nesse post, como um feedback, para eu saber o quanto ainda preciso melhorá-lo e evoluí-lo.

Valeu!

Sim, programação funcional é relevante hoje

Há um tempo tenho me interessado pelo paradigma de programação funcional, estudado e tentado aplicar vez ou outra algum de seus conceitos que faça sentido no domínio do problema que estou tentando resolver.

Com base nisso, resolvi escrever este post para dizer que, sim, programação funcional é relevante hoje, tanto quanto foi ontem – se não um pouco mais; e também dar uma visão geral sobre alguns de seus conceitos.

O que é programação funcional?

Segundo a definição de Paul Hudak em seu paper de 1989, “Conception, evolution, and application of functional programming languages”:

Programação funcional é um paradigma de programação que trata a computação como uma avaliação de funções matemáticas e que evita estados ou dados mutáveis. Ela enfatiza a aplicação de funções, em contraste da programação imperativa, que enfatiza mudanças no estado do programa.

Assim, praticar programação funcional consiste em definir funções e usar o computador como um avaliador de expressões. Aliás, uma característica predominante da programação funcional é que o significado de uma expressão é o seu valor, e o papel do computador é obtê-lo através da avaliação da expressão. Por exemplo, considere a expressão 2 + 3. Qual é o seu significado? 5. Agora, considere a expressão (2 x 2) + 1. Qual é o seu significado? 5. Ou seja, a avaliação nos faz concluir que as duas expressões significam a mesma coisa.

Outra característica básica e fundamental em linguagens funcionais é que funções são valores de primeira importancia, podendo estas serem usadas como parâmetro ou retorno de outras funções. Além do que, funções também são avaliadas como qualquer outra expressão matemática.

Aplicação do paradigma funcional

Programação funcional, obviamente, pode ser aplicada para resolver problemas de domínio matemático, mas não somente isso. Absolutamente!

Atualmente, muito do revival – se é que posso dizer assim – do paradigma de programação funcional se deve a aplicação dela no campo da concorrência, do processamento paralelo. Isso por conta de sua natureza stateless. É nesse campo que estão os grandes méritos de Erlang, e a motivação de F# e Scala. (Se bem que Scala pode, sim, trabalhar com estados. Quando a F#, eu não sei. Mas isso não importa muito agora.)

Há pouco ouvi falar também sobre uma bibliotéca fantástica para construção de interfaces gráficas escrita em Haskell, mas sinceramente nunca testei. (Na verdade, nunca escrevi uma só linha de código em Haskell.)

Exemplos de linguagens funcionais

Existe uma pancada uma grande número de linguagens funcionais, talvez muito mais do que você possa imaginar. Apenas para citar algumas: Lisp, Haskell, Scheme, XSTL, OCaml, Erlang, F# e Scala. Mas, acredite, há muitas outras!

Conceitos funcionais em código

Como esse é um blog de programação, e estamos falando de programação, quero explicar rapidamente alguns conceitos de programação funcional exemplificando em código.

1- Lambda Calculus

O principal fundamento da programação funcional é a teoria Lambda Calculus, cuja qual podemos encontrar a seguinte definição na Wikipedia:

In mathematical logic and computer science, lambda calculus, also written as λ-calculus, is a formal system designed to investigate function definition, function application and recursion. It was introduced by Alonzo Church and Stephen Cole Kleene in the 1930s as part of an investigation into the foundations of mathematics, but has emerged as a useful tool in the investigation of problems in computability or recursion theory, and forms the basis of a paradigm of computer programming called functional programming.[1]

The lambda calculus can be thought of as an idealized, minimalistic programming language. It is capable of expressing any algorithm, and it is this fact that makes the model of functional programming an important one. Functional programs are stateless and deal exclusively with functions that accept and return data (including other functions), but they produce no side effects in ‘state’ and thus make no alterations to incoming data. Modern functional languages, building on the lambda calculus, include Erlang, Haskell, Lisp, ML, Scheme, Scala and F#.

Entendemos então que, em programação funcional, funções são abordadas no puro sentido matemático. A definição da Wikipedia para Lisp diz:

Lisp é uma família de linguagens de programação concebida por John McCarthy em 1958. Num célebre artigo, ele mostra que é possível usar exclusivamente funções matemáticas como estruturas de dados elementares (o que é possível a partir do momento em que há um mecanismo formal para manipular funções: o Cálculo Lambda de Alonzo Church).

Via de regra, toda linguagem funcional oferece algum tipo de construção para cálculo lambda.

Por exemplo, considere a seguinte função matemática:

f(x) = x + 30

Em Scala, ela poderia ser escrita assim:

val f = (x: Int) => x + 30
f(5)   // 35

Ou mesmo em Ruby, que apesar de não ser funcional, oferece suporte a algumas abordagens desse paradigma, poderia ser escrito assim:

f = lambda {|x| x + 30}
f[10]   # 40

2- High-order function

High-order functions são funções que podem receber outras funções como parâmetro, e também retorná-las como resultado. A estas damos o nome de função de primeira classe. Essa é uma característica extremamente importante em linguagens funcionais. Vejamos um exemplo:

def escolhido(a: Int, b: Int): Int = if (a >= b) a else b

def imprEscolhido(f: (Int, Int) => Int, a: Int, b: Int) =
println("O escolhido foi: " + f(a, b))

...

// usando a função escolhido
imprEscolhido(escolhido, 1, 5)   // 5

// usando uma função anônima
imprEscolhido((x: Int, y: Int) => x, 12, 2)   // 12

2- Currying

Currying é a técnica de transformar uma função que recebe multiplos argumentos de maneira que ela possa ser chamada como uma cadeia de funções, com apenas um argumento por vez. Na prática, o que acontece é que a cada chamada a uma função da cadeia, uma nova função é retornada.

Vamos ver um exemplo que pode ser encontrado na integra no site A Tour of Scala:

// cria uma função para filtrar uma lista
def filter(xs: List[Int], p: Int => Boolean): List[Int] =
  if (xs.isEmpty) xs
  else if (p(xs.head)) xs.head :: filter(xs.tail, p)
  else filter(xs.tail, p)

// cria uma função "módulo" para ser usada no filtro,
// por isso ela retorna "true" ou "false"
def modN(n: Int)(x: Int) = ((x % n) == 0)

// cria uma lista com números de 1 a 8
val nums = List(1, 2, 3, 4, 5, 6, 7, 8 )

// imprime aplicando módulo em 2
println(filter(nums, modN(2)))   // List(2,4,6,8)

// imprime aplicando módulo em 3
println(filter(nums, modN(3)))   // List(3,6)

Se você não está familiarizado com código Scala, não se preocupe, à primeira vista parece meio esquisito mesmo. Por isso, não se atente aos detalhes. O importante aqui é você entender que a saída desse programa depende:

1º) Do número que é aplicado ao primeiro argumento (n) da função modN, quanto ela é chamada e o seu resultado passado como argumento à função filter – pois o seu resultado será uma “nova função” que receberá apenas o segundo argumento (x) que ela definiu;

2º) Do número que a função filter aplica ao único argumento que a função p (que é resultado da chamada a modN) aceita.

Ou seja, é como se a função modN tivesse seus dois argumentos parcialmente informados em dois momentos diferentes, tornando a sua chamada muito mais simples e flexível. Essa é a idéia da cadeia.

Vamos um ver outro exemplo, ainda em Scala, talvez um pouco mais simples:

// cria uma função que retorna "outra função" que recebe
// apenas o segundo argumento desta
def idadeAceita(m: Int)(i: Int): Boolean = i <= m

// ao ser chamada, a função idadeAceita retorna uma "nova
// função" que dei o nome de aplicarIdade e recebe apenas
// o segundo argumento definido por idadeAceita
val aplicarIdade: (Int) => Boolean = idadeAceita(18)

...

aplicarIdade(14)   // true
aplicarIdade(40)   // false

Acho que esse exemplo fala por si e dispensa maiores explicações. :)

Não é interessante como os diversos conceitos abordados até aqui vão se completando?

Que mais?

Bem, tudo que eu disse nesse post gigante é apenas uma visão geral. Talvez a pontinha do iceberg. Então espero que ele te motive a estudar um pouco mais sobre programação funcional. (O texto está repleto de links para outros texto interessantes.)

Valeu!

Rails Summit, o melhor evento que já participei!

A Rails Summit Latin America foi o melhor evento de tecnologia que já participei até hoje. Simplesmente, excelente!

O meu destaque fica para as apresentações de Chad Fowler e Obie Fernandez.

Quem estiver interessado, aqui tem uma trilha legal do evento.

Se você perdeu esse ano, pel’amor, não perca ano que vem não!

Parabéns ao Akita e à Locaweb…

Intuitividade de Ruby

Uma das coisas que mais gosto em Ruby é que ela é uma linguagem muito expressiva e intuitiva.

Quer ver um exemplo? Pois bem…

Suponha que você queira saber se uma determinada classe é filha de outra, como você faria?

irb(main):001:0> Integer < Fixnum
=> false

Logo, Integer não é filha de Fixnum. Mas, e o contrario, será que é verdadeiro?

irb(main):002:0> Integer > Fixnum
=> true

Sim, Fixnum é filha de Integer.

Percebeu a intuitividade? Ainda não? Vamos lá então…

Para dizer que uma classe é filha de outra, em Ruby, usamos o operador < (menor), pois a classe filha passará a ocupar um lugar hieraquicamente abaixo de sua classe mãe.

class Filha < Mae
  ...
end

Assim, nada mais intuitivo do que testar a posição hierarquica de uma classe em relação a outra usando os operadores > (maior) e < (menor).

E agora, que tal? É ou não é intuitiva?

Executar JRuby a partir do Java

Nos últimos tempos tenho dedicado boa parte do meu tempo livre estudando JRuby. Tem sido uma verdadeira diversão!

Com o objetivo de compartilhar um pouco do que tenho aprendido, eis aqui este post…

Quer dizer que o osrevni inverso também é verdade?

Muito se fala da capacidade do JRuby de acessar código Java de maneira tão natural quanto o faz com seu próprio código – o que é definitivamente fantástico. Mas não tenho visto muitos exemplos de código Java acessando código JRuby. Por quê? Não sei dizer. Talvez porque não tenham visto tanta utilidade nisso. Essa não é minha opinião, já que tenho interesse em implementar algumas coisas em JRuby e usar a partir do Java.

Uma das coisas que fiz nesses meus estudos sobre usar JRuby a partir de Java foi testar o compilador jrubyc para gerar .class, mas não cheguei bem onde eu queria – até troque umas palavras com Charles Nutter a respeito -, porque o .class gerado por ele não é do tipo que se pode instanciar e usar diretamente num código Java, dada a natureza totalmente dinâmica de Ruby. Nas palavras do próprio Charles:

The code compiled by jrubyc is not a “normal” Java class[…] This is not a Java class you can instantiate and call methods on directly from Java[…].

Como não desisti, tenho algumas alternativas para compartilhar.

OBS.: Para executar os exemplos apresentados é necessário ter jruby.jar no classpath do seu projeto. Quando escrevi este post estava usando a versão 1.0, porque não havia uma versão mais atual na máquina que eu estava usando. Mas agora já atualizei o código para a versão 1.1.3.

Primeira alternativa: JRuby puramente Ruby

No exemplo abaixo, criou uma classe Ruby comum – sem qualquer recurso específico do JRuby – e, logo após, a carrego, instancio e executo seu método a partir do Java.

matematica_apenas_ruby.rb

class MatematicaApenasRuby
  def soma(a, b)
    a + b
  end
end

MatematicaApenasRubyTest.java

public class MatematicaApenasRubyTest {
    public static void main(String args[]) throws Exception {
        List pathsLoad = new ArrayList();
        pathsLoad.add("/Workspace/Ruby/IntegracaoJava/lib/");

        Ruby rubyRuntime = JavaEmbedUtils.initialize(pathsLoad);
        rubyRuntime.getLoadService().load("matematica_apenas_ruby.rb", false);

        Object mat_ruby = rubyRuntime.evalScriptlet("MatematicaApenasRuby.new");
        Integer res_ruby = (Integer)JavaEmbedUtils.invokeMethod(rubyRuntime, mat_ruby, "soma", new Integer[] {3, 2}, Integer.class);

        System.out.println("Soma 3 + 2 invocando diretamente JRuby: " + res_ruby);
    }
}

O que esse código Java faz é bem simples, ele:

1- Inicializa um ambiente de runtime para Ruby, indicando onde estão os arquivos .rb;
2- Executa o script de criação da classe MatematicaApenasRuby;
3- Executa o script de instanciação da classe MatematicaApenasRuby;
4- E, por fim, invoca o método soma passando dois parametros.

Que tal, acho simples? Pois muito bem, continuemos…

Segunda alternativa: JRuby implementando Java

Neste segundo exemplo, o que eu faço é criar uma classe JRuby que estende uma classes Java abstrata, o que facilita ainda mais na hora de usar a partir do Java. Vejamos como fica.

matematica_impl_java.rb

require 'java'

class MatematicaImplJava < Java::IntegracaoPoliglota::Matematica
  def soma(a, b)
    a + b
  end
end

Matematica.java

package integracao.poliglota;

public abstract class Matematica {
    public abstract int soma(int a, int b);
}

MatematicaImplJavaTest.java

public class MatematicaImplJavaTest {
    public static void main(String args[]) throws Exception {
        List pathsLoad = new ArrayList();
        pathsLoad.add("/Workspace/Ruby/IntegracaoJava/lib/");

        Ruby rubyRuntime = JavaEmbedUtils.initialize(pathsLoad);
        rubyRuntime.getLoadService().load("matematica_impl_java.rb", false);

        Object mat_impl_java = rubyRuntime.evalScriptlet("MatematicaImplJava.new");
        Matematica matematica = (Matematica)JavaEmbedUtils.rubyToJava(rubyRuntime, (IRubyObject)mat_impl_java, Matematica.class);

        System.out.println("Soma 10 + 2 usando a interface Java: " + matematica.soma(10, 2));
    }
}

E esta alternativa, gostou? Eu gostei bastante. Porque no meu caso, o que eu quero é poder definir uma interface em Java e implementar com JRuby a la Ruby Way e depois usar no Java. É claro que não estou levando em conta o fator “performance”, só estou considerando o fator “alternativa de implemententação”. Só isso.

Mas vamos lá, o que esse código faz?

1- A classe JRuby estende uma classe Java abstrata, como dito antes;
2- A classe que faz o teste, em linhas gerais, faz um cast do objeto JRuby para a classe Java abstrata;
3- E no final das contas, invoca o método da classe Java.

Será que programação poliglota é o futuro?

Se é ou não é, eu não sei. Mas sei que deixei de ser um arquiteto de uma nota só há muito tempo; e estou muito emplogado com JRuby – ele é o melhor dos dois mundos!

E você, o que acha? Deixe um comentário…

Sírius Software em peso na Rails Summit

Ontem fizemos as inscrições dos consultores da Sírius Software para a Rails Summit Latim America 2008.

E você, vai? A gente se vê por lá…

Rails Summit Latin America: Já foi dada a largada!

Finalmente foi dada a largada para o maior evento de Rails da América Latina.

O Akita postou novidades em seu blog. Clique aqui para saber.

Locawebcast on Rails

Acabei de assistir ao primeiro webcast do Fábio Akita na Locawebcast, dando uma breve introdução a Ruby on Rails àqueles que estão interessados em ter uma primeira impressão ou mesmo tirar dúvidas iniciais. Achei que ficou bem legal.

Se você está interessando em conhecer Ruby on Rails, acho que vale a pena você também assistir.