De forma abrangente, variáveis são endereços de memória a qual damos um nome, de forma que possamos usá-los para armazenar valores, e posteriormente recuperar estes valores.

Em geral, as variáveis precisam ser declaradas com um tipo, sendo que elas só podem armazenar valores deste tipo. Isto é o que se chama de tipagem estática. Já no Ruby as coisas funcionam de forma diferente. Uma variável no Ruby pode armazenar valores de qualquer tipo ao longo do tempo. Esta é a chamada tipagem dinâmica ou duck typing.

É importante notar que como todo dado em Ruby é um objeto, as variáveis sempre armazenarão referências a objetos. Isso significa que o mais perto que chegamos dos objetos são as referências armazenadas pelas variáveis, sendo que as referências são valores binários que nos permite acessar um objeto, atuando assim como intermediários. Além disso, devido a tipagem dinâmica, uma variável pode armazenar referências a objetos de diversas classes ao longo da sua vida.

Convenções de nomes de variáveis

O Ruby possui uma convenção de nomes para as sua variáveis, de forma que somente pelo nome possamos saber o escopo da variável. Mas é importante saber que esta não é apenas uma convenção cujo uso é recomendado, pelo contrário, ela de fato faz parte da sintaxe da linguagem. Sendo assim, uma vez que você cria uma variável, o escopo dessa variável será determinado pelo nome que você deu.

Quanto ao escopo, as variáveis podem ser variáveis locais, variáveis globais, variáveis de instância e variáveis de classe.

Variáveis locais

Variáveis locais são variáveis definidas dentro de um método, só existindo dentro dos limites daquele método específico. Os seus nomes devem começar com letras minúsculas ou com underscore(_), embora o mais comum seja que eles comecem com letras minúsculas mesmo. Exemplo de variável local: idade, nome_completo e data_de_nascimento.

Variáveis globais

Uma variável global é aquela que, uma vez criada, é acessível em qualquer parte do programa, existindo inclusive variáveis globais predefinidas no Ruby. A convenção de nomes diz que estas variáveis devem ter seu nome começando com $. $versao é um exemplo de nome de uma variável global.

Variáveis de instância

As variáveis de instância implementam os atributos de uma classe, e coletivamente representam o estado do objeto, sendo que cada objeto possui uma cópia de cada variável de instância definida na classe de forma independente dos outros objetos da mesma classe. A convenção do Ruby para os nomes de variáveis de instância é que elas comecem com @. Sendo assim, uma variável chamada @nome seria uma variável de instância.

Variáveis de classe

Algumas vezes, as classes precisam armazenar informações referentes a si próprias, ou seja, ter, de alguma forma, o seu próprio estado, e é aí que entram as variáveis de classe. Uma variável de classe é compartilhada entre todos os objetos desta classe, portanto podem ser usadas por cada um deles, e também pelos métodos de classe, sobre os quais falaremos no futuro. Além disso, dada uma certa classe, só existirá uma cópia de cada variável de classe dela, mesmo que existam dezenas de objetos desta classe. As variáveis de classe devem ter o seu nome começando com @@, como por exemplo a variável @@contador.

Algumas regras adicionais

Além das regras já mencionadas, depois do primeiro caractere do seu nome, uma varíavel só poder ter combinações de letras, números e o caractere de underscore. E quando uma variável possui mais de uma palavra no seu nome, as palavras são separadas pelo undescore. Além disso, o caractere após @ e @@ não pode ser um dígito, ou seja, @@1 e @2 são nomes de variáveis inválidos no Ruby.

E como fica isso tudo no irb?

No irb, podemos definir variáveis locais, globais, de instância e de classes, mesmo sem termos coisas como classes ou métodos. Para isto, basta aplicarmos as convenções de nome relativas a cada escopo.

Valores padrão

As variáveis de instância e globais possuem automaticamente nil como valores padrão, ou seja, você pode usar essas variáveis, por exemplo, imprimindo seus valores, mesmo que não tenha explicitamente atribuído nenhum valor para elas.

Já as variáveis locais e de classes precisam ser explicitamente inicializadas, caso contrário, quando você tentar utilizá-las acontecerá um erro. No caso das variáveis locais, o interpretador do Ruby pensará que você está tentando usar um método inexistente, já que os nomes de variáveis locais e métodos em parte seguem a mesma convenção de nomes. Já no caso das variáveis de classe, o interpretador conseguirá identificar que se tratam de variáveis de classe, gerando então a mensagem de erro apropriada, que no caso é a informação que variáveis de classe precisam ser inicializadas explicitamente.

Um último exemplo

Pra finalizar, abaixo há exemplos de todos os 4 escopos de variáveis do Ruby.

opcao = "Sim"
$versao = 1.0
@idade = 15
@@contador = 28

Acima temos, respectivamente, uma variável local, uma variável global, uma variável de instância e uma variável de classe.

Agora que já somos amigos de longa data do método puts, está na hora de conhecer o resto da família, assim como saber um pouco mais sobre o nosso amigo. Sendo assim, inicie e o irb e prepare-se para mais uma dose de Ruby.

