La oferta:

Te unirás a un equipo con años de experiencia que usa metodologías Scrum/Kanban. Pensamos en términos de soluciones y no en términos de tecnologías o “no se puede”. Trabajarás con el equipo de desarrollo, el de gestión de producto y el de planificación. Aseguramos la calidad del producto usando técnicas como revisiones de código, integración contínua y testing automático. Esperamos que, día a día, aportes soluciones para la mejora contínua de nuestra plataforma. Trabajarás con tecnología “cutting edge”, ya que nuestra industria es relativamente nueva.

Como ingeniero de software:

• Salario máximo de €5.000, por 40 horas a la semana
• Ordenador portátil y smartphone de tu elección
• Training y desarrollo personal
• Oficina molona en Ámsterdam

Requerimientos:

• Formación y actitud universitaria
• Mínimo de 3 años trabajando en un entorno de desarrollo ágil como ingeniero de software
• Experiencia notable en Ruby on Rails, PHP, Python o Java
• Experiencia notable en desarrollo web, orientado a objetos y MVC
• Dedicación a la calidad usando revisiones de código, integración contínua y testing automático
• Familiaridad con HTML, CSS, Javascript y Ajax

Interesados, email a: cesar@pebbl.es

This is my way of stirring the pot here in Valencia and the first step in my plan for world domination. Stay tuned.

Besides Ignite, I have been hiding for a couple months in the beCode cave, pretending to program and mingling with the kung-fu masters..

A toro pasado todo parece tan fácil. Como si no hubiera podido ser de otra manera. Pero sin el apoyo de Rebeca, Xavi, Carballo, Manu, Mária, Dani, Marta y otros voluntarios habría sido otra cosa.

Semanas antes del evento, me reuní con cada uno de los voluntarios cara a cara, una lección aprendida coordinando a más de 70 voluntarios en el TEDxValencia. Aparte de explicarles “qué” quería que hicieran y que me contaran “cómo” querían hacerlo, quería contarles el “porqué”:

¿Y porqué hemos organizado Ignite Valencia? Para remover las aguas. Para provocar las mentes. Para encender intelectos y curiosidades. Para conectar grupos de gente apasionada. Para eliminar los cortafuegos. Para que se planten las semillas de nuevas colaboraciones y proyectos. Y para muchas otras cosas que se nos escapan y están fuera de nuestras expectativas iniciales.

En breve colgaremos los vídeos de las charlas pero mientras tanto, aquí tenéis las fotos que nos regaló Marina de Inclós foto.

Gracias a Openfinance por el “rescate” de último minuto con su patrocinio del proyector. Gracias a beCode el soporte logístico pre y post evento. Gracias a Barret Films por filmar el evento y conseguirnos una entrevista en Levante TV. Gracias a Ópera por creer en nosotros. Gracias a Aplikados por la cartelería y material gráfico. Gracias a Aduo por las chapitas de regalo. Gracias a en General por agitar a las masas. Gracias a Trampoline manager por coordinar la impresión del material gráfico. Y finalmente gracias a Marta Rosella por sus artículos en lamono y ARA multimedia.

Esta es mi manera agitar las aguas en Valencia y es el primer paso en mi masterplan de clonar a VlcTechHub. Permanezcan a la escucha.

Aparte de todo esto, llevo ya un par de meses metido en la madriguera de beCode, haciendo como que programo y mareando a los maestros de kung-fu y del hachazo.

Ejecuta el último comando, pero con sudo delante. Muy útil para todas las veces que se teclea un “churro” enorme y el sistema responde: “You don’t have permissions…”

La lógica, si es que hay alguna, detrás de todo esto es crear un sitio donde se venga a trabajar y a jugar, a aprender y a enseñar y en definitiva a construir cosas. Para un soldado de fortuna como yo, es una manera de tener acceso a un equipo de expertos que me apoye en cualquier proyecto. Para el colectivo, se suma un colaborador en el que apoyarse para multiplicar fuerzas.

Hoy inauguramos “la cueva” de BeCode, el espacio que nos une. Si tenéis una oportunidad, no dudéis en pasar a saludar y tomar algo con nosotros.

La solución, refactorizada (en pastebin, para mayor legibilidad), y los tests.

La mejoras:

