Gerardo Ortega - Blog

Desplegando Ruby on Rails en VPS (Unicorn + Nginx + Capistrano) con Ubuntu Server

2014-02-09T15:14:00.000-06:00

Hoy abordaremos como desplegar una aplicación hecha en Ruby on Rails en un VPS. En mi caso usando Digital Ocean como proveedor. Comencemos:

Primero accedemos vía SSH a nuestro servidor, si aún no a has configurado y asegurado el acceso SSH a tu VPS puedes visitar un post donde explico como hacerlo. Si ya tienes todo listo entonces procedemos.

Configuraciones en el Servidor

 ssh -p numero-de-puerto nombre-de-usuario@123.123.123.123

Si no lo hemos hecho aún, actualizamos los paquetes e instalamos curl

sudo apt-get update
sudo apt-get install curl

Instalamos la última versión estable de la RVM (Ruby Version Manager)

curl -L get.rvm.io | bash -s stable

Cargamos la RVM

source ~/.rvm/scripts/rvm

Instalamos las dependencias de la RVM

rvm requirements

Instalamos Ruby 2.0.0 (o bien podemos instalar la 2.1.0)

rvm install 2.0.0

Usamos la version 2.0.0 por defecto en RVM

rvm use 2.0.0 --default

Intalamos la última versión de rubygems en caso que RVM no la tenga aún

rvm rubygems current

Instalamos la gema de Rails, junto a Git, Bundler y NodeJS (necesario para las compilaciones de assets)

gem install rails --no-ri --no-rdoc
sudo apt-get install git-core
gem install bundler

**En caso que necesitemos instalar una versión especifica de Rails y no la más reciente (lo cual es lo recomendado) podemos hacerlo indicando que versión queremos.

gem install rails -v 3.2.14

Instalamos nuestro motor de base de datos, yo uso y recomiendo PostgreSQL, así que los siguientes pasos serán para instalarlo y configurarlo con Rails.

sudo apt-get install postgresql postgresql-server-dev-9.1
gem install pg -- --with-pg-config=/usr/bin/pg_config

Creamos un nuevo usuario en postgres (cambiar los campos correspondientes)

sudo -u postgres psql
create user nuevo-usuario with password 'contrasenia';
alter role nuevo-usuario superuser createrole createdb replication;
create database nombre_del_proyecto_production owner nuevo-usuario;

Instalamos Nginx

sudo apt-get install nginx
nginx -h
cat /etc/init.d/nginx
/etc/init.d/nginx -h
sudo service nginx start
cd /etc/nginx

Configuración Local

Comenzamos agregando Unicorn al Gemfile

gem 'unicorn'

Ahora creamos los siguientes archivos en el directorio /config * unicorn.rb * unicorn_init.sh * nginx.conf
Una vez creada, asignamos permisos de ejecución a unicorn_init.sh

chmod +x config/unicorn_init.sh

Agregamos la configuración de Nginx el archivo que hemos creado en el directorio /conf llamado nginx.conf (cambia nombre_de_proyecto y nombre_de_usuario con tus datos, el nombre del proyecto correspondería al nombre que le hayas asignado a tu aplicación de rails y el nombre de usuario es con el que accedes al servidor y por ende tiene asignado un directorio en la carpeta /home/nombre_de_usuario...)

upstream unicorn {
  server unix:/tmp/unicorn.nombre_de_proyecto.sock fail_timeout=0;
}

server {
  listen 80 default_server deferred;
  # server_name example.com;
  root /home/nombre_de_usuario/apps/nombre_de_proyecto/current/public;

  location ^~ /assets/ {
    gzip_static on;
    expires max;
    add_header Cache-Control public;
  }

  try_files $uri/index.html $uri @unicorn;
  location @unicorn {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;
    proxy_pass http://unicorn;
  }

  error_page 500 502 503 504 /500.html;
  client_max_body_size 20M;
  keepalive_timeout 10;
}

Ahora editamos el archivo conf/unicorn.rb (recuerda cambiar nombre_de_proyecto y nombre_de_usuario conforme a tus datos). También puedes editar el número de workers que deseas que tenga tu aplicación, de momento solo he incluido dos.

root = "/home/nombre_de_usuario/apps/nombre_de_proyecto/current"
working_directory root
pid "#{root}/tmp/pids/unicorn.pid"
stderr_path "#{root}/log/unicorn.log"
stdout_path "#{root}/log/unicorn.log"

listen "/tmp/unicorn.nombre_de_protecto.sock"
worker_processes 2
timeout 30

# Force the bundler gemfile environment variable to
# reference the capistrano "current" symlink
before_exec do |_|
  ENV["BUNDLE_GEMFILE"] = File.join(root, 'Gemfile')
end

Editamos el archivo config/unicorn_init.sh (nuevamente recuerda cambiar el nombre_de_usuario y nombre_de_proyecto)

#!/bin/sh
### BEGIN INIT INFO
# Provides:          unicorn
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Manage unicorn server
# Description:       Start, stop, restart unicorn server for a specific application.
### END INIT INFO
set -e

# Feel free to change any of the following variables for your app:
TIMEOUT=${TIMEOUT-60}
APP_ROOT=/home/nombre_de_usuario/apps/nombre_de_proyecto/current
PID=$APP_ROOT/tmp/pids/unicorn.pid
CMD="cd $APP_ROOT; bundle exec unicorn -D -c $APP_ROOT/config/unicorn.rb -E production"
AS_USER=nombre_de_usuario
set -u

OLD_PIN="$PID.oldbin"

sig () {
  test -s "$PID" && kill -$1 `cat $PID`
}

oldsig () {
  test -s $OLD_PIN && kill -$1 `cat $OLD_PIN`
}

run () {
  if [ "$(id -un)" = "$AS_USER" ]; then
    eval $1
  else
    su -c "$1" - $AS_USER
  fi
}

case "$1" in
start)
  sig 0 && echo >&2 "Already running" && exit 0
  run "$CMD"
  ;;
stop)
  sig QUIT && exit 0
  echo >&2 "Not running"
  ;;
force-stop)
  sig TERM && exit 0
  echo >&2 "Not running"
  ;;
restart|reload)
  sig HUP && echo reloaded OK && exit 0
  echo >&2 "Couldn't reload, starting '$CMD' instead"
  run "$CMD"
  ;;
upgrade)
  if sig USR2 && sleep 2 && sig 0 && oldsig QUIT
  then
    n=$TIMEOUT
    while test -s $OLD_PIN && test $n -ge 0
    do
      printf '.' && sleep 1 && n=$(( $n - 1 ))
    done
    echo

    if test $n -lt 0 && test -s $OLD_PIN
    then
      echo >&2 "$OLD_PIN still exists after $TIMEOUT seconds"
      exit 1
    fi
    exit 0
  fi
  echo >&2 "Couldn't upgrade, starting '$CMD' instead"
  run "$CMD"
  ;;
reopen-logs)
  sig USR1
  ;;
*)
  echo >&2 "Usage: $0 "
  exit 1
  ;;
esac

Configuración de Capistrano

Agregamos Capistrano y Capistrano RVM al Gemfile

gem 'capistrano'
gem 'rvm-capistrano'

Despues de haber ejecutado bundle install para instalar las gemas correspondientes ejecutamos el siguiente comando en el directorio principal de nuestra aplicación

capify .

Editamos (creamos en caso que no lo tengamos) el archivo deploy.rb en el directorio /config y agregamos la siguiente receta(recuerda sustituir los valores correspondientes conforme a los tu configuración):

require "bundler/capistrano"
require "rvm/capistrano"

server "123.123.123.123", :web, :app, :db, primary: true

set :application, "nombre_del_proyecto"
set :user, "nombre de usuario"
set :port, 22 #sustituye con el puerto que usas
set :deploy_to, "/home/#{user}/apps/#{application}"
set :deploy_via, :remote_cache
set :use_sudo, false

set :scm, "git"
set :repository, "git@github.com:username/#{application}.git" #o simplemente copia y pega la url del repositorio en el servicio que uses
set :branch, "master"


default_run_options[:pty] = true
ssh_options[:forward_agent] = true

after "deploy", "deploy:cleanup" # keep only the last 5 releases

namespace :deploy do
  %w[start stop restart].each do |command|
    desc "#{command} unicorn server"
    task command, roles: :app, except: {no_release: true} do
      run "/etc/init.d/unicorn_#{application} #{command}"
    end
  end

  task :setup_config, roles: :app do
    sudo "ln -nfs #{current_path}/config/nginx.conf /etc/nginx/sites-enabled/#{application}"
    sudo "ln -nfs #{current_path}/config/unicorn_init.sh /etc/init.d/unicorn_#{application}"
    run "mkdir -p #{shared_path}/config"
    put File.read("config/database.example.yml"), "#{shared_path}/config/database.yml"
    puts "Now edit the config files in #{shared_path}."
  end
  after "deploy:setup", "deploy:setup_config"

  task :symlink_config, roles: :app do
    run "ln -nfs #{shared_path}/config/database.yml #{release_path}/config/database.yml"
  end
  after "deploy:finalize_update", "deploy:symlink_config"

  desc "Make sure local git is in sync with remote."
  task :check_revision, roles: :web do
    unless `git rev-parse HEAD` == `git rev-parse origin/master`
      puts "WARNING: HEAD is not the same as origin/master"
      puts "Run `git push` to sync changes."
      exit
    end
  end
  before "deploy", "deploy:check_revision"
end

Ahora edita el archivo Capfile creado en el directorio principal de tu aplicación y verifica que esté de la siguiente manera:

load 'deploy'
load 'deploy/assets'
load 'config/deploy'

Despliegue

cap deploy:setup

Edita en el servidor /home/nombre-de-usuario/apps/nombre-de-proyecto/shared/config/database.yml conforme a los datos de conexión en el servidor remoto, en mi caso usando PostgreSQL para el entorno de producción quedaría de la siguiente manera.

production:
  adapter: postgresql
  encoding: unicode
  host: localhost
  database: nombre_de_bd_production
  pool: 5
  username: nombre_usuario_en_postgres
  password: 'ontrasenia'

Luego de haber ejecutado las configuración inicial y asumiendo que todo esta bien...

cap deploy:cold

Luego del deploy:cold

sudo rm /etc/nginx/sites-enabled/default
sudo service nginx restart
sudo update-rc.d -f unicorn_nombre_del_proyecto defaults

Por último para cada cambio nuevo que hagamos, hacemos push desde nuestro repositorio local y luego el deploy usando capistrano

