
RVM es una herramienta de linea de comandos (principalmente linux) que permite instalar y gestionar fácilmente múltiples versiones de Ruby al mismo tiempo y distintas listas de gems.

Para instalarlo antes debemos instalar la aplicación CURL si aun no la tenemos:

```bash
sudo apt-get install curl
```

Curl servirá para descargar la última versión de rvm con el siguiente comando:

```bash
curl -sSL https://get.rvm.io | bash -s stable
```

Luego ejecutamos:

```bash
source /home/myuser/.rvm/scripts/rvm
```

Para ver que funciona correctamente escribimos:

```bash
rvm use
```

Y deberíamos ver el texto: `Now using system ruby.`

- Atención: Al abrir una nueva consola, es posible que al usar rvm use nos aparezca el siguiente texto:

```
RVM is not a function, selecting rubies with 'rvm use ...' will not work.
You need to change your terminal emulator preferences to allow login shell. Sometimes it is required to use \`/bin/bash --login\` as the command. Please visit https://rvm.io/integration/gnome-terminal/ for an example.
```

Para solucionarlo podemos editar el archivo .bashrc en nuestra carpeta home, /home/miusuario/.bashrc y añadir la instrucción al final del archivo:

```bash
source /home/myuser/.rvm/scripts/rvm
```

## Instalando versiones de Ruby

Ahora que a hemos instalado RVM ya podemos proceder a instalar diferentes versiones de Ruby. Para ver las versiones disponibles de Ruby podemos ejecutar la instrucción:

```bash
rvm list known
```

Podemos instalar una versión concreta, pero si queremos instalar la última versión estable ejecutamos:

```bash
rvm install ruby-head
```

Esto tardará un poco porque descargará y compilara la versión seleccioanda y sus dependencias.

Una vez terminada la instalación de Ruby, podemos ejecutar:

```bash
rvm list
```

Y nos aparecerá la versión instalada. Ahora crearemos una lista de Gems:

```bash
rvm gemset create myGemsList
```

Con este comando veremos que se ha creado correctamente nuestra lista de gems

```bash
rvm gemset list
```

Si nos fijamos la lista que hemos creado no está seleccionada por defecto. Para ello podemos usar

```bash
rvm gemset use myGemsList
```

Ahora podemos instalar las gems que queramos con la instrucción `gem install ...`

## Usar una versión de Ruby y un gemset por defecto al entrar a un directorio

Normalmente, como para cada proyecto usaremos una versión de ruby y una lista de gems concreta, nos interesará que al entrar al directorio automáticamente pasemos a usar esas configuraciones.

Para ello ejecutaremos el comando:

```bash
rvm --ruby-version use ruby-head@myGemsList
```

Se crearán dos archivos .ruby-gemset y .ruby-version con la información de las versiones a usar de modo que si cerramos la consola y volvemos a acceder al directorio, veremos que ya se están usando las versiones especificadas:

```bash
rvm list
rvm gemset list
```


Cómo gestionar distintas versiones de Ruby y listas de gems

Ruby Version Manager (RVM)

ruby-version-manager-rvm


En este artículo veremos cómo instalar todas las aplicaciones necesarias para montar un servidor en un entorno de producción para aplicaciones Ruby on Rails.

## Instalar Git

Git es un sistema de control de versiones. Aunque sus posibilidades son muchas y altamente recomendado para utilizarlo en aplicaciones Ruby on Rails, en este manual sólo lo requerimos como dependecia para poder instalar RVM.

```bash
yum install git-core
```

## Instalar RVM

