La metaprogramación y los lenguajes dinámicos
La metaprogramación es una técnica muy poderosa, y muy socorrida en el terreno de los lenguajes dinámicos. Puede llevarnos a reducir muy fuertemente el total de código que escribimos - Y lo que es mucho más importante, a minimizar la cantidad de código repetido innecesariamente. Nos lleva claramente a aumentar la calidad y mantenibilidad de nuestro código.
Programas que escriben programas
La metaprogramación consiste en escribir código que no ataca directamente al dominio del problema que queremos atacar, sino que al código que lo resolvería. Dicho sea de otro modo, el código que escribimos no modifica los datos o el estado de nuestra información, sino que el del programa.
Las ventajas de los lenguajes dinámicos
La metaprogramación no es una nueva idea - Nació hace ya más de 40 años, con el lenguaje Lisp, y se popularizó tremendamente en el lenguaje Smalltalk, a principios de los 80.
Ambos lenguajes fueron revolucionarios en diversos aspectos, y si no gozan hoy en día de mayor popularidad, se debe a que, en sus implementaciones originales sufrían de problemas de rendimiento en el hardware de su época. Sin embargo, sus ideas básicas han servido para conformar a una gran cantidad de lenguajes que han ido adquiriendo una cada vez mayor popularidad y aceptación: Los lenguajes dinámicos.
Podemos categorizar a un lenguaje de dinámico cuando no requiere de ciclos determinados y claramente separados de compilación y ejecución. Mucha gente cree erróneamente que los lenguajes dinámicos (por ejemplo, Perl, Ruby, Python o PHP, ampliamente utilizados en el mundo del Software Libre) son interpretados - La realidad es completamente distinta, son lenguajes que cuentan con compiladores tremendamente eficientes, que en fracciones de segundo pueden convertir decenas de miles de líneas de código en una representación binaria (bytecode para sus respectivas máquinas virtuales).
La característica definitoria de estos lenguajes como dinámicos no es el compilador ágil (aunque, claro está, lo requieren) - Es la presencia de la instrucción (o familia de instrucciones) «eval». En resumidas cuentas, eval recibe un parámetro, típicamente una cadena, y lo evalúa como código fuente - Como una primer probadita de metaprogramación, consideren el siguiente código de Ruby:
def crea_clase(nombre, clase_padre)
eval "class #{nombre} < #{clase_padre} ; end"
end
Al invocar a este método -claro está, en tiempo de ejecución- puedo ampliar la jerarquía de clases existente. Por ejemplo, si quiero definir suficientes clases para representar los muebles de una oficina, podría decirle a Ruby:
['Mesa', 'Silla', 'Archivero', 'Librero'].each do |tipo|
crea_clase(tipo, 'Mueble')
end
Obviamente, la lista de objetos no necesariamente la tengo representada en mi código fuente - puede ser proporcionada por el usuario o determinada a partir del entorno de ejecución. Y a partir de este punto, para todos los propósitos de nuestro código, sería como si en tiempo de compilación hubiéramos incluido explícitamente en el código:
class Mesa < Mueble; end
class Silla < Mueble; end
class Archivero < Mueble; end
class Librero < Mueble; end
Pero esto va mucho más allá de una manera cómoda y reducida de especificar clases.
Lenguajes específicos de dominio
A partir del número noviembre-diciembre de 2007 de SoftwareGurú hemos recibido entregas del tutorial de Ruby on Rails escrito por Carlos Ortega. Cuando nos acercamos por primera vez a Rails, lo primero que encontramos es una serie de declaraciones que no pertenecen a Ruby, y aparentan un estilo de programación declarativo. Por ejemplo, al definir un modelo:
class Person < ActiveRecord::Base
validates_presence_of :name
validates_numericality_of :age, :greater_than => 0, :less_than => 100
end
ActiveRecord es el ORM de Ruby on Rails - presenta una abstracción de los datos en las tablas de la base de datos, dándoles una interfaz natural orientada a objetos. El módulo ActiveRecord::Validations::ClassMethods extiende al lenguaje a través de la metaprogramación, y expone una serie de validadores, que presentan una sintaxis natural de escribir y fácil de leer - Un lenguaje específico al dominio de las validaciones.
Reflectividad
La mayor parte de los lenguajes dinámicos son también reflectivos. Los objetos (y, recuerden, en los lenguajes completamente orientados a objetos, todo es un objeto - Incluyendo las clases, no sólo los objetos instanciados) pueden ser interrogados respecto a los métodos que ofrecen. Un ejemplo simple que muestra el poder combinado de la reflectividad junto con la metaprogramación es este simple rastreador universal: </p>
def trace(obj)
obj.methods.each do |meth|
eval "def obj.#{meth}(*args)
warn 'Llamando al método #{meth} en #{obj.class}'
super(*args)
end"
end end </code>
Basta llamar a nuestra función «trace» con cualquier objeto del sistema para que nos muestre un rastreo completo de cada una de las acciones que éste realice. Por ejemplo (desde la consola interactiva de Ruby):
>> p = Person.find(:first)
trace(p) p.name Llamando al método method_missing en Person Llamando al método class en Person Llamando al método class en Person Llamando al método class en Person
Llamando al método send en Person => “Fulano D. Tal” </code>
Aquí podemos encontrar cómo es que incluso la misma clase Person (que no es otra que la que declaramos hace algunas líneas) recibe sus métodos: ¡A través de la reflexibilidad, preguntándole a la base de datos acerca de su propia estructura!
El espacio no permite, tristemente, dar más ejemplos de cómo podemos explotar estas técnicas - Pero espero que con esta sencilla muestra puedan comprender la riqueza que esta técnica nos proporciona, y lo conciso que puede hacer a nuestro código.
Attachments
200805_softwareguru_1.jpg (497 KB)
200805_softwareguru_2.jpg (469 KB)
200805_softwareguru_3.jpg (146 KB)
