O que é Ruby on Rails

Ruby on Rails é um framework livre que promete aumentar velocidade e facilidade no desenvolvimento de sites orientados a banco de dados (database-driven web sites), uma vez que é possível criar aplicações com base em estruturas pré-definidas. Frequentemente referenciado como Rails ou RoR, o Ruby on Rails é um projeto de código aberto escrito na linguagem de programação Ruby. As aplicações criadas utilizando o framework Rails são desenvolvidas com base no padrão de arquitetura MVC (Model-View-Controller).

O Rails é um "meta-framework" (ou seja, um framework de frameworks), composto pelos seguintes frameworks:

• O Active Record é uma camada de mapeamento objeto-relacional (object-relational mapping layer), responsável pela interoperabilidade entre a aplicação e o banco de dados e pela abstração dos dados;
• Compreende o Action View (geração de visualização de usuário, como HTML, XML, JavaScript, entre outros) e o Action Controller (controle de fluxo de negócio);
• O Action Mailer é um framework responsável pelo serviço de entrega e até mesmo de recebimento de e-mails. É relativamente pequeno e simples, porém poderoso e capaz de realizar diversas operações apenas com chamadas de entrega de correspondência;
• Active Support é uma coleção de várias classes úteis e extensões de bibliotecas padrões, que foram considerados úteis para aplicações em Ruby on Rails;
• Action Web Service provê uma maneira de publicar APIs interoperaveis com o Rails, sem a necessidade de perder tempo dentro de especificações de protocolo. Implementa WSDL e SOAP. O Action Web Service não estará mais presente na versão 2.0 no Rails, visto que o mesmo está voltando-se para a utilização do modelo REST. Mesmo assim, aos ainda interessados em utilizá-lo, será possível fazê-lo através da instalação de um plugin.

Ruby on Rails segue dois conceitos que visam aumentar a produtividade do desenvolvedor: DRY e Convention over Configuration. Estes métodos estão implementados por todo oRails, mas podem ser mais notados nos "pacotes" do Active Record (ORM, Object Relational Mapper) e Action Pack (MVC).