• He dividido la clase Parseator en dos, creando una clase separada para el modelo de la gramática a parsear, y otro para el parseador en si.
• He usado atajos de Ruby y construcciones tipo case para simplificar (o no) el código.

La kata en si no era muy compleja (enunciado en PDF), pero el truco estaba en que había que programarla usando técnicas de TDD. Interesante, puesto que una de las desventajas del TDD es que la velocidad inicial de desarrollo es bastante baja.

Para desarrollar la kata nos emparejaron e hicimos dos pomodoros de desarrollo con cinco minutos de descanso para discutir en grupo por dónde íbamos.

Resumen de la kata

La kata en si consistía en desarrollar un intérprete de líneas de comando al que se le pasan flags de tres tipos:

• -l: Flag booleano
• -p 8080: Flag numérico
• -d /tmp/log: Flag de texto

El primer paso es desarrollar un esquema en el que se indiquen los flags que acepta el programa, de qué tipo son y el valor por defecto si se omite el flag. Una vez tenemos el esquema, el programa tiene que ser capaz de interpretar una cadena de entrada, analizar si es sintácticamente correcta, analizar si es semánticamente correcta y lanzar excepciones si la entrada no es correcta.

Finalmente… antes de enseñaos la solución

Desde aquí, gracias a la gente de CSD por organizar el Dojo en las mazmorras de su oficina y por echarnos de comer y beber (free beer!) mientras programábamos.

Nuestra solución

Aunque no conseguimos resolver la kata en dos pomodoros, aquí estos son los tests y la solución en Ruby que creamos mi compañero Yago y yo.

Los tests:

require_relative '../lib/parseator.rb'

describe Parseator do
  before :each do
    @example_in = {"l" => ["bool", false],
                           "p" => ["number", 8080],
                           "d" => ["string", "/usr/local"] } 
    @parser = Parseator.new(@example_in)
  end
  describe ", Sintactic Tests" do
    it "instantiates a Parseator object" do
     @parser.should be_an_instance_of Parseator
    end
    it "parses the empty string as valid" do
      @parser.valid?("").should ==  true
    end
    it "fails if first flag does not start with -" do
      @parser.valid?("poop").should ==  false
    end
    it "parses a single boolean flag" do
      @parser.valid?("-t").should ==  true
    end
    it "parses N boolean flags" do
      @parser.valid?("-p -m").should == true
    end 
    it "parses a single flag with args" do
      @parser.valid?("-p 8080").should == true
    end 
    it "parses a mix of boolean and arg flags without negative numbers" do
      @parser.valid?("-p 8080 -m -l /hola/yo").should == true
    end 
    it "parses a mix of boolean and arg flags without negative numbers with traling and leading spaces" do
      @parser.valid?("-p 8080 -m -l /hola/yo").should == true
    end 
    it "fails with an incorrect mix of boolean and arg flags with negative numbers" do
      @parser.valid?("-p 8080 -m -500 p -l /hola/yo").should == false
    end 
    it "parses a mix of boolean and arg flags with negative numbers" do
      @parser.valid?("-p 8080 -m -500 -l /hola/yo").should == true
    end 
    it "parses a mix of boolean and arg flags with negative numbers without spaces before argument" do
      @parser.valid?("-p8080 -m -500 -l /hola/yo").should == true
    end 
  end

  describe ", Semantic Tests, " do
    it "raises exception when passing a flag that is not defined" do
      lambda { @parser.parse("-t") }.should raise_error UndefinedParam
    end
    it "returns a hash with default value when passing a single boolean flag" do
      test_string = "-l"
      @parser.parse(test_string).should have_key("l") 
      @parser.parse(test_string)["l"].should == true
    end
    it "returns a hash with false when passing an empty string, for the boolean flag" do
      @parser.parse("").should have_key("l") 
      @parser.parse("")["l"].should == false
    end
    it "returns a hash with value when passing a single string" do
      test_string = "-d /usr/bin"
      @parser.parse(test_string).should have_key("d") 
      @parser.parse(test_string)["d"].should == "/usr/bin"
    end
    it "returns a hash with value when passing a single number" do
      test_string = "-p 8080"
      @parser.parse(test_string).should have_key("p") 
      @parser.parse(test_string)["p"].should == 8080 
    end
    it "returns a hash with value when passing a single negative number" do
      test_string = "-p -8080"
      @parser.parse(test_string).should have_key("p") 
      @parser.parse(test_string)["p"].should == -8080 
    end
    it "returns correctly when passing mix of strings, booleans and numbers" do
      test_string = "-p -8080 -l -d /usr/test"
      @parser.parse(test_string).should have_key("p") 
      @parser.parse(test_string)["p"].should == -8080 
      @parser.parse(test_string).should have_key("d") 
      @parser.parse(test_string)["d"].should == "/usr/test"
      @parser.parse(test_string).should have_key("l") 
      @parser.parse(test_string)["l"].should == true
    end
    it "defaults correctly with some params defined" do
      test_string = "-p -8080 -d /usr/test"
      @parser.parse(test_string).should have_key("l") 
      @parser.parse("")["l"].should == false
    end
    it "defaults correctly with no params defined, aka empty string test" do
      test_string = "-p -8080 -d /usr/test"
      @parser.parse(test_string).should have_key("l") 
      @parser.parse("")["l"].should == false
    end
    it "fails when passing valid and invalid flags" do
      test_string = "-p -8080 -m /usr/test"
      lambda { @parser.parse(test_string) }.should raise_error UndefinedParam
    end
    it "raises exception, with explanation test when passing a flag that is not defined" do
      lambda { @parser.parse("-t") }.should raise_error UndefinedParam, "Syntax error. Correct format is UNIMPLEMENTED"
    end
    it "raises exception, with explanation, passing a defined flag with wrong param" do
      lambda { @parser.parse("-l /usr/test") }.should raise_error IncorrectParam, "Incorrect parameter -l /usr/test"
    end
    it "raises exception, with explanation, passing a number flag to a string flag" do
      lambda { @parser.parse("-d 8080") }.should raise_error IncorrectParam, "Incorrect parameter -d 8080"
    end
    it "raises exception, with explanation, passing a number flag with wrong param" do
      lambda { @parser.parse("-p /usr/test") }.should raise_error IncorrectParam, "Incorrect parameter -p /usr/test"
    end
  end