puts

Como já disse antes, o método puts exibe(ou imprime) o seu argumento na saída padrão, que no caso é a janela de comando, e logo depois insere um caractere de nova linha, ou seja, pula uma linha. Para vê-lo em funcionamento mais uma vez, digite as intruções abaixo no irb.

puts "Ola novamente, amigo rubysta"
puts "Como vai a familia?"
puts "A minha voce conhecera logo abaixo"

Ok, nenhuma novidade acima, uma vez que já havíamos visto o puts imprimir a string que passamos pra ele. Acontece que ele pode receber mais de um argumento em uma única chamada, como demonstrado na seguinte instrução:

puts "Primeiro argumento", "Segundo argumento", "Terceiro argumento"

Como vimos, para passarmos mais de um argumento pro puts, basta inserir uma vírgula entre cada argumento. Além disso, o puts os exibirá na ordem que passarmos, e também irá inserir um caractere de nova linha depois de exibir cada um deles.

print

O método print é o irmão preguiçoso do puts. Assim como este último, ele exibe na saída padrão o argumento que passarmos pra ele, só que ele é ocupado demais pra inserir um caractere de nova linha pra nós. Veja abaixo e comprove você mesmo.

print "Nao insista, nao irei pular uma linha pra voce"

Como acabamos de confirmar, ele realmente se limita a imprimir apenas o argumento que passamos pra ele, sendo assim, o irb exibe o retorno dessa instrução(=>nil) imediatamente após a string que passamos pro print.

Agora vamos testar se o print, assim como o puts, aceita mais de um argumento em uma única chamada. Sendo assim, digite o código a seguir.

print "Uma", "Saida", "Horrivel"

Ao executarmos esta instrução no irb, confirmamos que o print também aceita mais de um argumento em uma mesma chamada, só que a saída gerada fica péssima. Além do => nil, o retorno da instrução, ficar colado com o último argumento, cada argumento é exibido imediatamente após o outro.

Mas como nós somos bons demais pra sermos vencidos pelo print, iremos fazê-lo pular uma linha de qualquer jeito. Para isso, temos que inserir explicitamente um caractere de nova linha, que é representado pela sequência de escape \n. Se você não está familiriarizado com este recurso, saiba que sequências de escape são sequências de caracteres começadas por \ e que servem para representar caracteres especiais, como o caractere de nova linha(\n). Além disso, elas podem ser usadas dentro de strings de forma geral, ou seja, não funciona apenas com o método print. Mas não se preocupe, futuramente voltarei a falar sobre o assunto. Por hora, digite a instrução abaixo e veja o resultado.

print "Agora sim!n", "Uma linha pra cada argumenton", "Finalmente temos um pouco de espacon"

Não disse que consegueríamos dobrar o print? Cada argumento agora está em uma linha separada, exatamente como queríamos.

printf

O último é o printf, de longe o método mais sofisticado da família. Ele pode ser usado de forma simples, ou seja, com apenas um argumento e se comportando exatamente como o print, como neste caso:

printf "Argh, estou me comportando como o print"
printf "Que vergonha para um metodo refinado como eunNunca me senti tao humilhadon"

No entanto, o printf tem mais utilidade quando o usamos com mais de um argumento, sendo o primeiro deles uma string chamada string de formato, que define como a saída será formatada. Os argumentos posteriores representam os valores que serão inseridos no formato definido pela string de formato.

printf "%sn%sn", "Agora esta melhor", "Finalmente um uso digno de minha competencia"

O caractere %s é um especificador de formato, e simboliza que na saída gerada pelo printf, aquele local será substituído por uma string. Existem outros especificadores de formato, aos quais nós veremos futuramente.

Uma curiosidade sobre o printf, é que ele nasceu originalmente na linguagem C, tendo inclusive o mesmo nome, e desde então já passou por algumas outras linguagens, como no Java, por exemplo.

Por fim, embora ainda haja muitas outras coisas interessantes que o printf pode fazer, iremos analisá-lo em maiores detalhes no futuro, quando já tivermos visto alguns assuntos necessários ao melhor entendimento do seu funcionamento.

puts “Fim do post”

Chegamos ao fim de mais um post. Espero que tenham gostado e que tenham entendido o funcionamento destes três métodos. É claro que há muito mais coisas a serem ditas sobre eles, mas com o que foi mostrado aqui já dá pra ter uma boa idéia do funcionamente básico de cada um deles.

O irb(Interactive Ruby Shell) é um shell criado por Keiju Ishitsuka para programação em Ruby, ou seja, você pode digitar código Ruby nele e ver o resultado da execução deste código imediatamente. Isto o torna uma excelente ferramenta para testes simples e principalmente para o aprendizado, e como o usaremos muito ao longo do tutorial de Ruby, vale a pena conhecê-lo melhor. Sendo assim, prepare-se para uma breve introdução ao irb.

Iniciando

Iniciar o irb é incrivelmente simples, basta abrir uma janela de comando no seu computador, e então digitar irb. Pronto, o irb já está rodando.

Entendendo o prompt do irb

