Esse é o primeiro de três possíveis artigos usando o mesmo plugin, esporo que gostem.

att,

Bom, seus problemas terminaram. Faca o seguinte, primeiramente voce precisa descobrir quem e o programa que esta ocupando a porta do seu servidor, por isso digite o seguinte comando em um terminal

lsof|grep 3000

dai vai aparecer algo mais ou menos assim

ruby   5303  vinicius  5u  IPv4

beleza, o que interessa e a numeracao apos nome ruby. Vamos derrubar esse processo digitando o seguinte

kill -9 5303

note que estou usando a mesma numeracao do processo por isso ele sera eliminado da lista. Agora voce podera rodar normalmente seu server sem nenhum problema.

att,

O que é RoR?

RoR é um acrônimo para RubyOnRails, ta certo?. Esse, na realidade, é um poderoso framework open-source de desenvolvimento web criado para construir, de forma muito rápida, aplicações web de alta qualidade. É bastante simples de instalar, seu único pré-requisito é o próprio Ruby instalado e configurado na máquina local, ai o resto é resto.

Como disse, o RoR precisa do Ruby por isso, pra inicio de conversa vamos instalar o Ruby que é uma linguagem de programação assim como java, dotnet, python, etc… Se você for usuário Microsoft, abaixo tem um link pra baixar um instalador da linguagem Ruby, o one-click install, no windows. Nele não existe segredo, é só ir pressionando próximo até aparece o fechar e pronto “Ruby funcionando!”.

http://rubyinstaller.rubyforge.org/wiki/wiki.pl

Para facilitar o entendimento desse micro-artigo, vou trabalhar com o windows XP e a distribuição Ubuntu do Linux. Os exemplos serão mostrados em ambos os sistemas operacionais, até por que uso ambos.

Continuando, pra quem usa linux a instalação do Ruby é meio diferente, mesmo assim, sem mistério. Como disse, eu uso Ubuntu, mas acredito que seja o mesmo para as demais distribuições por isso, faça o seguinte. Abra um terminal e digite:

sudo apt-get install ruby

Esse comando instala e configura o Ruby como se fosse o one-click install do windows, muito fácil ne mesmo?.

Agora que temos o Ruby instalado, basta fazer o mesmo com o Rails por isso vamos da seguinte maneira. Novamente, será exibido os passos para Ubuntu e posteriormente Windows, digite no terminal os comandos seguintes:

[Linux Ubuntu]

sudo gem install rails -y
sudo gem install sqlite3-ruby
sudo apt-get install libopenssl-ruby1.8

[Windows XP]

gem install rails -y
gem install sqlite3-ruby

Aguarde um tempinho (não se preocupe caso aparente que o comando não respondeu ou esta demorando um pouco, o sistema esta catalogando todas as dependências necessárias para o download, terminando, será exibidos a listagem com o que ta sendo instalado) e pronto. Muito complicado né mesmo? O primeiro comando instala o RoR com todas as suas dependências (pra isso o –y, em futuras versões do Ruby esse parâmetro não será necessário). O segundo comando instala um adaptador que vai possibilitar nossa aplicação conversar com um banco sqlite3 (é possível baixar o adaptador sem o banco está instalado, mas o sistema só vai rodar se encontrar o banco por isso instale-o também). O último comando só vale pra Linux, ele vai instalar a biblioteca openssl usada pelo mongrel para iniciar o serviço, quando não tem, da pau.

DICA: Se você usa proxy pra acessar a internet, no Windows precisa configurar uma variável para que o RubyGems possa baixar as gems. Faça o seguinte:

a) acesse as propriedades de meu computador;
b) depois avançado>variáveis de ambiente;
c) nela você vai criar uma variável chamada HTTP_PROXY e o valor dela devera ser http://<ip_proxy>:<porta_proxy>

d) abra novamente o terminal para que a modificação tenha efeito e pronto.

Continuando, vamos testar nosso ambiente. Uma forma bastante simples e pratica de fazer isso, por sinal muito parecida com a do java (javac), é digitando no terminal:

ruby -v
rails -v

Tanto pra Windows quanto Linux. O primeiro comando informa a versão do Ruby que esta instalada. O segundo informa a versão do Rails que foi baixada. Os dois comandos respondendo direitinho prova que ta tudo certinho com nossos passos até então (qual quer problema reveja os passos novamente).

Bom, como já temos os dois prontos, podemos fazer um teste mais rigoroso criando uma aplicação de demonstração para ver a coisa no vera mesmo.

Criando um Demo em Rails

Antes de tudo, você que usa Windows precisa realizar mais um passo chato configurando o Ruby na variável Path do sistema. Acesse as propriedades de Meu Computador, avançado>variáveis de ambiente e acrescente a seguinte instrução dentro da variável path.

C:\ruby\bin

O endereço tem de ser o da instalação do Ruby, coloque a unidade C: por que é o padrão da instalação. Após isso, feche o terminal para que ele re-carregue todas as configurações e pronto.

Crie em algum lugar uma pasta para centralizar seus projetos (isso não é um pré-requisito, mas deixa seu ambiente de trabalho mais organizado). Abra novamente o terminal de comandos (se você ainda estiver com o terminal anterior aberto, poderá usá-lo), por ele acesse a pasta de projetos Rails recém criada e digite:

rails Demo

Rails é o comando que vai criar sua aplicação, ele pede somente um parâmetro que é justo o nome do aplicativo. Esse comando instrui o Rails a criar um sistema web, note que ele não cria uma estrutura vazia. Isso acontece por que Rails segue uma serie de convenções para facilitar a vida de quem vai produzir sistemas. Uma dessas convenções é justamente a padronização do ambiente da aplicação por pastas especificas que ele próprio (RoR) se encarrega de gerenciar. Logicamente, você tem livre arbítrio para seguir suas próprias convenções e não as dele (RoR), só fique ciente que esse será um trabalho a mais que terá e você precisara gerenciar isso. Agora podemos acessar o demo e iniciar nosso primeiro sistema web digitando (a partir da pasta do projeto):

[Linux Ubuntu]
script/server

[Windows XP]
ruby script/server

Note que em um ambiente Windows, precisamos referenciar a variável de sistema Ruby. Agora vamos aponte o browse para o seguinte endereço:

http://localhost:3000

Se tudo correr direitinho, será exibido a pagina de boas vindas do projeto.

Como faço para atualizar meus projetos RoR?

Em vista de tudo pronto e funcionando, é bastante comum que você (programador) queira sempre esta com a versão mais atual de seu framework preferido. Com RoR não é diferente, mas existe uma condição para que isso ocorra. Alguns recursos do Ruby precisam se encontrar atualizados, por exemplo, RoR é instalado a partir de um gerenciador de pacotes do Ruby chamado RubyGems, ele se encarrega de verificar e baixar todas as dependências do RoR incluindo RDoc e, por ai vai. RubyGems é um recurso do Ruby muito usado, por isso sempre é bom da uma atualizada nele até por que versões mais recentes dos pacotes gems sempre irão pedir a versão mais atual do RubyGems e isso inclui RoR. A boa notícia é que fica fácil atualizar seus recursos depois RubyGems está pronto pra isso, basta certificar-se de que o sistema será atualizado corretamente a partir dos comandos:

[Linux Ubuntu]
sudo gem update –system
sudo gem install rails
sudo gem update rake
sudo gem update sqlite3-ruby

[Windwos XP]
gem update –system
gem install rails
gem update rake
gem update sqlite3-ruby