git push origin master
cap deploy

Eso es todo, si tienes dudas, puedes contactarme o dejar tus comentarios.

Usando R desde Ruby (Rserve + rserve-client)

2014-02-09T12:48:00.000-06:00

Hace poco escribí un post sobre como instalar R y RStudio (en Ubuntu), en esta ocasión voy a abordar cómo integrar R con Ruby. De manera que podemos aprovechar todo el potencial de R aplicado al análisis de datos en nuestras aplicaciones hechas en Ruby.

En resumen esto es lo que haremos:

Asumiendo que ya tenemos instalado R en nuestra computadora, procedemos a instalar Rserve.
Instalamos el cliente de Ruby para conectarse con Rserve.
Listo, con esto podemos proceder a hacer pruebas.

Instalando Rserve

Para instalar Rserve, simplemente necesitamos ingresar al R desde la consola (o CRAN) y proceder a instalar R.

Desde la consola (Ubuntu)

sudo R
> install.packages("Rserve")
> library(Rserve)
> Rserve()

Usando RStudio

Los mismos comandos anteriores (solo los que tienen >)

Instalando el cliente de R para Ruby (rserve-client)

gem install rserve-client

Ahora probamos que todo esté bien desde la terminal con irb

irb
> require "rserve"
> include Rserve
> c = Connection.new
> x = c.eval("R.version.string");
> puts x.as_string

E incluso podemos hacer algo más avanzado...

> x = c.eval('list(l1=list(c(2,3)),l2=c(1,2,3))').to_ruby

Si quieres más información puedes dejar tus comentarios o visita:

http://www.slideshare.net/sausheong/rubyand-r
https://github.com/clbustos/Rserve-Ruby-client
http://www.rforge.net/Rserve/doc.html

Instalando R y RStudio en Ubuntu 12.04, 12.10, 13.04, 13.10

2014-02-09T11:02:00.001-06:00

Como saben R es el lenguaje de programación para análisis estadístico de datos más usado en el mundo. Ahora veremos como instalarlo en Ubuntu junto a RStudio. Sin más preámbulos comencemos.

Instalando R

sudo add-apt-repository "deb http://cran.rstudio.com/bin/linux/ubuntu $(lsb_release -cs)/"
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E084DAB9
sudo apt-get update
sudo apt-get install r-base r-base-dev

Instalando RStudio

Una vez instalados los paquetes anteriores necesarios para ejecutar R procedemos a instalar RStudio, para esto nos dirigimos al sitio de descargas de este excelente IDE. Descargamos la versión acorde a nuestro sistema operativo y hardware, en mi caso he elegido el .deb de 64 bits. Luego procedemos a instalarlo desde el software center de Ubuntu.

Y eso es todo, podemos comenzar a usarlo:

Instalando y configurando PostgreSQL en un VPS con Ubuntu (Digital Ocean en mi caso)

2014-02-08T10:27:00.000-06:00

Antes que nada nos conectamos vía SSH a nuestro servidor, en caso que ya tengamos configurado el acceso SSH podemos saltarnos los siguientes pasos, sino a continuación comparto mi manera de proceder cuando configuro por primera vez SSH en un servidor remoto.

Configuración SSH en VPS

ssh a root en la terminal con la IP de tu servidor

ssh root@123.123.123.123

Agregamos el fingerprint e ingresamos la contraseña provista por el proveedor para luego cambiarla a una de nuestra preferencia

passwd

Creamos un nuevo usuario

adduser nombre-de-usuario

Establecemos privilegios para el nuevo usuario

visudo

Buscamos la sección de privilegios de usuarios

# User privilege specification
root  ALL=(ALL:ALL) ALL

Agregamos privilegios de super usuario al usuario recién creado, presiona Ctrl + X y guarda los cambios

nombre-de-usuario ALL=(ALL:ALL) ALL

Procedemos a configurar el acceso SSH

nano /etc/ssh/sshd_config

Buscamos y cambiamos el puerto a uno que no sea el que está por defecto (el 22 está por defecto: por seguridad es mejor escoger uno entre el 1025..65536) y bloqueamos el acceso SSH desde la cuenta root

Port 22 # cambialo a cualquiera que desees usar
Protocol 2
PermitRootLogin no

Agrega al final del sshd_config el usuario que acabamos de crear, presiona Ctrl + X y guarda los cambios

AllowUsers nombre-de-usuario

Recargamos SSH para aplicar los cambios

reload ssh

Ahora desde una nueva consola y sin cerrar la actual procedemos a probar la conexión usando los datos que recién creamos.

ssh -p numero-de-puerto-que-elegimos nombre-de-usuario@123.123.123.123

En caso que algo no funcione verifica si hiciste bien los pasos anteriores o deja un comentario con tus dudas.

Instalando y configurando Postgres

Nos conectamos via SSH a nuestro servidor

 ssh -p numero-de-puerto usuario@123.123.123.123

Antes de todo procedemos a actualizar los paquetes en el servidor remoto

sudo apt-get update

Instalamos PostgreSQL 9.1

sudo apt-get install postgresql postgresql-server-dev-9.1

Creamos un nuevo usuario en Postgres y le asignamos privilegios, adicional procedemos a crear una base de datos.

sudo -u postgres psql
create user nombre-de-usuario with password 'contraseña';
alter role nombre-de-usuario superuser createrole createdb replication;
create database nombre-de-bd owner nombre-de-usuario;

Listo, cada vez que queramos a acceder a una base de datos en particular simplemente ingresamos

psql nombre-de-bd

Si tienes alguna duda puedes preguntar en los comentarios :)

Instalar ScreenCloud en Ubuntu 13.10 13.04 14.04

2014-02-08T09:15:00.000-06:00

ScreenCloud se ha convertido en mi herramienta favorita para tomar capturas de pantalla por su facilidad de uso y compartir. Hace poco actualice mi Ubuntu de la 12.04 a la 13.10, y al tratar de instalar nuevamente ScreenCloud habían ciertos errores con dependencias no encontradas usando el .deb del sitio oficial.

A continuación dejo los pasos a seguir para lograr instalarlo:

sudo su
echo 'deb http://download.opensuse.org/repositories/home:olav-st/xUbuntu_12.04/ /' >> /etc/apt/sources.list.d/screencloud.list 
wget -O - http://download.opensuse.org/repositories/home:olav-st/xUbuntu_12.04/Release.key | apt-key add -
apt-get update
apt-get install screencloud

Workflow básico para GIT

2014-01-29T00:09:00.000-06:00

A continuación comparto los comandos básicos para el trabajo día a día usando Git como sistema de control de versiones de código. Comandos que nos pueden de sacar de apuros muchas veces.

#Antes de hacer cualquier cambio

git pull #sincroniza tus cambios con el repositorio remoto
 
git checkout -b nombre-de-la-nueva-rama #crea una nueva rama para cualquier nueva corrección de bug/característica/asunto
 
 
#Luego agrega cambios a tu trabajo
#mantenlos en trozos pequeños, entre más pequeños sus commits es mejor, por si las cosas salen mal
 
git add . #agrega cualquier nuevo archivo que hayas creado
 
git status (y/o) git diff #miras los cambios con los que realizarás tu commit
 
git commit -m “Mensaje detallado acá”  #haz tu commit con un buen mensaje detallado
 
git checkout master  #cambia nuevamente a la rama master cuando la nueva caracteristica esté lista, revisa si tus pruebas pasan antes de hacerlo, todo ejecuta bien?
 
git merge nombre-de-la-rama #actualiza la rama master para sincronizar tus últimos cambios
 
git push #envía tis cambios al repositorio remoto

Listo...

Comparar cadenas en Java: == o .equals()

2014-01-28T23:10:00.002-06:00

Para comparar dos cadenas en Java debes saber lo siguiente. Al usar == pruebas si dos objetos tienen la misma referencia. Y al usar .equals() pruebas si los valores de las cadenas son iguales. Por ejemplo:

String ejString1 = new String("ejemplo");
String ejString2 = new String("ejemplo");

// Retornará falso
ejString1 == ejString2;

// Retornará verdadero
ejString1.equals(ejString2);

// Retornará verdadero, porque Java usa el mismo objeto.

"ejemplo" == "ejemplo";

Pero ten cuidado al comparar cadenas con valores null. En tal caso, el == manejará adecuadamente las cadenas con valores null, peroo llamando al método .equals() desde una cadena null causará una excepción.

String nullString1 = null;
String nullString2 = null;

//Retorna verdadero
nullString1 = nullString2;

//Lanza una exepción
nullString1.equals(nullString2);

Cuando se trabaja con cadenas concatenadas y se compara en tiempo de compilación, la comparación resulta en los mismos objetos.

// retorna true
"prueba" == "pru" +"eba";

Sin embargo si se invoca a un método como .substring() en tiempo de ejecución se generan objetos distintos:

//retornará false
"prueba" == "!prueba".substring(1)

Entendiendo la Orientación a Objetos en Javascript

2013-09-07T09:57:00.002-05:00

Si eres desarrollador web, con seguridad usas javascript con frecuencia. Es probable que ya sepas como crear y usar objetos, pero no te sientes cómodo al hacerlo, después de todo Javascript no se asemeja mucho a algunos de los lenguajes "puramente" orientados a objetos. Pero, con un poco de ayuda es posible que puedas comprender lo que realmente significa orientación a objetos en Javascript.

¿Qué es un objeto en Javascript

En términos de Javascript, un objeto es una colección de pares key-value (llave / valor), dónde la llave (key) debe ser una cadena. El valor no tiene ningún tipo de restricciones, por tanto puede almacenar primitivas, objetos y funciones (en ese contexto se les llama "mètodos"). Las variables y los campos del objeto solo referencia al objeto. Los objetos pueden ser comparados solo en terminos de identidad referencial.

¿Cómo crear un objeto en Javascript?

Hay muchas maneras de crear un objeto en Javascript, dejame nombrar algunas de éstas.

Objeto Literal

var perro = {
  name: "Oso",
  ladrar: function() {
  console.log("wau, wau")
  }
}

Lo cual crea explicitamente el objeto perro con el campo nombre y el método ladrar. El concepto básico aquí es que muchas veces en tu aplicación hay necesidad de tener muchos objetos con la misma estructura y comportamiento. La orientación a objetos se revela en las instancias, no en las clases.

Método Object Create

var gato = Object.create
  gato.nombre = "Misifú"
  gato.miau = function() {
  console.log("miau miau")
}