Logo após iniciar o irb, você verá algo como irb(main):001:0>, seguido do cursor de entrada. Como à primeira vista isso pode parecer estranho e sem significado, vou explicar brevemente o que isso quer dizer.

irb(main) é o nome da sessão atual. Neste caso, estamos executando a sessão principal do irb, mas podemos criar subsessões, no entanto, veremos mais sobre isso no futuro.

001 indica o número da linha atual.

0 refere-se ao nível de identação, o qual será mais detalhadamente explicado no futuro.

Além disso, o caractere dois pontos(:) atua como separador destas seções.

Começando a brincadeira

Ok, agora é hora de usarmos o irb de verdade. Pra começar, digite o número 6 e pressione a tecla Enter. Você provavelmente verá => 6 na linha de baixo, podendo em seguida digitar outra entrada na linha seguinte.

Uma curiosidade sobre isso é que se você criasse um arquivo chamado, por exemplo, arquivo.rb, colocasse apenas o número 6 nele, e o executasse com o comando ruby arquivo.rb, nenhuma saída seria gerada. Isso aconteceria porque o interpretador do Ruby avaliaria a expressão, que no caso retorna o resultado 6, mas não exibiria nada, porque você não especificou nada no código dizendo que queria exibir o valor de retorno da expressão. Acontece que o irb, depois de executar o código fonte exatamente como o interpretador do Ruby o faria, sempre exibirá o valor de retorno da sua instrução, mesmo que você não tenha especificado que queria vê-lo no tela, como occoreu no caso acima.

Mas deixando de lado os detalhes minuciosos, vamos continuar a brincadeira. Agora que já vimos que o irb sabe avaliar expressões complexas como 6, vamos ver se ele também sabe efetuar adições. Sendo assim, digite 21 + 21 e pressione novamente a tecla Enter. A menos que o seu irb tenha faltado a uma enorme quantidade de aulas de matemática, você verá => 42 na linha seguinte.

Dando continuidade, vamos agora revisitar o nosso velho amigo, o método puts. E caso você tenha o mau hábito de esquecer dos amigos, o puts é o método que exibe o seu argumento na saída padrão, no caso a janela de comando, e em seguida pula uma linha. Digite então puts 54 + 87 e apertem mais uma vez a tecla Enter. O resultado dessa instrução será a exibição do número 141 na linha logo abaixo, e na linha seguinte aparecerá => nil.

Como eu disse acima, o irb primeiro executa a sua instrução como o interpretador do Ruby faria, e então exibe o valor de retorno da sua instrução. Sendo assim, primeiro ele exibiu 141, que é o resultado da execução de puts 54 + 87, e então exibiu na linha seguinte o valor de retorno desta instrução, no caso nil, que por hora vocês devem entender como nulo.

Pra finalizar, vamos ver se o irb também sabe executar loops. Digite 10.times { puts “Eu sou um loop.” } no irb e… preciso realmente dizer pra apertar Enter de novo? Depois disso, vocês veram a mensagem Eu sou um loop repetida 10 vezes, e o => nil, indicando o retorno da instrução acima. Não se preocupem caso não entendam essa estrutura de repetição ou o motivo do retorno ter sido 10, no momento estamos aprendendo o irb, logo, a compreensão da sintaxe do Ruby não é imporante no momento.

Despedindo-se do irb

Para finalizar o irb, basta digitar exit ou quit.

Quem não gosta de screenshots?

Como eu sou muito legal, eu fiz um screenshot(ou printscreen) desta sessão do irb tanto no Kubuntu como no Windows XP. Sendo assim, clique no link abaixo referente ao seu sistema operacional e confira se tudo aconteceu como o esperado.

Sessão do irb no Windows XP

Sessão do irb no Kubuntu

Se por acaso você digitou os comandos conforme eu disse acima e obteve resultados diferentes, assuma que você está errado e eu estou certo. A propósito, adote isto como regra: na dúvida, você está errado e eu certo.

That’s all folks

E chegamos ao fim de mais um instrutivo post. Esperam que tenham gostado desta breve introdução ao irb, lembrando que isso foi apenas o suficiente para acompanhar os próximos posts, ainda teremos mais conteúdo sobre o irb no futuro.

Como dica final, eu os aconselho a ficar brincando com o irb um pouco além do que eu demonstrei aqui, fazendo outras operações aritméticas e interagindo com ele das formas que vocês acharem possíveis.

Há poucas dias atrás, houve uma certa discussão em torno de um post no blog do Obie Fernandez, um rubysta de fama internacional. O post se chamava Top 10 Reasons Why Java Sucks Ass, que em português significaria algo como 10 Razões Porque Java É Uma Droga.

Neste post, apesar de dizer algumas verdades sobre o Java, Obie estava sendo claramente motivado pelo senso de humor, já que não tem como considerar seriamente uma lista que inclui Java tem IDEs como um dos seus itens.

Mas parece que parte da comunidade Java não achou graça, e reagiu, ao meu ver, de forma exagerada nos comentários do post. Um deles, Daniel Spiewak, até mesmo escreveu um post parecido, dessa vez enumerando as 10 Razões Porque Ruby É Uma Droga.