O DRY (Don't Repeat Yourself, Não se repita) é o conceito por trás da técnica de definir nomes, propriedades e códigos em somente um lugar e reaproveitar essas informações em outros.

Por exemplo, ao invés de ter uma tabela Pessoas e uma classe Pessoa, com uma propriedade, um método "leitor" (getter) e um "modificador" (setter) para cada campo na tabela, tem-se apenas no banco de dados. As propriedades e métodos necessários são "injetados" na classe através de funcionalidades da linguagem Ruby.

Com isso, economiza-se tempo, já que não é necessário alterar a tabela, o "bean", o "form bean", o "local home", o "home", o "session", ... Alterando apenas no banco de dados, tudo o que se baseia nessas informações é atualizado automaticamente.

Na maioria dos casos, usamos convenções no dia-a-dia da programação, em geral para facilitar o entendimento e manutenção por parte de outros desenvolvedores. Sabendo disso, e sabendo que o tempo gasto para configurar XML em alguns frameworks de outras linguagens é extremamente alto, decidiu-se adotar esse conceito.

Ele diz basicamente que deve-se assumir valores padrão onde existe uma convenção. Se o desenvolvedor quiser, pode-se sobrescrever essa convenção com o valor necessário. Por exemplo, uma classe User pode ter seus dados armazenados na tabela Customer. Seguindo a convenção, seria na tabela Users. Com isso, o tempo de desenvolvimento cai ainda mais.

A maioria dos sites não necessita de esquemas sofisticados de escalabilidade, bastando alguns aceleradores. Em sites menores ou normais, uma configuração padrão do servidor web consegue suportar uma boa quantidade de carga, principalmente se forem usados o FastCGI, LightTPD ou Mongrel, que são necessários para obter uma velocidade aceitável de abertura da página. Comparando uma aplicação com FastCGI e sem FastCGI (rodando Ruby direto como CGI), a diferença é perceptível em qualquer aplicação. O processamento do código (sem contar o tempo de download) em CGI ocorre em no mínimo 10 segundos mesmo em servidores Quad Core, enquanto que em FastCGI o desempenho é notável: em no máximo 1 segundo a página é processada, tal qual linguagens web como PHP.

Existem casos de sites feitos em Rails que suportaram 5 milhões de visitas em um mês, ou seja, aproximadamente 115 por minuto, uma performance considerada suficiente para 90% das aplicações atuais. Nestes sites, uma questão frequente é sobre a escalabilidade de aplicações escritas em Rails. Ao contrário de outras tecnologias, você não precisa fazer um código específico para que o sistema esteja preparado para "escalar". Quando necessário pode-se adotar uma das táticas disponíveis para escalabilidade em Rails. Vale notar que o único problema da escalabilidade é a manutenção de sessões entre servidores. Portanto, a saída mais óbvia é guardar estas sessões em volumes NFS, acessíveis por todos os servidores de aplicação. Outra tática é usar o armazenamento de sessões diretamente no banco de dados. Uma terceira, seria salvar a sessão em um cookie na máquina do usuário.

FONTE: WIKIPEDIA

Ruby: Orientação a objetos em detalhes

Olá, pessoal! 

De fato, a linguagem ganhou bastante destaque no cenário mundial graças ao framework Ruby on Rails, e por esse mesmo motivo percebo que a grande maioria dos desenvolvedores iniciam o aprendizado sobre Rails e Ruby ao mesmo tempo. Com isso, alguns pontos importantes da linguagem são “aprendidos” de forma secundária, sem um entendimento mais aprofundado sobre como as coisas realmente funcionam.

Por esse motivo, vou iniciar a série falando sobre Orientação a Objetos em Ruby. Não vamos, aqui, abordar o paradigma de Orientação a Objetos em si, mas sim algumas particularidades da linguagem.

Nesse contexto, uma das frases mais famosas é: “Em Ruby tudo é objeto”.

Mas o que isso realmente significa?

Significa que até mesmo uma classe é um objeto. Nesse caso, uma classe é um objeto da classe Class. O principal para entendermos essa afirmação está relacionado com o fato de que Ruby é uma linguagem interpretada e as definições de nossos programas são literalmente executadas. Logo, quando definimos uma classe, estamos na verdade criando uma instância da classe Class e, com isso, para entendermos de forma mais clara o funcionamento do modelo de objetos em Ruby, é necessário pensarmos em função dos objetos, e não das classes.

Um exemplo: podemos definir uma simples classe em Ruby da seguinte forma:

class Person
end
p = Person.new

Quando esse código for interpretado, um objeto do tipo Class será criado e associado com uma constante global, que no caso é “Person”.

Vejam que pelo simples fato de escrevermos class Person end já estaremos criando um objeto. Quando fazemos Person.new, estamos criando um objeto Person, e o método new do objeto Class é executado por padrão.

Uma outra frase famosa: “Ruby é uma linguagem 100% orientada a objetos”.

Isso quer dizer que, diferentemente da maioria das linguagens, não temos construções como number = Math.abs(number), onde um método separado é chamado. Esse é um código Java onde o static method abs da classe Math é chamado para poder calcular o valor absoluto do número passado como
parâmetro.

Em Ruby, a responsabilidade de determinar o valor absoluto de um número pertence aos próprios números. Logo, podemos ter algo como: number = number.abs. Nesse caso, podemos dizer que estamos enviando a mensagem “abs” para o objeto number.

Uma nova frase famosa: “Em Ruby as classes são abertas”.

Isso significa que, ao contrário da maioria das outras linguagens de programação, podemos “injetar” códigos para modificar qualquer classe. Pelo dinamismo da linguagem, isso acontece em tempo de execução, e essa é uma das funcionalidades que mais tornam a linguagem poderosa. Não só podemos injetar códigos, mas também modificar comportamentos.

Vamos a um exemplo prático. Iremos definir uma classe com apenas um método e logo abaixo iremos acrescentar um novo.

class Animal
  def speak
    puts "speaking..."
  end
end

class Animal
  def walk
    puts "walking..."
  end
end

No segundo trecho, é como se nós estivéssemos “abrindo” a classe Animal e injetando um novo método.

class Animal
  def speak
    puts "Speaking"
  end
end

def walk
  puts "Walking"
end

Animal.send(:public, :walk)

No caso acima, utilizar o “send” permite-nos criar objetos da classe Animal que respondem à mensagem “walk”.

Uma dúvida que talvez possa surgir: o que o método walk está fazendo “perdido” no exemplo acima? Na realidade ele não está “perdido”. Ele já está dentro de um objeto chamado main, que no caso é uma instância da classe Object.

Continuando os exemplos de “classes abertas”, em um dos exemplos acima foi citado que em uma instrução do tipo Person.new, o método new do objeto Class é executado por padrão. Se Class é um objeto da classe Class, podemos “abri-la” e também alterar seu respectivo funcionamento.

Vejam um exemplo:

class Class
alias oldNew new
def new(*args)
print "Creating a new ", self.name, "\n"
oldNew(*args)
end
end

class Name
end

n = Name.new #Creating a new Name

Nesse trecho de código, primeiramente “abrimos” a classe Class e criamos um alias (apelido) para o método new. Agora ele se chama oldNew. Tecnicamente falando, o método de classe alias cria um novo método e o aponta para a implementação do método antigo.

Em seguida, definimos o “nosso” método new e inserimos um simples print, indicando que estamos criando um novo objeto. Por último, realizamos a chamada do “verdadeiro” método new passando os mesmos argumentos, para que ele possa alocar espaço para o objeto.

Com isso é como se estivéssemos “sobrescrevendo” o método new.

Quando a instrução n = Name.new for executada, deveremos ver a mensagem “creating a new Name” sendo exibida.

Relembrando que tudo é objeto.

Para finalizar, vamos verificar uma simples atribuição do tipo.

number = 7 + 3  

Algumas pessoas se assustam ao saber que nesse caso o = (igual) na verdade é um método. Nesse exemplo da atribuição acontece o seguinte:

1. O + (mais) é um método do objeto 7, e este é uma instância da classe Fixnum.
2. 3 também é uma instância da classe Fixnum e é passada como parâmetro para o método + (mais)
3. O resultado (que é uma instância da classe Fixnum) é atribuído para o objeto “number”.

Vamos a um outro exemplo mais detalhado.

Vejamos esta instrução:

Person.name = "My new name!" 

Aparentemente estamos acessando o atributo “name” da classe Person e atribuindo um novo valor. Correto?

Não. A classe Person possui este método(name=) que permite atualizar o valor. Ruby irá interpretar a chamada da seguinte forma:

Person.nome=("My new name!") 

Percebam que na verdade o método se chama name= e recebe como parâmetro uma String como o novo nome. Logo, em Ruby não é possível acessar diretamente os atributos de uma classe.

Em meu próximo artigo irei abordar outras peculiaridades da linguagem para que em breve possamos falar de um assunto bastante discutido na comunidade Ruby: Metaprogramação!

Até a próxima!

FONTE: iMasters