Object.create instancia un objeto gato vacío -sin ningún campo, convirtiéndose en un prototipo del objeto creado. Más adelante abordaremos los prototipos, mientras enfoquémonos en el objeto gato. Agregamos algunos atributos y comportamiento por medio de la asignación de valores y funciones a sus campos inicialmente no existentes. Por supuesto en tiempo real puedes cambiar ambos campos con nuevos valores (o funciones) e incluso remover algún campo.

Función constructor

function Leon(nombre) {
this.nombre = nombre;
this.rugir = function() {
console.log(" arrr arrr")
}
}
var leon = new Leon("Tonio")

Primero que todo qué es Leon? Como puedes ver es una función, pero un tipo especial, es llamado constructor, ya que construye nuevos objetos con determinados atributos y comportamiento. Ojo, en este ejemplo cada objeto construido con Leon tendrá un método rugir distinto. Más adelante veremos como compartir métodos.
Esta es la primera manera de diferenciar las clases de los objetos - si creaste un objeto con un constructor puedes decir, que el objeto es su instancia-.

leon instaceof Leon //= true

Pero recuerda - leon no es una instancia de la clase Leon, sino que leon es una instanciada por el constructor Leon.

Herencia por prototipos

En javascript la herencia se basa en objetos, así que un objeto "a" puede heredar atributos y comportamiento de un objeto "b", entonces el objeto "b" es llamado prototipo del objeto "a". Por supuesto "b" puede también puede tener prototipo, entonces cada objeto tiene una cadena de prototipos. Veamos un ejemplo:

var protoGato = {
nombre: "Misifu",
miagar: function() {
return this.nombre + ": miau miau"
}
}
// 1
var gato = Object.create(protoGato)
console.log(gato.nombre) // Misifu
console.log(gato.miagar()) // Misifu: miau miau

//2
protoGato.nombre = "Proto"
console.log(gato.nombre) // Proto
console.log(gato.miagar()) // Proto: miau miau

// 3
gato.nombre = "Nyan Cat"
console.log(gato.nombre) // Nyan Cat
console.log(protoGato.nombre) // Proto
console.log(gato.miagar()) // Nyan Cat: miau miau

//4
gato.miagar = function() {
return this.nombre + ": rrruf rrruf"
}
console.log(gato.miagar()) // Nyan Cat: rrruf rrruf
console.log(protoCat.miagar()) //Proto: miau miau

Como puedes ver en este ejemplo los campos de protoGato son reservados, si gato no tiene manera de interpretar un campo lo busca en el prototipo, y luego de forma recursiva en el prototipo del prototipo... Si ese campo es una función se pasa también el objeto correcto - en el cual el método es invocado - como tal. Y si el método encontrado usa un campo de un objeto el interprete comienza buscando desde el objeto original.
Por tanto un prototipo define por defecto los atributos y comportamiento de los objetos que heredan de éste y esa es la manera de compartir y rehusar comportamientos comunes. La gran diferencia acá es que no heredas de claces instanciadas, sino que solo instancias, de manera que si cambias un atributo de un prototipo en tiempo real, todos los objetos que heredan de éste serán afectados a menos que estos sobrescriban el atributo.

Prototipo común para objectos construidos

Hemos visto como crear objetos con prototipo con Objetc.create. También puedes asignar un prototipo común para objetos creados por constructor:

vas animal = {
ladrar: function() {
return this.nombre + ": wau wau"
}
}

function Lobo(nombre) {
this.nombre = nombre
}

Lobo.prototype = animal

var lobo = new Lobo("Tyson")
console.log(lobo.ladrar()) // Tyson: wau wau

Lobo.prototype = animal significa que quieres que cada objeto construido tenga un animal como prototipo. Por supuesto que el prototipo puede ser también creado con un constructor.

function Animal() {
//...
}

function Lobo() {
//...
}

Lobo.prototype = new Animal()
var lobo = new Lobo()

En este caso el objeto lobo is tanto instancia de Lobo como de Animal en terminos del operador instanceof. ¿Por qué lobo lobo intanceof Animal es verdadero? Supongamos que eliminamos todos los atributos correspondientes a Lobo, como se va a comportar lobo? como Animal, por supuesto, entonces esa es la respuesta.

Laravel, un framework PHP comprometido con la elegancia y sencillez

2013-09-05T16:28:00.000-05:00

Normalmente en la red no leo cosas buenas de PHP, a pesar de ser el lenguaje de programación backend más popular en Internet. De mi parte, aunque me siento más inclinado a trabajar con Ruby y Ruby on Rails, debo reconocer que no he tenido malas experiencias trabajando con PHP, aunque desde luego no he elaborado proyectos de gran envergadura, sin embargo gracias a Wordpress y Drupal que uso a menudo para proyectos, tengo buenas impresiones de PHP.

Sin embargo y aterrizando a desarrollos más serios de aplicaciones, me he encontrado con un framework muy bueno llamado Laravel. No voy a entrar en controversia acerca de si Laravel es mejor que X framework de PHP, porque no he tenido experiencias previas con otros, pero éste me ha llamado mucho la atención y sin duda sería mi primera elección en caso de realizar algún proyecto en PHP.

Laravel es un framework PHP comprometido con elegancia y sencillez. El desarrollo no tiene que ser doloroso, sobre todo en PHP. De hecho, puede ser agradable usando las herramientas adecuadas. Laravel es para todos los programadores de PHP, incluso principiantes.

Por cierto, la documentación de Laravel la hace una gran opción tanto para programadores principiantes como avanzados. Además de la documentación, la comunidad de Laravel siempre está dispuesto a ayudar y a responder preguntas que no están cubiertas en la documentación. Los Bundles son una gran manera de empaquetar y compartir código en Laravel. Pueden ser cualquier cosa - desde un ORM completo, hasta herramientas de depuración simples, y es muy fácil de usar en las aplicaciones que creamos!

Laravel

Instalando Node.js y npm en Ubuntu 12.04 y 13.04

2013-09-04T18:52:00.001-05:00

Hoy en día se ha popularizado el framework node.js, que lleva al lenguaje JavaScript, tradicionalmente usado para desarrollo del lado del cliente -front end- a otro nivel, permitiendo ahora trabajar del lado del servidor -backend- y desarrollar sistemas en tiempo real. En esta ocasión quiero explicar como se instala node.js junto con "node packaged modules" npm (que nos servirá para instalar paquetes de librerias, de los cuales hay disponibles miles y la cantidad aumenta rápidamente) en Ubuntu 12.04 y Ubuntu 13.04.

Instalación de node.js y npm en Ubuntu 12.04 LTS

Asumiendo que tienes una instalación fresca de Ubuntu 12.04 LTS

1. Configuramos el sistema para manejar la compilación y la instalación desde el código fuente.

$ sudo apt-get install build-essential

2. Si es necesario soporte a SSL entonces necesitas instalar libssl-dev

$ sudo apt-get install libssl-dev

3. Para instalar el script que usaremos vamos a necesitar instalar curl.

$ sudo apt-get install curl

4. Descargamos el script "node-and-npm-in-30-seconds.sh" que realizará la descarga, compilación e instalación, o bien podemos copiar el script a continuación:

# The install script
# Adapted from https://gist.github.com/579814
 
echo '# Added by install script for node.js and npm in 30s' >> ~/.bashrc
echo 'export PATH=$HOME/local/bin:$PATH' >> ~/.bashrc
echo 'export NODE_PATH=$HOME/local/lib/node_modules' >> ~/.bashrc
. ~/.bashrc
 
mkdir -p ~/local
mkdir -p ~/Downloads/node-latest-install
 
cd ~/Downloads/node-latest-install
curl http://nodejs.org/dist/node-latest.tar.gz | tar xz --strip-components=1
 
./configure --prefix=~/local # if SSL support is not required, use --without-ssl
make install # ok, fine, this step probably takes more than 30 seconds...

A continuación ejecutamos el script ./nombredelscrip (si es necesario, recuerden darle privilegios sudo. Este paso toma un buen rato, dependiendo de tu compu y recursos.
Finalmente puedes verificar la versión instalada de node y npm, con los siguientes comandos:

$ node -v
$ npm -v

Instalación de node.js y npm en Ubuntu 13.04

1. Ingresa a la página de descarga de Node.js y busca la columna Linux Binaries (.tar.gz), y descarga la versión más reciente para arquitecturas de 32 o 64 bits.

2. Digamos que haz descargado el paquete node-v0.10.18-linux-x64.tar.gz dentro de la carpeta Descargas. Luego abre la terminal e ingresa lo siguiente.


$ cd ~/Descargas
$ mkdir -p ~/local/node
$ tar xzf node-v0.10.7-linux-x64.tar.gz -C ~/local/node --strip-components=1
$ echo 'export PATH=$HOME/local/node/bin:$PATH' >> ~/.bashrc
$ echo 'export NODE_PATH=$HOME/local/node/lib/node_modules' >> ~/.bashrc
$ . ~/.bashrc

3. No hay paso 3. Eso es todo

Cleaver, crea una presentación usando Markdown

2013-09-04T17:26:00.002-05:00

Markdown pasó del anonimato a ser uno de los lenguajes de marcado más utilizados, usado para documentar código, escribir artículos... y ahora incluso para crear presentaciones minimalistas de manera simple y rápida. Cleaver permite la creación de presentaciones HTML en tiempo record, con un buen aspecto sin escribir una sola linea de código o preocuparse por reposicionar elementos en una presentación tradicional.

Cómo comenzar

Primero debemos crear un archivo Markdown en el cual escribiremos el contenido de la presentación.


# Instalando Cleaver

$ npm install -g cleaver
# Crea un demo.md
$ vi demo.md

Cleaver tiene una plantilla con metadatos por defecto para definir nuestra presentación.


title: Basic Example

author:
    name: "Jordan Scales"

twitter: "@jdan"
url: "http://jordanscales.com"
style: my_style.css
output: basic.html

controls: true

Ahora vamos a crear una pequeña presentación.

Vamos a necesitar crear un archivo Markdown para nuestro contenido, en mi caso demo.md.

title: Bienvenido a mi blog!
author:
name: "Gerardo Ortega"
twitter: "@g3ortega"
url: "http://g3ortega.com"
output: demo.html
controls: true

--

# Mi blog

## Este es un sitio donde escribo de:
* desarrollo web
* tips
* javascript y ruby :)

--

# A qué me dedico?

* soy desarrollador web
* ruby on rails

y mucho más

--

# Gracias

## Encuentrame en Twitter: @g3ortega!

Y el 'ultimo paso es simplemente compilarlo: cleaver demo.md ésto generará un archivo demo.html conforme a lo que hemos establecido. Ahora solo resta abrirlo en el navegador.

Usando PostgreSQL con Ruby on Rails

2013-08-31T14:09:00.000-05:00

Hace no mucho publicaba un post sobre como instalar y configurar PostgreSQL para trabajar con Ruby on Rails, ahora quiero repasar algunos pasos de la instalación, adicional después daré algunos comandos y tips útiles para el proceso de desarrollo en Rails.

Instalación de PostgreSQL en Ubuntu 13.04 y Ubuntu 13.10

La instalación sobre Ubuntu es bastante sencilla, de momento estoy corriendo Ubuntu 13.04 y la instalación de la versión 9.1 se realiza con el comando sudo apt-get install postgresql, adicional solo requirimos instalar una libreria para desarrollo sudo apt-get install libpq-dev Ahora solo necesitamos agregar un nuestro usuario de sistema desde la linea de comandos:

$ sudo su postgres -c psql
postgres

postgres=# CREATE ROLE nombredeusuario SUPERUSER LOGIN;
postgres=# \q

Podemos verificar la instalación con el comando psql --version.

Postgres y Ruby on Rails

Si queremos crear una nueva aplicación en Ruby on Rails con Postgresql preconfigurado, es sencillo con el comando -d que provee rails, el cual nos permite pasar como parámetro diferentes servidores de bases de datos, entre éstos PostgreSQL.

$ rails new prueba -d postgresql

Automaticamente rails generará una aplicación, y podemos notar que la gema pg esta en el Gemfile, sustituyendo a la gema sqlite3 que es incluida por default.

Una vez creada nuestra aplicación en rails debemos configurar los parámetros de acceso a postgre, esto lo hacemos en el archivo /config/database.yml principalmente el nombre de usuario y la contraseña en caso que lo hayamos establecido de esa manera.

Luego usamos el siguiente comando de rails para crear las bases de datos que establece por defecto para los entornos de desarrollo, producción y pruebas. Si no deseamos los nombres por defecto (p.e. prueba_development, prueba_production) podemos cambiarlos en el archivo database.yml antes de realizar este paso.

$ rake db:create:all

Si el paso anterior no nos da ningún error, significa que se han creado correctamente las bases de datos, por ahora siguiendo con nuestro ejemplo podemos crear un CRUD simple, para comprobar el ingreso de datos y hacer uso de nuestras bases de datos recién creadas.

$ rails g scaffold aplicacion nombre descripcion:text

Proseguimos a crear la tabla para almacenar nuestras aplicaciones:

$ rails db:migrate

Podemos comprobar que nuestra tabla ha sido creada usando el comando psql más el nombre de nuestra base de datos o bien usando el comando rails db que nos dirigirá al cliente en consola de postgres.

Algunos comandos de postgresql útiles:
\d = nos muestra la lista de relaciones en nuestra base de datos
\d nombredetabla = nos muestra el diseño de la tabla dada
\? = para una completa lista de comandos
\h = para lista de comandos sql
\h nombredecomando = nos da información sobre un determinado comando sql
\q = para salir del cliente psql

Si quieres aprender mas de PostgreSQL y SQL puedes leer la documentación en el sitio que esta muy buena http://www.postgresql.org/docs/9.1/interactive/index.html, o bien dirigirte a una serie de videotutoriales en español de Jesús Conde http://www.youtube.com/playlist?list=PLAF4831DDBDB8E841.

Próximamente estaré subiendo un post sobre como migrar datos de otros servidores de bd hacía PostgreSQL.

Tutorial básico sobre Markdown [GUIA]

2013-06-09T12:49:00.002-05:00

¿Qué es Markdown y para qué sirve?

Markdown es un lenguaje de marcado ligero, que nos permite escribir contenido en texto plano que luego puede ser traducido en formato HTML válido, y con la ayuda de alguna herramienta puedes visualizar instantáneamente el resultado. Actualmente se ha popularizado porque viene por defecto en algunos servicios de control de versiones como Github o Bitbucket, para escribir READMEs, wikis, etc... e incluso en algunos CMS sencillos, o bien generadores de sitios dinámicos como Jekyll.

Parrafos

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.   
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

será igual a

<p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.</p>
 
<p>Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.</p>

Negritas y cursivas

*Lorem ipsum*      => <em>Lorem ipsum</em>
**Lorem ipsum**    => <strong>Lorem ipsum</strong>

Encabezados

#Heading 1 (h1)  
##Heading 2 (h2)  
###Heading 3 (h3)  
####Heading 4 (h4) 
#####Heading 5 (h5) 
######Heading 6 (h6)

Listas desordenadas

* esta es una lista  
* esta es una lista  
* esta es una lista  
 
- esta es una lista  
- esta es una lista  
- esta es una lista

Lineas

-------------------------------- 
or
================================

Blockquotes

&gt; Duis aute irure dolor in reprehenderit in voluptate velit esse  
&gt; cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non  
&gt; proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Links