Acontece que essa não foi a única situação parecida nos últimos dias, teve também uma discussão entre parte da comunidade Ruby on Rails brasileira e um programador .NET, que se iniciou por conta de um post chamado Porque Rails é melhor que ASP.NET? e terminou no post Ruby on Rails não tem futuro - corra atrás da sua certificação enquanto é tempo, no blog do Carlos Brando, que de certa forma originou o post que compara o Rails ao ASP.NET quando escreveu Por que .NET é melhor do que Rails?.

Por fim, houve também uma certa repercussão em torno do artigo 7 reasons I switched back to PHP after 2 years on Rails, ou 7 razões porque eu voltei pro PHP após 2 anos no Rails, escrito por Derek Sivers e publicado no blog sobre Ruby da O’Reilly.

Diante destas discussões, eu pensei em escrever sobre o protecionismo de alguns programadores, sejam eles programadores Java, .NET ou PHP, mas então eu lembrei de mim mesmo.

Há cerca de um ano e meio atrás, eu tinha recém iniciado os estudos do Java, e então um amigo me falou que existia uma linguagem “nova” chamada Ruby, e então me indicou o famoso tutorial Why’s (Poignant) Guide to Ruby.

Na ocasião, eu sequer me dei ao trabalho de pensar sobre o assunto, e apesar de ter ido dar uma olhada no tutorial, eu o fiz já com o resultado definido: não gostaria do tutorial e muito menos do Ruby. Pensei na hora “Aquilo definitivamente não pode prestar”. Enfim, eu fiz a proeza de realizar uma ação já tendo decidido qual é o resultado dela antes mesmo de iniciá-la.

Pouco tempo depois, esse mesmo amigo também me aconselhou a estudar sobre o Ruby on Rails, além de explicar algumas de suas vantagens, no qual foi novamente ignorado sem maiores buscas técnicas do que seria este tal Ruby on Rails. Pelo contrário, dessa vez eu sequer me dei ao trabalho de fingir dar uma chance ao Rails, não buscando material algum sobre o assunto.

Depois de muito tempo, e em grande parte por influência dos excelentes artigos do Fábio Akita sobre o Ruby on Rails, eu decidi dar uma nova chance ao Ruby e também ao Rails. Como resultado desta nova busca, dessa vez sem um resultado pré-definido, eu me tornei um fã tanto do Ruby como do Rails, tendo ambos hoje como meus principais objetos de estudo.

Ainda assim, eu demorei um certo tempo para perceber o quão estúpido eu fui. Na verdade, eu só percebi mesmo ao ver este mesmo comportamento sendo repetido por outras pessoas. Então eu consegui identificar o motivo desta atitude nessas outras pessoas, e só então a ficha caiu, e eu vi que era a mesma motivação que me moveu no passado: o protecionismo.

Sendo assim, hoje é fácil para mim olhar pra trás e me achar uma besta pela minha atitude passada, assim como também é fácil criticar a reação dos programadores Java, .NET e PHP envolvidos nas discussões mencionadas.

No entanto, justamente por ter sido tão irracional no passado, baseado no protecionismo de não querer que outra coisa seja boa para que isso não signifique que o que eu estou estudando não é, eu entendo o comportamento desses programadores. Se eu não dei importância ao assunto quando me foi apresentado por um amigo, não é de se espantar que eles façam o mesmo quando apresentados por estranhos.

E mais importante que entender, eu tento me policiar agora para não fazer o mesmo novamente. Não somente nesta questão, mas em outras também, ou seja, quando identificar algo que eu considero irracional vindo de outra pessoa ou de outro grupo, tentar olhar para mim mesmo pra ver se não encontro uma correspondência nas minhas próprias ações. Até porque, eu só percebi o meu erro através da reprodução dele por parte de outras pessoas.

Sendo assim, aconselho aqueles que tiverem lendo isso a fazer o mesmo, olhar para essas e outras atitudes irracionais, e então olharem para dentro de si mesmos para verificar se há correspondências. Muitas vezes não notamos que cometemos os mesmos erros que achamos estúpidos quando o vemos em outras pessoas. Sendo assim, usemos os erros alheios como ferramenta para descobrir os nossos, pois lamento informar, mas não é só os outros que cometem erros muitas vezes estúpidos.

E para finalizar, gostaria de dizer que isto não é de maneira alguma uma crítica a comunidade Java, PHP ou .NET, até porque a raíz de comportamentos estúpidos não está em nenhuma dessas linguagens de programação, e sim no comportamente humano.

Ainda não é hora de detalhar a implementação da Orientação a Objetos(OO) do Ruby, mas para melhor compreensão dos próximos posts do tutorial, vou definir brevemente alguns termos básicos sobre o assunto.

Classes

As classes são um dos principais elementos da OO. De forma simplificada, elas são modelos de conceitos existentes no mundo real. Ou seja, uma classe descreve como é este determinado conceito que ela está representando. Vamos considerar para efeitos de exemplificação uma classe que representa um… Tiranossauro Rex. Esta classe, assim como todas as outras, tem basicamente dois elementos:

Atributos: representam informações de vital importância para o conceito que estamos representando, e de certa forma personaliza uma ocorrênia em particular do conceito representado. Por exemplo, os atributos de um Tiranossauro Rex poderiam ser nome(sim, aqui os T-Rex têm nome), altura, peso, nível de saúde e nível de fome. Observe que estes atributos diferenciam um Tiranossauro de outro, uma vez que cada um deles teriam os seus próprios valores para cada um dos atributos. Quando implementamos uma classe através de uma linguagem de programação orientada a objetos, esses atributos são chamados de variáveis de instância.

Comportamentos: agora já sabemos que nossos queridos e dóceis T-Rex possuem atributos que definem certas características fundamentais, no entanto, filmes como Jurassic Park nos mostram que eles são muito mais do que isso. Eles podem correr, perseguir jipes, comer advogados no banheiro, apanhar do King Kong e uma infinidade de outras coisas legais. Em outras palavras, os Tiranossauros Rex possuem comportamentos, que nada mais são que as operações ou atividades que eles desempenham. E uma vez que usemos uma linguagem de programação para implementar uma classe, estes comportamentos passam a ser chamados de métodos.

Objetos

Agora já sabemos que conceitos do mundo real são esboçados através de classes, mas são apenas esboços, não existem de verdade. Uma classe que representa um Tiranossauro apenas detalha as características que ele tem e as ações que ele pode fazer, mas não representa nenhum deles em particular.

Sendo assim, para termos um T-Rex de verdade, e não apenas uma definição de classe, precisamos usar a classe que define como um Tiranossauro deve ser, e então criar uma instância desta classe, ou seja, um objeto. Desta forma, um objeto irá representar um T-Rex em particular, e aí sim poderemos fazer as coisas legais que vemos nos filmes.

Além disso, podemos criar quantos objetos quisermos, sendo que cada um deles terá as variáveis de instância e métodos que definimos na classe do objeto, que no nosso caso é uma classe que define um Tiranossauro. Além disso, os valores de suas variáveis de instância de um objeto são independentes dos valores de outros objetos, até porque isto é o que identifica um objeto específico. Sendo assim, se definirmos que a altura de um Tiranossauro Rex é 20 metros, apenas a altura daquele T-Rex será 20 metros, os outros continuarão com as suas alturas individuais inalteradas. Além disso, os valores de todas as variáveis de instância de um objeto é chamado de estado do objeto.

Considerações Finais

Basicamente, é isso que eu tenho a dizer no momento sobre orientação a objetos. De forma alguma este post pode ser encarado como uma introdução formal e profunda do assunto, mas atende perfeitamente ao propósito de definir de forma rápida conceitos cuja compreensão é necessária para o entendimento dos próximos posts. No entanto, eu ainda irei voltar neste assunto várias vezes, de forma a colocar as coisas de um jeito um pouco mais técnico, além de abordar aspectos não mencionados aqui. Entreranto, isto não quer dizer que vocês estarão livres de classes incomuns ou analogias esdrúxulas.

No dia 27 de outubro de 2007 acontecerá o 2º Seminário Ruby on Rails, em São Paulo, mais precisamente na Universidade São Marcos, que fica em Ipiranga. O evento, que é promovido pela Tempo Real Eventos, terá as seguintes apresentações:

TaQ e Ronie Uliana: os dois falarão sobre o que aconteceu de interessante no mundo Ruby e Ruby on Rails de um ano pra cá.

Dextra: apresentará um tutorial prático.

Improve It: abordará o Projeto Lucidus, sendo representada pelo Vinicius Manhães Teles e outros membros da equipe.

e-Genial: o Carlos Eduardo, fundador da e-Genial, falará do envolvimento da sua empresa com o Rails, destacando alguns cases, incluindo provavelmente o excelente Treina Tom.

Bit Bucket: será apresentada pelo Ronaldo Ferraz.

Como deu pra perceber, este ano o evento será focado em cases, sendo assim, se você tem algo pronto que foi desenvolvido com o Ruby on Rails, esta é a sua chance. Você poderá apresentá-lo em uma palestra de 15 minutos, embora para isso tenha que ter um poster da sua aplicação.

Em relação a ausências, acho que dos principais nomes do Rails no Brasil, ou pelo menos dos que eu lembro de cabeça, só faltou mesmo o Fabio Akita, que certamente seria uma excelente adição, e o Carlos Brando, que poderia apresentar o seu carreitaTI como case, já que este foi desenvolvido usando o Ruby on Rails.

Por fim, o evento acontecerá das 9:00 até 18:00, e a inscrição antecipada custa R$45, sendo assim, se você pretende ir, é bom se inscrever logo, já que está promoção só dura até o dia 20 de outubro.

Ok, chega de enrolação! Agora abordaremos a parte mais divertida do aprendizado de uma nova linguagem de programação: o bom e velho Hello World. E como diversão nunca é demais, vou colocar abaixo 4 versões dele, além de comentar brevemente cada uma.

1- Usando o irb