end

El código:

class UndefinedParam < StandardError; end
class IncorrectSyntax < StandardError; end
class IncorrectParam < StandardError; end

# Extend class string to check if params are numbers (floats included)
class String
  def is_numeric?
    begin Float(self) ; true end rescue false
  end
end

class Parseator
  # Constructor takes as parameter a hash with the valid flags, type and default value
  def initialize(model_hash)
    @model = model_hash
  end

  # valid? returns true if params is syntactically correct
  def valid?(params)
    if params == ""
      return true
    else
      if params =~ /^\s*(\-[a-zA-Z]{1}\s*(\-?[0-9]+|[^-\s]+)*\s*)*\s*$/
        return true
      else
        return false
      end
    end
  end

  # returns a Hash with the parameters and the set values
  # or raises an exception if there are Syntax or Semantic errors
  def parse(params)
    params_out = Hash.new
    if valid?(params) # First, check there are no syntax errors
      # first go through the input string and add that to the results 
      # match[0] is the flag
      # match[1] is the value
      params.scan(/\-([a-zA-Z]{1})\s*(\-?[0-9]+|[^-\s]+)*/).each do |match|
        if @model.has_key?(match[0])
          # bool params
          if @model[match[0]][0] == "bool"
            unless match[1].nil? # bool types do not have a value
              raise IncorrectParam, "Incorrect parameter -#{match[0]} #{match[1]}"
            end
            params_out[match[0]] = true
          # string params
          elsif @model[match[0]][0] == "string"
            if match[1].nil? || match[1].is_numeric? 
              raise IncorrectParam, "Incorrect parameter -#{match[0]} #{match[1]}"
            end
            params_out[match[0]] = match[1]
          # number params
          elsif @model[match[0]][0] == "number"
            if match[1].nil? || !match[1].is_numeric?
              raise IncorrectParam, "Incorrect parameter -#{match[0]} #{match[1]}"
            end
            params_out[match[0]] = match[1].to_i
          end
        else
          raise UndefinedParam, "Syntax error. Correct format is UNIMPLEMENTED"
        end
      end

      # second, go through the model and see what params are missing, to add the defaults 
      @model.keys.each do |key|
        unless params_out.has_key?(key)
          params_out[key] = @model[key][1] # default value
        end
      end
      return params_out
    else # Raise syntax error if not valid?
      # This method can be refined to analyze the string for the location of the syntax error(s)
      # Left as an exercise for the reader
      raise IncorrectSyntax
    end
  end