Novamente, tanto Linux quanto Windows. O primeiro comando atualiza o próprio sistema RubyGems (que é exigido pela versão mais recente do RoR) como já mencionado. O segundo comando instala Rails mais recente com todos os novos recursos. O terceiro comando atualiza a ferramenta Rake (um construtor de aplicações Ruby similar ao make do Linux). Por fim, o último comando vai atualizar o adaptador sqlite3 que foi instalado (você pode ter vários adaptadores, um para cada banco preferido seu).

Novamente, a execução dos comandos pode levar um tempinho para ser concluído, não se preocupe caso não aparece nenhum texto de imediato. Quando estiver finalizado, você poderá listar todas as gems instaladas usando o comando:

gem list

Esse é um comando do Ruby por isso pode ser rodado a qualquer instante. Existe um outro que possibilita você ler a documentação de todas as gems instaladas:

gem server

Executando essa instrução acima, você estará iniciando um servidor web na porta 8808 que dará acesso à documentação das gems de instaladas. Você verá uma lista des gems com links para o RDoc web e uma breve descrição da gem. O endereço para o server é:

http://localhost:8808/

Depois que estiver com a versão mais recente de RoR, pode acontecer que algumas de suas aplicações não funcionem. Esse é um problema muito simples de resolver por tanto faça o seguinte:

a) Acesse a arquivo config/environment.rb de sua aplicação;

b) Altera o valor da variável RAILS_GEM_VERSION para a nova versão do RoR que você quer usar, tipo: de RAILS_GEM_VERSION = ‘2.0.0′ para RAILS_GEM_VERSION = ‘2.1.2’.

O Ruby!

Até esse momento vimos um pouco sobre RoR. Nada muito detalhado, mas com algumas informações fundamentas pra quem ta iniciando. RubyOnRails é um Framework muito poderoso que não seria capaz de fazer o que faz se não fosse a linguagem de programação Ruby. Ruby é uma linguagem tão boa que hoje já temos empresas grandes como a Sun investindo nela. Existe até um projeto pouco conhecido chamado JRuby (eu disse pouco?) que vem tomando espaço de uns outros menos barulhentos mas muito legais como o Groovy (pra quem quiser saber mais, abaixo segue um post com 33 pontos de comparação para essas linguagens), detalhe, não estamos aqui para falar disso por isso deixaremos esses discurções para quem sabe mais do assunto por tanto.

http://www.javafree.org/news/view.jf?idNew=3118

Quando instalamos o Ruby no computador para testar o RoR, junto com ele foi instalado um programinha muito bom para se testar código, o irb (interactive Ruby shell), que nos possibilita chama-lo e já ir colocando códigos e testando. Nada muito complexo, excelente pra quem ta iniciando assim como eu. Agora, antes de tudo, vamos fazer algumas modificações no ambiente para facilitar e dar um pouco mais de agilidade as nossas vidas (essa configuração só se aplica ao Linux pos não sei como fazer isso no Windows, mas quem souber e quiser contribuir, sinta-se a vontade para postar aqui).

Acesse o diretório de seu usuário na pasta /home/, por exemplo:

/home/vinicius/

Dentro digite:

sudo gedit .irbrc

Será exibido um documento em branco, nele acrescente a linha:

require ‘irb/completion’

Ok, a partir de agora seu irb possui suporte para auto-complemento usando a tecla de atalho tab, mas isso ainda não esta funcionando pos falta um passo a ser seguido. Procure a pasta onde o Ruby foi instalando, no meu pc ela fica em /etc/lib/ruby. Pelo terminal, a partir dela faço o seguinte, localizo a pasta 1.8.2 que possui os arquivos rb depois digito o comando:

Rdoc *.rb

Esse comando vai gera a documentação do Core do Ruby a partir dos arquivos rb. Após essa trabalheira toda, agora sim poderemos utilizar o irb com recursos de auto-complemento. Vamos fazer só um teste rápido pra validar o que fizemos, acesse o terminal e digite:

irb

String.<PRECIONE_TAB>

A instruição irb vai iniciar a execução do programa IRB. Quando, nele, digitamos o nome de uma classe do Ruby e chamamos o método methods da classe, é exibo um array contendo todos os métodos dessa classe. Se os passos feitos antes do inicio do irb funcionaram, nós poderemos escrever, por exemplo, o nome de uma classe qualquer mais o ponto e pressione o TAB duas vezes (bem como o exemplo acima) que os métodos serão exibidos lado a lado na tela.

Beleza, tudo certo para nosso pequeno Tour? Vamos esquecer um pouquinho o que vimos em RoR e nos focarmos no Ruby por isso, antes de mais nada, é preciso entender que em Ruby tudo é um objeto e quando eu falo tudo me refiro a tudo mesmo (ta bom, tem algumas exceções que fogem a regra tipo variável, mixin e blocos) por isso, qualquer coisa que se faça esta sendo feito em um objeto. Por exemplo, vamos criar um método e uma classe, hum!! Como criar um método e uma classe?

Como disse, o IRB é um ambiente de teste que possibilita testar tudo o que vem na cabeça por isso uma definição de método tipo:

def meu_nome
puts “vinicius luiz”
end

ou uma declaração de classe tipo:

class Teste1

end

São coisas totalmente aceitas dentro dele. Não se preocupe em “onde que ele ta pondo essas coisas” ou “quando vai precisar compilar”. Ruby é uma linguagem totalmente dinâmica por isso o que você escrever no IRB já estará pronto para uso.

Agora que temos uma definição de método e uma declaração de classe, vamos ilustrar so mais um pouquinho e não se preocupe se o que vir for meio estranho. Como disse, em Ruby tudo é muito simples inclusive declarações de classe. Class em si é um objeto por isso podemos criar outras classes da seguinte maneira (esse é um modo muito diferente do convencional):

Teste2 = Class.new

Isso não é um bicho de sete cabeças pra se entender correto? O que fizemos foi simplesmente criar uma classe nova instanciando ela do objeto Class, simples não?

Agora, temos um método que vai imprimir uma string “vinicius luiz” quando for chamado no irb. Como o irb e um objeto Object, o que estamos fazendo na realidade é uma chamada em Object, exemplo (agora segue uma lista):

meu_nome
self.meu_nome
Object.meu_nome

Note a primeira chamada não é mais segredo já a segunda e a terceira! Como você percebeu, o método criado na realidade foi enfiado (sutil não?) no objeto Object e como IRB herda Object, também acessa esse mesmo método novo. Até o momento não vimos nada complicado, mas temos uma terceira forma de se chamar essa mesma função, digite:

Kernel.meu_nome

Kernel? Mas quem e esse Kernel afinal? Calma, eu explico! Kernel é um modulo que pega os dados postos no IRB e coloca em Object. Qualquer método que esteja sendo criado no IRB (na realidade em qualquer lugar no ruby) ficara acessível através do contexto de qualquer classe, do Kernel ou de Object, deu pra entender isso? Humm, pêra ae! Eu disse qualquer classe?

Ta lembrado das classes criadas no inicio, agora é à hora de usá-las, vamos fazer o seguinte:

Teste1.meu_nome
Teste2.meu_nome

Antes de prosseguir, permita me fazer uma pergunta. “Quem nasceu primeiro, o ovo ou a galinha?”, ehhh, to brincando. Bom, continuando.

Como toda classe por padrão herda de um Objeto expecifico (e já estamos cansados de saber disso), em Ruby não é diferente por isso nossas classes também, visto que herdam do objeto Object, terão acesso à função meu_nome.