Abra uma janela de comando e então digite irb. Feito isto, o irb será executado, sendo assim, basta digitar a instrução puts “Hello World!” e pronto!

2- Executando um arquivo .rb

Código fonte Ruby é salvo em arquivos com a extensão .rb, sendo assim, digite puts “Hello World!” e salve-o em um arquivo com o nome hello_world.rb. Depois disto, basta abrir uma janela de comando, ir até o diretório onde você salvou o arquivo, e então executar o comando ruby hello_world.rb. Feito isto, você verá na tela a frase mais famosa da computação.

3- Executando um arquivo .rb orientado a objetos

Digite o código abaixo, excluindo obviamente os números e os pontos após os números. e então salve-o em um arquivo chamado hello_world_oo.rb. Em seguida abra novamente a janela de comandos, e digite ruby hello_world_oo.rb no diretório em que o arquivo foi salvo. Pronto, mais um Hello World rápido e indolor.

class HelloWorld
  def say_message
    puts "Hello World!"
  end
end

hello_world = HelloWorld.new
hello_world.say_message

4- Usando o interpretador do Ruby sem um arquivo .rb

Acima, quando chamamos o interpretador do Ruby, nós passamoos o nome do arquivo .rb para ser executado logo após o comando ruby, no entanto, podemos chamá-lo sem fornecer nenhum arquivo. Para isto, digite apenas ruby na janela de comando, e então digite a instrução puts “Hello World!” e aperte a tecla enter. Em seguida, você deve inserir o caractere de fim de arquivo, que no Windows XP é representado por Ctrl+D, e logo depois pressionar o enter mais uma vez. Aí está o último e menos elegante Hello World deste post.

Alguns breves esclarecimentos

Como sempre acontece em um Hello World, você não deve se preocupar se não entender a sintaxe dos exemplos acima. O objetivo é apenas mostrar pequenos “programas” para que você tenha um primeiro contato com código fonte Ruby.

De qualquer forma, imagino que vocês devem ter inferido que a instrução puts serve para exibir uma mensagem na saída padrão, que no caso é a janela de comando.

Ok, agora você já sabe bem o que é o Ruby e também já possui algumas boas fontes de pesquisa, sendo assim, já podemos começar a brincar com ele, certo? Errado. Antes temos que baixar e instalar o Ruby. Ou não, dependendo da sua plataforma. De qualquer forma, lá vão as instruções para os 3 SOs mais comuns.

Windows

Instalar o Ruby no Windows é extremamente simples. Basta ir até o a área de download do site oficial do Ruby, baixar o instalador, e então executá-lo. O instalador segue o padrão next->next->finish do Windows, ou seja, não tem mistério algum.

Ao instalar o Ruby no Windows, além do interpretador, será instalado também o RubyGems, RDoc, irb e o SciTE, que são, respectivamente, um gerenciador de pacotes do Ruby, um gerador de documentação, um ambiente para execução instantânea de código Ruby e um editor de texto para programação. Ou seja, tudo que você precisa para iniciar os estudos da linguagem será instalado de uma só vez.

Linux

Muitas distribuições do Linux já vêm com o Ruby instalado. Mas se não for o seu caso, você pode usar o sistema apt-get para baixá-lo e instalá-lo, lembrando que o apt-get só está disponível no Debian e em distribuições derivadas dele. Sendo assim, se você estiver em uma dessas distribuições, como o Ubuntu, poderá usar o comando sudo apt-get install ruby irb rubygems rdoc“, instalando assim o Ruby, o irb, o RubyGems e o RDoc.

Além disso, é importante notar que mesmo que a sua distribuição já venha com o Ruby, como no Kubuntu, isso não significa que ela virá com todo o necessário para o estudo da linguagem, sendo assim, você terá que executar o comando anterior, apenas excluindo a palavra ruby da lista, ou seja, deve utilizar o comando sudo apt-get install irb rubygems rdoc.

Mac OS X

O Mac OS X também já vem como o Ruby pré-instalado, no entanto esta versão pode não ser a mais recente. Portanto, se você quiser instalar uma versão mais atual, pode usar o gerenciador de pacotes Locomotive, ou baixar um instalador similar ao instalador do Windows no site Ruby One-Click Installer for OSX. Este instalador possui todo o necessário para inicar os estudos do Ruby.

Verificando a instalação

Após ter instalado o Ruby em seu computador, você pode (e deve) verificar se tudo aconteceu como previsto. Para isto, execute o comando ruby -v na janela de comando do seu sistema, e então verifique a saída produzida. O ideal é que seja informada que a versão instalada do Ruby é a 1.8.6, que é a mais atual no momento. Se for o caso, ou se a versão informada for ligeiramente anterior (1.8.5, por exemplo), significa que o Ruby está pronto para ser usado.

Em geral, ao iniciar o estudo de uma nova linguagem de programação perde-se a maioria das referências adquiridas anteriormente, uma vez que se está entrando em um mundo novo. Pensando nisso, decidir compartilhar algumas das minhas principais fontes de informação sobre Ruby, de forma a facilitar a transição para esta linguagem.

Sites

