47

En un proyecto en el que estoy trabajando se me ocurrió saber cuantos devs habían pasado por ahí, es decir cuantas personas diferentes modificaron el código, como no sé cual es comando de git que le corresponde lo resolví en bash:

git log | grep Author: | sort -u | cut –delimiter=” ” -f2 | sort -u | wc -l

Por supuesto que el cálculo no es exacto pero en menos de 1 minuto obtuve una respuesta bastante cercana a la realidad:

47

¿Lindo número para jugar en quiniela eh?

PD: Gente, Lead Projects, Developers, CTOs, Etc. Hay que tratar de mantener ese número lo más bajo posible, en mi opinión más de 4 es mucho, así que para este caso estoy en un orden 10x de lo que es aceptable para mí .

PD: Que bueno hubiese sido que de 5 números menos

¿Qué opininan?

Jornadas de software libre en Junin

Hace poco me invitaron para dar una charla en las Jornadas de Software libre de Junin, y el viernes pasado llegué allí con tal motivo, comimos un asado *muy* bueno con coca cola por supuesto , al otro día tuve que abrir el día con mi charla de Ruby (todos sabemos lo que significa comenzar a las 9:00 AM un sábado!) la charla salió muy bien para mi gusto y la gente parecía bastante entusiasmada,hicieron varias preguntas, después vino “El Profe” Román con una charla acerca de como participar del proyecto Open Office, y más tarde y para cerrar el día, Javier hablando acerca Asterix, quiero destacar que la organización fué excelente todo muy lindo.Al final hubo regalos!!! Muchas gracias a todos los organizadores por esta gran jornada!.

Para los que quiera ver los slides:

Ruby-un-lenguaje-simple-natural-y-productivo-gaston-ramos

Acá les dejo algunas fotos:

 

Rails edge, Ruby 1.9 style String interpolation support

Este es el primer post de una serie que he decidido comenzar titulada “Analizando commits de rails edge”. Aclaro que los post no van a tener orden alguno y que voy a comentar los que me llaman la atención a _mí_ .
En este caso el commit se trata de agregar a rails la nueva forma de interpolación de strings que trae ruby 1.9 ( la idea es que se pueda usar con versiones menores también), pueden ver el código en este archivo:

activesupport/lib/active_support/core_ext/string/interpolation.rb

Cómo uds sabrán en Ruby se pueden interpolar strings de la siguiente manera:

>>"%s, %s" % ["Masao", "Mutoh"]
=> "Masao, Mutoh"

Cómo lo explica el comentario en el código:

 # call-seq:
  #   %(arg)
  #   %(hash)
  #
  # Format - Uses str as a format specification, and returns the result of applying it to arg.
  # If the format specification contains more than one substitution, then arg must be
  # an Array containing the values to be substituted. See Kernel::sprintf for details of the
  # format string. This is the default behavior of the String class.
  #   * arg: an Array or other class except Hash.
  #   * Returns: formatted String
  # Example:
  #    "%s, %s" % ["Masao", "Mutoh"]
  #
  # Also you can use a Hash as the "named argument". This is recommended way so translators
  # can understand the meanings of the msgids easily.
  #   * hash: {:key1 => value1, :key2 => value2, ... }
  #   * Returns: formatted String
  # Example:
  #   For strings.
  #   "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
  #
  #   With field type to specify format such as d(decimal), f(float),...
  #   "%d, %.1f" % {:age => 10, :weight => 43.4}

Es decir que ahora podemos interpolar strings de la siguiente manera:

