Javascript é uma ótima linguagem. Ela passou a ser usada e respeitada cada vez mais. Durante muito tempo ficou destinada a ficar somente no Front-end, enquanto outras linguagens, como Ruby, ficariam no Back-end. E muita gente estava satisfeita com isso.

Mas alguém teve uma ideia: E se colocarmos essa linguagem, que somente fica no Front-end, no sever-side? Surgiu o Node.js.

Node.js surgiu numa época chamada de revolução do Javascript. Ficou extremamente popular e agora o temos em todos os lugares.

Mas o Javascript, apesar de tudo, não é uma linguagem divertida. E isso é quase um consenso. Passei as últimas 4 semanas usando coffeescript e é muito bom. É simples, tem uma boa sintaxe que "lembra" Ruby e é suportado e encorajado no Rails. Quando voltei a escrever em "plain Javascript", tive uma sensação estranha de que o js é mais complicado do que deveria. Mas o coffeescript tem um problema. Ele é um Javascript. É necessário pensar em Javascript para escrever em CoffeeScript.

Enfim, já estava conformado com o fato de que, como alguém que se diverte programando em Ruby, js seria uma constante.

Mas então surgiu uma luz...

Tudo mudou quando fiz um experimento simples e precisei de um parseador de ruby para js. Uma das vantagens de fazer parte da comunidade Ruby é que, quase sempre, alguem já fez algo e está praticamente pronto. Acabei encontrando a gem Opal. E minha fé na humanidade foi restaurada.

Opal é um compilador de Ruby para Javascript. "Source-to-source" com uma performance igual ao js escrito nativamente. Segue um exemplo:

 1 module Fooable
 2   def work?
 3     super
 4     puts "It works!"
 5   end
 6 end
 7 
 8 class BaseBar
 9   def work?
10     puts "YEAH"
11   end
12 end
13 
14 class DoesIt < BaseBar
15   include Fooable
16   def method_missing(sym, *args, &block)
17     puts "You tried to call: #{sym}"
18   end
19 end
20 
21 does_it = DoesIt.new
22 does_it.work?
23 does_it.answer_me?

Esse é um exemplo mostrando um pouco da capacidade do Opal em gerar código Javascript. Você pode testar esse código bem aqui.

É possivel chamar, facilmente, um código Javascript nativo e continuar programando como ruby:

 1 class Light
 2 
 3   def self.init
 4     point_light = `new THREE.PointLight(0xF8D898);`
 5 
 6     point_light.position.x = -1000
 7     point_light.position.y = 100
 8     point_light.position.z = 1000
 9     point_light.intensity = 2.9
10     point_light.distance = 10000
11     point_light
12   end
13 
14 end

Além de me sentir totalmente confortável em escrever Javascript, me trouxe outra vantagem: Todo o código pode ser testado de uma maneira que estou acostumado a fazê-la:

 1 describe Light do
 2 
 3   it 'should respond to init' do
 4     Light.should respond_to(:init)
 5   end
 6 
 7   it "init should not be nil" do
 8     Light.init.should_not be_nil
 9   end
10 
11   describe "init" do
12     before { @light = Light.init }
13 
14     it "should set x position" do
15       @light.position.x.should eq(-1000)
16     end
17     it "should set distance" do
18       @light.distance.should eq(10000)
19     end
20   end
21 
22 end

Caso tenha clicado no link para testar o código que informei acima, deve ter notado que o Javascript compilado é mostrado na janela da direita. Concordo que não é um Javascript bonito, mas é eficiente. E, atualmente, nunca vi um programador reclamar do codigo C que é gerado quando programa em Ruby. :).

Estou fortemente inclinado a acreditar que Javascript é o novo C.

Comentários