end

Ahora que lo miro… @model huele a refactoring…

Aparte, os recomiendo que instaléis también RVM para la gestión de diferentes versiones de Ruby y Rails, que luego os simplificará la vida cuando tengáis que cambiar el entorno de desarrollo para mantener aplicaciones que ya tengáis en el servidor.

Finalmente también os recomiendo Passenger para simplificar la integración con Apache y así emular lo más posible el entorno de producción, en lugar de usar WEBrick el servidor web que lleva Rails por defecto.

Mi configuración:

• Mac OSX 10.7.3
• XCode 4.3
• RVM 1.10.3
• Ruby 1.9.3
• Rails 3.2.1
• MySQL 5.5
• Passenger 3.0.11

Ten en cuenta que muchos de los comandos instalarán las últimas versiones de las herramientas y librerías, así que tus resultados puede variar. Por ejemplo, al ejecutar ‘gem install rails’ en el momento de publicar este post, la versión que se instala es Rails 3.2.1., la última versión disponible a finales de Febrero 2012.

1. Instalar Xcode

Te lo puedes bajar en el App Store de Apple, o en el Developer center. Necesitas un Apple ID.

Con XCode 4.3 las herramientas de la línea de comando son opcionales. Instálalas en Xcode > Preferences > Downloads.

2. Homebrew

Homebrew es una applicación que nos sirve para facilitar la instalación de software libre sobre Mac OS X. Siguiendo las instrucciones:

$> /usr/bin/ruby -e "$(curl -fsSL https://raw.github.com/gist/323731)"
==> This script will install:
/usr/local/bin/brew
/usr/local/Library/Formula/...
/usr/local/Library/Homebrew/...

Press enter to continue
==> Downloading and Installing Homebrew...
==> Installation successful!
Now type: brew help

3. RVM

Para instalar RVM, el sistema de gestión (que no control) de versiones de Ruby, lo primero es instalar Git (este si que es un sistema de control de versiones, para liarlo más)

$> brew install git

Una vez tenemos git instalado, instalamos RVM…

$> bash -s stable < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer) 
1

... y lo configuramos:
1
$> source ~/.rvm/scripts/rvm

Pero no todo es tan fácil. Si ejecutamos

$> rvm notes

Notes for Mac OS X 10.7.3, No Xcode.

For JRuby:  Install the JDK. See http://developer.apple.com/java/download/  # Current Java version "1.6.0_26"
For IronRuby: Install Mono >= 2.6
For Ruby 1.9.3: Install libksba # If using Homebrew, 'brew install libksba'
...

Es decir, que si queremos soporte para Ruby 1.9.3 tenemos que instalar libksba:

brew install libksba

Y luego instalar RVM con clang como compilador (gracias Stack Overflow)

$> rvm install 1.9.3 --with-gcc=clang

Para hacer que 1.9.3 sea la versión por defecto:

$> rvm --default use 1.9.3
$> ruby -v
$> ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin11.3.0]

4. Rails

A medida que vamos instalando herramientas, se hace más fácil la instalación:

$> gem install rails

Esto instala Rails y gems dependientes, incluyendo Bundler (gestión de gemas para deployment). Comprobemos que versión tenemos instalada.

$> rails --version
Rails 3.2.1

5. MySQL 5.5

Puedes elegir la base de datos SQL o No-SQL que más te guste. Para esta guía he elegido MySQL 5.5.

$> brew install mysql

Para crear la base de datos y los usuarios:

$> unset TMPDIR
$> mysql_install_db --verbose --user=`whoami` --basedir="$(brew --prefix mysql)" --datadir=/usr/local/var/mysql --tmpdir=/tmp

Lanza el servidor

$> mysql.server start

Haz tu instalación de MySQL más segura (cambia el password de root, borra los usuarios anónimos, bloquea el acceso remoto, borra la base de datos de test y vuelve a cargar las tablas de privilegios):

$> mysql_secure_installation

Crear un usuario de desarrollo de MySQL

$> mysql -u root -p
mysql> use mysql;
mysql> insert into user(host, user, password) values ('localhost', 'dev_user', '');