Site oficial do Ruby: possui downloads, documentação, notícias e informações sobre o Ruby de uma forma geral, sendo provavelmente o site mais completo sobre a linguagem.

Ruby on BR: portal brasileiro que tem como objetivo difundir o conhecimento sobre Ruby e Ruby on Rails. O seu conteúdo está dividido principalmente entre notícias e artigos, além disso, possui provavelmente o maior fórum em português sobre Ruby.

Try Ruby!: mini-tutorial sobre Ruby, onde você encontra pequenas lições sobre a linguagem e pode praticar o conteúdo no próprio browser, vendo inclusive o resultado das instruções que você digitar.

Blogs

Akita on Rails: blog do Fábio Akita, autor do livro Repensando a Web com Rails e coordenador da tradução do livro Getting Real para português do Brasil. O Akita é um dos maiores evangelizadores do Ruby e do Rails no Brasil, além disso, escreve muito bem, o que torna o seu blog uma leitura deliciosa.

Eustáquio “TaQ” Rangel: blog do TaQ, outro grande evangelizador do Ruby no Brasil. No seu blog há vários posts interessantes sobre a linguagem, além de dois tutoriais em PDF, um sobre Ruby e o outro sobre Ruby on Rails.

Leonardo Bighi: blog do Leonardo Bighi, um amigo pessoal e excelente desenvolvedor web, com ampla experiência em PHP, e que há tempos se dedica unicamente ao Ruby e Ruby on Rails, sendo ambos temas frequentes de posts no seu blog.

Livros

Programming Ruby: A Pragmatic Programmer’s Guide: o famoso PickAxe, escrito por Dave Thomas e Andy Hunt (e também por Chad Fowler, na 2ª edição do livro). Além de ser um excelente livro, ele contribuiu significativamente para a popularização do Ruby fora do Japão, principalmente porque quando foi lançada a 1ª edição do livro a documentação do Ruby ainda deixava muito a desejar, sendo esta lacuna preenchida pelo livro.

Ruby - Conhecendo a Linguagem: livro do TaQ sobre o Ruby. Este livro é baseado no tutorial em PDF que ele gentilmente continua disponibilizando em seu blog.

Já disse anteriormente que o Ruby é uma linguagem totalmente orientada a objetos e dinamicamente tipada, agora é hora de sermos mais específicos e analisar a linguagem um pouco mais a fundo

Olhando pra trás

O Ruby foi criado por Yukihiro “Matz” Matsumoto, que como o nome indica, é japonês. Matz se interessou por programação pouco depois de ser apresentado aos computadores, e como consequência natural, se formou em Ciência da Computação.

Em 1993, Matz conversava com um colega sobre linguagens de script, estando ele neste momento bastante impressionado devido ao seu poder e possibilidades. Ao pesquisar na Internet sobre o assunto, ele encontrou Perl e Python, mas de alguma forma não era exatamente isso o que ele queria. Como ele mesmo disse em uma entrevista realizada em 2001, ele queria uma linguagem de script que fosse mais poderosa que Perl e mais orientada a objetos que Pythton. E foi por isso que Matz decidiu criar sua própria linguagem.

Sendo assim, em 24 de fevereiro de 1993, Matz começou a desenvolver o Ruby usando a linguagem C. Quando iniciou o projeto, Matz brincava com um amigo dizendo que a linguagem deveria ter o nome de uma pedra preciosa, em alusão ao Perl, e então este amigo o sugeriu Ruby. Matz gostou do nome, e acabou o adotando como nome oficial da linguagem.

A primeira versão foi lançado para o público em dezembro de 1994, na forma de uma versão alpha. Depois disso ele continuou desenvolvendo a linguagem sozinho até meados de 1996, quando uma comunidade Ruby começou a se formar, e desde então ele passou a ter cada vez mais ajuda desta crescente comunidade.

Embora a popularidade do Ruby crescesse consideravelmente no Japão, pode-se dizer que inicialmente trata-se de um fenômeno apenas naquele país. Mas então surgiu o famoso livro PickAxe, que nada mais é que o apelido do livro Programming Ruby: A Pragmatic Programmer’s Guide, escrito por Dave Thomas e Andy Hunt. A importância deste livro para o Ruby fora do território japonês foi tão grande, que o próprio Matz credita à 1ª edição do livro parte da popularidade mundial do Ruby.

Desde então, o Ruby tem se tornado cada vez mais popular, em especial após o lançamento 3 anos atrás do Ruby on Rails, um framework web escrito em Ruby que revolocionou o desenvolvimento web, sendo definitivamente o maior responsável pela atual popularidade da linguagem.

Uma visão mais técnica

Considerando os aspectos técnicos do Ruby, chegamos à seguinte lista de características:

Orientação a objetos: o Ruby é considerado uma linguagem totalmente orientada a objetos, o que significa que tudo que você manipula em Ruby é um objeto, incluindo dados que normalmente são tipos primitivos em outras linguagens, como números inteiros e números de ponto flutuante. Como consequência disso, as variáveis no Ruby sempre armazenam referências a objetos.