Como deu pra ver, tudo em Ruby é um objeto incluindo qualquer coisa pôs métodos, variareis, etc. definidos em qualquer lugar não são coisas dispersas em um espaço estático e acessível sem vinculação com nada. Tudo que for definido será inserido em Object que por sua vez deriva pro o IRB, pro Kernel e pra qualquer outro objeto.

Acho que da pra dizer que o Kernel no ruby seria como o java.lang do java (corrijam me se estiver errado). Uma biblioteca importada por padrão, com métodos acessíveis sem a necessidade de informar o nome de sua classe.

Conclusão

Bom pessoal, falei um pouco de RoR, sua instalação, atualização e algumas outras pequenas configurações que existem pra serem feitas nos diferentes ambientes testados. Acho que não teve muita coisa nova pos o que mostrei já deve ta mais que batido.

Pode acontecer deu ter me equivocado? Pode sim, sem nenhum problema por isso me corrigirem se for o caso pos como disse no inicio, esse material foi pra fixar mais as idéias.

Estudem Ruby, não se prendam somente em RoR, RoR, RoR. É um bom framework? Sim, com toda certeza um dos melhores, mas Ruby a meu ver é muito mais essencial pra quem ta iniciando. Existem materiais excelentes na internet, quem poder e quiser baixar, eles estão ai aos milhares por isso, colocarei só um aqui pra vocês.

http://rapidlibrary.com/index.php?q=ruby+way

Existem alguns livros nacionais muito legais como “Ruby: desvendando a linguagem” (esse particularmente eu aconselho) e outros mais. Agora, quem quiser postar alguma coisa, sou todo ouvidos hehehehe.

No sábado dia 1/11/2008, fizemos uma reunião e divilgação da Comunidade AmapáOnRails na sede da InovaSoft, onde estavam os programadores Vinicius, Anderson, Huan, Veronica, Robson.

Falamos um pouco sobre programação e outros assuntos legais, vimos o Ruby fazendo suas mágicas ao vivo e a cores, eu também mostrei um pouco do meu KungFu usando a linguagem Ruby. Bem foi um sábado legal. Agradeço ao pessoal que apoia a comunidade e convido todas a usarem Ruby. Valeu!!

Bem Continuando……….

Vamos colocar nossa classe de Teste aqui para relembra-la!

Bem se a Metaclasse é um Objeto da classe “Class” e todos os métodos dos Objetos desta classe buscam seus métodos na Metaclasse, entao eu posso adicionar métodos na Metaclasse e usá-los nos Objetos. Vejamos! Antes para criarmos uma classe tinhamos algo como no exemplo acima, mais poderiamos fazer assim:

Bem ficou bem claro! Talvez a mágica esteja sendo desvendada, isso pode ser legal para alguns e muito triste para outros. Bem eu amo a simplicidade de Ruby, alguns amam suas mágicas, outros temem seu dinamismo. Porém o mais importante é que todos ao conhecer Ruby sempre criam algum sentimento por ele.

Voltando ao Assunto!

Agora, é que as coisas ficam mais complicadas e mágicas.

Em Ruby, os objetos de uma classe sempre compartilham os mesmos métodos e esses métodos ficam em sua Metaclasse, isso voces ja viram, porém, é possivel que objetos possuam métodos particulares, isso nós chamamos de singleton_methods.

Os métodos singleton de um Objeto só pertencem a ele, e não aos outros objetos da classe! São métods individuais, é como o ruby propoe que possamos dar individualidade aos objetos, ele deixa que nós dinamicamente adicionemos alguma funcionalidade que só aquele objeto precisa, e não nos obriga a adicionar essa funcionalidade a todos os obejtos de uma classe, isso é ser singleton_methods. Bem vejamos como isso é feito!

Lembrando que os métodos singleton são guardados no próprio objeto e não na metaclasse.

Bem existem muitas outras coisas cobre o assunto mais acho que o mais importante ja vimos! O mais interessante é podermos ver as coisas claramente. Ruby é uma linguagem que superficialmente é muito simples, porém quando nos aprofundamos podemos nos confundir em algumas coisas, o mais importante é poder ver a coisas claramente para sermos melhores!

Valeu!!

O que é uma Metaclasse?
Para que serve uma Metaclasse?

Bem antes vamos falar de Classes e Objetos. Vamos fazer uma classe simples para usarmos como exemplo.

Uma Classe é composta de atributos e métodos, entao todos os Objetos de uma classe tem em comum seus atributos e métodos. Porém cada objetos tem seus atributos específicos, ou seja, se uma classe tem o atributo “nome” todos os objetos teram um nome, so que para cada objetos o nome é particular, ex. Joao, Maria, Jose, etc. sendo assim cada Objeto tem seu próprio atributo e é individual. Já os métodos, sao todos iguais para todos os objetos, a ação de um método é sempre igual em todos os objetos.

E o que isso implica? É que quando se instancia um Objeto, o Objeto é colocado em memória e lá é reservado espaço de memória para todos seus atributos, isso é importante para que possamos guardar valores individuais para cada Objeto. Porém os métodos são iguais a todos os Objetos e não faz sentido ocupar espaço em memória colocando para cada Objeto seus métodos é muito mais inteligente colocar todos os métodos em um único Obejto e esses métodos serem usados por todos os Objetos da mesma Classe.

Bem este Objeto que guarda em sí todos os métodos de uma Classe chama-se Metaclasse! Em Ruby uma Metaclasse é um Objeto(constante) Singleton, que guarda em sí todos os métodos e representa a classe durante a execução do código.

Em miudos, em Ruby uma Metaclasse é um Objeto que representa a Classe, ou seja, uma espécie de procurador, ou executor do que está escrito na Classe. Estranho, mais é isso, lembrando que Classe nunca faz nada, pois em Orientação a Objetos só Objetos podem fazer algo e não Classe. Isso torna o ruby uma linguagem altamente Orientada a Objetos. Costuma-se dizer que em Ruby até as Classes são Objetos porém não é bem verdade Classes continuam sendo documentos e as Metaclasses é que são os Objetos que representão a Classe.

Fica Assim! Quando se escreve uma classe em Ruby automaticamente o interpretador cria um Objetos(Metaclasse) que representa essa Classe, este Objeto é uma constante por isso tem a primeira letra em maiúcula e é singleton, ou seja, só existe uma instancia em execução. Por fim não podemos deixa de lembrar que a Metaclasse é um Objeto, sendo um Objeto ele vem de uma classe, que é a classe “Class”, e tem atributos e métodos como qualquer Objeto. Vejamos:

Notem que no Objeto(metaclasse) que representa a Classe “Teste” não tem o método “falar”, isso porque ele não e da classe “Teste” e sim da classe “Class” e tem o métodos da sua classe. Mais o Objeto(metaclasse) guarda em si alguns métodos legais, como o método “new”.

Em algums linguagens de programação a criação de uma instacia de um objeto é feito pelo interpretador, já em Ruby a criação de uma instacia de um Objeto é feita pela sua Metaclasse, isso é ser Orientado a Objetos.

Bem classicamente o método “new” lê a documentação, ou seja a “Classe” e cria um Objeto com seus atributos em memória. Essa ação é realizada pelo método “new”. Sendo um método é possivel mudar seu comportamento, pensemos algo como.

• Primeiro abrir uma conexao com o Banco de dados
• Ir em uma tabela e coletar o nome de suas colunas
• depois criar um Objeto que tenha seus atributos representando essas colunas
• criar também todos os métodos de persistencia para essas informações no bando

Ficou mais legal assim o método “new”! heheh!

Olha que legal, em Ruby por a Metaclasse ser responsável pelo criação de Objetos, a Metaclasse tem em si um método “new”, sendo um método eu posso sobrescreve-lo e mudar seu comportamento natural, e colocar mais aqueles passos no método “new”, assim eu posso automatimente criar um Objeto que seja um modelo de Dados persistente em Banco de dados. legal isso. Acho que voces ja viram essa idéia no Activerecord do RubyonRails. Talvez voce esteja falando, poxa como é facil, aquela mágica todo é so isso!

Porém o Poder a Metaclasse vai muito além disso, vejamos outro exemplo classico e muito poderoso:

Vamos pensar em atributos. Para que seus atributos sejam Encapsulas corretametne é necessário que se tenha os métodos acessores. Métodos acessores, como o nome ja diz são os métodos que dão acesso ao atributo, os famosos métodos gets e sets, sempre chatos! Bem para criarmos um atributo e seus acessore a classe ficaria assim:

Bem assim é que se faz encapsulamento de atributos, é sempre a mesma coisa e sempre chata, agora pense em um objeto que tem vários atributos para cada atributo seus métodos acessores, isso é um tormento e não melhora em nada o código, pois sempre é meiro do mesmo jeito.

Deixando a chatisse dos métodos acessore de lado, e lembrando que nós temos uma Objeto(metaclasse) que faz as coisas para mim, porque não criarmos um método na Objeto(metaclasse) que escreva os métodos acessores para mim. Poxa isso seria mágico eu passaria a chatisse para o Objeto(metaclasse) fazer. Isso ja foi feito e é usado assim:

Existe o método “attr_acessor” escreve o Atributo e seus métodos acessores, este método é do Objeto(metaclasse).

Como existe o método “attr_accessor” existem vários outro metodos que nso ajuda a diminuir a aquntidade de código durante a programação. O mais legal de tudo é que voce pode escrever seus próprio métodos de ajuda, sei lá, alguma rotina que voce esteja reescrevendo, ou algo que de para automatizar é legal esse recurso, lembrabdo de nao esquecer do conseito DRY.

Bem acho que este artigo ta ficando muito cansativo e longo, vamos continuar vendo em outro artigo!

No proximo artigo veremos como colocar funcionalidades na Metaclass.

E onde fica os métodos dos objetos na metaclasse, e adicionar novos metodos de instancia,

Espero que estejam gostando do assunto, valeu!!

Hoje falaremos sobre Tipos, Numeros, Strings, Array

Antes de começarmos a falar propriamente da linguagem ruby, vamos pensar um pouco sobre algumas caracterí­sticas de outras linguagens de programaçío. No fundo de qualquer linguagem de programaçío o objetivo é disponibilizar uma sintaxe e semantia que sejam capaz de escrever a soluçío de um problema que seja finito e bem delineado. Porém existem várias complicações nesse meio, ou seja, imagine qual seria a atribuição verdadeira de uma linguagem, podemos pensar de várias formas, mais vamos aos extremos:

Uma Linguagem tem que ser:

Uma Linguagem tem que ser completa, com todas as funções possiveis prontas, tem que ser rigida e formal o suficiente para que não leve o programador a errar, tem que ser formal o suficiente que transforme o ato de programar algo previsí­vel e desenhavel como um processo de engenharia, onde antes de começar a ato de programar seja possí­vel prever o resultado com grande garantia.

Bem essa seria a linguagem ideal, porém vamos aos detalhes. Uma linguagem que tenha todas as funções possiveis prontas e ja disponí­veis seria ótimo pois ja teria tudo a mío durante a programação, porem o aprendizado de várias funções prontas seria mais demorado e complexo tornando mais dificil o aprendizado do linguagem. Uma linguagem que seja formal o suficiente para não deixar o programador errar torna o resultado mais previsí­vel, porém, torna o processo de programar algo mecanico e mata a possibilidade de criar metodos novos de resolvel algum problema de uma maneira diferente limitando a capacidade dos programadores. Tornar o processo de programar algo como um processo puramente de engenharia seria o ideal pois tornaria os software mais previsí­veis, porém o ato de programar e um ato de arte não de pura matemática, sendo onde deve ser bem dosado o que será arte e o que será planejamento e previsão.

Ou uma linguagem deve ser simples, só com as funcionalidades indispesáveis, com alto poder de explansão, tem que ser totalmente flexivél e adaptavél para que libere a criatividade do programador, deve ser dinamica o suficiente para que o software seja algo perfeito e nada previsí­vel.

Bem essa também seria a linguagem ideal porém vamos as detalhes: Uma liguagem simples que só contenhas funçoes básicas seria muito simples de aprender, porem a toda nova necessidade seria necessário que seja escrito, onde tornar o ato de programar totalmente artí­stico em nada previsí­vel torna o software mais sucessí­vel a erros e falhas.

Bem isso são alguns pontos que são interessantes serem lembrados antes de começarmos a falar em ruby, pois ruby é uma linguagem que tende mais a segunda opção acima não tão extrema, mais algo perto. A linguagem ruby foi feita por um programador e visa a satisfação do programador, ela também e altamente expansí­vel e adaptavel, e dinamica e simples.

Bem Vamos a Ruby!

TIPOS

Bem, em ruby nao tem tipos! não da maneira que se tem em java, como primitivos, ou seja, numeros, caracteres, booleanos.

Em Ruby tudo é objeto, e sendo assim:

1 - é um Objeto da classe Fixnum

1231231.654645 - é um objeto da classe Float

“a” - é um objeto da classe String

true - é um objeto da classe TrueClass

false - é um objeto da classe FlaseClass

Sabendo que objetos tem métodos, quas sío os métodos de um Fixnum ou do 1

irb(main):007:0> 1.methods