Para instalar RVM podemos seguir el siguiente artículo: [Ruby Version Manager (RVM)](http://www.webtutoriales.com/articulos/ruby-version-manager-rvm)

## Instalar Ruby 1.9.2

Ahora con RVM ya podemos instalar Ruby (tardará un poco). Instalaremos la versión 1.9.2, pero lo bueno de RVM es que más adelante puedes instalar cualquier versión.

```bash
rvm install 1.9.2 rvm install 1.8.7 ...
```

Para especificarle qué versión usar y ponerla por defecto:

```bash
rvm use 1.9.2 ruby -v rvm --default use 1.9.2
```

## Instalar Ruby on Rails

Tan sólo hay que hacer:

```bash
gem install rails --no-ri --no-rdoc
```

¿Fácil, no?. El parámetro --no-ri y --no-rdoc sirve para no instalar la documentación. Al ser entorno de producción no la necesitamos.

A tener en cuenta que estamos instalando las gems en el gemset por defecto dentro de la versión en que nos encontramos. Podemos crear varios gemsets, e incluso exportarlos e importarlos.

```bash
rvm gemset list
```

Nos muestra los grupos de gems disponibles y el que estamos usando.

## Instalar Passenger

Passenger es un módulo para Apache y Nginx para poder ejecutar las aplicaciones Rails. Es mucho más sencillo hacer deploys que antes cuando se utilizaban instancias de Mongrels.

```bash
gem install passenger --no-ri --no-rdoc
```

Ahora ejecutaremos el instalador de passenger para el servidor web Apache.

```bash
passenger-install-apache2-module
```

Es un assistente de instalación excepcionalmente completo y te guía sobre las dependencias y problemas que puede haber y como solucionarse. Con los paquetes instalados anteriormente apenas tendremos problemas.

Ejemplo de nuestra instalación:

```bash
\* GNU C++ compiler... found at /usr/bin/g++ \* Curl development headers with SSL support... found \* OpenSSL development headers... found \* Zlib development headers... found \* Ruby development headers... found \* OpenSSL support for Ruby... found \* RubyGems... found \* Rake... found at /usr/local/rvm/wrappers/ruby-1.9.2-p180/rake \* rack... found \* Apache 2... found at /usr/sbin/httpd \* Apache 2 development headers... not found \* Apache Portable Runtime (APR) development headers... not found \* Apache Portable Runtime Utility (APU) development headers... not found
```

En nuestro caso faltaban algunas dependencias, que el mismo manual nos dice cómo instalarlas, por ejemplo: (Fijaros bien en vuestro caso, ya que pueden variar)

```bash
yum install httpd-devel yum install apr-devel yum install apr-util-devel
```

Una vez instaladas se puede volver a llamar al assistente de instalación de Passenger

```bash
passenger-install-apache2-module
```

Finalmente, hay que abrir el archivo de configuración de apache **httpd.conf** y añadir estas líneas:

```
LoadModule passenger_module /usr/local/rvm/gems/ruby-1.9.2-p180/gems/passenger-3.0.5/ext/apache2/mod_passenger.so PassengerRoot /usr/local/rvm/gems/ruby-1.9.2-p180/gems/passenger-3.0.5 PassengerRuby /usr/local/rvm/wrappers/ruby-1.9.2-p180/ruby
```

Reiniciamos Apache:

```bash
/etc/init.d/httpd restart
```

## Realizar deploy

Ejemplo de cómo hacer un deploy (subir la web) a producción de una aplicación Ruby on Rails. Si tenemos la aplicacion en /applications/nuestra_aplicacion_rails, añadiremos un virtual host en el archivo de configuración de Apache (normalmente en /etc/httpd/conf/httpd.conf) parecido a este:

ServerName www.tudominio.com DocumentRoot /applications/nuestra_aplicacion_rails/public # Ruta de vuestra aplicación rails, aseguraos de apuntar a la carpeta 'public'! AllowOverride all Options -MultiViews

## Configurar los Virtual Hosts de Plesk

Si no se utiliza plesk se puede obviar este paso. Con plesk la configuración del virtual host debemos ponerla en un archivo distinto (en vez de en el archivo de configuración de apache anterior). Normalmente se encuentra en:

```bash
vi /var/www/vhosts/tudominio.com/conf/vhosts.conf
```

Añadiendo:

```
ServerAlias \*.tudominio.com ServerName www.tudominio.com DocumentRoot /applications/nuestra_aplicacion_rails/public AllowOverride all Options -MultiViews
```

Y ejecutamos esto para que al regenerar la configuración del plesk se mantenga:

```bash
/opt/psa/admin/bin/websrvmng --reconfigure-vhost --vhost-name=tudominio.com -a -v
```

## Probando una aplicación

Podemos hacer una aplicación de prueba antes de subir la definitiva:

```bash
mkdir /applications/
cd /applications
rails new nuestra_aplicacion_rails
```

Si todo ha funcionado accedemos a nuestro dominio y veremos la página inicial de una aplicación rails!

## Problemas habituales

Uno de los problemas habituales tiene que ver con los permisos y los usuarios asignados a las carpetas. Habitualmente no se usa el usuario root en las carpetas de las aplicaciones. Una buena idea es usar el mismo usuario de apache o crear uno nuevo con permisos adecuados para poder escribir y leer en los directorios de las aplicaciones.


Preparar un entorno de producción para hacer deploys de aplicaciones Ruby on Rails

Instalar GIT, RVM, Ruby, Ruby on Rails y Passenger

instalar-git-rvm-ruby-ruby-on-rails-y-passenger


A continuación mostraré algunos trucos y consejos varios de más utilidad cuando se trabaja desde la consola en el desarrollo de aplicaciones web con Ruby on Rails.

Para abrir la consola a partir de **Rails 3** podemos ejecutar el comando:

```bash
rails console
```

o script/console en versiones anteriores.

## Método map/collect

Una de las mejores características de Ruby es cómo trata a las colecciones de objetos y lo fácil que es manipularlas.

La instrucción map y collect tienen la misma funcionalidad: A partir de una colección de datos devuelven un nuevo array con los datos manipulados.

Además, gracias a la navegabilidad que nos ofrece ActiveRecords para obtener información relacionada de distintos modelos, podemos obtener resultados asombrosos rápidamente. Véamos un ejemplo.

Si tenemos una colección de Posts:

```ruby
Post.all
=> [#Post id: 125, title: "Título de este post"...,
#Post id: 4501, title: "Otro título"...,
#Post id: 5410, title: "Ruby on rails"...,
#Post id: 10105, title: "Ejemplo de título"...]
```

Para obtener sólo los ids, podemos ejecutar:

```ruby
Post.all.map(&:id)
=> [125, 4501, 5410, 10105]
```

Si queremos ver los títulos:

```ruby
Post.all.map(&:title)
=> ["Título de este post", "Otro título", "Ruby on rails", "Ejemplo de titulo"]
```

Si deseamos obtener más información de un objeto en concreto podemos hacerlo del siguiente modo:

```ruby
Post.all.map{|i| puts i.user.name}
```

Mostrará el nombre de cada usuario que ha escrito un mensaje.

## Select

El método select es también muy importante. Podemos seleccionar sólo los elementos de una colección que cumplan cierta condición:

```ruby
Post.all.map{|i| i.user.name}.select{|i| i.eql?("Lorena")}
```

De la colección de nombres de usuarios devolverá la que tenga de nombre "Lorena"

## Benchmark en tiempo real

Rails trae un conjunto de herramientas para hacer pruebas de benchmarking de la aplicación, pero si desde la consola queremos realizar una prueba rápida podemos utilizar el método realtime de la clase Benchmark, por ejemplo:

```ruby
foo =""; puts Benchmark.realtime {1000.times{
foo += "eeeeeeee"}
}
=> 0.00336003303527832

> > foo =""; puts Benchmark.realtime {1000.times{
> > foo << "eeeeeeee"}
> > }
> > => 0.000760078430175781
```

En este caso vemos que utilizar la instrucción << es mucho más rápido que +=.

## Acceder al último valor ejecutado

Una forma rápida de guardar el contenido ejecutado en la instrucción anterior desde la consola es utilizar el símbolo '_'.

```ruby
"cadena de texto"
=> "cadena de texto"
var = _
puts var
cadena de texto
```

## Mostrar las consultas SQL en la consola

Para ver las consultas SQL que se ejecutan al utilizar los modelos ActiveRecord, podemos ejecutar esta instrucción en la misma consola en "Rails 3":

```ruby
ActiveRecord::Base.logger = Logger.new(STDOUT)
```


Consejos y funcionalidades más útiles en la consola de Ruby on Rails

Usando la consola de Ruby on Rails

usando-la-consola-de-ruby-on-rails


Para paginar resultados en Ruby on Rails podemos usar el plugin o gem **Will_paginate**.

El uso de este plugin es muy sencillo y nos permite paginar cualquier colección de elementos obtenidos de un modelo.

## Instalación de la gem WILL_PAGINATE

Para instalar la gem podemos usar el siguiente comando

```bash
sudo gem install will_paginate
```

Si queremos usar el plugin en vez de la gem podemos descargar el código desde [github](http://github.com/mislav/will_paginate)

## Controlador

En el controlador es donde debemos definir los parámetros de paginación y los elementos que queremos paginar. En **Rails 3** podemos definirlo de la siguiente forma:

```ruby
@comments = Comment
  .where(:condicion_ejemplo => 1)
  .order("created_at DESC")
  .paginate(:page => params[:page]), :per_page => 10)
```

En versiones anteriores de Rails podemos usar la instrucción find() en vez de where().

## Vista

En la vista donde queramos colocar el paginador podemos usar el siguiente comando, pasándole por parámetro la colección de objetos paginados.

```
<%= will_paginate(@comentarios) %>
```


Paginación de una colección de objetos con will_paginate

Paginación en Ruby on Rails

paginacion-en-ruby-on-rails


La mejor forma de generar urls amigables y leíbles en Ruby on Rails es utilizando el método **parameterize**.

Este método reemplaza caracteres especiales en una cadena de texto y se usa de la forma siguiente:

```ruby
"El veloz murciélago hindú comía feliz cardillo y kiwi".parameterize
```

El resultado sería:

```
el-veloz-murcielago-hindu-comia-feliz-cardillo-y-kiwi
```

Así de sencillo.

## Transliteraciones

Sin embargo, si deseamos hacer una url amigable a partir de caracteres Unicode como los usados por el alfabeto Chino, Ruso, etc el método parameterize no sería útil. Existen gems que nos lo ponen igual de fácil. Por ejemplo la [Unidecode gem](http://rubyforge.org/projects/unidecode/)


Urls amigables en Ruby on Rails

urls-amigables-en-ruby-on-rails


En muchos lenguajes de programación existen excepciones. Las excepciones sirven para controlar varios tipos de errores que pueden suceder durante la execución de un programa. Cuando ocurre el error, con las excepciones se puede capturar para tratarlo en vez de terminar el programa por completo.

En Ruby on Rails, el tratamiento de excepciones se encapsula entre cláusulas **begin** y **end** de la siguiente forma:

```ruby
begin # codigo...
  rescue TIPO_EXCEPCION_1
  STDERR.puts "Ha ocurrido un problema de tipo 1"
  rescue TIPO_EXCEPCION_2
  STDERR.puts "Ha ocurrido un problema de tipo 2"
  else
  STDERR.puts "Ha ocurrido otro problema"
  ensure # se ejecuta siempre haya o no excepción
end
```

## Tipos de excepciones

A continuación mostramos los tipos de excepciones de Ruby:

- Exception
  - fatal
  - NoMemoryError
  - ScriptError
    - LoadError
    - NotImplementedError
    - SyntaxError
  - SignalException
    - Interrupt
  - StandardError
    - ArgumentError
    - IOError
      - EOFError
    - IndexError
    - LocalJumpError
    - NameError
      - NoMethodError
    - RangeError
      - FloatDomainError
    - RegexpError
    - RuntimeError
    - SecurityError
    - SystemCallError
      - _Errorno::___ (ENOENT, etc.) (system-dependent)
    - ThreadError
    - TypeError
    - ZeroDivisionError
  - SystemExit
  - SystemStackError

## Alzar excepciones

Podemos lanzar excepciones propias usando la palabra raise:

```ruby
def metodo_que_lanza_excepcion
  raise "error 1"
end
```

metodo_que_lanza_excepcion rescue puts $!

El código anterior definimos un método y luego fuera de este método definimos qué pasará cuando se lanze la excepción. En este ejemplo imprimimos con el comando puts el mensaje que se passa por parámetro: "error 1"


Declaración y captura de excepciones en Ruby

Tratamiento de excepciones en Ruby

tratamiento-de-excepciones-en-ruby


## Clases y objetos

Una clase es una definición de un objeto que contiene atributos a los que representa y métodos que puede ejecutar. En Ruby una clase se define de la siguiente forma:

```ruby
class Coche
    def initialize(color, puertas)
        @color = color
        @puertas = puertas
    end
end
```

El método initialize es un método especial de Ruby que se utiliza como constructor cada vez que se crea una nueva instancia del objeto.

En Ruby todas las classes deben empezar con letra mayúscula.

## Public, private, protected

Los métodos de una clase por defecto, y si no se indica lo contrario, son públicos. Además de público, un método puede ser protected o private.

Para determinar de qué tipo es basta con añadir la palabra clave private al principio de los métodos privados por ejemplo:

```ruby
class coche
    def abrirPuertas
    end

    def cerrarPuertas
    end

    private
    	def abrirGuantera
    	end
    end
end
```

La palabra clave protected se usa de la misma forma que private con la diferencia que un si una clase hereda el método también puede usarla como si fuera público, mientras que si se llama desde el exterior se comporta como un método privado.

## Herencia

Otra de las particularidades de cualquier lenguaje orientado a objetos es sin duda la herencia. En Ruby se define la herencia de la siguiente manera:

```ruby
class Vehiculo
    def initialize()
    end
end

class Coche < Vehiculo
end
```

La clase coche hereda todos los métodos públicos o protegidos de vehículo.

Al igual que Java por ejemplo, Ruby tampoco soporta la herencia múltiple, es decir, una clase sólo puede heredar de otra clase y no de varias.

## Poliformismo

El poliformismo sirve para dar genericidad a un método de una clase. Por ejemplo: Supongamos que tenemos dos tipos de objetos un triangulo y un círculo que heredan la clase forma. La clase forma tiene un método que se llama devolverPerimetro

```ruby
class Forma
    def devolverPerimetro()
    end
end

class Circulo < Forma
    def devolverPerimetro()
    ...
    end

end

class Triangulo < Forma
    def devolverPerimetro()
    ...
    end

end
```

Está claro que no se calcula de la misma forma el perímetro de un círculo que el de un triangulo, por ello cada objeto lo definirá de una forma distinta.

El poliformismo nos da la posibilidad de que si tenemos un objeto forma pero no sabemos si es triangulo o circulo, podamos llamar al método devolverPerimetro y nos devolverá el perímetro correcto.


Introducción a Ruby y a la programación orientada a objetos

Ruby. Programación orientada a objetos

ruby-programacion-orientada-a-objetos


Ruby es un lenguaje interpretado orientado a objetos creado por Yukihiro Matsumoto. Lo creó basándose en otros lenguajes como perl y python en referencia sobretodo a la sintaxis y también en smalltalk por su orientación a objetos.

Una de las mejores cualidades de este lenguaje es su sencillez para leerlo.

En Ruby, todos los tipos de datos son considerados objetos, incluso lo que otros lenguajes como Java consideran tipos primitivos (enteros, booleanos, NULL, etc). Además, es importante saber que Ruby no necesita definir de qué tipo es una variable antes de inicializarla.

A continuación se muestran ejemplos básicos de programación como la sintaxis de las variables, las estructuras de control y algunas particularidades más que utiliza Ruby.

## Ejemplos de sintaxis

Veamos la sintaxis para crear un método. En este ejemplo se le pasa una cadena de texto por parámetro y se devuelve otra cadena de texto modificada.

```ruby
def mifuncion(texto)
  cadena = texto + " y adiós."
  return cadena
end

puts mifuncion("Hola")
```

La función **puts** imprime por pantalla el resultado del método llamado.

Para ejecutar el código basta guardar el código en un archivo llamado, por ejemplo, hola.rb y desde la línea de comandos ejecutar:

```bash
ruby hola.rb
```

## Diferencia entre métodos que acaban en ? o !

A veces nos interesará saber si un atributo o variable está definida. Podemos usar la expressión:

```ruby
atributo.nil?
```

Que devolverá cierto o falso según si está definida o no.

En cambio si una variable está seguida de el símbolo !, indica que se modifica el contenido de la variable. Mientras que si no lo lleva devuelve una copia modificada del contenido de la variable.

## Variables

Hay diferentes tipos de variables: Las locales, las globales y las de instancia de un objeto.

Una variable local es una variable como la usada en el ejemplo anterior llamada "cadena".

Las variables globales son las que se pueden acceder desde cualquier sitio y se escriben con el símbolo $ delante.

Las variables para instanciar un objeto se escriben con una arroba @ delante:

```ruby
@coche = Coche.new
```

Y para acceder a cualquier atributo de un objeto:

```ruby
@coche.color = "verde"
```

## Estructuras de control

Las estructuras de control que más usaremos son la condicional **if** y el **while**.

```ruby
dinero = 40

if dinero < 10
  puts "Tienes menos de 10"
elsif dinero > 10
  puts "Tienes mas de 10"
else
  puts "Tienes 10"
end
```

El bucle while se escribe de la siguiente forma:

```ruby
total = 10
while total>0
  puts total
  total -= 1
end
```

## Arrays y Hashes

Ruby permite crear estructuras de datos de tipo Array y de tipo Hash. Un array tiene como índice un entero mientras que un hash tiene como índice una cadena de texto.

Un ejemplo de array y como se recorre con un iterador:

```ruby
muebles = ['Silla', 'Mesa', 'Armario']
  muebles.each do |m|
  puts "#{m}"
end
```

Ahora un ejemplo de hash y como se recorre con un iterador:

```ruby
muebles = {
  :silla => 'salón',
  :mesa => 'salón,'
  :armario => 'dormitorio'
}

muebles.each_with_index do |m,i|
  puts "indice: #{i} contenido:#{m}"
end
```

También es posible recorrer un array pasando por todos los indices numéricos con un for

```ruby
muebles = ['Silla', 'Mesa', 'Armario']
for i in 0..muebles.length
  puts muebles[i]
end
```

Tenemos así una gran variedad de formas de recorrer las estructuras de datos.


Introducción básica a la sintaxis del lenguaje interpretado Ruby

Introducción a Ruby

introduccion-a-ruby


Para instalar la _framework_ **Ruby on Rails** en Windows primero debemos instalar Ruby. Recomiendo que visitéis esta página para descargar la [última versión](http://rubyforge.org/frs/?group_id=167&release_id=6163) (el ejecutable .exe versión estable.)

El instalador es sencillo le vamos dando a siguiente. Cuando nos pregunte qué componentes queremos instalar los seleccionamos todos. Luego nos pide la ruta dónde queremos intalar el software.

Uno de los componentes instalados se llama RubyGems. Es un componente que permite descargar e instalar aplicaciones de internet mediante un simple comando que nosotros le entremos. Lo usaremos para descargar e instalar Rails.

Desde la linea de comandos de Windows (Inicio>Ejecutar>cmd) escribiremos el siguiente comando:

```bash
gem install rails --include-dependencies
```

Puede tardar unos minutos porque primero se descargará y luego se instalará Rails.

Ahora para comprobar que se ha instalado con éxito podemos crear la area de trabajo para una aplicación propia. Escribiremos en la linea de comandos:

```bash
rails hola_mundo
```

Este comando creará una aplicación llamada **hola_mundo** y veremos en la consola que crea muchos otros archivos. Estos archivos son parte de la _framework_. Y se crearán en la carpeta desde donde ejecutemos éste comando.

Ahora entramos en el directorio hola_mundo que se ha creado y escribimos este comando:

```bash
rails server
```

Ahora ya tenemos un servidor listo para trabajar con Rails. En el puerto 3000: **http://localhost:3000** deberías ver una página con el mensaje de bienvenida.


Instala Ruby on Rails bajo entornos Windows

Cómo instalar Ruby on Rails en Windows

como-instalar-ruby-on-rails-en-windows


Ruby on Rails (también conocido por RoR) es una area de trabajo (framework) pensada para trabajar con el lenguaje de programación Ruby.

Ruby es un lenguaje orientado a objetos relativamente nuevo (creado en 1995 por Yukihiro Matsumoto con sintaxis parecida a Perl y con notables características de Smalltalk), que ha ganado popularidad últimamente gracias a Rails por la facilidad y rapidez en la creación de robustas aplicaciones web.

Uno de los principales objetivos de RoR es la reutilización de código para no perder tiempo programando algo que ya está creado. Además, la framework también está pensada para que trabajar con bases de datos SQL sea de lo más sencillo. Sin embargo, es importante conocer las convenciones de programación que existen en Rails por ejemplo: el nombre de las tablas de las bases de datos. Rails recomienda nombrar las tablas con el nombre de la clase que la representa en plural y en minúsculas (la clase 'Forum' si tuviera una tabla se debería llamar 'forums'). Como este hay varios convenios más que a simple vista parecen inútiles pero luego permiten ahorrar una cantidad de tiempo impresionante cuando luego queramos hacer la documentación o editar código, etc.

Rails sigue el paradigma de programación MVC (Modelo Vista Controlador). MVC es un patrón de arquitectura del software que separa los datos, la lógica, y la interfaz del usuario en distintas capas.

- **Modelo**: Es la representación del dominio de la información conocida también por capa de dominio.
- **Vista**: Es la capa de presentación: la interfaz del usuario.
- **Controlador**: Es la capa que se encarga de interactuar con las capas anteriores. Responde a eventos del usuario y provoca cambios en la capa de dominio y en la capa de presentación.

En próximos tutoriales mostraremos cómo instalar Ruby on Rails en nuestro servidor.


Ruby on Rails es una framework para crear robustas aplicaciones web con una rapidez asombrosa