>> "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
ArgumentError: malformed format string - %{
	from (irb):2:in `%'
	from (irb):2
>>

Auuuchh! estoy probando con un irb con ruby 1.8.6, así que necesito requerir el archivo:

>> require 'activesupport/lib/active_support/core_ext/string/interpolation.rb'
=> true
>> "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
=> "Masao, Mutoh"

Ahora sí! podemos interpolar string nombrados pasando un hash como argumento, Hermoso!
Estuve mirando en los fuentes de Ruby 1.9 y no encuentro dónde está escrita esta nueva funcionalidad, el método que define la interpolación con”%” es rb_str_format_m y está en la línea número 1202 del archivo string.c en el trunk de ruby, pero sólo está la vieja forma de interpolación. Entonces dónde está ? Alguien sabe?
Es más hice esta prueba:

$ irb1.9
require 'activesupport/lib/active_support/string/interpolation.rb'
=> true
irb(main):002:0> "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
ArgumentError: malformed format string - %{
	from (irb):2:in `%'
	from (irb):2
	from /usr/bin/irb1.9:12:in `'

Y la versión que tengo de ruby 1.9 es:
ruby 1.9.0 (2008-06-20 revision 17482) [i486-linux]
Un poco vieja, probemos con ruby 1.9 compilado desde trunk
ruby 1.9.2dev (2009-07-11 trunk 24027) [i686-linux]

./ruby  -e 'puts "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}'
Masao, Mutoh

Funcionó! entonces en algún lugar tiene que estar.

Rails 2.3, rake y reenable method

Estoy terminando de hacer una migration a Rails 2.3 de la
app con la que estoy trabajando, resulta que me encontré con el siguiente tema:
Luego de instalar rails y migrar la app, llegó el momento de hacer un deploy a
staging, entonces me econtré con el siguiente error:

undefined method `reenable' for <Rake::Task db:schema:dump =>
[environment]>:Rake::Task

googleando un poco llegué a este link que dice que hay que instalar
la nueva versión de rake, investigando un poco más, llegué a este PATCH
que hace uso del método Rake::Task#reenable, el caso es que este método
se agrega e con la versión de rake 0.8.2 y como el pibe dice en el comentario
del patch, no hay problemas por que rails 2.3 require rake 0.8.3…. pero
que pasa cuando:

1- Instalo rails 2.3
2- Hago un ‘rake rails:freeze’
3- hago ‘cap staging deploy:migrations’

Y no tengo rails 2.3 instalado en el server y por eso justamente hice un freeze.

Si leemos la task que arma las dependencias de rails:

  s.add_dependency('rake', '>= 0.8.3')
  s.add_dependency('activesupport',    '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('activerecord',     '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('actionpack',       '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('actionmailer',     '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('activeresource',   '= 3.0.pre' + PKG_BUILD)

uando hacemos el freeze nos copia todas estas cosas menos el rake,
lo cual parece razonable. Pero creo debería agregar en config/environment.rb

config.gem “rake”, :version => ‘0.8.3′

Que opinan uds?

Instalando Mod_Ruby

Bueno dada la escasa y fea documentación que mod_ruby tiene me decidí a escribir un pequeño tutorial de instalación del mismo en debian, que paso a detallar:

Primero instalamos el modulo de apache para ruby (mod_ruby)

apt-get install libapache2-mod-ruby

Luego debemos crear el siguiente archivo:
vi /etc/apache2/mods-available/ruby.conf

y ponemos lo siguiente:

<IfModule mod_ruby.c>
  RubyRequire apache/ruby-run

  <Files *.rbx>
  SetHandler ruby-object
  RubyHandler Apache::RubyRun.instance
  </Files>
</IfModule>

Entre otras cosas le decimos que debe tratar los archivos .rbx como
archivos de ruby.

Luego de esto ya tenemos los dos archivos necesarios para habilitar el módulo en apache:

ruby.load (que secopia al instalar el módulo) y ruby.conf generado por nosotros. Ahora cómo mod_ruby ejecuta los scrips de ruby como CGI necesitamos poner la directiva Options +ExecCGI en el folder dónde vamos a poner nuestros scripts, en mi caso particular necesito que todos los usuarios del sistema puedan ejecutar sus scripts desde su ~/public_html entonces para lograr esto tenemos que editar la configuración del módulo user_dir, editamos el archivo

vi /etc/apache2/mods-available/userdir.conf
y agregamos lo siguiente:
 <IfModule mod_userdir.c>
        UserDir public_html
        UserDir disabled root

        <Directory /home/*/public_html>
                AllowOverride FileInfo AuthConfig Limit Indexes
                Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
                # Para poder ejecutar scripts en ruby agregamos la linea de abajo
                Options +ExecCGI
                <Limit GET POST OPTIONS>
                        Order allow,deny
                        Allow from all
                </Limit>
                <LimitExcept GET POST OPTIONS>
                        Order deny,allow
                        Deny from all
                </LimitExcept>
        </Directory>
</IfModule>

No sé si esto muy seguro o tiene alguna consecuencia no deseada, si es así comenten!
Bueno ahora sólo necesitamos habilitar el móludo para esto ejecutamos el siguiente comando:

a2enmod ruby

y hacemos un reload del apache

/etc/init.d apache2 reload

despues de esto para probarlo ponemos un archivo en nuestro home

vi /home/gaston/test-ruby.rb

con un simple:

puts "hello world"

vamos al navegador a la siguiente url:

http://aca-va-la-url-de-tuserver/~gaston/test-ruby.rb

y vamos a ver un hermoso “hello world” si todo salió bien.

Bueno, con mod_ruby solo para escribir una página web dinámica vamos a tener que hacer algo cómo esto:

puts “<h1>Mi Título</h1>”

lo cual es muy molesto, para hacer las cosas un póco más lindas y más fácil debemos usar eruby que nos permite ejecutar código ruby dentro de archivos de text (como por ejémplo un arhivo html)

Entonces comencemos por instalar eruby:

apt-get install eruby

y luego tenemos que modificar nuevamente el archivo /etc/apache2/mods-available/ruby.conf de esta manera:

<IfModule mod_ruby.c>
  RubyRequire apache/ruby-run
  RubyRequire apache/eruby-run

  <Files *.rbx>
  SetHandler ruby-object
  RubyHandler Apache::RubyRun.instance
  </Files>

 <Files *.rhtml>
  SetHandler ruby-object
  RubyHandler Apache::ERubyRun.instance
 </Files>

</IfModule>

Y luego debemos agregar la siguiente directiva al archivo de configuración de apache /etc/apache2/apache2.conf

AddType text/html .rhtml

Con esto recargamos el apache y ya podemos escribir nuestros .rhtml
y poner código ruby entre los tags <%= %>

Links útiles:

http://en.wikipedia.org/wiki/ERuby

http://wiki.modruby.net/ja/?InstallGuide

http://modruby.net/

http://ubuntuforums.org/archive/index.php/t-356350.html

http://www.ruby-doc.org/docs/ProgrammingRuby/html/web.html

Acts as state machine y metaprogramming

Fe de erratas: En el artículo de abajo dónde expliqué cómo generar un named_scope por cada estado declarado con acts_as_state_machine hay un BUG el tema es así, los named_scope se definían en un método (self.define_named_scopes) que era llamado desde el constructor de la clase User, por consiguiente si queremos usar uno de estos named_scopes antes de que se instancie algún objeto de esta clase, el scope no existe, cómo era de esperar.

Entonces la solución rápida sería hacer directamente así:

class User   < ActiveRecord::Base
   acts_as_state_machine :initial => :inactive
   state :inactive
   state :active

   event :active do
     transitions :from => :inactive, :to => :active
   end

  ########################################################
  # define all state as named_scopes
  #
  self.states.each{|st|
    self.named_scope st, :conditions => { :state => st.to_s },
                      : order => 'created_at DESC'
  }
end

---

Hace bastante que vengo usando la genial biblioteca “Acts as state machine” que nos permite tener un máquina de estados finita (o autómata finito) en un modelo Active Record y a partir de las últimas versiones en cualquier objeto Ruby, y desde hace un tiempito que vengo pensando “Qué bueno sería que ASSM te genere un named_scope por cada estado posible”, entonces si por ejemplo tenemos 2 estados: active, inactive podríamos hacer algo así:

User.inactive # Esto retorna todos los usuarios con estado inactive
User.active # Esto retorna todos los usuarios con estado active

Bueno, acá está la solución que se me ocurrió:

class User   < ActiveRecord::Base
   acts_as_state_machine :initial => :inactive
   state :inactive
   state :active

   event :active do
     transitions :from => :inactive, :to => :active
   end

   def initialize(*args)
      self.class.define_named_scopes
      super *args
    end

  def self.define_named_scopes
    self.states.each{|st|
    self.named_scope st, :conditions => { :state => st.to_s },
                      : order => 'created_at DESC'
    }
  end
end

Nice eh! tenemos un método que escribe los named_scope por nosotros y seguro que se puede mejorar o quizás agregar una opción a AASM para que lo haga cuando lo deseemos, el tema es que cómo necesitamos la lista de los estados, debemos ejecutar esto después de especificar los mismos, aunque una solución más elegante sería modificar AASM y hacer que los named_scope se genere cada vez que especificamos un estado.

Hasta la próxima!

Nested Forms rails 2.3

En el proyecto en el que estoy actualemente estamos usando Rails 2.3, uno de los motivos de usar rails 2.3 es que nos venía muy bien la nueva feature “Nested Forms”, resultaque estuve dando vueltas con algunos problemas hasta que finalmente los saque funcionando bien.

Les cuento yo tengo un formulario para crear un user, el modelo de user es el siguiente:

class User < ActiveRecord::Base
   has_one :person, :as => :personable, :dependent => :destroy
   accepts_nested_attributes_for :person
....
end

Es decir que un user tiene datos de contacto a travez de has_one :person (suena raro creo que se podría cambiar por has_one :contact_info, :class_name => “Person”) , y entonces el form era el siguiente:

<% form_for(:user, :url => users_path) do |f| -%>

<p><%= label_tag 'login' %><br/>
<%= f.text_field :login %></p>

<p><%= label_tag 'password' %><br/>
<%= f.password_field :password %></p>

<p><%= label_tag 'password_confirmation', 'Confirm Password' %><br/>
<%= f.password_field :password_confirmation %></p>

<% f.fields_for(:person) do |person_fields| %>
  <p><%= person_fields.label :email %><br/>
  <%= person_fields.text_field :email %></p>

  <p><%= person_fields.label :first_name, 'First Name:' %><br/>
  <%= person_fields.text_field :first_name %></p>
<% end %>

<p><%= submit_tag 'Create User' %></p>

<% end -%>

Resulta que esto no me funcionó y me daba el siguiente error:

ActiveRecord::AssociationTypeMismatch (Person(#-619527948) expected, got HashWithIndifferentAccess(#-607513158)):

El problema puntual era que no generaba bien el form y en vez de generar esto:

<input id="user_person_attributes_first_name"
  name="user[person_attributes][first_name]" 
  size="30" type="text" />

generaba esto:

<input id="user_person_first_name"
  name="user[person][first_name]" 
  size="30" type="text" />

Y entonces daba el error por que ActiveRecord (Nested model) genera un método person_attributes= en modelo dónde declaramos el accepts_nested_attributes_for (user en este caso) y por eso el form anterior no funciona como era de esperar.

En el controller tenía lo siguiente:

class UsersController < ApplicationController
  def new
    @user = User.new(:person => Person.new)
  end

  def create
    @user = User.new(params[:user])
    @user.save
  end
.....
end

La solución fue modificar el form y hacer así:

<% form_for @user do |f| -%>

<p><%= label_tag 'login' %><br/>
<%= f.text_field :login %></p>

<p><%= label_tag 'password' %><br/>
<%= f.password_field :password %></p>

<p><%= label_tag 'password_confirmation', 'Confirm Password' %><br/>
<%= f.password_field :password_confirmation %></p>

<% f.fields_for(:person) do |person_fields| %>
  <p><%= person_fields.label :email %><br/>
  <%= person_fields.text_field :email %></p>

  <p><%= person_fields.label :first_name, 'First Name:' %><br/>
  <%= person_fields.text_field :first_name %></p>
<% end %>

<p><%= submit_tag 'Create User' %></p>

<% end -%>

cambié el

<% form_for(:user, :url => users_path) do |f| -%>

por

<% form_for @user do |f| -%>

El form para editar un user quedó prácticamente igual y funciona con los attributes de person y todo sin hacer nada del lado del controller. Ahora la pregunta es: Esta bien que nested_forms solamente funcione con la forma?:

<% form_for @user do |f| -%> 

Si alguien tiene la respuesta que comente!

Saludos

Tirar el código

Estoy leyendo un libro de Smalltalk y la verdad leí una frase que me encantó, así que quería dejar plasmada acá:
“El código escrito es importante, pero mucho más importante es el conocimiento que vamos obteniendo conforme programamos. Si aprendemos día a día, probablemente el código viejo no sea bueno. Tirar código no es malo, lo malo es no aprender a diario.”

How Do You Plan Infrastructure?

Sigo con la lectura del libro de Kent Y Martin, ahora quiero compartir on Uds. una parte del capítulo 10 titulada “How Do You Plan Infrastructure?”:

“When you plan in a function-oriented, such as we suggest, the obvious question is how to deal with infrasctuture. Before we can start building functionality we have to put together the distributed object messaging infranstructure components before you deliver any customer functionality.

This style of development is a common feature of the dead and dying projects we’ve seen-and we don’t think it’s a coincidence. Doing infrastructure without customer function leads to following risks:

• You spend a lot of time no delivering things that are valuable to the customer, wich straints the relationship with with customer.
• You try to make the infrastructure cover everything you think you might need, wich leads to an overly complex infrastructure.

Therefore, evolve the infrastructure as you build the functionality. For each iteration, build just enough infrastructure for the stories in that iteration. You won’t build a more complex infrastructure than you need, and the customer is engaged in building the infrastructure because she sees the dependent functionality as it’s evolving.”

Creo no hace falta agregar nada, sólo que estoy totalmente de acuerdo con lo que dice.

Overtime doesn’t help.

Hace poco comencé a leer el libro “Planning Extreme Programming” de Kent Beck y Martin Fowler (dos grosos) leyendo el capítulo 7 hay un párrafo que me gustó mucho y quería compartirlo, paso a detallar:

“Overtime doesn’t help. Although in the very short term it does speed up the team, if you do it for any length of time you will get bitten badly. The big killer is motivation. It’s much better to have a motivated programmer work seven hours than a tired, distracted programmer work ten. Even if the programmers want to work long hours it’s not a good idea. Long hours make people tired, tired people make mistakes, and mistakes take time to fix. We’ve both gone into clients in the morning and spent all day chasing a bug that was put in a ten o’clock the previous night. Particularly with young Silicon Valley teams, where long hours are such an important tribal ritual,  we have to work hard to get people not to do overtime. If they really have no life, get them to play computer games in the evening instead. It’s much more productive to have castles mown by trebuchets than it is to slip bugs into complicated software.”

La verdad me encantó esta parte del capítulo, sobre todo por que en este último tiempo me he econtrado con varias personas que valoran el “overtime”  por más que ello no favorezca a que el sistema avance, y en lo personal trato de no trabajar fuera de hora o cuando estoy muy cansado.