["%", "inspect", "<<", "singleton_method_added", "&", "clone", ">>", "round", "method", "public_methods", "instance_variable_defined?", "divmod", "equal?", "freeze", "integer?", "chr", "*", "+", "to_i", "methods", "respond_to?", "-", "upto", "between?", "prec", "truncate", "/", "dup", "instance_variables", "__id__", "modulo", "succ", "|", "eql?", "object_id", "zero?", "~", "id", "to_f", "singleton_methods", "send", "prec_i", "taint", "step", "to_int", "frozen?", "instance_variable_get", "^", "__send__", "instance_of?", "remainder", "to_a", "+@", "nonzero?", "-@", "type", "**", "floor", "<", "protected_methods", "<=>", "instance_eval", "display", "==", "prec_f", "quo", ">", "===", "downto", "id2name", "size", "instance_variable_set", "kind_of?", "abs", "extend", ">=", "next", "to_s", "<=", "coerce", "hash", "ceil", "class", "tainted?", "=~", "private_methods", "div", "nil?", "untaint", "times", "to_sym", "[]“, “is_a?”]

Notem que o Objeto 1 tem todos os metodos necessários para ser auto-suficiente, ou seja, o objeto 1 é capas de se somar, subtrair, multiplicar, dividir e muitas outras ações usando os métodos. Legal isso sendo assim a linguagem ruby não tem nada a ver com soma, isso e responsabilidade dos objetos.

Bem parece que a linguagem ruby realmente e bem simples, ela nao faz quase nada, nem mesmo operações matemáticas básicas. Então o quela realmetne faz.

Bem uma coisa interessante da linguagem ruby e o “sintax sugar”, e como e chamado alguns recursos de ajuda ao programador, coisas que tornam algo complicado de ser lido ou escrito em açucar sintatico para o programdor.

Olhem esse exemplor - a = 10 + 20

Bem para se chamar um método de um objeto escreve-se assim “Objeto.Metodo”

Então ja que em Ruby o 10 e um Objeto Fixnum e + é um metodo do objeto ficaria ssim:

a.=(10.+(20))

ai entra o sintax sugar em açao e deixa voce escrever assim:

a = 10 + 20

Isso nao mudou nada o 10 continua sendo objeto e + um metodo do objeto 10, porem a sintaxe ficou açucarada e bem mais legí­vel, legal isso.

A função de sintax sugar é muito usada em ruby, sempre que ruby puder tornar as coisas mais legí­ves e simples ele as tornará.

Funções avançadas em numeros

Voltando as números, talvez voce tenha notado que apesar de a Classe Fixnum ter bastantes métodos ela nao contem métodos muito avançados de matemática, isso fica a cargo de um módulo chamado Math

Raiz Quadrada de 25 ficaria assim em ruby

Math.sqrt(25)

Metodos do módulo Math

["inspect", "cos", "log10", "private_class_method", "const_missing", "clone", "method", "public_methods", "atan", "public_instance_methods", "instance_variable_defined?", "erf", "method_defined?", "equal?", "freeze", "included_modules", "const_get", "asinh", "methods", "respond_to?", "sin", "module_eval", "class_variables", "sqrt", "dup", "protected_instance_methods", "cosh", "instance_variables", "public_method_defined?", "erfc", "__id__", "eql?", "object_id", "const_set", "atanh", "id", "singleton_methods", "tan", "send", "frexp", "class_eval", "taint", "frozen?", "instance_variable_get", "sinh", "include?", "private_instance_methods", "__send__", "instance_of?", "private_method_defined?", "to_a", "name", "exp", "autoload", "type", "<", "protected_methods", "instance_eval", "<=>", "acos", "display", "==", ">", "ldexp", "===", "instance_method", "instance_variable_set", "tanh", "kind_of?", "extend", "protected_method_defined?", "const_defined?", ">=", "ancestors", "atan2", "to_s", "<=", "public_class_method", "log", "hash", "class", "tainted?", "instance_methods", "asin", "=~", "private_methods", "class_variable_defined?", "hypot", "nil?", "untaint", "constants", "acosh", "is_a?", "autoload?"]

Conversão de numeros

Felizmente a classes Numericas possuem métodos de conversão, ficando assim:

1.to_i - Converte para inteiro

1.to_s - Converte para String

1.to_f - Converte para Float

1.chr - Converte na tabela Ascii

Tem muito mais conversoes possí­vel que voce pode ver na documentaçío

STRING

Bem agora vamos falr um pouco sobre String

String é uma cadeia de Caracteres, em ruby não, String é um objeto da Classe String.

“Ola eu sou uma String” ou ‘Ola eu sou uma String’

A diferença entre scrings com Aspas dupla e Simples e que Strings com Aspas duplas aceita caractere de formatação, tipo quebra de linha e outros.

Vamos dar uma olhada nos métodos diponí­veis em Strings

“Ola eu sou uma String”.methods

["%", "select", "[]=”, “inspect”, “<<”, “each_byte”, “clone”, “method”, “gsub”, “casecmp”, “public_methods”, “to_str”, “partition”, “tr_s”, “empty?”, “instance_variable_defined?”, “tr!”, “equal?”, “freeze”, “rstrip”, “*”, “match”, “grep”, “chomp!”, “+”, “next!”, “swapcase”, “ljust”, “to_i”, “swapcase!”, “methods”, “respond_to?”, “upto”, “between?”, “reject”, “sum”, “hex”, “dup”, “insert”, “reverse!”, “chop”, “instance_variables”, “delete”, “dump”, “__id__”, “tr_s!”, “concat”, “member?”, “object_id”, “succ”, “find”, “eql?”, “each_with_index”, “strip!”, “id”, “rjust”, “to_f”, “singleton_methods”, “send”, “index”, “collect”, “oct”, “all?”, “slice”, “taint”, “length”, “entries”, “chomp”, “frozen?”, “instance_variable_get”, “upcase”, “sub!”, “squeeze”, “include?”, “__send__”, “instance_of?”, “upcase!”, “crypt”, “delete!”, “detect”, “unpack”, “to_a”, “zip”, “lstrip!”, “type”, “center”, “<”, “protected_methods”, “instance_eval”, “map”, “<=>”, “rindex”, “display”, “any?”, “==”, “>”, “split”, “===”, “strip”, “size”, “sort”, “instance_variable_set”, “gsub!”, “count”, “succ!”, “downcase”, “min”, “kind_of?”, “extend”, “squeeze!”, “downcase!”, “intern”, “>=”, “next”, “find_all”, “to_s”, “<=”, “each_line”, “each”, “rstrip!”, “class”, “slice!”, “hash”, “sub”, “tainted?”, “private_methods”, “replace”, “inject”, “=~”, “tr”, “reverse”, “nil?”, “untaint”, “sort_by”, “lstrip”, “to_sym”, “capitalize”, “max”, “chop!”, “is_a?”, “capitalize!”, “scan”, “[]“]

Com certeza uma das atribuiçoes mais importantes de uma linguagem de programaçao e manipular bem strings ou textos, e ruby com certeza da conta do recado, trabalhar com String e ruby e buito facil e produtivo.

Manipulaçío de String

a = “bom” => “bom”

a * 3 => “bombombom”

a + ” dia” => “Bom Dia”

a << ” Hacker” => “Bom dia Hacker”, a diference de + e << e que o + gera um novo objeto e o << adiciona no memo objeto.

a.upcase => “BOM DIA HACKER”

a.downcase => “bom dia hacker”

a.capitalize => “Bom dia hacker”

Percorrendo e Alterando uma String

a = “Estudando Ruby” => “Estudando Ruby”
a[0] = “e” => “estudando Ruby”

a[10] => 82, codigo da tabela ascii

a.delete(”R”) => “estudando uby”

a.insert(9,”R”) => “estudando Ruby”

a.reverse => “ybuR odnadutse”

Bem temos em ruby uma maneira simples de concatenar textos

Exite a notaçío “#{}”

Imagine escrever o texto assim

a = “nome do usuario”

“Bom dia”+ a => “Bom dia nome do usuario”

“Bom dia #{a}” => “Bom dia nome do usuario”

Tem muito mais coisas legais sobre String, mais veremos mais adiante em outro artigo.

ARRAY

Agora vamos ver um pouco sobre Array

Array é um capitulo aparte em Ruby, aqui e que ruby mostra seus diferenciais e torna tudo mais interessante, algo que com certeza voce vai se beneficiar.

a = [] => Cria um array vazio

a = [1,2,3,4,5] => cria e ja popula uma array

Vamos dar uma olha nos methos da classe array

a.methods

["select", "[]=”, “inspect”, “<<”, “compact”, “&”, “clone”, “last”, “method”, “public_methods”, “partition”, “delete_if”, “empty?”, “instance_variable_defined?”, “equal?”, “freeze”, “each_index”, “*”, “grep”, “sort!”, “assoc”, “+”, “to_ary”, “methods”, “respond_to?”, “-”, “reject”, “insert”, “reverse!”, “dup”, “push”, “delete”, “instance_variables”, “concat”, “member?”, “__id__”, “|”, “find”, “eql?”, “pack”, “join”, “reverse_each”, “object_id”, “each_with_index”, “collect!”, “rassoc”, “id”, “at”, “compact!”, “singleton_methods”, “index”, “collect”, “send”, “all?”, “reject!”, “flatten”, “slice”, “taint”, “length”, “entries”, “pop”, “instance_variable_get”, “frozen?”, “transpose”, “include?”, “__send__”, “instance_of?”, “detect”, “to_a”, “indexes”, “zip”, “map!”, “uniq”, “type”, “fetch”, “protected_methods”, “instance_eval”, “map”, “<=>”, “values_at”, “rindex”, “display”, “any?”, “==”, “===”, “shift”, “size”, “sort”, “instance_variable_set”, “clear”, “min”, “kind_of?”, “extend”, “find_all”, “to_s”, “indices”, “each”, “class”, “flatten!”, “slice!”, “hash”, “first”, “tainted?”, “replace”, “inject”, “=~”, “private_methods”, “delete_at”, “reverse”, “nitems”, “nil?”, “untaint”, “sort_by”, “unshift”, “max”, “fill”, “is_a?”, “[]“, “uniq!”]

Algumas funções básicas sobre arrays

a = Array.new ou a=[]

a << “Joaquim” => ["Joaquim"]

a.insert(1,”Silva”) => ["Joaquim","Silva"]

a.first => “Joaquim”

a.last => “Silva”

a.empty? => false

Bem na verdade a classe array tem muitos métodos, e com certeza tem um que supre sua necessidades, vamos ver um pouco sobre interação com array.

a = [4,5,6,7,8,9,10]

a.each {|i| puts i} => 4,5,6,7,8,9,10

Bem existem várias variaçoes de interadores em array, mais acredito que ainda falaremos muito sobre esse assunto, que certamente sera aborado em outros temas, sendo assuim, ficamos por aqui!

Depois continuamos, valeu!

• Classes
• Atributos
• Metodos

Na construção de uma Classe, observamos:

• Herança
• Abstração
• Encapsulamento
• Polimorfismo

E por fim tudo Acaba em Objeto.

Ou seja, Objetos são Instancias de Classes que forma construídas observado Heranças, Encapsulamento, Polimorfismo e abstração.

Bem! Voce pode estar se perguntando, isso eu ja sabia! Porem vale apena lembrar antes de entrarmos no assunto, pois em alguns momentos esses conseitos serão importantes para esclarecer dúvidas sobre as várias implementações do Paradigma.

Para entendermos melhor vamos analizar a função seguir:

a = 10 + 20

Vamos Ver o que é cada um dos membros dessa função.

“a” - é uma variável

“=” - é um operador

“10″ - é um número

“+” - é um operador

“20″ - é um número

Na primeira olhada na funçao podemos identificar facilmente as partes que a compoem. E bem claro que a função e composta de variáveis, operadores e números.

Bem voltemos então as bases da Orientação a Objetos(no começo do artigo), procure por variáveis, operadores e números. Isso mesmo não existe variáveis, operadores e números, na Orientação a Objetos sã existem, Objetos compostos de atributos e metodos.

Vamos rever a função, agora Orientado a Objetos

a = 10 + 20

“a” - é um objeto

“=” - é um método do objeto “a”

“10″ - é um objeto

“+” - é um método do objeto “10″

“20″ - é um objeto

Poderia ser escrito assim:

a.=(10.+(20))

Ou seja, tudo em uma linguagem Orientada a Objetos são objetos.

É assim que Ruby implementa a Orientação a Objetos, tudo que é manipulado em um Programa segue a seguinte ordem, Palavra Reservada, Objeto ou Método, não existe nada além disso.

Isso simplifica muito o aprendizado da linguagem, pois aprendendo as palavras reservadas, o resto é tudo objetos, e quando voce precisa fazer alguma coisa com um objeto basta chamar seus métodos e pronto, simples assim.

Vejamos um exemplo de um objeto em ruby

“eu sou um objeto”

Voce deve estar olhando e vendo que isso é uma String, isso mesmo, e também e um objeto, e tem um monte de métodos

Vamos fazer o texto ficar todo em maiúsculo

“eu sou um objeto”.upcase

“EU SOU UM OBJETO”

Notem, nós chamamos o métodos “upcase” diretamente na String. O Objeto é auto-suficiente, contém todos os métodos pertinentes a sí, isso é muito importante, pois libera a linguagem dessas obrigações.

Vejamos os numeros

10

Isso também é um objeto e tem seus métodos por exemplo, o + é um métodos do objeto 10.

10.+(20)

ou 10 + 20

Um pouco mais de filosofia sobre Orientação a Objetos!

Bem voce deve estar pensando, “bem se o + e um método do objeto 10, eu poderia sobrescreve-lo, e fazer o + realizar qualquer coisa!”, Sim isso mesmo voce pode sobrescrever qualquer método e modifica-lo de acordo com suas necessidade.

Ficaria assim:

class MeuNumero < Fixnum
def +(numero)
42
end
end

numero = MeuNumero.new(1)
# Repare como um operador de soma é um método em ruby, ao contrário de outras linguagens
puts numero+2 # 1+2 = 42 ??? Sim, sobrescrevemos o método de soma para retornar 42 sempre.

Bem mais isso não e perigoso, imagine um método que chama + e que realiza uma divisao, poderia confundir o programador. Isso é verdade, porém da muita flexibilidade, e deixa tudo Orientado a Objetos.

Muitas linguagens como o Java deixam os operadores dentro da prãpria linguagem e nao como um método do objeto numero, e os númentos também são primitivos e não objetos, com isso se diminui a possibilidade de uso errado das coisas, porém deixa a linguagem muito suja e complexa, pois nao sabe quando deve-se chamar um método ou quando deve-se chamar uma função da linguagem, e também deixa o conseito de Orientação a Objetos errado, por isso que java é PseudoOrientada a Objetos, em alguns pontos ela e totalmente procedural, ou seja:

a = 10 + 20

Isso é totalmente procedural pois:

“10″ - é um número(primitivo)

“+” - é uma função da linguagem java

“20″ - é um número(primitivo)

Essa função em java não é nada orientado a objeto.

Bem essa era a parte filosãfoca do nosso artigo, mais era importante saber e relembrar as bases do Conseito de Orientação a Objetos, pois serão muito úteis no aprendizado da linguagem Ruby.

No proximo artigo veremos mais a fundo na Linguagem Ruby.

Bem antes de falar dos interpretadores de Ruby, vamos falar um pouco sobre interpretadores. Na verdade era interessante deixar bem claro a diferença entre anbiente de execução e instruções executadas.

O que é Ruby, na verdade Ruby é o nome que se dá ao conjuto de Interpretador e Linguagem que o interpretador reconhece, ou seja, o Linguagem Ruby é reconhecida pelo Interpretador Ruby.

Bem nem sempre foi assim, a muitos e muito tempo (hehe to brincando), os programas eram compilados, ou seja escrevia-se o código fonte e depois o código era convertido para linguagem de máquina (binarios) e executado diretamente pelo processador, nunca mais necessitando ser lido o código fonte. É assim que a linguagem C faz usando o Compilador GCC. Ou seja Tem a Linguagem C e o Compilador que entende a Linguagem C.

Voltemos a Ruby, no mundo Ruby é um pouco diferente. A diferença logo de cara é que o Codigo Ruby não é Compilado para Binários e sim Interpretado durante a Execução. Fica mais ou menos assim, quando executamos um programa Ruby, primeiramente chamamos um programa que reconhece as instruçoes Ruby (o interpretador ruby), este programa lê as instruções e executa durante a solicitação. O legal é que o Interpretador sempre precisa de ler o código fonte para executar a instrução. O legal disso é:

Primeiro! Seu código pode ser rodado em qualquer ambiente. Basta que haja um interpretador Ruby no ambiente, tails como Linux, Windows, Unix, BSD, etc.

Segundo! Ao Interpretar o codigo pode ser otimizado excessivamente para ser mais rápido e mais eficiente.

Bem mais não acaba ai, linguagens orientadas a objetos tem um grande desafio em uso de memória. Notem que quando se instancia um Objeto ele e repleto de Atributos e isso consome muita memória, porem, também torna as variaveis bem mais regenciaveis, pois elas sempre dependem de um objeto. Bem para resolver este problemas existe um outro programa que auxilia o Sistema Operacional a gerenciar a memória, ele tem por objetivo remover objetos não usados da memória e liberar espaço para outros objetos. Este programa tem o nome de Coletor de Lixo.

Ja notamos que a coisa ta ficando cada vez mais interessante. Então vamos falar dos interpretadores de Ruby.

MRI - Matz Ruby Interpreter

Como o Próprio nome ja diz é o interpretador que o Matz fez, ele é o primeiro Interpretador Ruby, é lindo em sua forma, porém não é o mais otimizado, talvez porque o Matz não buscasse o que o java buscava, em ser o melhor, mais seguro e mais rápido de todos. O que significa isso, um programa ruby executado pelo interpretador MRI, é bem mais lento que um programa Java ou um programa Smalltalk, quem, porém isso não é necessariamente um grande problema, pois com a facilidade de programação que a linguagem proporciona, é possivel otimizar código tornando a aplicação em si mais rápida idependente do interpretador.

YARV - MRI1.9

Este é o grande esforço da comunidade Ruby para melhorar o MRI, ele tem por objetivo resolver alguns problemas conseituais do MRI e aumentar sua performance, porém isso nao está sendo tão simples assim, por mais interessantes que venham se mostrando os testes a velocidade em si não tem melhorado muito, isto é normal, em alguns casos a otimização de um interpretador leva vários anos para encontrar algo performático e seguro.

Rubinius

Este com certeza é o mais elegante e promissor de todos. A idéia do Rubinius é fazer um interpretador de Ruby escrito em Ruby. Como? O jeito é fazer os elementos essenciais em C, e depois o restante todo em ruby puro. É como construir uma ferrovia, os primeiros trilhos usaśe um caminhão pra llevar, quando cabe a locomotiva, ja usa-se a prórpia ferrovia apra levar os proximos trilhos. Qual é a grande vantagem de se escrever um interpretador de Ruby em Ruby, a grande sacada é que escrever em Ruby é muito fácil e rápido, em quanto um interpretador de Ruby em C precisa de 10 mil linha um Escrito em Ruby precisa de 1 mil, e enquanto em um Interpretador escrito em C voce precisa mudar 1000 linhas pra melhorar algo em Ruby voce precisa mudar apesa 10, isso tornaria a evolução do Rubinius algo vertiginoso e inesperado. Porém o inicio ainda é muito lento e singular, talvez ainda demore um pouco para chegar ao estado perfeito da arte.

Bem além disso a idéia do Rubinius é ser um Maquina Virtual, a diferença entre ser uma VM ou somente um Interpretador é que é necessário implementar no interpretador todas as rotinas que o sistema Operacional disponibiliza diretamente ao sistema, ou seja, ao inves de vc pedir ao SO para ler um arquivo, pedesse a MV que por sua vez pede a Sistema Operacional, isso torna a Sua Aplicação bem mais portavel, pois dependendo do Sistema Operacional ele disponibiliza diferentes recusos, e é possivel vc estar usando algum recusrso que nao esteja disponível em todos SO, um exemplo classico é a gerador de imagens MAGIC, que é escrito em C e é possivel usar no MRI, porém nem todos os SO tem o MAGIC instalado e disponível. Voltando uma VM é muito mais capaz de resolver tudo que seu programa pede sem depender o Sistema Operacional, isso torna seu Programa mais portavel.

Além disso tem algo muito legal que aconteceu durante o desenvolvimento do Rubinius. A idéia de compatibilidade, o Rubinius priorizou testes automatizados em seu desenvolvimento, com isso usando os mesmos testes que o Rubinius fez é possivel avaliar a compatibilidade de vários interpretadores, ous eja, é dizer que um MRI 1.8 é compativel com MRI1.9 e compativel com RUbinius, etc. Isso da mais tranquilidade pois é possivel saber se um codigo escrito em Ruby sera bem interpretado por qualquer Interpretador Ruby.

JRUBY

Talvez essa seja a melhor opção hoje para interpretar código Ruby. O que é JRuby? JRuby é um esforço da comunidade e da propria SUM em possibilitar que o interpretador java reconheça código Ruby. A pergunta que nao quer calar! Porque a SUM deseja que o código ruby seja interpretador pela JVM? É porque a Linguagem Ruby é muito melhor que a linguagem Java, eheh, bem não é so por isso, a linguagem Ruby implementa muito bem outros paradigmas que a linguagem Java não é capaz, tais como meta programação, desenvolviemnto ágil, etc..

E o que Ruby ganha com isso? Toda a maturidade, velocidade, segurança da JVM. Sem falar que para a JVM chegasse a ser o que é hoje, formam investidos milhares de milhares dolares e tempo, e quando se executa seu programa Ruby sobre essa estrutura voce automaticamente se beneficia disso.

Outra vantagem é ser Enterprise, bem esse conseito inútil é muito respeitado belas grandes empresas, onde ter uma aplicação em uma linguagem conhecida é muito mais aceitavel que ter uma aplicação melhor em uma linguagem pouco conhecida, quando voce tem um programa Ruby sendo executado sobre a JVM, o programa normalmente é mais aceito. Sem falar que a maioria das empresas que exigem coisas Enterprise não sabem nada sobre tecnologia e seguem o fluxo de todas as outras, e ter a SUM dizendo que acredita em Ruby ja as deixa mais calmas e conformadas, eu sei que isso não é nenhum parametro tecnico mais é muito usado no mundo doente dos Enterprise.

O bom efeito colateral em usar JRuby é a possibilidade de usar toda as Bibliotecas, APIs, escritas em Java em seus programas Ruby, isso é legal até certo ponto, porém em alguns casos reduz a curva de resistencia em se usar uma nova linguagem, onde os programadores Java podem continuar usando sua bibliotecas Java em vez de ter que reescreve-las em Ruby, bem só o futuro dirá se isso é realmente uma boa idéias, eu escrevi um outro artigo falando sobre isso deem uma lida. Da Vinci Machine Project!

IronRuby

A idéia do IronRuby é fazer que o interpretador .NET da Microsoft reconheça código Ruby, este projeto também é mantido pela comunidade e própria Microsoft. Bem por mais estranho que pareça este projeto deveria ser bem melhor que o projeto JRuby, levando em conta que a VM .NET da Microsoft é bem mais preparada para executar linguagem dinamicas como Ruby. Porém é um projeto apagado e sem muitas grandes novidades, talvez pela antipatica que a comunidade retem pela Microsoft. Existem outras coisas, o projeto .NET é proprietário, fechado bem ao estilo Micro$oft, porém existe um outro projeto que é o Mono que nada mais é que a implementação da VM .NET em software livre, e o IronRuby é capaz de rodar também sobre Mono, mais mesmo assim a projeto IronRUby não decolou ainda, mais eu acredito bastante que seja viavél talvez não seja a melhor opção hoje mais no futuro pode se tornar algo interessante

MagLev

Uma estrela cadente! Talves essa seja a melhor imagem para descrever o Maglev. A idéia do Maglev e fazer o Interpretador GemsStone de Smalltalk reconhecer código Ruby. Essa idéia veio de Avi Bryant, o cara é muito bom. Tudo começou em um tempo em que a comunidade Ruby vinha sofrendo com a frase “Rails não escala”, e Avi Bryant disse, “Eu vim do futuro e sei como isso acaba”. Após isso ele me aparece na RubyConf com nada mais nada menos que a Maglev, puxou o Datashow e rodou alguns códigos Ruby sobre a GemStone, o que mais assuntou é que a Maglev chegou a ser 60 vezes mais rápida que o MRI, e algumas grandezas mais rápida que o JRuby. Isso criou um clima estranho, pois centenas de programadores estavam se dedicando em fazer o Jruby que é 2 ou 3 vezes mais rápido que MRI, ou Rubinus que é algumas vezes mais lento que o MRI.

Bem o mais legal é que Smalltalk e uma linguagem dinamica como Ruby, entao um interpretador de Smalltalk e quase a mesma coisa que um interpretador de Ruby, isso torna as coisas muito mais simples de serem feitas, diferente de Jruby que tem que fazer uma JVM interpretar código dinamico, que é muito dificil, a GemStone foi facilmente adaptada para rodar código Ruby com a mesma eficiencia que roda código SmallTalk.

O ruim de tudo isso é que a GemStone é um VM proprietária e tem custo para usa-la, e nao tem o código fonte aberto, tal como o MRI, JVM, Rubinus. Isso me preocupa, mais voltando ao pensamento Interprise pode ser uma solução viável apra alguma empresas.

Bem mais nem tudo são flores, o Avi Bryant, foi mostro o Maglev na RubyConf e depois sumiu, eu venho buscando mais coisas sobre Maglev e nao veja nada na comunidade, talvez seja esse o plano deles ser bombático sempre, mais isso deixa a gente sem rumo, ou pode ser que o projeto ta meio parado mesmo, bem vamos vem.

Este são os projetos mais conhecidos de Interpretadores e VM Ruby. Como o Ruby é OpenSource quanquer pessoa pode pegar o MRI e fazer algumas modificações, sendo assim pode existir vários outros projetos ai que eu não conheço, mais acredito que esses sejam os mais relevantes. Depois a gente fala mais sobre VM, para deixar mais claro as diferenças e caracteristicas de cada VM Ruby tais como Rubinius, Jruby, IronRuby, Maglev.

Valeu!!!

Da Vinci

A Proxima Grande Revolução da Informática!

De Tempos em Tempos acontecem algumas coisas que mudam o mundo de maneira tão grande que é impossível tentar prever as coisas depois da mudança, e também após a mudança fica dificil lembrar como viviamos sem ela. Bem são essas mudanças que mudam o rumo de nossas vidas e torna o mundo diferente.

Talvez voce esteja se perguntando, do que o IsaacGuerra ta falando! Que mudança é essa?

Revolução da Tecnologia

Sim eu vejo um projeto que pode mudar o modo em que programamos e tratamos a programação!

Só o simples pensamento de que a maioria das coisas que fazemos pode ser bem mais fácil, que  tudo que criamos pode ser mais acessível, ja cria em mim um anseio e uma esperança que me faz ter curiosidade e um pouco de medo do futuro.

Bem vamos falar de programação!! de Código que é o que interessa!

Hoje com certeza vivemos uma mudança interessante mais muito timida da forma que programamos, com o aparecimento de linguagens mais gostosas como Ruby, Smalltalk, Phyton, etc.. Porém, como o Fabio King sempre diz, nao existe a linguagem completa que resolve tudo que agrega em si a solução total para todos os problemas e isso.

É isso que eu busco em uma liguagem, algo que eu possa nao escrer tudo em uma boa linguagem e sim que eu possa usar a linguagem certa na hora certa, onde tudo que eu fizer seja cambiavel entre elas, sem nenhum transtorno. Neste sentido eu busqui muito, hoje eu acedito que possamos fazer muita coisa em muitas linguagens legais, tais como C, C#, PHP, JAVA, RUBY, PHYTON, PERL, LISP, SMALLTALK, JAVASCRIPT, etc.. Em si toda linguagem faz alguma coisa de bom, agrega em amlgum ponto algo memorável e que ajuda o programador fazer algo.

Porem por mais que eu tenha procurado uma linguagem que faça tudo da melhor maneira ainda nao encontrei. Bem mais foi quando eu vi algumas coisas acontecerem meio timidas e elas foram se encaixando e mostrando que este sonho, o sonho de poder juntar tudo varias linguagens em uam só, nde seis Conponentes, APIs, Bibliotecas sejam cambiaves. Bem eu esperava a linguagem completa mais nao é isso que vai ser.

A Algum tempo a SUM a mantenedora do JAVA abriu o fonte de sua maquina virtual, isso nao foi bombastico nem muita novidade, porém, de alguma forma esse movimento esta mudando o mundo. Na verdade o JAVA e um conjunto de tecnologia sendo RunTime, SDK e linguagem, onde a pior parte de tudo isso com certeza e a linguagem, porém a Maquina Virtual ja tem mais de dez anos e muitos bilhoes de dolares de grandes empresas investidos em otimiza-la, com isso criu-se um ambiente seguro e confiável. Bem mais onde entra e revolução.

Notem que a JVM ja e Multiplataforma agora o grande esforço é que ela seja multilinguagem, onde todas linguagens de ante mao ganham o poder de serem multiplatafor, ganham também o poder e as otimizações do Ambiente Java, e por fim o melhor onde as APIs e bibliotecas ja escritas podem ser consumidas por qualquer Linguagem. Bem isso é legal e dizer que eu posso a partir do Phyton acessar um recurso escrito em Java, bem isso e legal, mais o mais legal e que algo escrito em Ruby seja acessivel em Java, e assim por diante, ou seja todos os recursos escritos habitarem um ambente comum e ser acessível por qualquer linguagem, com isso todo esforço será reusado.

Isso e diser que suas bibliotecas escritas hoje possam ser usadas nas proximas linguagens que vc quiser usar, e entendender que seu programa pode ser escrito por várias linguagens onde cada linguagem faça o que tem de melhor e por fim o seu sistema seja melhor.

Bem esse projeto ja existe e se chama “Da Vinci Machine Project”.

Uma linguagem que foi extremamente importante para o inicio do projeto Da Vinci foi Ruby com o JRuby, onde é possivel rodar aplicações Ruby sobre a VM Java, e mais legal e poder usar todas as bibliotecas escrita em Java em Ruby, bem é interessante também para equipes multidisciplinares, com a possibilidade de escrita em várias linguagens não obriga a equipe escrever tudo na mesma linguagem. Bem eu vou continuar esse assumto com mais dados tecnicos, falando mais sobre HotSpot, JIT, GC, etc.

Valeu!!!