Tipagem dinâmica: na maioria das linguagens, nós temos que declarar uma variável e associá-la a um tipo, o que é chamado de tipagem estática. Já no Ruby, uma variável ao longo da sua vida pode armazenar referências a objetos de várias classes. Isto é chamado de tipagem dinâmica, que é quando o tipo de uma variável pode mudar ao longo do tempo. É importante ressaltar que tipagem dinâmica não significa tipagem fraca, o Ruby por exemplo é uma linguagem com tipagem dinâmica e forte, ou seja, não se tratam de conceitos excludentes.

Execução: código fonte Ruby possui a extensão .rb e é executado diretamente por uma VM (Virtual Machine), sem qualquer processo de compilação. Por esta razão, o Ruby é uma linguagem interpretada.

Flexibilidade: o Ruby é extremamente flexível, permitindo aos programadores até mesmo mudar a sua estrutura interna, se assim o desejarem. Então, caso você não goste, por exemplo, de usar o sinal aritmético “+” para efetuar uma soma, basta alterar a classe Numeric.

Operadores: os operadores no Ruby são syntatic sugar para métodos, e você pode redefini-los a vontade.

Convenções: existem algumas convenções ao nomear variáveis que faz com que rapidamente identifiquemos a sua natureza, como por exemplo uma variável chamada @idade. Neste caso, devido à convenção do Ruby, podemos afirmar que se trata de uma variável de instância.

Expressões regulares: o Ruby oferece suporte nativo a expressões regulares, além disso, o seu uso é extremamente simples.

Blocos: esta é uma das características mais interessantes da linguagem. Blocos podem ser descritos como uma forma alternativa de passar argumentos para métodos, no entanto, é mais preciso dizer que se trata de uma transferência de fluxo entre um método e um trecho de código externo. Através dos blocos podemos, entre outras coisas, implementar iterators. Além disso, os blocos tamvém possibilitam a existência de uma outra capacidade do Ruby bastante festejada: closures.

Tratamento de exceções: assim como muitas linguagens modernas, o Ruby oferece tratamento de exceções nativamente, e como não poderia deixar de ser, o seu uso é bastante simples.

A filosofia por trás do Ruby

Ao projetar o Ruby, Matz foi guiado pelo Príncipio da Menor Surpresa, o que significa que o código escrito em Ruby deve se comportar de maneira a minimizar a surpresa daqueles que o lerem. Dessa forma, Matz esperava possibilitar que os programadores se expressassem naturalmente usando o Ruby. Como resultado dessa redução da surpresa, o Ruby tornou-se uma linguagem orientada aos humanos, de forma que o código escrito na linguagem seja facilmente compreendido, transferindo o trabalho difícil de para os computadores.

Outro princípio por trás da criação do Ruby é tornar o processo de desenvolvimento divertido, o que acaba resultando em uma maior produtividade, afinal, somos mais produtivos quandos estamos envolvidos em atividades divertidas.

Implementações Alternativas

Existem implementações alternativas do Ruby, como o JRuby, que é uma versão do interpretador do Ruby para a JVM (Java Virtual Machine). Existe também uma implementação do Ruby para o .NET Framework chamada IronRuby, no entanto, esta implementação ainda está na versão pré-alpha. Além dessas, há ainda outras menos conhecidas, como Rubinius e YARV.

Desvantagens

Seria leviano da minha parte introduzir alguns conceitos básicos sobre Ruby sem mencionar seus pontos fracos, uma vez que toda e qualquer linguagem tem os seus.

Um dos maiores problemas atuais do Ruby é a performance da sua VM, que deixa a desejar mesmo se não a compararmos com máquinas virtuais mais avançadas, como a JVM.

Outra característica negativa da linguagem é a sua relativa dependência em relação ao desenvolvimento em C, já que a biblioteca principal do Ruby possui muitas partes escritas nesta linguagem, não sendo, portanto, totalmente escrita em Ruby.

O futuro

O Ruby atualmente está na versão 1.8.6, sendo que a versão 1.9 está em desenvolvimento.

Ruby no Brasil e no mundo

Atualmente, o Ruby é a 10ª linguagem de programação mais utilizada no mundo, de acordo com o Tiobe. Já no Brasil, o Ruby é utilizado por mais de 15% dos programadores, sendo que em 2008 há a previsão desta quantidade aumentar para 33%, segundo os resultados da pesquisa internacional feita pelo instituto Evans Data.

E agora?

Agora cabe a você decidir se irá estudar Ruby on não. Enfim, eu acho que é uma linguagem maravilhosa, mas esta é sempre uma decisão pessoal. Então, se você gostou do que leu acima, ou está insatisfeito com a linguagem/plataforma que está utilizando no momento, dê uma chance ao Ruby. E mesmo que você não venha a utilizá-lo, aprender uma nova linguagem de programação sempre o tornará melhor nas outras linguagens que você utiliza.

Por fim, gostaria de mencionar que uma linguagem pode ter valor sem que este valor seja tirado da linguagem que você já utiliza. Qualidade definitivamente não é uma característica excludente entre as linguagens de programação.