6. Passenger

Phusion passenger es un módulo de Apache para deployear (¿alguien conoce un verbo mejor?) aplicaciones de Ruby on Rails. Es el método recomendado por los creadores de Rails.

$> gem install passenger
$> passenger-install-apache2-module

Para configurar Apache con passenger, sigue las instrucciones en pantalla (te las resumo a continuación). Enciende Apache desde System Preferences > Sharing > Web Sharing (tiene que estar activado)

Edita con sudo el fichero /etc/apache2/httpd.conf e incluye la configuración de Passenger al final del fichero:

Include /etc/apache2/other/passenger.conf

Cierra httpd.conf y crea el fichero de configuración para passenger

touch /etc/apache2/other/passenger.conf

Edita con sudo el fichero /etc/apache2/passenger.conf

LoadModule passenger_module /Users/cesar/.rvm/gems/ruby-1.9.3-p125/gems/passenger-3.0.11/ext/apache2/mod_passenger.so
PassengerRoot /Users/cesar/.rvm/gems/ruby-1.9.3-p125/gems/passenger-3.0.11
PassengerRuby /Users/cesar/.rvm/wrappers/ruby-1.9.3-p125/ruby

Ten en cuenta que mi directorio home es 'cesar', pero el tuyo seguramente será otro.

Reinicia Apache

sudo apachectl restart

Comprueba en /var/log/apache2/error_log que no hay errores. Por ejemplo:

[Thu Feb 23 18:00:21 2012] [notice] Apache/2.2.21 (Unix) DAV/2 Phusion_Passenger/3.0.11 configured -- resuming normal operations

7. Crea una aplicación Rails de ejemplo

Voy a seguir el ejemplo típico del blog de Rails, que está en la guía Getting Started with Rails.

Crear el directorio para los proyectos rails. Yo lo tengo en mi home:

$> cd ~
$> mkdir railsprojects
$> cd railsprojects

Para crear la aplicación:

$> rails new blog

Configura Passenger y Apache para esta aplicación, activando virtual hosts si no está activado en /etc/apache2/httpd.conf . Busca:

# Virtual hosts
# Include /private/etc/apache2/extra/httpd-vhosts.conf

Borra el '#' de la segunda línea, para incluir el fichero de hosts virtuales. A continuación, edita (con sudo) /private/etc/apache2/extra/httpd-vhosts.conf y añade:

<VirtualHost *:80>
       ServerName blog.lvh.me
       DocumentRoot /Users/cesar/railsprojects/blog/public
       RailsEnv development
       <Directory /Users/cesar/railsprojects/blog/public>
           AllowOverride all
           Order allow,deny
           Allow from all
           Options -Indexes +FollowSymLinks MultiViews
       </Directory>
</VirtualHost>

Ten en cuenta que mi directorio home es 'cesar', pero el tuyo puede ser otro.

Reinicia Apache una vez más con sudo apachectl restart

En tu navegador visita blog.lvh.me (ya he hablado de LVH en otro post. Es lo mismo que localhost).

Si ves esta pantalla, ya tienes Rails configurado y funcionando. Ahora hay que terminar de cerrar el stack, configurando la base de datos MySQL.

Editar el Gemfile en el directorio blog y añade:

gem 'mysql2'

Instala la nueva gema con

$> Bundle install

Edita ~/railsprojects/blog/config/database.yml y cambia la sección 'development':

development:
adapter: mysql2
encoding: utf8
database: blog_development
pool: 5
username: dev_user
password:
socket: /tmp/mysql.sock

Crea la base de datos:

$> rake db:create

Dale permisos al usuario dev_user:

$> mysql -u root -p
mysql> grant SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, RELOAD on *.* to 'dev_user'@'localhost';
$> flush privileges;

Genera el scaffolding de Post, que crea una migración con el script en SQL para modificar la base de datos:

$> rails generate scaffold Post name:string title:string content:text

Si se ha creado una tabla posts en la base de datos: Has triunfado. Enhorabuena ya tienes el entorno de Rails listo en tu Mac OS X 10.7.3

Si tenéis curiosidad por conocer la base técnica de la web, os podeis pasar el jueves 2:

20:30h
Parc Cientific de la Universitat de Valencia
Catedrático Agustín Escardino 9
Valencia