[Blog](http://blog.g3ortega.com)

Imágenes

![image](http://imagenurl.jpg)  
![image](http://imagenurl.jpg "Titulo de la Imagen")  # con etiqueta alt

Mas información...

http://daringfireball.net/projects/markdown/syntax
http://whatismarkdown.com/

Editores Markdown?

Online

http://dillinger.io/

http://markable.in/editor/

http://www.ctrlshift.net/project/markdowneditor/

Windows / Mac

http://markdownpad.com/

Ubuntu/Linux

UberWriter

sudo add-apt-repository ppa:w-vollprecht/ppa
sudo apt-get update
sudo apt-get install uberwriter

ReText

sudo add-apt-repository ppa:mitya57 && sudo apt-get update
sudo apt-get install retext

Twiteando desde Ruby. Usando gema de Twitter para Ruby [Parte I]

2013-05-29T01:30:00.001-05:00

Hoy daremos un pequeño paseo por una de mis gemas favoritas para Ruby, hablo de la gema para Twitter, que podemos encontrar en https://github.com/sferik/twitter. Como pudieron ver, si ingresaron al enlace en cuestión, hay una gran cantidad de documentación realmente útil disponible, así que para comenzar no pretendo reinventar la rueda, aunque además de lo básico también exploraremos algunas maneras ingeniosas de usar esta excelente gema.

Entonces arrancamos, y para comenzar podemos ir abriendo nuestra querida consola o terminal. De momento estoy suponiendo que ya tienes instalado Ruby en tu PC o Mac, sino instalarlo es una cosa sencilla, puedes consultar mi tutorial para Ubuntu 12.04 aquí.

Instalando gema de Twitter

gem install twitter

Luego sigue un paso necesario por razones de seguridad. En el sitio de la gema lo expresan de la siguiente manera:

Para asegurar que el código que se está instalando no ha sido manipulado, se recomienda que compruebe la firma. Para ello, es necesario añadir la llave pública como un certificado de confianza (sólo es necesario hacerlo una vez)

gem cert --add <(curl -Ls https://raw.github.com/sferik/twitter/master/certs/sferik.pem)

A continuación instalamos la gema con directivas de alta seguridad:

gem install twitter -P HighSecurity

Creando aplicación en Twitter

Ya con esto tenemos la mitad del trabajo hecho, ahora falta el otro 25%, que no son sino configuraciones que podemos hacer directamente en Twitter.

Para ello nos vamos a esta URL, y registramos una nueva aplicación en Twitter:

Una vez creada nuestra aplicación nos dirigirá a otra pantalla que contiene información valiosa que utilizaremos en los pasos siguientes.

¿Que es OAuth y qué son Access Tokens?

Los datos que necesitaremos luego son: Consumer key y Consumer secret. Pero antes de continuar abordaré un poco de qué significa OAuth y el porqué de estos datos.

Wikipedia define OAuth de la siguiente manera:

OAuth (Open Authorization) es un protocolo abierto, propuesto por Blaine Cook y Chris Messina, que permite autorización segura de un API de modo estándar y simple para aplicaciones de escritorio, móviles, y web.

Para desarrolladores de consumidores, OAuth es un método de interactuar con datos protegidos y publicarlos. Para desarrolladores de proveedores de servicio, OAuth proporciona a los usuarios un acceso a sus datos al mismo tiempo que protege las credenciales de su cuenta. En otras palabras, OAuth permite a un usuario del sitio A compartir su información en el sitio A (proveedor de servicio) con el sitio B (llamado consumidor) sin compartir toda su identidad.

De manera que de momento, tenemos una especie de llave de acceso y una clave para acceder a nuestra aplicación en twitter. Pero lo único que nos falta es acceder a nuestro perfil [o a cualquier otro] con el fin de publicar contenido y realizar acciones propias de twitter como seguir, ver información de usuarios, retwitear, etc. Y para hacer eso necesitaremos un Access Token.

Twitter define los Access Token de la siguiente manera:

Para hacer llamadas autorizadas a las API de Twitter, la aplicación debe primero obtener un token de acceso OAuth en nombre de un usuario de Twitter. La forma en que va a obtener esos tokens dependerá de su caso de uso. https://dev.twitter.com/docs/auth/obtaining-access-tokens.

Configuraciones finales y generación de Access Token

Antes de continuar debemos hacer un paso adicional. De momento nuestra aplicación tiene solo permisos de lectura, pero para lo que la necesitamos en este tutorial, es necesario tener permisos de lectura y escritura.Así que estando en nuestra aplicación, nos vamos a "Settings" o ajustes.

Una vez allí, nos vamos a la sección de Tipo de Aplicación, en la cual seleccionamos la última opción "Read, Write and Access direct messages".

Guardamos y regresamos a la sección de "Details". En la parte hay un apartado para nuestro token de acceso, presionamos en "Crear mi token de acceso" y listo. Ya con eso tendremos los datos que necesitamos para hacer nuestras pruebas.

El "Hello World" del tutorial

Muy bien, ahora que ya hemos generado los datos que necesitábamos, procederemos a configurar nuestra primera aplicación en Ruby en consola, que nos preguntará si queremos publicar un Tweet y nos dará la oportunidad de hacerlo.

La estructura básica será la siguiente:

Primero necesitaremos incluir la gema de Twitter en nuestra aplicación:

     require 'twitter'

Luego vamos a necesitar todo lo que hemos generado a partir de nuestra aplicación de Twitter

    Twitter.configure do |config|
      config.consumer_key = 'TU_CONSUMER_KEY'
      config.consumer_secret = 'TU_CONSUMER_SECRET'
      config.oauth_token = 'TU_TOKEN_DE_ACCESO'
      config.oauth_token_secret = 'TU_TOKEN_SECRETO'
    end

Un poco de relleno

puts "Publicar un nuevo Tweet..."
tweet= gets() #Obtenemos lo que el usuario digite

Y ahora es momento de la magia

    Twitter.update(tweet)

El código completo:

   require 'twitter'

  Twitter.configure do |config|
      config.consumer_key = 'TU_CONSUMER_KEY'
      config.consumer_secret = 'TU_CONSUMER_SECRET'
      config.oauth_token = 'TU_TOKEN_DE_ACCESO'
      config.oauth_token_secret = 'TU_TOKEN_SECRETO'
    end

   puts "Publicar un nuevo Tweet..."
   tweet= gets() #Obtenemos lo que el usuario digite

   Twitter.update(tweet)

"Hello World" con ciertas mejoras

Ahora digamos que tenemos múltiples usuarios. Entonces que pasaría si quisieramos usar nuestra aplicación previamente creada para actualizar el estado de varios usuarios.

   require 'twitter'

  Twitter.configure do |config|
      config.consumer_key = 'TU_CONSUMER_KEY'
      config.consumer_secret = 'TU_CONSUMER_SECRET'
    end

     
    gerardo = Twitter::Client.new(
        :oauth_token => "Mi token acceso",
        :oauth_token_secret => "Mi acceso secreto"
    )

   david = Twitter::Client.new(
        :oauth_token => "Su token de acceso",
        :oauth_token_secret => "su token secreto"
    )

   puts "Publicar un nuevo Tweet como Gerardo..."
   tweet= gets() #Obtenemos lo que el usuario digite
   gerardo.update(tweet)

   puts "Publicar un nuevo Tweet como David..."
   tweet= gets() #Obtenemos lo que el usuario digite
   david.update(tweet)

Eso ha sido todo para esta primera parte. En la segunda parte estaremos explorando otras interesantes caracteristicas de esta excelente gema. Si tienen dudas o problemas al respecto, favor preguntar en los comentarios. Saludos.

Instalando Ruby con RVM en 5 pasos o menos [Ubuntu 12.04]

2013-05-28T22:54:00.001-05:00

Muy bien. No es un secreto que la Ruby Version Manager se ha convertido en la opción preferida por la mayoría de desarrolladores de Ruby al momento de instalar y controlar multiples entornos de trabajo para este lenguaje. Desde hace algunos meses la instalación de Ruby usando RVM se ha vuelto más sencilla, y ahora quiero explicar brevemente cómo instalar ruby en 5 pasos:

Paso 1: Obtenemos las dependencias necesarias y algunas utilidades

$ sudo apt-get install build-essential git-core nodejs curl

Paso 2: Obtenemos la última versión estable de la RVM

$ \curl -L https://get.rvm.io | bash -s stable

Paso 3: Ejecutando Scripts de Configuración

$ source ~/.rvm/scripts/rvm

Podemos comprobar que este paso se realizó con éxito digitando rvm -v lo cual nos devolverá la versión de la RVM que hemos instalado. En caso que esto no aparezca, es posible que debás cerrar la terminal y abrirla nuevamente :)

Paso 4: RVM instalará algunas dependencias para asegurarse que Ruby trabajará como debe ser :)

rvm autolibs enable && rvm requirements

Paso 5: Instalando Ruby

$ rvm install 1.9.3 && rvm use 1.9.3 --default

Hemos terminado, podemos verificarlo ingresando ruby -v que nos dará la versión de ruby que acabamos de instalar, en este caso la 1.9.3, en caso que tengas algún problema, favor deja un comentario, será un gusto responder a tus dudas.

Instalando y configurando PostgreSQL en Ubuntu 12.04 para desarrollar en Ruby on Rails

2013-05-19T15:23:00.001-05:00

Una de las tendencias actuales en cuanto a motores de bases de datos open source, es el creciente aumento en el uso de PostgreSQL para proyectos escalables y de gran envergadura. Muchas empresas están considerando migrar a PostgreSQL(si es que no lo han hecho aún) como alternativa a MySQL, ahora en manos de Oracle y con poco apoyo de parte de la comunidad, la cual se ha inclinado más hacia MariaDB.

En este post daré una reseña rápida de instalación y configuración de PostgreSQL sobre Ubuntu 12.04 LTS. Luego veremos como integrarlo con Rails.

Instalando PostgreSQL y PgAdmin3 en Ubuntu 12.04

Instalamos PostgreSQL y el paquete de desarrollo (Asegurate que sus repositorios de paquetes estén actualizados (sudo apt-get update) y si es necesario su sistema lo este también (sudo apt-get upgrade).

$ sudo apt-get install postgresql-9.1 libpq-dev

Acontinuación, opcionalmente podemos instalar PgAdmin para tener una GUI de administración de PostgreSQL.

$ sudo apt-get install pgadmin3

Ahora crearemos un usuario y lo vincularemos con nuestra sesión de usuario

$ sudo su postgres -c psql
postgres=# CREATE ROLE nombredeusuario SUPERUSER LOGIN;
postgres=# \q

Algunos comandos de postgresql útiles:\d = nos muestra la lista de relaciones en nuestra base de datos
\d nombredetabla = nos muestra el diseño de la tabla dada
\? = para una completa lista de comandos
\h = para lista de comandos sql
\h nombredecomando = nos da información sobre un determinado comando sql
\q = para salir del cliente psql

Configuraciones en Rails

Configuramos nuestr Gemfile, por defecto nos configura SQLite3 como el gestor de base de datos por defecto y agrega la gema correspondiente, podemos comentar o eliminar esa parte y agrega la gema de PostgreSQL.

# Quitar gema 'sqlite3'
gem 'pg' #Agregando gema para PostgreSQL

Nos vamos a nuestro archivo de configuracion de bases de datos en /config/database.yml

development:
  adapter: postgresql
  encoding: unicode
  database: nombreapp_desarrollo
  pool: 5
  timeout: 5000
  username: nombredeusuario
  password:

test:
  adapter: postgresql
  encoding: unicode
  database: nombreapp_pruebas
  pool: 5
  timeout: 5000
  username: nombredeusuario
  password:

Luego dejamos que el Bundler haga su magia:

$ bundle install

Por ultimo, en caso de que ya tuviéramos migraciones listas, creamos las migraciones y si es necesario las bases de datos tambien:

$ rake db:create:all
$ rake db:migrate

Aprendiendo sobre Gestión de Proyectos [Online y GRATIS]

2013-05-04T17:09:00.001-05:00

Soy de la opinión que en los próximos años (sino ahora mismo) se gestará una revolución en materia de educación. De momento no vaticino el final de la forma tradicional de educación, a menos no al mediano plazo, pero veremos una transformación en la manara como nos formamos. Ya no dependeremos de una institución educativa para adquirir las competencias necesarias para desempeñar un rol en la sociedad, sino que nosotros mismos podremos decidir que aprender y en que momento. De manera que ser autodidacta será una de las cualidades mejor valoradas en el futuro.

Justamente me dispuse a buscar algunos cursos sobre Gestión de Proyectos, enfocados en la normativa del PMI (Project Management Institute), una organización encargada de certificar profesionales y mejorar el proceso de Gestión de Proyectos. De momento me encontré con dos excelentes vídeos brindados gratuitamente por la EOI (Escuela de Organización Industrial) de España, muy buenos y recomendados.

Instalar Sublime Text 2 en Ubuntu

2012-07-13T13:46:00.000-05:00

Como desarrollador web he probado variedad de editores, actualmente hay muy buenas alternativas, pero hay un problema, generalmente uso Ubuntu para desarrollar, y algunas de las mejores alternativas de editores no están disponibles para Linux, pero resulta que hace poco, una de las mejores alternativas que ha ido creciendo rápidamente en popularidad, anunció su disponibilidad no solo para Windows o Mac, sino para Linux también, y yo no podría estar más feliz por eso. A continuación los pasos para instalarlo.

En mi opinión, Sublime Text 2 es un el editor de código que se puede encontrar hoy en día, algunas de sus ventajas más notables son:

Es multiplataforma
Soporte nativo para una basta cantidad de lenguajes
Capacidad de extenderse mediante el uso de plugins y snippets.
Paleta de comandos
Autocompletado
Subrayado avanzado y configurable.
... y muchas más.

Pueden entrar a la pagina oficial para descargarse los clientes, disponibles para Windows, Mac OS y Linux, pero en el caso de Linux, si lo que se quiere es aprovechar al máximo las funcionalidades de éste potente editor se debe instalar desde la linea de comandos, ya que al descargarlo desde la página oficial solo tendremos acceso a un ejecutable y no dispondremos de ciertas caracteristicas, por ejemplo el uso del comando subl en la linea de comandos. Para installar Sublime Text 2 en Linux, y particularmente en Ubuntu: Agregamos el siguiente PPA:

sudo add-apt-repository ppa:webupd8team/sublime-text-2

actualizamos:

sudo apt-get update

Instalamos:

sudo apt-get install sublime-text-2

Y con ello tendremos Sublime Text instalado en:

/usr/lib/sublime-text-2

Y listo, con eso tendremos instalados el potente editor en nuestro S.O., happy coding :)

Configurando Git y Github para Ruby on Rails en Ubuntu 12.04

2012-07-13T13:39:00.000-05:00

Esta vez veremos como instalar, configurar y usar, Git y GitHub, trabajare con la version de Git para Linux, en este caso mi distribución es Ubuntu 12.04, pero si bien el procedimiento puede variar en otros sistemas operativos, éste tutorial puede servir de punto de partida para instalarlo, y una vez hecho ese primer paso, es útil para conocer como configurar una cuenta en GitHub y sincronizarla con nuestro repositorio local usando Git.

Que necesitamos?

1. Tener instalado Git Para verificar si ya hemos instalado Git simplemente ejecutamos el comando:

git --version

Si nos devuelve la versión de Git no tenemos de que preocuparnos, en mi caso la versión que tengo instalada es la 1.7.9, si nos devuelve un error entonces significa que no tenemos instalado Git y debemos hacerlo por medio del siguiente comando:

 sudo apt-get install git

2. Abrir una cuenta en GitHub GitHub es el repositorio web de código, con control de versiones más grande en el mundo, muchas de las principales empresas tecnológicas del mundo tienen repositorios en GitHub que trabajan colaborativamente entre sus empleados o personas externas (si el proyecto en cuestión es libre). Durante el desarrollo del curso de Ruby on Rails usaremos Git para el control de versiones del proyecto, desplegando el código directamente en GitHub, por lo tanto será necesario que se registren en GitHub para poder seguir el proceso.

En resumen:

Crearemos una aplicación en Ruby en Rails
Modificaremos el archivo .gitignore del directorio de nuestro nuevo proyecto
Iniciaremos Git y haremos nuestro primer commit
Crearemos una llave SSH y configuraremos nuestro repositorio en GitHub
Realizaremos algunas pruebas

Comencemos

1. Creamos una aplicación en Ruby on Rails Para crear una nueva aplicación en Ruby on Rails solo es necesario ejecutar:

rails new nombre_la_aplicacion

Este comando automáticamente nos creará una estructura propia de rails, de preferencia podemos crear un directorio que sea unicamente para las aplicaciones que crearemos en RoR:

mkdir proyectos_rails

Y dentro de ésta carpeta colocaremos nuestro proyecto que en este caso lo denominaremos gitrails

rails new gitrails

2. Modificamos el archivo .gitignore del directorio de nuestro proyecto. Verificamos si nos encontramos en el directorio de nuestro proyecto, de no ser asi cambiamos al directorio, siguiendo con nuestro ejemplo sería:

cd gitrails

Ya dentro del directorio de nuestro proyecto procedemos a modificar el arhico .gitignore, esto lo hacemos por medio de:

gedit .gitignore

En mi caso uso Sublime Text 2 asi que el comando sería un poco diferente:

subl .gitignore

En el archivo .gitignore encontraremos algo como ésto:

# Ignore bundler config
/.bundle

# Ignore the default SQLite database.
/db/*.sqlite3

# Ignore all logfiles and tempfiles.
/log/*.log
/tmp

A esta solo agregamos algunas lineas:

# Ignorar otros archivos innecesarios 
doc/
*.swp
*~
.project
.DS_Store

3. Iniciaremos Git y haremos nuestro primer commit Para iniciar Git:

git init

Luego agregamos el directorio donde se encuentra nuestra aplicación en RoR:

git add.

Podemos verificar que los directorios se hallan agregado con:

git status

Y por último hacemos nuestro primer commit, o bien nuestra primera versión del proyecto en el que estamos trabajando:

git commit -m "Primera Versión"

-m es el mensaje con el que se guardará la versión que estamos guardando

4. Crearemos una llave SSH y configuraremos nuestro repositorio en GitHub A estas alturas deberiamos de tener lista nuestra cuenta en GitHub, por lo tanto procedemos a crear una llave SSH para agregarla a GitHub y poder subir nuestro contenido, para ello ejecutamos el comando:

ssh-keygen

Luego nos preguntará acerca de que nombre, ruta o contraseña queremos poner a nuestra llave, en mi caso no incluí ninguno de esos datos por tratarse de una prueba, pero en entornos profesionales es necesario por cuestiones de seguridad.

Ahora que tenemos nuestra llave publica creada es necesario que copiemos el contenido de nuestra llave SSH en GitHub, para eso ejecutamos:

cat ~/.ssh/id_rsa.pub

En mi caso estoy usando la llave generada por defecto, si se creo una llave con un nombre diferente debe cambiarse al final del comando, luego procedemos a copiar el contenido de nuestra llave y pegarlo en Github:

Nos vamos a herramientas, y luego en la barra lateral seleccionamos SSH Keys

Agregamos una nueva clave SSH, pegando los el contenido de nuestra llave:

A continuación se nos pedirá nuevamente nuestra contraseña, la ingresamos, y estaremos listos crear nuestro primer repositorio y sincronizarlo con nuestro proyecto local, de manera que nos vamos a http://github.com/new o bien nos vamos al primer icono del menú superior derecho...

Ingresamos el nombre del repositorio y opcionalmente una descripción:

Le damos en crear repositorio y continuación nos mostrará una página con algunos comandos que nos servirán de mucha utilidad, asi que basados en estos procedemos a configurar nuestro repositorio local, copiamos y usamos los siguientes comandos: Ingresamos nuestro nombre...

git config --global user.name "Your Name"

Ingresamos nuestro correo...

git config --global user.email tucorreo@gmail.com

Agregamos el origen...

git remote add origin https://github.com/gerardoortega/gitrails.git

Y por último publicamos nuestro proyecto en GitHub usando:

git push -u origin master

Al momento de publicar la primera versión de nuestro proyecto por medio del comando anterior nos pedirá nuestro nombre de usuario y contraseña.

5. Realizaremos algunas pruebas Con los pasos anteriores conseguimos sincronizar nuestro proyecto con el repositorio de Github que creamos, podemos comprobar que todo salio bien actualizando la URL de nuestro repositorio y confirmando que los archivos han sido publicados:

Por último y para conocer más de cerca las ventajas del uso de Git para el control de versiones podemos realizar las siguientes pruebas: * Primero creamos una nueva rama o branch

git checkout -b rama

Las ramas o branches nos sirven para administrar ciertas áreas del proyecto de forma completamente independiente al proyecto principal (el cual se encuentra en la rama principal llamada master), por ejemplo, en un proyecto se ven involucrados diferentes grupos de profesionales, como diseñadores, analistas, testers, etc. se puede crear una rama para cada equipo, para que puedan trabajar en sus áreas sin temor a corromper un componente del proyecto que tenga repercusiones mayores. Para continuar con nuestro ejemplo vamos a modificar el Readme del proyecto en una rama independiente, asi que llamaremos a la rama READMEmodificado

git checkout -b READMEmodificado

(donde -b viene de branch y sirve para crear una nueva rama y checkout sirve para cambiar a una rama especifica) Como hemos cambiado a la nueva rama que hemos creado (READMEmodificado) mediante el comando checkout inmediatamente podemos comenzar a trabajar sobre esta branch, por lo tanto haremos algunas modificaciones:

rm -rf app/

--con esto borramos el contenido de la carpeta app/

git status

--para ver el estado actual y los archivos que han sido eliminados

git checkout -f

--para volver al estado anterior a las modificaciones

git status

--confirmamos que los cambios han sido deshechos, y todo esta como en un principio

rm -rf app/

--volvemos a borrar el directorio app/

git reset --hard HEAD

--regresamos al estado original de otra manera

rm -rf app/

--borramos nuevamente el directorio

git commit -am "Cambios estupidos"

--guardamos una version con los cambios que hemos hecho

git checkout master

--cambiamos a la rama master (la principal)

git branch

--lo usamos para saber en que rama estamos

git branch -D READMEmodificado

--para borrar la rama que creamos hace poco

git checkout -b READMEmodificado

--creamos nuevamente la rama que habíamos borrado y cambiamos a esta nueva rama

gedit README.rdoc

--procedemos a borrar el contenido de README.rdoc y colocamos un contenido alternativo

git mv README.rdoc README.markdown

--cambiamos la extensión del README y lo trasladamos a README.markdown

git commit -am "README Mejorado"

--hacemos un commit de los cambios que hemos hecho con el nombre de "README Mejorado"

git checkout master

--cambiamos a la rama master

git merge READMEmodificado

--combinamos los cambios hechos en la rama que creamos con la rama principal

git log

-- para conocer el registro de cambio

git status

--consultamos el estado de los cambios realizados

git push

--publicamos los cambios en el repositorio de GitHub (ya no es necesario usar origin master, solo se usan la primera vez) Con eso tendremos una mejor noción de lo que podemos realizar con Git, y en general darnos cuenta de lo valiosa que es esta herramienta.

Como convertirse en un codificador experto

2012-07-13T13:29:00.001-05:00

La programación es una parte vital dentro del proceso del desarrollo web, donde la creatividad garantiza mejores resultados. Si la codificación no esta al máximo potencial, el sitio resultante no llevará a cabo lo que se espera de éste, en el tiempo acordado, y el resultado será muy pobre. Con las buenas prácticas, un aspirante a programador puede fácilmente convertirse en un experto en poco tiempo, lo cual trae muchos beneficios consigo. En este articulo quiero discutir algunos tips para convertirse en un experto en codificación..

Aprende los conceptos básicos de programación

Es importante aprender los conceptos básicos de programación antes de seguir adelante en el camino. En primer lugar, el aspirante debe desarrollar la bases de programación, y a continuación, crear modificaciones usando lo aprendido para perfeccionar sus habilidades. Siempre es bueno ganar conocimiento de la sintaxis y el lenguaje usado en busca de buenos resultados, pero sin olvidar que la tarea no solo consiste en saber escribir código, sino en resolver problemas con el código que se escriba.

Mantente alejado de los “ladrones”

Mantenerse alejado de los ladrones es no trabajar con las empresas y personas que usan plantillas confeccionadas de programación. La mayoría de las empresas no se centran en tono a impartir conocimientos, sino que utilizan códigos pre-existentes para satisfacer sus necesidades. Cualquier asociación con tales delincuentes de seguro echara a perder tu creatividad en la medida de no permitir a los programadores desarrollar su potencial y excelencia al momento de codificar.

La aplicación de herramientas básicas de desarrollo

Hay una serie de herramientas básicas de desarrollo disponibles en torno a brindar ayuda en el proceso de codificación. Utilizar estas herramientas es un aspecto beneficioso para un programador que esta dispuesto a aprender los consejos y trucos del oficio. Estas herramientas pueden ayudar ala depuración de CSS y Javascript para obtener mejores resultados. Hay algunas herramientas avanzadas que podrian ser eficaces en su uso, pero nada útiles para aprender a codificar.

No uses los modos tradicionales

Basarse en los modos tradicionales de codificación no es una buena idea, si el aprendizaje es el objetivo. Los codificadores a menudo pasan de un editor a buscar los problemas resueltos en el navegador. En lugar de esa práctica, no ir al navegador hasta que el problema se resuelva es una buena táctica, ya que mejora el aprendizaje, brinda más conocimiento sobre el entorno en el que se trabaja y permite solucionar futuros problemas porque se conoce el más a fondo las herramientas.

Preferir la codificación manual

Dar preferencia a la codificación manual es otro paso en la dirección de aprender, usando consejos y trucos de la codificación. El uso de generadores de código no es una buena señal, ya que mata cualquier posibilidad de que se desate la creatividad. Escribir CSS con un generador de código de hecho te ahorrará mucho tiempo, pero no ofrece nada nuevo de aprender para un codificador novato. Cuando la sintaxis está escrita de forma manual, tienes la oportunidad de aprender muchas posibilidades para un desarrollador.

Evita la labor de “copy and paste”

Evitar el copiar y pegar es una de las cosas más importantes que un programador puede hacer para aprender mejores habilidades. El código debe ser escrito de manera manual para obtener nuevas habilidades y sobretodo el hecho de tomar un fragmento de código, copiarlo y pegarlo sin ningún esfuerzo, no agrega ningún valor agregado a nuestro independizar.

Nunca prefieren máquina o ayudantes

Preferir una máquina para generar códigos o la búsqueda de un editor, donde el trabajo manual es cercano a cero es una mala estrategia. De esta manera, un codificador, de nuevo, no va a aprender nada. Cuando un editor se ha seleccionado, le salva de todo tipo de problemas y le da un amplio margen de aprendizaje. Así que tener un editor de utilidad es más beneficioso que cualquier máquina o ayudantes cuando el objetivo es aprender el código.

Conclusión

No es fácil convertirse en un experto en la codificación, ya que en principio, un montón de trabajo duro tiene que ser hecho en el proceso. Ser creativo es el primer paso para convertirse en un programador experto.

Las mejores prácticas para programar en HTML5

2012-07-13T13:11:00.003-05:00

A continuación publico una lista de algunas de las mejores prácticas para programar en HTML5, entre estás Usar un generador de código HTML5, usar una cheat sheet o hoja de trucos como guía en tus desarrollos, revisar la compatibilidad de tus aplicaciones, como habilitar HTML5 en versiones viejas de Internet Explorer IE6, IE7 y IE8, utilizar correctamente los elementos HTML5 y por último validar tu código.

Usa un generador

Cuando se construye un sitio web, a menudo comienzan con una plantilla de base que se puede adaptar a sus necesidades. En lugar de escribir todo el código HTML5 desde el principio (ideal cuando recién estamos aprendiéndolo), puedes ahorrar tiempo mediante el uso de algunos generadores HTML5 muy útiles, disponibles en linea. Su uso es bastante fácil: se llena un formulario básico para configurar las opciones deseadas, haces clic en un botón y listo, una plantilla HTML5 básica ha sido generada para ti. Hay un montón de generadores HTML5, en particular recomiendo SwitchToHTML5 Y Shikiryu generator, que tiene algunas opciones más que el primero. Y si prefieres un producto más completo y listo para usar, HTML5 Boilerplate es lo que necesitas.

Usa una hoja de trucos (cheat sheet)

Con las nuevas adiciones o cambios en HTML5 que suceden con bastante frecuencia, puede llegar a ser difícil recordar todas las características nuevas y variadas. Una de las mejores herramientas para mantener a la vista las etiquetas de HTML5 y sus propiedades, es sin duda los cheat sheets creados por InMotion Hosting. Las cheat sheets o hojas de trucos se dividen en tres sencillas imagenes imprimibles: Etiquetas, Atribibutos de controladores de eventos y soporte de navegadores. Las tres ojas de trucos las puedes descargar aquí.

Ten cuidado con los asuntos de compatibilidad

HTML5 es una nueva tecnología, que ya se puede usar en los principales navegadores del mercado en sus versiones más recientes, pero hay que recordar que varias especificaciones no han sido implementadas en algunos navegadores. CanIUse.com es definitivamente un sitio web para tener en cuenta si estas desarrollando páginas web en HTML5. Es la herramienta más completa para conocer rápidamente si un elemento cuenta con soporto en un navegador especifico. CanIUse.com también contiene tablas de compatibilidad para CSS3, SVG y JavaScript.

Conoce cómo habilitar HTML5 en versiones antiguas de IE

Internet Explorer siempre ha sido un dolor de cabeza para los desarrolladores web y diseñadores. Estoy bastante seguro que la mayoría de los lectores deben tener experiencias de hacer que una pagina web funcione correctamente en IE6 y IE7... a pesar que las nuevas versiones de IE son mucho mejores de lo que solía ser, la pesadilla del desarrollador no ha terminado aún. De hecho, IE8 y las versiones anteriores no entienden absolutamente nada de HTML5. La buena noticia es que un pequeño script permite habilitar HTML5 en Internet Explorer 8 y versiones anteriores. El uso del script es muy simple, basta con pegar el siguiente código en la sección <head> de nuestros documentos en HTML5:

<!--[if lt IE 9]>
<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->

Otra herramienta muy útil para tener en cuenta es Modernizr, una completa biblioteca JavaScript que te ayudará a crear páginas web HTML5 que funcionen perfectamente en todos los navegadores. Usar Modernizr es bastante fácil. Sólo tienes que ir a la página siguiente, para especificar las propiedades HTML5/CSS3 que vayas a utilizar, a continuación, descarga el script generado. Incluyelo en la cabecera <head> de tu documento, y ya está. Modernizr detectará las característica que se puedan utilizar en el navegador del cliente y agregará cases en la etiqueta <html>. Si una función es compatible con el navegador, esa característica se añade por con su nombre y se adiere a la etiqueta para sustituir la funcionalidad. Si la función no está disponible, la clase se agrega y se le antepone un “no-”.

Utilice elementos correctamente

Antes de HTML5, soliamos codificar los sitios web usando muchos elementos <div>. El mayor problema con ésta técnica es, sin duda, que el código fuente se pude hacer dificil de leer. Es por eso que HTML5 introdujo nuevas etiquetas para usarse en lugar de la antigua <div>. Estas nuevas etiquetas incluyen header (cabecera), footer (pie de página), article (artículo), section (sección), aside (a un lado, aparte), nav (navegación) y muchas otrás. Un documento HTML5 básico debe tener el siguiente aspecto:

<!doctype html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <title></title>
</head>
<body>
 <header>
 ...
 </header>

 <div role="main">
 ...
 </div>

 <footer>
 ...
 </footer>
</body>
</html>

Valida tu código

Después de codificar tu pagina en HTML5, la forma más rápida y más eficaz para asegurarte de que tu código es semánticamente correcto es, en efecto mediante un proceso de validación. Un buen viejo amigo, el W3C Validator puede validar tus páginas HTML5 y te mostrará si haz cometido algún error. Es una gran herramienta para el control de calidad.

Entorno de Desarrollo de Ruby on Rails en Ubuntu 12.04

2012-07-13T13:00:00.004-05:00

Recientemente cree una guia de instalación de Ruby on Rails para Ubuntu 12.04, pero hoy he decido crear una nueva guia de instalación de RoR para Ubuntu 12.04 Precise Pangolin de una manera más simple y directa, recuerda que hay muchas maneras de hacer las cosas y que estos son mis ajustes y preferencias, pero como siempre tu puedes adaptarlos a tu manera de trabajo, asi que aquí voy:

Paso 1: Obtenga los repositorios y las actualizaciones de listas de ejecución.

sudo apt-get update && sudo apt-get upgrade

Paso 2: Agregar las aplicaciones requeridas.

[fancy_code_box]sudo apt-get install build-essential openssl libreadline6 libreadline6-dev git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion ruby ncurses-term mercurial ruby-dev exuberant-ctags libnotify-bin curl make ssh openjdk-6-jdk git-doc imagemagick postgresql-contrib libpq-dev postgresql pgadmin3 vim vim-rails vim-gnome nodejs[/fancy_code_box]

Paso 3: Configurar github, porque como sabes todo el mundo esta usando github.

git config --global user.name git-username

git config --global user.email git-email-address

ssh-keygen -t rsa -C git-email-address

Si tienes una cuenta de github, debes saber cómo agregar la clave que acaba de ser generarada en tu cuenta de GitHub. Si no lo sabes, por favor consulta la documentación que ofrece github siguiendo este ENLACE, o bien ve al post que realice, donde hablo del tema aquí.

Paso 4: Instalar RVM, Ruby y Rails

Éste en realidad ha cambiado un poco. Puede hacer las cosas de la misma manera como siempre lo haz hecho, sin embargo, también puede ejecutar un comando e instalar rvm, Ruby 1.9.3 y la última versión de Rails, que en el momento de este post era 3.2.6.

curl -L https://get.rvm.io | bash -s stable --rails
echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.bashrc 
source .bashrc

Tienes un entorno de desarrollo en marcha, pero yo nunca termino con el mínimo, y tú tampoco deberías!

Paso 5: Instalación de algunas otras gemas

No es necesario todo esto, y lo más probable es que los incluya en su Gemfile para la aplicación que desea utilizar, y esa es probablemente la manera correcta, pero usualmente se requiere de algunas otrás gemas, en particular estas son algunas de las que he estado probando.

heroku taps guard guard-rails guard-test guard-livereload pg capistrano rvm-capistrano devise cancan paperclip simple_form delayed_job rails_admin contact_us qwandry twitter-bootstrap-rails ZURB-foundation annotate pry prawn

Herramientas de desarrollo, útiles para trabajar con Ruby on Rails

Instalando Gedit-Gmate

Agrega esteroides para Rails al editor Gedit

sudo apt-add-repository ppa:ubuntu-on-rails/ppa
sudo apt-get update
sudo apt-get install gedit-gmate

Instalando Sublime Text 2

En resumen mi editor de código favorito, con amplio soporte para Rails.

sudo add-apt-repository ppa:webupd8team/sublime-text-2
sudo apt-get update
sudo apt-get install sublime-text

Instalando Retext 1.0 (Editor de markdowns)

sudo add-apt-repository ppa:mitya57
sudo apt-get update
sudo apt-get install retext

Configurando Vim para Rails

curl -Lo- https://bit.ly/janus-bootstrap | bash

Porqué aprender a programar en Ruby, algunas razones para aprender Ruby

2012-07-13T12:54:00.002-05:00

Como parte de mover las entradas relacionadas al Diseño y Desarrollo Web de mi blog hacia este secundario, esta vez traigo el post donde explico algunas de las razones por las que debes aprender a desarrollar en Ruby.

Cuando descubrí Ruby, me di cuenta que había encontrado lo que había estado buscando. Más que cualquier otro lenguaje con el que he trabajado. Ruby es un caso especial. Puedes concentrarte en la solución de los problemas del negocio, en lugar de luchar con los problemas del compilador y el lenguaje. Esto puede ayudarte a convertirte en un mejor programador, dándote la oportunidad de pasar más tiempo en la creación de soluciones para los usuarios y no para el compilador.

En años recientes, Ruby ha evolucionado muy bien. Un gran número de métodos se han añadido he incorporado en las clases y módulos existentes, y el tamaño de las librerías estándar (las bibliotecas incluidas en la distribución de Ruby) ha crecido enormemente. La comunidad ahora cuenta con un sistema de documentación estándar (RDoc), y RubyGems se ha convertido en el sistema de elección para el empaquetado de código en Ruby para su distribución. Contamos con el mejor framework de desarrollo web de su clase, Ruby on Rails, con otras excelente alternativas. Somos lideres en el mundo en lo que pruebas se refiere, con herramientas como RSpec y Cucumber, y se esta trabajando en la solución a difíciles problemas como el empaquetado o la gestión de dependencias, con excelentes resultados hasta ahora. Definitivamente Ruby es un lenguaje maduro, que debes probar.

He comenzado a publicar pequeñas guías acerca de Ruby on Rails, pero he decidido complementarlas con algunas lecciones de Ruby, porque aprender Rails sin saber Ruby, es como querer conducir una motos, sin saber andar en bicicleta, así que espera próximamente algunas lecciones de Ruby, pero si eres impaciente como yo, querras comenzar ya… así que aquí te dejo algunas guías y tutoriales que te ayudarán:

http://tryruby.org
Un sitio que te servirá de guía para aprender Ruby.

http://www.ruby-lang.org/es/documentation/quickstart/
Una pequeña guía de introducción desde la página oficial

http://www.ruby-lang.org/es/documentation/ruby-from-other-languages/
¿Vienes desde otros lenguajes de programación? Esta pequeña guía te servirá de gran ayuda

http://www.codeschool.com/courses/rails-for-zombies
Por último, quiero dejarte este sitio, para que tengas una probadita de Ruby on Rails.

Extras

Si todavía quieres mas razones para usar Ruby, te dejo con la conferencia que diera David Hansson (creador de Ruby on Rails). La conferencia està en ingles, y se centra menos en técnicas de programación y mas en la filosofía de Ruby, en general ¿Que hace a Ruby un lenguaje perfecto para ti y tus amigos? Hansson tiene la respuesta:

Instalar Ruby en Windows y Linux - [Aprender Ruby Básico - Parte 1]

2012-07-13T11:12:00.000-05:00

Con éste post comenzaré la serie para aprender lo básico sobre Ruby, luego les prometo postear algo sobre Sinatra, Capistrano, Heroku y por supuesto Rails. Mientras durante las próximas dos semanas, estaré publicando un curso de Ruby Básico, que servirá para introducirte al mundo de éste genial lenguaje de programación, en esta lección veremos algunas razones para aprender Ruby, la instalación de Ruby en Windows y Linux, y por último una introducción al IRS (Interactive Ruby Shell).

Porque Ruby?

Antes de iniciar, veamos algunas de las razones por las cuales querrias aprender Ruby. Hay buenas razones para pensar que ya sabes algo de PHP o de alguno de los "populares" lenguajes del lado del servidor, entonces, valdrá la pena aprender Ruby?

Aqui estan algunas razones por las cuales uso Ruby, y que lo hacen un irresistible lenguaje:

Ruby es flexible

En el proceso de aprendizaje de Ruby descubrirás que hay muchas maneras diferentes de codificar la misma parte de una funcionalidad. Ésto significa que como desarrollador puedes elegir la manera más expresiva de explicar lo que estas haciendo. Muchos desarrolladores dicen que Ruby les permite escribir su código como si lo estuvieran hablando. Es a causa de la flexibilidad.

Ruby es fácil de aprender

Ruby tiene una curva de aprendizaje bastante pequeña; luego que veas algunos screencast por tu cuenta, encontrarás que estarás comodo con la sintaxis y las ideas del lenguaje. Muy pronto te estaré enseñando lo básico de Ruby y empezarás a codificar, pero solo serás mejor si aprendes más, lee un libro, visita las comunidades del tema, busca videos del tema en Youtube...

Ruby tiene muchos Frameworks geniales

El framework obvio aca es Ruby on Rails. Sin embargo, hay muchos otros grandiosos frameworks, ya sea para la web o no, les hecharemos un vistazo durante éstas lecciones.

Ruby parece simple por encima, pero es complejo por debajo.

Finalmente, me gusta Ruby porque a menudo parece simple superficialmente. Sin embargo, esa simplicidad enmascara una enorme complejidad. Por ejemplo, algunas funcionalides que he escrito en otros lenguajes ya estan integradas en Ruby, permitiendome unicamente escribir un par de lineas de código.

Espero te hayas convencido que aprender Ruby es una buena inversión. Una cosa más: Quita el pensamiento de que Ruby es solo un lenguaje web del lado del servidor. Aunque puede serlo perfectamente, tienes que saber que además hay mucho Ruby fuera de la web, recientemente ha hecho su incursion en plataformas mobiles y en aplicaciones de escritorio integrales. Ruby no es un simple lenguaje web.

Instalando Ruby en Windows

Instalar Ruby en Windows es realmente simple- Solo debes ir al sitio web de Ruby y dar clic en "Download Ruby" a la derecha. Luego desplazate hacia abajo hasta encontrar la sección "Ruby on Windows", veráz que la más sencilla manera de hacerlo es usando RubyInstaller. Ahora mismo, escogeremos la última versión de Ruby, la cual es 1.9.2p???. Descargala e instalala, como cualquier otro programa de Windows.

Una vez que la hayas instalado, es bastante simple asegurarte que todo esta trabajando bien. Solo abre la linea de comandos e ingresa:

ruby --version

Estuvo fácil no?

Instalando Ruby en Linux (Ubuntu 12.04)

Para el caso de Linux, el procedimiento es un poco más largo, usaremos la RVM que nos servirá además para controlar diferentes versiones de Ruby en una sola maquina, como anteriormente habia creado un post sobre el tema, solo les dejo el enlace para que lleven a cabo la instalación:

Instalando Ruby con RVM en Linux

Conociendo el IRB (Interactive Ruby Shell)

Ahora que tenemos Ruby instalado, hechemos un vistaso a una de las principales herramientas que usaremos en las lecciones, llamada IRB que es una especie de linea de comandos shell que interactua directamente con Ruby. En mi caso usando Ubuntu solo debo ingresar irb en la consola y automaticamente entro en la IRB (Para salir bajo linux de irb presiona Ctrl + c) , asi que puedo desde ya hacer algunas operaciones, por ejemplo prueba con ingresar:

1 + 2 #Realiza una suma sencilla
print("Hello World") #Imprime en pantalla "Hello World"
puts "Hola Mundo" #Imprime en pantalla "Hola Mundo"

Puedes probar otras sentencias más complejas, de paso quiero recomendarte Try Ruby, un curso interactivo de 15 minutos sobre Ruby que te ayudará además a familirizarte con la IRB. Como podrás apreciar, luego de escribir una linea de código (y presionar enter), verás la evaluación de la linea que ingresaste, justo después de la flecha.

Al ejecutar las sentencias de arriba, print y puts (put string) son llamados a funciones. Nota que en una, se ha incluido el parametro en parentisis y en otra no. Comunmente en Ruby, los parentisis en el llamado de una función son opcionales. Yo pude haber llamado a print sin éstos, o a puts con éstos. Dependerá de tu sentido de stylo! También puedes ver que retornan nil (Equivalente a null en otros lenguages), lo que para Ruby es un valor nulo.

Como conclusión a la lección de hoy, veamos como se escribe una función. Puedes escribir una función en IRB: es lo suficiente inteligente para darse cuenta que necesita más antes de que pueda evaluar la función, y no retornara un valor despues de cada linea de código:

def saludo #enter
return "Hola que tal?" #enter
end
=> nill #retorna un valor nill
def saludo2 #enter
"no es necesario un return" #enter
end
=> nill #determina que el parametro es nulo y lo retorna
saludo #ejecutamos la primera función
=> "Hola que tal?" #retorna el valor de la función
saludo2 #ejecutamos la segunda función
=> "no es necesario un retorno"

Esto demuestra el siguiente principio de la sintaxis en Ruby: si bien puedes usar return al final de una función si asi lo deseas, no es necesario. Las funciones en Ruby automaticamente retornaran la evaluación de la última linea de la funcion. Por supuesto, utilizaras return cuando escribas funciones más complejas, como aquellas con multiples posibles valores.

Conclusión

En este tutorial, el primero en la serie "Aprender Ruby Básico", hemos instalado Ruby en nuestras computadoras y hechado un vistazo al IRB, una herramienta muy importante que será usada a menudo mientras exploremos un poco más de Ruby. Gracias por leerlo, y dejanos saber tus comentarios al respecto.

Instalando Ruby en Linux - Ubuntu 12.04

2012-07-13T09:43:00.002-05:00

En este tutorial veremos como instalar Ruby 1.9.3 en Ubuntu -en este caso particular usando Ubuntu 12.04-. Haremos uso de RVM que nos servirá para controlar diferentes versiones de Rails.

[ACTUALIZACIÓN] He creado un tutorial mas simplificado, con la nueva versión de RVM, puedes consultarlo aquí.

En resumen:

Actualizaremos los repositorios del sistema
Instalaremos git, curl, rvm.
Instalaremos los paquetes requeridos

1. Actualizar repositorios del sistema.

sudo apt-get update

2. Instalar git.

 sudo apt-get install git

3. Instalar curl

sudo apt-get install curl

4. Instalar RVM

curl -L get.rvm.io | bash -s stable

5. Agregar fuente, para comenzar a usar RVM Para esto ejecutamos el siguiente comando:

source ~/.rvm/scripts/rvm

6. Revisar los paquetes requeridos

rvm requirements

RVM necesita de algunos paquetes que servirán para ejecutar correctamente Ruby, y por ende Rails.

Dependencias

A continuación copiamos y ejecutamos algo similar a ésto:

sudo apt-get -y install build-essential openssl libreadline6 libreadline6-dev zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion

7. Instalar el Javascript runtime

sudo apt-get install nodejs

8. Instalar Ruby

rvm install 1.9.3

Antes de proceder con la instalación se nos mostrarán algunas dependencias, de las cuales hablabamos en el paso 6, simplemente presionamos ENTER y al final presionamos "q" para salir y continuar con la instalación de Ruby.

Instalando Ruby 1.9.3[/caption] Establecer Ruby 1.9.3 como la versión por defecto

rvm use 1.9.3 --default