Angel "Java" Lopez : Rails

Esos Raros Lenguajes Nuevos (1) VANs en ALT.NET Hispano

lopez — Mon, 09 Apr 2012 17:33:42 GMT

En Marzo dí una charla presencial en el Microsoft User Group de Argentina, en Buenos Aires, ver:

Esos Raros Lenguajes Nuevos: Javascript/Node, Scala, Erlang, Clojure, Ruby, Python

Ahora, el sábado que viene (14 de Abril) y el siguiente sábado (21 de Abril) la gente de ALT.NET Hispano ha organizado dos VAN (reuniones virtuales) para que pueda comentar sobre esos lenguajes, que no son tan raros ni tan nuevos, pero que en general pueden parecerlo dentro de la comunidad .NET:

- Javascript en NodeJs
- Scala
- Erlang
- Clojure
- Python
- Ruby

Este es el anuncio de la primera reunión:

La comunidad ALT.NET Hispano (http://altnethispano.org) realizará una VAN sobre Esos raros lenguajes nuevos NodeJs, Scala, Clojure, Erlang, Python, Ruby Parte 1, con Angel Java Lopez.

Fecha: Sábado 14 de Abril del 2012 a las 18:00 hrs. Hora Internacional (GMT/UTC), con una duración aproximada de 2 horas.

Pueden plantear sus comentarios e inquietudes sobre el tema de la reunión en: https://groups.google.com/d/topic/altnet-hispano/mRQRHvoAvKc/discussion

Para mayor información sobre cómo atender la reunión consulten: http://tinyurl.com/van-hispano

Mi idea es mostrar a qué problemas se orientan estos lenguajes. Por ejemplo, cómo tratan de resolver temas de escalabilidad y computación distribuida en los cuatro primeros (Javascript en NodeJs, Scala, Erlang, Clojure). Y cómo se ha ido formando comunidades, y ecosistemas de paquetes y desarrollo web, especialmente en los dos últimos (Python y Ruby). Mi plan es dar los tres primeros (Javascript/NodeJs, Scala, Erlang) este sábado que viene, y los otros (Clojure, Python, Ruby) en la siguiente sesión.

Este es el primer post de la serie, donde voy a ir escribiendo, comentando sobre recursos y enlaces que fui descubriendo, además de los ya presentados en el post que mencioné al principio.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Esos Raros Lenguajes Nuevos: Javascript/Node, Scala, Erlang, Clojure, Ruby, Python

lopez — Sat, 03 Mar 2012 18:21:37 GMT

El jueves pasado tuve el gusto de dar una charla sobre lenguajes, en el Microsoft User Group de Argentina, en su sede de Buenos Aires. Mi idea era presentar lenguajes de programación, alguno nuevo, otros ya con más de 15 años de existencia, que la comunidad de programadores .NET o de tecnologías Microsoft no ve frecuentemente.

Para mí, es un tema interesante: ver que a lo largo del tiempo, en la historia de la computación, hay lenguajes de programación que aparecen, tiene éxito u olvido. Pasan los años, y seguimos teniendo nuevos lenguajes. Vean que en el ambiente de las computadoras personales, no ha pasado lo mismo con los sistemas operativos: prácticamente se estabilizó en dos opciones con variantes: Windows y Linux (y otros Unix no derivados de Linux directamente). Podría poner Mac OS como aparte también. En cambio, en el ámbito de los lenguajes de programación, sigue habiendo actividad de creación, y viejos lenguajes aún sobreviven (desde Fortran hasta COBOL, y Smalltalk, por poner ejemplos diversos). Y aparecen lenguajes nuevos cada año, como en el 2011 que vió nacer a Dart, de la mano de Google (que también se animó antes a crear el lenguaje Go).

Los lenguajes que presenté fueron:
- Javascript (en NodeJs)
- Scala
- Erlang
- Clojure
- Ruby
- Python (no alcanzó el tiempo, pero lo incluyo en este post)

Un punto que destaqué es que los primeros cuatro (Javascript/NodeJs, Scala, Clojure, Erlang) tratan, entre otros objetivos, de encarar el problema de paralelismo, y multithreading. Ante la desaceleración de la ley de Moore, se trata de aprovechar el hardware de computadoras multicore. Eso lleva a que los lenguajes tengan que soportar múltiples threads (tema que casi todos hoy soportan, de una u otra forma, aunque algunos sólo recientemente: Smalltak, Ruby tuvieron mucho tiempo implementados “green threads”, hilos simulados por el lenguaje, sin aprovechar los threads del sistema operativo, que explotan los múltiples recursos del hardware). Pero también lleva a la complicación: tenemos que escribir programas contenplando múltitples hilos de ejecución, concurrencia, condiciones de carrera, lockeos, etc. Veremos que Erlang (y Scala con Akka) lleva a un paso más: ejecutar en varias máquinas. Ese camino es muy interesante para mí, porque libera la restricción de tener que explotar solamente una máquina: para procesos pesados (desde web crawling, big data, etc...) podemos repartir el trabajo en varias máquinas “normales”. De hecho, vean cómo el mercado de las supercomputadoras ha ido decayendo, porque desde fines del siglo pasado se han encontrado soluciones basadas en clusters, grillas, etc... con varias computadoras atacando un problema.

También quería mostrar que estos lenguajes se pueden probar en Windows, sin grandes problemas de instalación. Muchos de estos lenguajes “nuevos y raros” nacen en ambientes Unix/Linux y no siempre su instalación en Windows fue fácil. Pero en estos tiempos, ya tenemos un buen soporte de Windows para los lenguajes que presenté.

De cada lenguaje mostré algún ejemplo simple, y otro ejemplo más complejo (aunque corto) que mostrara alguna característica destacada. Espero poder volcar todos los enlaces y comentarios hechos en este post. Comencemos.

Javascript/NodeJs

Sitio: http://nodejs.org/
Descripción, Historia: http://en.wikipedia.org/wiki/Nodejs http://en.wikipedia.org/wiki/JavaScript
Download que usé: el de Windows v0.6.7 pero pueden usar cualquiera de Windows 6.x. La actual es http://nodejs.org/dist/v0.6.12/node-v0.6.12.msi
Listas de Correo: http://groups.google.com/group/nodejs http://groups.google.com/group/nodejs-dev
Ejemplos que usé: https://github.com/ajlopez/NodeSamples
Mostré un servidor HTTP simplícimo, hello world asincrónico, y dibujar en canvas multiusuario, usando el módulo socket.io
Mis enlaces: http://delicious.com/ajlopez/nodejs
Mis posts: http://ajlopez.wordpress.com/category/nodejs/ http://msmvps.com/blogs/lopez/archive/tags/NodeJs/default.aspx
En especial:
Programando Juegos Sociales en Línea (Parte 8) Agregando Node.js
http://msmvps.com/blogs/lopez/archive/2012/01/12/social_2D00_games_2D00_programming_2D00_part_2D00_8_2D00_adding_2D00_node_2D00_js.aspx
AjFabriq en NodeJs (Parte 3) Una aplicación Distribuida Simple
http://msmvps.com/blogs/lopez/archive/2011/09/15/ajfabriq_2D00_on_2D00_nodejs_2D00_part_2D00_3_2D00_a_2D00_distributed_2D00_simple_2D00_application.aspx

Javascript aparece como lenguaje en el lanzamiento del Netscape Navigator de 1995 (éramos tan pobres :-). Fue desarrollado por Brendan Eich http://en.wikipedia.org/wiki/Brendan_Eich de Netscape, con el nombre Mocha (un gusto de café como también lo es la palabra “java”) y luego LiveScript.
Node.js es creado por Ryah Dahl de Joyent http://joyent.com/ Pueden ver un video de introducción en http://ajlopez.wordpress.com/2011/10/15/code-snippets-are-for-sissies/

Comentarios:

Node.js tiene un REPL (Read Eval Print Loop)
Corre sobre el motor de Javascript Google V8. Un motor muy rápido, pero orientado a tener un solo thread a nivel de Javascript (en las librerías internas de C usa threads). Node.js entonces implementa servidores (y código general, si uno quiere) que ejecutan un solo thread de Javascript. Con eso evita el problema de programar en múltiples threads. Pero entonces ¿qué ganamos? Todo Node.js (sus funciones de base, los módulos adicionales) se orienta a ejecución asincrónica. Por ejemplo, el thread principal puede pedir una consulta a una base de datos (usando un driver/módulo de Node.Js adecuado) SIN QUEDARSE esperando la respuesta. El thread principal sigue ejecutando. Cuando la consulta de base de datos tiene algún resultado, lo anuncia (en un sistema interno de eventos). El thread principal de Javascript está atendiendo esos eventos. La escalabilidad se logra aprovechando que la entrada/salida (a disco, red, etc.) se puede derivar asincrónicamente, sin ocupar el thread principal. Internamente, usa características de los sistemas operativos (como el soporte de select() en Linux, o los Completion I/O ports de Windows).
En el ejemplo de dibujo sobre canvas usando socket.io, usamos npm para instalar el módulo:

npm install socket.io

desde el directorio Server

Scala

Lo ejecutamos con

scalac pingpong.scala
scala -cp . examples.actors.pingpong

Ejemplo de mensajes entre actores: http://www.scala-lang.org/node/50
Mis enlaces: http://www.delicious.com/ajlopez/scala
Mis posts: http://ajlopez.wordpress.com/category/scala/

Comentarios:

Es multiparadigma (soporta objetos/clases y programación funcional). Lenguaje de autor, creado principalmente por Martin Odersky http://en.wikipedia.org/wiki/Martin_Odersky Compila a Java y permite reducir la ceremonia (por ejemplo, soporte de declarar directamente un objeto único, sin necesidad de declarar clase). Soporta actores, ejemplo que mostré en la charla. Con actores, Scala evita que el programador tenga que encargarse de los lockeos y manejo de múltiples threads.
Sobre actores ver: http://delicious.com/ajlopez/actormodel http://en.wikipedia.org/wiki/Actor_model
y también message passing: http://en.wikipedia.org/wiki/Message_passing
Ver el proyecto Akka, que extiende Scala a actores distribuidos: http://akka.io/

Clojure

Sitio: http://clojure.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Clojure
Download: Ver http://clojure.org/downloads Yo usé http://repo1.maven.org/maven2/org/clojure/clojure/1.3.0/clojure-1.3.0.zip y también la versión 1.2.0
Listas de Correo: http://groups.google.com/group/clojure

Comentarios:

Vimos cómo Clojure es un dialecto de Lisp, y tiene homoniconicity http://en.wikipedia.org/wiki/Homoiconicity . Compila internamente a Java, y hay una versión para CLR (Common Language Runtime de .NET). Mostré en el ejemplo de Game of Life http://www.youtube.com/watch?v=CFCYVfApPUc http://github.com/sfraser/MultithreadedGameOfLife el uso de Software Transactional Memory, ver http://en.wikipedia.org/wiki/Software_transactional_memory que es una de las formas que tiene Clojure de “atacar” el problema de la concurrencia.
Para probar Clojure en línea ver http://tryclj.com/
Ver http://java.ociweb.com/mark/stm/article.html sobre STM

Erlang

Sitio: http://www.erlang.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Erlang_(programming_language)
Download: http://www.erlang.org/download.html Yo usé http://www.erlang.org/download/otp_win32_R15B.exe
Ejemplos: http://pragprog.com/titles/jaerlang/source_code del libro de Joe Armstrong Programming Erlang http://pragprog.com/book/jaerlang/programming-erlang Ejemplos más sencillos: https://github.com/ajlopez/ProgrammingLanguagesSamples/tree/master/Erlang a ir actualizando.
Primeros pasos: http://www.erlang.org/static/getting_started_quickly.html

Comunidad en Argentina: http://erlang.org.ar/
Lista de Correo de Argentina: http://erlang.org.ar/ListaDeCorreo

Comentarios:

Vimos que Erlang es un lenguaje funcional: no hay variables, una vez ligada una “variable” a un valor, no se puede modificar. Todas son funciones. Tenemos varios procesos. Vimos el ejemplo key value store (kvs.erl) del libro de Joe Armsgrong.

Ejecutamos en el REPL erl:

c(kvs).
kvs:start().
kvs:store(apple, 10).
kvs:lookup(apple).

Luego vimos de lanzar DOS cajas de DOS. En una:

erl -sname galdalf
c(kvs).
kvs:start().

en la otra ejecutamos:

erl -sname bilbo
rpc:call(gandalf@localhost, kvs, store, [apple, 10]).
rpc:call(gandalf@localhost, kvs, lookup, [apple]).

Caso de éxito http://couchdb.apache.org/ NoSQL reescrito en Erlang.

Post http://ajlopez.wordpress.com/2011/08/24/erlang-links-news-and-resources-1/
Mis enlaces: http://delicious.com/ajlopez/erlang

http://lambda-the-ultimate.org/node/4453 Long rant on Erlang-style Actors: Lost Dimension

Vean el lenguaje E:
http://erights.org/index.html
http://wiki.erights.org/wiki/Walnut
http://erights.org/talks/thesis/index.html

Ruby

Sitio: http://www.ruby-lang.org/en/
Descripción e Historia: http://en.wikipedia.org/wiki/Ruby_(programming_language)
Download: http://www.ruby-lang.org/en/downloads/ Yo usé http://rubyinstaller.org/downloads/ Revisar mis posts sobre detalles de instalación importantes, como el DevKit. Y tambien http://delicious.com/ajlopez/ruby+install

Mis posts: http://ajlopez.wordpress.com/category/ruby http://msmvps.com/blogs/lopez/archive/tags/ruby/default.aspx donde explico paso a paso instalación de Ruby, Rails, y un primer sitio Rails. Y también mi experiencia en el último Ruby Meetup de Buenos Aires.
Mis enlaces: http://delicious.com/ajlopez/ruby

Comunidad en Argentina: http://ruby.com.ar/
Conferencia 2011: http://rubyconfargentina.org/en
Lista de Correo Argentina, Latinoamérica: http://groups.google.com/group/rubysur
Sitio: http://rubysur.org/

Python

Sitio: http://python.org/
Descripción e Historia: http://en.wikipedia.org/wiki/Python_(programming_language)
Download: Hay dos versiones, usé http://python.org/ftp/python/2.7.2/python-2.7.2.msi y también tenía instalado http://python.org/ftp/python/3.2.2/python-3.2.2.msi Pero sólo la última instalación está ligada a ejecutar automáticamente los archivos .py, ver http://stackoverflow.com/questions/3809314/how-to-install-both-python-2-x-and-python-3-x-in-windows-7

Ejemplos simples: https://github.com/ajlopez/ProgrammingLanguagesSamples/tree/master/Python
Comunidad en Argentina: http://python.org.ar/pyar/
Lista de Correo en Argentina: http://listas.python.org.ar/listinfo/pyar
Vean el video anunciando la próxima PyCon http://animoto.com/play/zVp1IGeGaLVKco0FDlwcmA
Mostré Django
https://www.djangoproject.com/
https://docs.djangoproject.com/en/1.3/topics/install/#installing-official-release
C:\Software\Django-1.3.1
https://docs.djangoproject.com/en/1.3/intro/tutorial01/

Ver también
IronPython (Python running on .NET)
Jython (Python running on the Java Virtual Machine)
PyPy (A fast python implementation with a JIT compiler)
Stackless Python (Branch of CPython supporting microthreads)

Ver la implementación web: http://webpython.codepoint.net/wsgi_tutorial madre de otras implementaciones como Rack en Ruby, y OWIN en .NET

Mis enlaces: http://delicious.com/ajlopez/python
Mis posts: http://ajlopez.wordpress.com/category/python/

Patrones encontrados

Existencia de REPL: todos
Compilación a otro lenguaje: Scala, Clojure, usando la máquina virtual y librerías de clases existentes
Pasaje de Mensajes: Erlang
Módulos: todos
Actores: Scala, algo también en Clojure y Erlang
Software Transactional Memory: Clojure

Bueno, espero que les haya dado un panorama de que hay vida más allá de C# y Java ;-)

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Ruby on Rails, Aplicación de Demo (1) Creando la Aplicación

lopez — Thu, 09 Feb 2012 17:32:35 GMT

Ya estuve escribiendo una serie de posts sobre mi experiencia en el pasado Ruby Fun Day en Buenos Aires:

Mi Día en el Ruby Fun Day con @bendycode

Ahora quiero comenzar a pasar en limpio mis pasos de aprendizaje estudiando el capítuylo 2 del libro de Michael Hartl : Ruby on Rails Tutorial: Learn from Example. Yo estoy siguiéndolo con la versión 3 de Ruby on Rails.

Ya había instalado Ruby en mi máquina Windows, usando http://rubyinstaller.org/ (otras opciones en http://www.ruby-lang.org/en/downloads/). En Windows, debemos instalar también DevKit (un “minimalist GNU for windows” (mingw)). Vean la página de Ruby Installer para el enlace de bajada. Las instrucciones para instalarlo están en http://github.com/oneclick/rubyinstaller/wiki/Development-Kit. (otros detalles).

Luego de todo eso, ejecuté el comando para instalar rails, en cualquier command prompt:

gem install rails

lo que instala Ruby on Rails, el framework de desarrollo de sitios web escrito en Ruby. Vean que es una gema (gem) que se instala como cualquier otra estando en línea. Ahora vamos a un directorio de trabajo (en mi caso c:\Git), donde ejecutamos

rails

Salida:

Luego ejecuté

rails new RailsDemoApp

con salida:

Eso crea un nuevo directorio, me cambio a ese:

cd RailsDemoApp

Este es el árbol de directorios que tengo:

Ruby maneja gemas (paquetes a instalar). Como vimos, Rails mismo es una gema. Y una aplicación Rails, como la recién creada, tiene un archivo GemFile donde se especifican las gemas que esta nueva aplicación necesita. Es usual entonces apelar a un programa que revisa ese archivo e instala cualquier gema que se necesite y no esté instalada. Ejecuto:

bundle install

Bundle es el nuevo instalador de paquetes que usa Ruby on Rails 3. Lee el archivo GemFile e instala (en el directorio de Ruby, en nuestra máquina, no en el directorio de la aplicació) las gemas que necesite. Ahora podemos ejecutar:

bundle show

Configuré el directorio actual (Git\RailsDemoApp) para que sea un repositorio Git:

git init
git add .
git commit –m “Initial Commit”

Agregué un nuevo repositorio en mi cuenta de GitHub usando https://github.com/repositories/new:

El nuevo repo: https://github.com/ajlopez/RailsDemoApp

Lo agregué como repositorio remoto a mi repo local, y envié lo que tengo a GitHub:

git remote add origin git@github.com:ajlopez/RailsDemoApp.git
git push origin master

Ya desde la instalación de bundle, podemos lanzar el servidor con

rails server

o en su forma corta

rails s

Veo el resultado en http://localhost:3000

Próximos pasos, para siguientes posts: agregar un modelo simple (usuarios, y microposts, con relación uno a varios), base de datos, vistas, controladores, “scaffolding”, y despliegue en Heroku. El Scaffolding (generació de código para CRUD) será la aproximación a usar en los próximos posts, como en el libro de Hartl, pero despues me gustaría escribir sobre cómo construir un sitio Rails paso a paso, como hace el mismo Hartl a partir del capítulo 3 de su libro.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mi Día en el Ruby Fun Day (7) Primer Modelo

lopez — Sat, 04 Feb 2012 18:01:31 GMT

Anterior Post

Una de las grandes “features” de Rails es poder generar código, definiendo un modelo simple. En el curso decidimos implementar una lista de charlas, con oradores. Para Orador, definimos modelo Speaker y se generó código con:

La clave es la opción generate del comando rails. Con esa opción se pueden generar distintos archivos de texto, con scaffold genera los controladores, vistas, y modelos, con acceso a datos, de un modelo simple. El modelo se describe con Speaker name:string (se pueden poner más campos de distintos tipos).

Generó varios archivos, como app/models/speaker.rb:

class Speaker < ActiveRecord::Base
end

O el controlador app/controllers/speakers_controller.rb:

class SpeakersController < ApplicationController
  # GET /speakers
  # GET /speakers.json
  def index
    @speakers = Speaker.all
    respond_to do |format|
      format.html # index.html.erb
      format.json { render json: @speakers }
    end
  end
  # GET /speakers/1
  # GET /speakers/1.json
  def show
    @speaker = Speaker.find(params[:id])
    respond_to do |format|
      format.html # show.html.erb
      format.json { render json: @speaker }
    end
  end
  # GET /speakers/new
  # GET /speakers/new.json
  def new
    @speaker = Speaker.new
    respond_to do |format|
      format.html # new.html.erb
      format.json { render json: @speaker }
    end
  end
  # GET /speakers/1/edit
  def edit
    @speaker = Speaker.find(params[:id])
  end
  # POST /speakers
  # POST /speakers.json
  def create
    @speaker = Speaker.new(params[:speaker])
    respond_to do |format|
      if @speaker.save
        format.html { redirect_to @speaker, notice: 'Speaker was successfully created.' }
        format.json { render json: @speaker, status: :created, location: @speaker }
      else
        format.html { render action: "new" }
        format.json { render json: @speaker.errors, status: :unprocessable_entity }
      end
    end
  end
  # PUT /speakers/1
  # PUT /speakers/1.json
  def update
    @speaker = Speaker.find(params[:id])
    respond_to do |format|
      if @speaker.update_attributes(params[:speaker])
        format.html { redirect_to @speaker, notice: 'Speaker was successfully updated.' }
        format.json { head :ok }
      else
        format.html { render action: "edit" }
        format.json { render json: @speaker.errors, status: :unprocessable_entity }
      end
    end
  end
  # DELETE /speakers/1
  # DELETE /speakers/1.json
  def destroy
    @speaker = Speaker.find(params[:id])
    @speaker.destroy
    respond_to do |format|
      format.html { redirect_to speakers_url }
      format.json { head :ok }
    end
  end
end

Y distintas vistas en app/views/speakers como index.html.erb:

<h1>Listing speakers</h1>
<table>
  <tr>
    <th>Name</th>
    <th></th>
    <th></th>
    <th></th>
  </tr>
<% @speakers.each do |speaker| %>
  <tr>
    <td><%= speaker.name %></td>
    <td><%= link_to 'Show', speaker %></td>
    <td><%= link_to 'Edit', edit_speaker_path(speaker) %></td>
    <td><%= link_to 'Destroy', speaker, confirm: 'Are you sure?', method: :delete %></td>
  </tr>
<% end %>
</table>
<br />
<%= link_to 'New Speaker', new_speaker_path %>

Luego, levantamos el servidor de nuevo con:

rails server

Levanta el servidor como antes, pero si navegamos a http://localhost:3000/speakers

Resulta que se generó código para soportar una lista de oradores, y una tabla de oradores en la base de datos, pero esta última todavía está vacía, sin la tabla correspondiente. El generador de código de Rails se encargó de dejar también los comandos de actualización de la base. Ejecutamos:

Vean que crea la tabla de Speakers (ver el directorio db/migrate donde quedó un archivo que define el paso 20111218214020_create_speakers.rb:

class CreateSpeakers < ActiveRecord::Migration
  def change
    create_table :speakers do |t|
      t.string :name
      
      t.timestamps
    end
  end
end

Noten que el nombre del archivo tiene la fecha/hora de creación, para luego reproducir en orden los comandos contra la base de datos para que ésta quede actualizada. Ahora, navegamos de nuevo a http://localhost:3000/speakers:

Puedo dar de alta un orador:

Y el resultado es:

Bien! Ya tenemos nuestro primer modelo simple, y las páginas (noten las URLs que se formaron) para manejarlo.

Próximos temas: extendiendo el modelo, relaciones uno a varios, desplegando en Heroku.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mi Día en el Ruby Fun Day (6) Rake y Bundler

lopez — Fri, 25 Nov 2011 10:06:00 GMT

Anterior Post
Siguiente Post

Una de las utilidades que viene con el Ruby Installer es el rake. Rake es un “make” para Ruby. Se basa en leer un Rakefile donde se definen las tareas. Notablemente, ese archivo es código Ruby. Rails nos dejó este archivo en el directorio de nuestra aplicación.

#!/usr/bin/env rake
# Add your own tasks in files placed in lib/tasks ending in .rake,
# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
require File.expand_path('../config/application', __FILE__)
MyRails::Application.load_tasks

El método load_tasks no está definido directamente en MyRails::Application (que está definida en config/application.rb) sino que se hereda de Rails::Application. Pero uno podría sobreescribir el método.

Si ejecutamos rake –T tenemos la lista de tareas que reconoce:

Vean que hay tareas para crear la base de datos, y para migrarla cuando tengamos nuevas tablas. Ya lo haremos cuando definamos algún modelo. Probemos ahora rake stats:

Nos muestra la cantidad de controladores, clases, líneas de código, métodos, etc.

Otro archivo (que apareción en Rails 3.x ver http://edgeguides.rubyonrails.org/3_0_release_notes.html) es el Gemfile:

source 'http://rubygems.org'
gem 'rails', '3.1.1'
# Bundle edge Rails instead:
# gem 'rails',     :git => 'git://github.com/rails/rails.git'
gem 'sqlite3'
# Gems used only for assets and not required
# in production environments by default.
group :assets do
  gem 'sass-rails',   '~> 3.1.4'
  gem 'coffee-rails', '~> 3.1.1'
  gem 'uglifier', '>= 1.0.3'
end
gem 'jquery-rails'
# To use ActiveModel has_secure_password
# gem 'bcrypt-ruby', '~> 3.0.0'
# Use unicorn as the web server
# gem 'unicorn'
# Deploy with 

# gem '

'
# To use debugger
# gem 'ruby-debug19', :require => 'ruby-debug'
group :test do
  # Pretty printed test output
  gem 'turn', :require => false
end

Es un archivo que define que gemas vamos a usar en nuestra aplicación. Este archivo es consumido por Bundler:

https://github.com/carlhuda/bundler
http://gembundler.com/

Si ejecutamos bundle:

Al final dice:

Así, con bundle show sqlite3 obtenemos:

Vean que deja un archivo Gemfile.lock con información de las gemas que termina usando.

Vayan notando la manera que trabaja el ecosistema de Ruby (con gemas) y Rails (adoptando algunas gemas para sus tareas). También noten que todo evoluciona: el Rails que estoy probando (versión 3.1.1) tiene bundler, cuando los anteriores (2.x) no lo tenían.

Próximos posts: armar un modelo sencillo, crear la base, probarlo, modificarlo, migrar la base, publicar.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mi Día en el Ruby Fun Day (5) Lanzando Rails

lopez — Tue, 22 Nov 2011 10:35:00 GMT

Anterior Post
Siguiente Post

Ahora ya tenemos generado nuestro primer sitio Rails. Recordemos la estructura:

Vamos a ver que Rails se basa en Modelo-Vista-Controlador. Vean el primer controlador que tenemos disponible \MyRails\app\controllers\application_controller.rb:

class ApplicationController < ActionController::Base
  protect_from_forgeryend

Vean \MyRails\app\views\layout\application_view.rb:

<!DOCTYPE html>
<html>
<head>
  <title>MyRails</title>
  <%= stylesheet_link_tag    "application" %>
  <%= javascript_include_tag "application" %>
  <%= csrf_meta_tags %>
</head>
<body>
<%= yield %>
</body>
</html>

Vamos a ver que lo de arriba está escrito en un lenguaje de templates (ERB) nativo de Ruby, que permite insertar código en el medio de texto (jeje… por qué no me sorprende ;-). Pero todo esto todavía no se está usando. La aplicación generada tiene un simple index.html en el directorio public.

Si ejecutamos rails en la línea de comando:

Hay varios subcomandos a explorar. El más interesante será el generate que permite ir generando código (vieron la luz! ;-) desde un modelo que vamos definiendo por línea de comando. Hoy probamos rails server:

Levanta un servidor web (veremos que Rails se basa en otras gemas, como WEBRick para conseguir esto). Podemos verlo en http://localhost:3000

Próximo paso recomendado es el rails generate. En el curso generamos un modelo simple con charlas y oradores. Veremos algo así en los próximos posts. Tengo que estudiar las rutas, y las distintas opciones de rake que nos van quedando (pueden espiar el Rakefile que quedó generado en el directorio MyRails, mientras tanto)

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mi Día en el Ruby Fun Day (4) Usando Git

lopez — Tue, 15 Nov 2011 11:06:00 GMT

Anterior Post
Siguiente Post

Un punto que Stephen Anderson usó todo el tiempo, es Git. Yo ya lo tenía instalado en mi máquina. Lo pueden instalar desde:

http://code.google.com/p/msysgit/downloads/list

Lo configuré en su tiempo para que estuviera en el Path (el instalador pregunta si quieren esa opción). Si quieren un cliente gráfico, pueden usar:

http://code.google.com/p/tortoisegit/downloads/list

Luego de creada la aplicación Rails (que todavía no lanzamos), me cambié al directorio de la misma, y lo preparé para ser un repositorio git:

El git add . agrega los archivos del directorio actual (y subdirectorios) a lo que se llama el “index” de git: digamos un área de “staging” antes del commit. El directorio de la aplicación es ahora el “working directory”. Pero no se hace commit de ese directorio, sino de lo que está en el “index”. De ahí la necesidad del comando add: decirle a git cuáles archivos del “working directory” se agregan al “index” para ser enviados en el próximo commit en el repositorio local (recuerden: git tiene repositorio local).

El primer commit:

El –m permite poner el mensaje de commit.

Como quiero tener el código también en mi repositorio de Github, y no sólo en mi máquina, creé un repositorio en GitHub:

Con este comando agrego un nuevo repositorio remoto de este proyecto (pueden tener varios), llamado tradicionalmente “origin”:

Es tiempo de enviar lo que está en el repositorio local al remoto:

Pueden ver el estado de mi repositorio remoto en:

https://github.com/ajlopez/MyRails

Próximos posts: levantar y probar la aplicación Rails, generar un modelo.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mi Día en el Ruby Fun Day (3) Creando una aplicación Rails 3

lopez — Mon, 14 Nov 2011 08:23:00 GMT

Anterior Post
Siguiente Post

En el anterior post, llegué a instalar Rails. Ahora queda disponible un comando en el PATH:

Si ejecutamos Rails new <name> se crea un directorio con toda la estructura de una aplicación Rails:

Pero vean que me dió error:

¿Qué pasa? Está tratando de compilar algo (supongo que en lenguaje C) del json (1.6.1), además de crear directorios y archivos. Y en Windows, nos faltan las herramientas de compilación que espera Rails. El mensaje nos lleva de nuevo a:

http://rubyinstaller.org/downloads/

donde me descargué el DevKit (es un archivo .exe). Atención, al ejecutarlo tiene que poner el directorio destino. Yo puse c:\Software\DevKit. Este es el directorio que quedó:

Una vez que el ejecutable creó ese directorio, hay que seguir las instrucciones de:

http://github.com/oneclick/rubyinstaller/wiki/Development-Kit

que son:

- Pasar al directorio de DevKit, en mi caso c:\Software\DevKit.

- Ejecutar ruby dk.rb init.

Esto genera un archivo config.yml con detecta todos los Ruby que están instalados y fueron detectados por el comando:

En mi máquina detectó c:\Ruby193. Pueden editarlo si tienen otros Ruby instalados.

- Luego hay que ejecutar ruby dk.rb install:

Ahora sí, puedo volver al directorio de trabajo (en mi caso c:\Git). Y ejecutar de nuevo el comando de creación de nuestra aplicación:

No hay problema en que algunos archivos ya existan. Pueden tener alguna pregunta como:

Contesté Y (Yes). Al final, queda esta aplicación Rails:

Próximos posts: usando git, lanzando la aplicación Rails, creando el modelo.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mi Día en el Ruby Fun Day (2) Instalando Ruby y Rails

lopez — Sat, 12 Nov 2011 17:10:00 GMT

Anterior Post
Siguiente Post

El domingo pasado estuve en el Ruby Fun Day, asistiendo a la Introducción a Ruby on Rails, el framework de desarrollo web escrito sobre Ruby. Stephen Anderson fue el instructor. Veamos si puedo pasar en limpio y por escrito los temas y ejercicios que hicimos.

Se recomendaba llegar con una notebook que ya tuviera instalado Ruby. Yo lo tomé de la página recomendada por RubyConf Argentina:

http://www.ruby-lang.org/en/downloads/

Yo usé Windows, así que usé RubyInstaller:

http://rubyinstaller.org/

Anderson también recomendó, para la gente que tenía Linux, usar RVM (Ruby Version Manager):

https://rvm.beginrescueend.com/rvm/install/

que permite especificar por directorio/proyecto cuales gemas (gems) vamos a usar (creo que se editaba un archivo .rvmrc). Las gemas son paquetes que se instalan localmente, con el comando gem (por ejemplo, el propio Ruby on Rails está empaquetado como una gema). Ni bien entramos al directorio configurado, rvm cambia las variables de ambiente (como GEM_HOME) para que apunte a un directorio donde están las gemas del proyecto. Entonces, con RVM podemos armar “gem sets”, conjuntos de gems que estarán activas cuando trabajemos con un proyecto. Esto permite que en un proyecto A estemos trabajando con unas gemas, tal vez con la gema X v 1.2, y en otro proyecto podemos referenciar a otras gemas o a las mismas pero de otra versión. Esto tiene un precio: mayor espacio en disco. Cada gem set guarda las gemas en un directorio propio: por lo que comentaron en el workshop, no establece enlaces simbólicos, así que una gema instalada en en el gemset “WebProjects” puede estar duplicada en otro gemset “CustomerXProjects”.

Para los que trabajamos en Windows, la página de instalación recomienda pik:

https://github.com/vertiginous/pik

Yo no usé todavía, pero espero que llegue la oportunidad de necesitarlo.

Luego de ejecutar RubyInstaller (con todas las opciones, como agregar su directorio binario en el PATH), tengo disponibles comandos como:

que es un intérprete interactivo. El instalador me dejó en el menú de sistema:

Les recomiendo el libro de Ruby que queda instalado.

Uno de los comandos (más importantes) es gem, con gem list veo las gemas que quedaron instaladas desde el principio:

Por ejemplo, rake es un “make” para Ruby. Puedo ejecutar rake –T para ver las tareas que ahora tiene definidas:

Vean que da error porque necesita un rakefile en el directorio actual.

Luego de instalar Ruby, llegó el momento de instalar Rails, el framework web más popular de Ruby, y el tema del workshop. Lo instalé con:

Ese es un listado parcial. Instala casi treintae gemas, trayéndolas de repositorios en línea (así que necesitan estar conectados para este comando). También genera dos tipos de documentación para cada gema: como en general la documentación está en línea, tal vez les convenga no generarla localmente. Pueden agregar los parámetros –no-ri –no-rdoc para que no genere los dos formatos de documentación asumidos:

gem --no-ri --no-rdoc install rails

También pueden ponerlo como asumido en gem, ver:

http://stackoverflow.com/questions/1381725/how-to-make-no-ri-no-rdoc-default-for-gem-install

Les recomiendo saltarse la documentación, porque es la parte que más tarda de la instalación. Si luego quieren sacar documentación del disco, es tan simple como borrar los directorios de documentación de cada gema (más abajo muestro donde quedaron en mi instalación).

Rails es bastante “grande” para instalar, vean otro listado parcial del avance de mi instalación:

Vean dónde dejó las gems y la documentación (mi directorio de instalación es C:\Ruby193):

Pueden conocer la versión de Ruby y de Gem instalada, ejecutando:

MinGW significa Minimalist GNU for Windows, ver:

http://www.mingw.org/

Vean que con el comando:

se levanta un servidor local con información de las gemas instaladas:

Noten que Ruby tiene un ecosistema de gemas muy bien armado y activo. Es practicamente “imposible” trabajar en Ruby sin el comando gem.

Durante el curso, la instalación de Rails en mi máquina habrá tardado de 20 a 30 minutos. Así que tengan paciencia. Estimo que el tiempo baja a un tercio o menos si evitan instalar la documentación (hay comandos para generarla luego).

Próximos posts: creando nuestra primera aplicación web Rails, usando Git, describiendo modelos, desplegando en Heroku.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez