Perliscopio

Ya viene Perl 5.14

2011-04-22T00:35:00.003-04:30

[English translation by google]

Hace unas horas salió el primer candidato a lo que será Perl 5.14 (ahora tenemos nuevas versiones de perl a cada rato :) en esta versión vienen nuevas características convenientes y algunas optimizaciones (sobre todo en windows).

Simetría entre arreglos, hashes y sus referencias

Esta es una de las características que más me gustan de Perl 5.14, pues simplifica la sintaxis cuando se manipulan referencias.

En el caso de los arreglos las primitivas como push, shift, unshift, pop y slice ahora aceptan referencias permitiendo cambiar el código:


  push @{ $arr->[1] }, 8
  $head = shift @{ $obj->arrayref }

por versiones más sencillas que ya no necesitan la dereferencia:


  push $arr->[1], 8
  $head = shift $obj->arrayref

lo que sin duda se ve mejor, sobre todo para los novatos.

Adicionalmnete keys, values y each trabajan con referecias a hashes, pero también trabajarán con arreglos y sus referecias, en este último caso se asumirán los valores del arreglo y las claves seran los índices enteros, así que se podrán hacer cosas como:


  for ( values $obj->arrayref ) { ... }
  for ( keys $obj->arrayref ) { ... }
  for ( keys %{$hoh->{genres}{artists}} ) {...}

En vez de:


  for ( @{ $obj->arrayref } ) { ... }
  for ( 0 .. @{ $obj->arrayref } ) { ... }
  for ( keys $hoh->{genres}{artists}    ) {...}

simplificando igualmente la sintaxis.

Una tabla de la documentación da varios ejemplos adicionales:


  |----------------------------+---------------------------|
  | Sintaxis tradicional       | Sintaxis compacta         |
  |----------------------------+---------------------------|
  | push @$arrayref, @stuff    | push $arrayref, @stuff    |
  | unshift @$arrayref, @stuff | unshift $arrayref, @stuff |
  | pop @$arrayref             | pop $arrayref             |
  | shift @$arrayref           | shift $arrayref           |
  | splice @$arrayref, 0, 2    | splice $arrayref, 0, 2    |
  | keys %$hashref             | keys $hashref             |
  | keys @$arrayref            | keys $arrayref            |
  | values %$hashref           | values $hashref           |
  | values @$arrayref          | values $arrayref          |
  | ($k,$v) = each %$hashref   | ($k,$v) = each $hashref   |
  | ($k,$v) = each @$arrayref  | ($k,$v) = each $arrayref  |
  |----------------------------+---------------------------|

Paquetes con bloques

Generalmente cuando se hace un script rápidamente, es más fácil declarar los paquetes (clases) en el mismo archivo, de igual manera es fácil caer en alguna trampa debido a que se tienen varios paquetes en un mismo entorno léxico, así cuando se declaran pragmas o variables léxicas, estas terminan afectando a otras clases o paquetes porque las declaraciones tienen como alcance léxico a todo el archivo, la manera estándar de evitar esto es declarando cada clase dentro de un bloque que acota su alcance léxico:


  {
    package Uno;
    ...
  }
  {
    package Dos;
    ...
  }
  ...

En perl 5.14 un paquete puede tener un bloque, haciendo que la construcción anterior se vea mejor:


  package Uno {
    ...
  }
  package Dos {
    ...
  }
  ...

Substitución no destructiva

Se implementa utilizando el modificador /r a una substitución, logrando que la variable ligada a la operación no sea afectada por la misma, en su lugar se retornará el valor modificado, así que el siguiente código:


  $result = do {
    my $ret = $text;
    $ret =~ s/pedro/juan/;
    $ret;
  };

Se podrá escribir de manera mas concisa en 5.14:


  $result = $text =~ s/pedro/juan/r

Este modificador también se agregó a la transliteración: tr///r

given devuelve valores

Siendo un fanático de Lisp esta característica me gustó, pues con frecuencia suelo simular (cond ...) en Perl haciendo:


my $result;
given ($val) {
    when(1) { $result = "uno" }
    when(2) { $result = "dos" }
    default { $result = undef }
}

En Perl 5.14 se podrá retornar un valor directamente, encapsulando toda la logica y sin necesidad de utilizar variables auxiliares fuera de la estructura:


my $result = do {
  given ($val) {
    when(1) { "uno" }
    when(2) { "dos" }
    default { undef }
} };

El do todavía es necesario ya que el parser de Perl todavía no reconoce la instrucción given como una expresión, aunque probablemente lo haga en el futuro.

\o{...} para incluir caracteres en código octal

Desde siempre Perl permite especificar caracteres como "\0376" sin embargo esta secuencia solo se permite para caracteres hasta 0777 (511), con la nueva secuencia se pueden especificar caracteres unicode con códigos mucho mayores, además el uso de esta secuencia permite eliminar confusiones con las retro-referencias (backreferences) en las expresiones regulares.

Mejoras en Unicode

Ahora se reconocen todo los nombres del unicode incluyendo abreviaturas y nombres de los caracteres de control, así que se pueden escribir caracteres como: "\N{ACK}", "\N{NBSP}", "\N{BEL}", entre otros. Estos nombres también se reconocen tanto en \N{} como en charnames.

Se introduce el pragma: use feature "unicode_strings" que permite resolver la mayoría de las inconsistencias en la búsqueda de expresiones regulares con unicode, este pragma permitirá que el resultado funcione igual sin importar si la cadena es utf8 o no.

Se introducen los modificadores /d, /l y /u en las expresiones regulares:

/l para compilar la expresión regular como si estuviera en el contexto del pragma: use locale
/u para compilar la expresión regular como si estuviera en el contexto del pragma: use feature "unicode_strings"
/d permite anular los efectos de los pragmas: use locale y use feature "unicode_strings"
/a para interpretar la expresión como si fuera ASCII así \s encontrará exactamente los caracteres [ \f\n\r\t], \d encontrará exactamente [0123456789], \w encontrá exactamente los 63 caracteres [A-Za-z0-9_], y las clases de caracteres [[:posix:]] solamente conseguiran los caracteres apropiados del ASCII, también se afectan apropiadamente: \b y \B. Los complementos de estas clases consiguen cualquier cosa fuera de esto, como se debe.

Filehandle cargará automáticamente IO::File

Ahora cualquier filehandle se comportará como un IO::File, cuando se invoque un método inexistente para un filehandle perl cargará automáticamente IO::File, y reintentará la invocación nuevamente.

Mejoras en las funciones tipo printf

Ahora todas las funciones de la familia printf entienden los modificadores del estándar C90: "hh" (char), "z" (size_t), and "t" (ptrdiff_t), si además perl se compila con un compilador C99 también se interpretará el modificador "j" (intmax_t).

Introspección sobre el proceso de compilación

La nueva variable global ${^GLOBAL_PHASE} permitirá a los programas hacer introspección sobre la fase de compilación que se lleva a cabo, lo que permitirá en el futuro mejorar las capacidades de autoextensión del lenguaje.

Para aquellos que no esten al tanto de las capacidades de Perl, enterense que los programas en Perl pueden ejecutarse en tiempo de compilación para alterar el mismo proceso de compilación del programa, por eso aparecen características como está, que facilitará el desarrollo de nuevas extensiones al lenguaje.

Inyección de operaciones en la máquina virtual

Ahora se pueden registrar nuevas operaciones en la máquina virtual de perl, esto facilitará en el futuro la extensión de la máquina virtual con nuevas propiedades y operaciones.

Otras mejoras

Se optimizó la concatenación de cadenas de caracteres que pueden llegar a ser hasta 100 veces más rápidas en ciertas plataformas (como windows).

Se optimizó el uso de %+ y %- para programas que no los utilizan.

Moose acelerando

2010-10-08T20:20:00.000-04:30

El más reciente y exitoso sistema de OOP para Perl, se esta haciendo cada vez más veloz.

En el blog de Moose podemos apreciar que se trabaja continuamente en perfilar el consumo de recursos y mejorar el rendimiento de este sistema, que en su última versión (1.15) es un poquito más lento compilando, mientras incluye más código "en linea" acelerando la ejecución de los programas.

Aplicaciones no tradicionales en Perl

2010-10-05T21:34:00.001-04:30

Acabo de ver una aplicación de esas que tal vez inicialmente no se me hubiera ocurrido hacer en Perl: "The Lacuna Expanse", esta aplicación es un juego y es masivamente paralelo, así que yo hubiera investigado como hacerla en Erlang o Haskell, sin embargo hicieron el servidor 100% en Perl, el cliente genérico esta en Javascript y luego hay otros clientes para telefonos hechos en variedad de lenguajes.

Se explota el uso de JSON RPC, y el CPAN les permitió utilizar Plack, Moose, DBIx::Class y la estrella de la fiesta: JSON::RPC::Dispatcher.

Si quieren más información pueden leer el artículo de Ovid y el de JT Smith.

Aquí les dejo el trailer para que alucinen.

Mi proveedor favorito

2010-10-05T20:34:00.002-04:30

Hoy entrevisté a un proveedor que pudiera convertirse en uno de mis favoritos, voy a hacer una interpretación libre de la conversación y a lo mejor se imaginan porque quede gratamente impresionado:

Yo: los llamé porque estoy abrumado con tantas cosas por hacer y necesito alguien que ayude a migrar bases de datos Oracle y aplicaciones de Power Builder.

Proveedor: Nosotros somos especialistas en Oracle y Power Builder entre otros, pero estamos trabajando mucho con PostgreSQL, Perl, Python.

Yo: Y si les pido ayuda para migrar aplicaciones Power Builder a la Web que tecnologías me recomiendan.

Proveedor: Bueno nosotros trabajábamos principalmente con Python usando Django, que es un ambiente excelente, sin embargo nos hemos dado cuenta de que aunque Perl no se ve tan bonito, nos rinde más para nuestro trabajo, así que últimamente estamos trabajando más con Catalyst y Perl en general.

Necesito más proveedores así, porque donde yo trabajo si vamos a migrar a software libre.

La nueva trampa de Java

2010-08-15T15:27:00.001-04:30

[ Este artículo es una copia del que se encuentra en Radar Libre ]

La demanda iniciada por ORACLE contra Google donde se argumenta que el sistema operativo Android viola patentes propiedad de ORACLE, muestra una debilidad de lo que usualmente muchos en la comunidad (incluyendome) consideramos software libre.

Desde que Sun Microsystems liberó la mayor parte del código de la plataforma Java, este asunto ha pasado por debajo de la mesa, pues las implementaciones que se utilizan son: la original, y alguna que otra licenciada directamente del propietario.

En un debate ocurrido hace un lustro, sobre El uso de Java en el Plan Nacional de Migración a Software Libre, Simon Phipps argumentaba que Sun Microsystems era una compañía amigable, que había prometido liberar el código y que estaba trabajando para ello.

En aquel momento mi argumento fue que las corporaciones no tienen alma, sentimientos o lealdad, que son básicamente actores de guerras que solo obedecen a motivos económicos y que verlas de cualquier otra manera era un riesgo que que el Estado no debería correr.

Después de un lustro y luego de la desaparición Sun, al ser adquirida por ORACLE, quedó demostrado que Simon Phipps probablemente tenía razón, Sun finalmente liberó lo que pudo de Java y nunca aplicó tarifas al licenciamiento de la plataforma, sin embargo yo también tenía razón: las corporaciones no tienen alma y ahora que Sun fue tragada por ORACLE se lanza al ataque en contra de quien pueda rendirle beneficios.

Este ataque es hoy posible gracias a un arma secreta que Sun mantenía en su arsenal: "Patentes de Software", para evitar suspicacias como las que siempre han rodeado a Mono, Sun emitió una liberación de uso de dichas patentes para cualquier implementación de Java, siempre y cuando la implementación incluyera todas las características y servicios de la plataforma y no se incluyera ninguna característica o servicio adicional, es decir que para evitar una demanda de propiedad intelectual por patentes el distribuidor debía asegurarse de:

implementar toda la plataforma y solo la plataforma

Aquí es donde Google cayó en la trampa porque al parecer no incluyó AWT y Swing que son parte integral de la especificación.

Sin embargo lo peligroso de todo este asunto no es la demanda de ORACLE a Google, que puede presentar una buena pelea judicial al estilo SCO, Novel e IBM, sino que la trampa ahora es mucho más sutil (pero no menos potente), ya no basta que un código sea GPL versión 2 para que sea realmente libre.

En los términos establecidos por la liberación de derechos de uso de las patentes de Sun se coarta la libertad 3, que da el derecho a modificar el código y redistribuir el resultado de la modificación, porque Oracle va a demandar por violación de patente al quedar fuera de la protección de la liberación de derechos de uso de patentes, independientemente de lo que diga la GPLv2.

Así que en realidad aunque la mayoría del código de la plataforma Java sea libre por derecho, de hecho no es libre porque ORACLE puede utilizar otros instrumentos para ejercer coacción sobre cualquiera que intente modificar la plataforma, y por lo tanto no cumple con el espíritu del decreto 3390, por ello debe prohibirse nuevamente el uso de esta plataforma en el Estado hasta que se aclare esta situación o se libere Java bajo la licencia GPL versión 3 que incluye protección legal contra las patentes.

Finalmente en un tono más personal deberíamos hacer un esfuerzo coordinado por dejar de consumir productos ORACLE para que la corporación aprenda por la única vía posible: su cuenta bancaria, que jugar con la libertad puede resultar peligroso y dañino.

Dejar de consumir productos de esta infame comañía no es difícil, casi cualquier cosa que se esté haciendo con su manejador de base de datos, se puede hacer con PostgerSQL y todo el resto de sus productos son bastante malos, incluyendo el lenguaje de programación Java (no la plataforma) así que en general, dejar de usar productos ORACLE se puede considerar de entrada como una ventaja competitiva.

Un tutorial de catalyst en español

2010-03-17T21:18:00.000-04:30

Como ando colapsado sin poder escribir, les dejo el blog de un amigo que va a escribir una serie de artículos sobre Catalyst.

Moose de dieta

2010-01-31T07:26:00.004-04:30

[English translation]

¿Te parece que Moose es demasiado pesado para tus aplicaciones?

La compilación de los objetos de Moose puede tomar un tiempo considerable durante el arranque de una aplicación, esto podría dar la impresión de que los programas que utilizan Moose son lentos, sin embargo la compilación solamente ocurre al cargar el programa, y dependiendo de la aplicación pude ser que Moose no sea tan pesado como parece.

Un ejemplo de ello es una aplicación en Catalyst (en versiones mayores a la 5.8), cuando arranca se deben compilar todos los objetos hechos en Moose y se siente la diferencia con las versiones anteriores, pero como Catalyst se va a ejecutar durante dias o meses, no importa mucho el tiempo de arranque.

Si la aplicación que quieres desarrollar es un comando que ejecuta una tarea rápida y termina tal vez Moose es muy pesado para tí, sobre todo cuando ejecutas los comandos repetidamente a través de otros comandos como xargs(1) o find(1).

Para los casos donde el tiempo de arranque de la aplicación no se amortiza bien con la ejecución, hay una solución en el CPAN: Mouse.

Mouse es un reemplazo de Moose muy optimizado que permite utilizar la gran mayoría de las características de Moose, pero es mucho más ligero porque esta desarrollado en XS (es decir en C) y se omiten algunas características para aligerar la ejecución.

Según la página del manual de Mouse, Moose solamente falla en el 1% de los tests de Mouse, haciendo al último muy compatible con el primero, pero la batería de pruebas se ejecuta 400% más rápido y en mi experiencia yo no puedo notar la diferencia entre utilizar Mouse y cosas como Class::Accessor::Fast, y aunque la segunda pudiera ser algo más rápida (algo que no he probado formalmente), tener a disposición un sistema de OOP como Moose definitivamente vale la pena.

Usar Mouse es muy simple, solo hay que cambiar Moose por Mouse, todo lo demás sigue igual.

Las características presentes en Mouse permiten hacer la mayoría de los programas y objetos que necesitas para aplicaciones y herramientas sencillas, y si llegas a necesitar las características adicionales de Moose, como la metaprogramación, Moose es la única opción razonable y no queda otra que pagar el precio de la compilación inicial.

Dulce dulce Moose

2010-01-18T08:19:00.001-04:30

[English translation]

Uno de los comentarios que recibí por el artículo anterior fue acerca de como se vería utilizando la sintaxis de MooseX::Declare.

Este módulo provee extensiones sintácticas que van mucho más allá del azúcar sintáctico regular de Moose. Utilizando la magia negra de Devel::Declare, MooseX::Declare crea toda una nueva sintaxis muy similar a la de Perl6, para declarar las clases y roles de Moose, sin embargo, el uso de estas extensiones me genera sentimientos encontrados.

Por un lado está la apariencia y simplicidad de la sintaxis implementada por el módulo, y por otra parte me he dado cuenta que al cambiar la sintaxis de esta manera dejan de funcionar herramientas que doy por sentadas, como perltidy, que da errores en la declaración de prototipos en los métodos, también dejan de funcionar bien módulos como PPI y hasta el coloreo de vim.

Estoy consciente de que todo es cuestión de reparar perltidy, PPI y el coloreo de vim, pero el detalle es que es difícil implementar cuanta sintaxis se le ocurra a cualquiera que introduzca nuevos módulos en el CPAN.

Siempre he argumentado que una de las ventajas de Devel::Declare es que permite evolucionar Perl5 a través del CPAN, módulos como TryCatch y MooseX::Declare muestran extensiones sintácticas que en algún momento podrían agregarse a Perl5 de resultar ampliamente aceptadas.

Pero ¿cómo llegarán a ser ampliamente aceptadas, si no las usamos porque rompen las herramientas que normalmente usamos?

A lo mejor nada de esto importa porque ya en marzo de 2010 llega Rakudo *, y todo el mundo comenzará la gran migración a Perl6.

Como en realidad tengo la misma cantidad de argumentos a favor y en contra, voy a seguir meditando en cuales tienen mas peso que otros. Pero mientras tanto aqui tienen la versión de roles del juego de los animales en MooseX::Declare, para que uds. se hagan una idea propia sobre sus costos y beneficios:

 1 #!/usr/bin/env perl
 2 use MooseX::Declare;
 3 
 4 class QuestionNode {
 5     has pregunta => ( is => "ro", isa => "Str", required => 1 );
 6     has [ "si", "no" ] => ( is => "rw", isa => "Str|QuestionNode", required => 1 );
 7 }
 8 
 9 role AnimalsGame {
10 
11     has tree => (
12         is      => "ro",
13         isa     => "QuestionNode",
14         default => sub {
15             QuestionNode->new(
16                 { pregunta => 'vive en el agua', no => 'tigre', si => 'tiburón' } );
17         }
18     );
19 
20     method play {
21         my $guess = $self->tree;
22         my ( $node, $branch );
23         while ( ref($guess) ) {
24             $node   = $guess;
25             $branch = $self->si( $node->pregunta ) ? "si" : "no";
26             $guess  = $node->$branch;
27         }
28         return if $self->si("Es un(a) $guess");
29         my $animal = $self->prompt("Nombre del animal: ");
30         my $diff   = $self->prompt(
31             "Una pregunta cierta para $animal pero falsa para $guess: ");
32         $node->$branch( QuestionNode->new( { pregunta => $diff, no => $guess, si => $animal } ) );
33     }
34 
35 }
36 
37 role ConsoleGame {
38     use Term::ReadLine;
39     use IO::Handle;
40 
41     has title => ( is => "ro", isa => "Str", default => "El juego de los animales" );
42     has term => (
43         is         => "ro",
44         isa        => "Object",
45         lazy_build => 1,
46         handles    => { prompt => "readline" }
47     );
48 
49     method _build_term {
50         Term::ReadLine->new( $self->title );
51     }
52 
53     method si(Str $prompt) {
54         while (1) {
55             my $answer = $self->prompt("$prompt? (y/n): ");
56             return ( $2 ? 1 : 0 ) if $answer =~ /^\s*((si|s)|(no|n))\s*/i;
57             $self->term->OUT->print("Responde 's' o 'n'\n");
58         }
59     }
60 
61     method run {
62         $self->play;
63         $self->play while $self->si("Quieres jugar de nuevo");
64     }
65 }
66 
67 class Game with AnimalsGame with ConsoleGame {}
68 
69 Game->new->run;

Evolución del estilo en Perl

2010-01-11T00:44:00.001-04:30

[English translation]

Las técnicas y el estilo en la programación es una de esas cosas que van cambiando con el tiempo, como Perl permite extender el lenguaje con facilidad, se forma un círculo evolutivo cuando a su vez las extensiones popularizan nuevos estilos de programación.

Hoy intento dar un rápido vistazo a varias maneras de programar en Perl que he utilizado durante los años, con la esperanza de que podáis apreciar las ventajas del estilo de la programación moderna en Perl.

Todos los programas de este artículo tienen el mismo objetivo, jugar el juego de los animales, que da la ilusión de que la computadora aprende. Sin embargo, no todos los programas utilizan las mismas estructuras de datos o logran el mismo nivel de robustez, en este sentido los estilos "antiguos" son menos robustos que los modernos.

Perl5 Antiguo

En los principios de Perl5 las computadoras tenían menos capacidad, así que los programas solían escribirse de manera bastante compacta, además se usaban "trucos inteligentes", como el uso de los hashes en este programa, en el cual no es fácil comprender como funciona exactamente %tree en el programa:

Estilo 1: Antiguo

 1 #!/usr/bin/env perl
 2 sub prompt {
 3     print $_[0];
 4     $line = <>;
 5     chomp $line;
 6     $line;
 7 }
 8 
 9 sub si {
10     prompt("$_[0]? (s/n): ") =~ /^\s*s/i;
11 }
12 
13 $pregunta = $root = "vive en el agua";
14 %tree = ( $root => [ 'tigre', 'tiburón' ] );
15 do {
16     {
17         $branch   = si($pregunta);
18         $guess    = $tree{$pregunta}[$branch];
19         $pregunta = $guess, redo if $tree{$guess};
20         $pregunta = $root, next if si("Es un(a) $guess");
21         $animal   = prompt("Nombre del animal: ");
22         $diff     = prompt( "Una pregunta cierta para $animal" .
23                             " pero falsa para $guess: " );
24         $tree{$diff} = [ $tree{$pregunta}[$branch], $animal ];
25         $tree{$pregunta}[$branch] = $diff;
26         $pregunta = $root
27     }
28 } while si("Quieres jugar de nuevo");

Son programas como esos lo que le dieron la (mala) fama de lenguaje de solo escritura. Sin embargo por aquellos días se valoraba mucho la inteligencia, y se inventaron los torneos de golf (la comunidad de Perl es la única que conozco que ha jugado golf con el lenguaje). En un partido de golf el programa anterior podría terminar fácilmente como se muestra a continuación:

Estilo 2: Golf

1 #!/usr/bin/env perl
2 sub p{print$_[0];$l=<>;chomp$l;$l}sub a{p("$_[0]? (s/n): ")=~/^\s*s/i}$q=
3 $s="vive en el agua";%t=($s=>["tigre","tiburón"]);do {{$v=a($q);$a=$t{$q}[$v];
4 $q=$a,redo if$t{$a};$q=$s,next if a"Es un(a) $a";$n=p"Nombre del animal: ";
5 $o=p"Una pregunta cierta para $n pero falsa para $a: ";$t{$o}
6 =[$t{$q}[$v],$n];$t{$q}[$v]=$o;$q=$s}}while a"Quieres jugar de nuevo";

Como te imaginarás, programas como el anterior solo lograron empeorar la situación,pues la práctica de este estilo terminó en lugares donde no debió usarse,programas que necesitaban mantenimiento y que por supuesto eran difíciles de mantener. Aun utilizando herramientas como perltidy que reformatean por completo el programa haciendo visible su estructura, es difícil comprenderlo:

Estilo 3: Sucinto

 1 #!/usr/bin/env perl
 2 sub p { print $_[0]; $l = <>; chomp $l; $l }
 3 sub a { p("$_[0]? (s/n): ") =~ /^\s*s/i }
 4 $q = $s = "vive en el agua";
 5 %t = ( $s => [ "tigre", "tiburón" ] );
 6 do {
 7     {
 8         $v = a($q);
 9         $a = $t{$q}[$v];
10         $q = $a, redo if $t{$a};
11         $q = $s, next if a("Es un(a) $a");
12         $n = p("Nombre del animal: ");
13         $o = p("Una pregunta cierta para $n pero falsa para $a: ");
14         $t{$o} = [ $t{$q}[$v], $n ];
15         $t{$q}[$v] = $o;
16         $q = $s
17     }
18 } while a("Quieres jugar de nuevo");

Los nombres en las variables son inútiles, los ciclos son difíciles de seguir y la estructura de datos que se utiliza utiliza trucos muy "inteligentes", que además no funcionan correctamente en algunos casos poco usuales, esto fue típico de alguna época, en las que las soluciones rápidas y sucias fueron mas la norma que la excepción.

Procedimientos y DSL

En este estilo se usan mucho los prototipos convirtiendo cada subrutina en operadores que a veces son difíciles de seguir. Los objetos se utilizan mediante la sintaxis indirecta que trae algunos problemas de ambigüedad.

Estilo 4: Procedimientos y DSL

 1 #!/usr/bin/env perl
 2 use Term::ReadLine;
 3 
 4 use strict;
 5 
 6 my $term = new Term::ReadLine "El juego de los animales";
 7 
 8 sub prompt($) { $term->readline(shift) }
 9 
10 sub si($) {
11     my $prompt = shift;
12     while ( my $answer = prompt "$prompt? (s/n): " ) {
13         return $answer =~ /^\s*((si|s)|(no|n))\s*/i;
14         print { $term->OUT } "Por favor responda 's' o 'n'\n";
15     }
16 }
17 
18 sub play {
19     my $guess = shift;
20     my ($node, $branch);
21     while ( ref $guess ) {
22         $node = $guess;
23         $branch = si $node->{pregunta};
24         $guess = $node->{ramas}[$branch];
25     }
26     return if si "Es un(a) $guess";
27     my $animal = prompt "Nombre del animal: ";
28     my $diff   = prompt "Una pregunta cierta para $animal" .
29                         " pero falsa para $guess: ";
30     $node->{ramas}[$branch] = { pregunta => $diff, ramas => [ $guess, $animal ] };
31 }
32 
33 my $tree = { pregunta => 'vive en el agua', ramas => [ 'tigre', 'tiburón' ] };
34 play $tree;
35 play $tree while si "Quieres jugar de nuevo";

No es que esto este del todo mal, en efecto usar los prototipos permite hacer extender Perl como lo hace Moose, usando el azúcar sintáctico que proveen las subrutinas en Perl.

Una característica interesante de este nuevo programa es una lógica mejor organizada y una estructura de datos mucho más fácil de comprender, sin embargo todavía usa algunas cosas inteligentes, como el acceso a las ramas utilizando el resultado de la comparación en la subrutina si() que retorna 1 en caso de ser cierto, pero undef en caso contrario, claro que Perl convierte undef en "" o en 0 según el contexto en que se use, pero no es una buena práctica andar haciendo eso por todos lados.

Clases hechas a mano

Los objetos en Perl como en cualquier otro lenguaje trajeron las ventajas del encapsulamiento, consistencia y el reuso del código, sin embargo, para obtener todas las ventajas de este tipo de programación había que hacer métodos (subrutinas) que controlaran el acceso a los atributos. Hacer esto en Perl era laborioso, repetitivo y muy muy aburrido:

Estilo 5: Objetos hechos a mano

 1 package QuestionNode;
 2 use Carp;
 3 use strict;
 4 
 5 sub new {
 6     my ( $class, $pregunta, $no, $si ) = @_;
 7     bless { pregunta => $pregunta, no => $no, si => $si }, ref $class || $class;
 8 }
 9 
10 sub pregunta {
11     my $self = shift;
12     return $self->{pregunta} unless @_;
13     croak "pregunta es un atributo de solo lectura";
14 }
15 
16 sub si {
17     my $self = shift;
18     return $self->{si} unless @_;
19     return $self->{si} = shift;
20 }
21 
22 sub no {
23     my $self = shift;
24     return $self->{no} unless @_;
25     return $self->{no} = shift;
26 }
27 
28 1;

 1 #!/usr/bin/env perl
 2 use QuestionNode;
 3 use Term::ReadLine;
 4 use IO::Handle;
 5 
 6 use strict;
 7 
 8 my $term = Term::ReadLine->new("El juego de los animales");
 9 
10 sub prompt($) { $term->readline(shift) }
11 
12 sub si($) {
13     my $prompt = shift;
14     while (1) {
15         my $answer = prompt("$prompt? (y/n): ");
16         return ( $2 ? 1 : 0 ) if $answer =~ /^\s*((si|s)|(no|n))\s*/i;
17         $term->OUT->print("Responde 's' o 'n'\n");
18     }
19 }
20 
21 sub play {
22     my $guess = shift;
23     my ( $node, $branch );
24     while ( ref $guess ) {
25         $node   = $guess;
26         $branch = si $node->pregunta ? "si" : "no";
27         $guess  = $node->$branch;
28     }
29     return if si "Es un(a) $guess";
30     my $animal = prompt "Nombre del animal: ";
31     my $diff   = prompt
32         "Una pregunta cierta para $animal pero falsa para $guess: ";
33     $node->$branch( QuestionNode->new( $diff, $guess, $animal ) );
34 }
35 
36 my $tree = new QuestionNode( 'vive en el agua', 'tigre', 'tiburón' );
37 play $tree;
38 play $tree while si "Quieres jugar de nuevo";
39

En el ejemplo se siguen usando los prototipos y la sintaxis indirecta para algunas cosas y para otras no.

Hacer los accessors en la clase QuestionNode era claramente una labor repetitiva y rápidamente la comunidad le buscó varias soluciones a este problema, que fueron agregadas al CPAN.

Asistentes de Clases

En el CPAN florecieron muchas herramientas que facilitaban la programación orientada a objetos, desde pragmas como "fields" que verificaban las claves de un hash a tiempo de compilación hasta los objetos invertidos (inside-out) implementados por Class::Std que mejoraban la encapsulación.

Yo fui un fanático de Class::Accessor (en realidad de Class::Accessor::Fast), y si hubiera hecho el programa en aquella época quedaría así:

Estilo 6: Objetos asistidos

game.pl:

1 #!/usr/bin/env perl
2 use AnimalsGame;
3 AnimalsGame->new->run;

QuestionNode.pm:

1 package QuestionNode;
2 use base "Class::Accessor";
3 use strict;
4 
5 __PACKAGE__->mk_ro_accessors("pregunta");
6 __PACKAGE__->mk_accessors("si", "no");
7 
8 1;

AnimalsGame.pm:

 1 package AnimalsGame;
 2 use QuestionNode;
 3 use Term::ReadLine;
 4 use IO::Handle;
 5 use base "Class::Accessor";
 6 use strict;
 7 
 8 __PACKAGE__->mk_ro_accessors(qw(tree term));
 9 
10 sub prompt {
11     my $self = shift;
12     $self->term->readline(shift);
13 }
14 
15 sub si {
16     my $self   = shift;
17     my $prompt = shift;
18     while (1) {
19         my $answer = $self->prompt("$prompt? (y/n): ");
20         return ( $2 ? 1 : 0 ) if $answer =~ /^\s*((si|s)|(no|n))\s*/i;
21         $self->term->OUT->print("Responde 's' o 'n'\n");
22     }
23 }
24 
25 sub play {
26     my $self  = shift;
27     my $guess = $self->tree;
28     my ( $node, $branch );
29     while ( ref $guess ) {
30         $node   = $guess;
31         $branch = $self->si( $node->pregunta ) ? "si" : "no";
32         $guess  = $node->$branch;
33     }
34     return if $self->si("Es un(a) $guess");
35     my $animal = $self->prompt("Nombre del animal: ");
36     my $diff   = $self->prompt(
37         "Una pregunta cierta para $animal pero falsa para $guess: ");
38     $node->$branch( QuestionNode->new(
39         { pregunta => $diff, no => $guess, si => $animal } ) );
40 }
41 
42 sub new {
43     my $class = shift;
44     my $opt   = shift || {};
45     my $title = $opt->{title} || "El juego de los animales";
46     my $term  = $opt->{term}  || Term::ReadLine->new($title);
47     my $tree  = $opt->{tree}  || QuestionNode->new(
48         { pregunta => 'vive en el agua', no => 'tigre', si => 'tiburón' } );
49     return $class->SUPER::new( { tree => $tree, term => $term } );
50 }
51 
52 sub run {
53     my $self = shift;
54     $self->play;
55     $self->play while $self->si("Quieres jugar de nuevo");
56 }
57 
58 1;

Las herramientas de asistencia de OOP captaron la atención del programador y los programas en Perl, se hicieron más fáciles de entender y programar de manera robusta.

Moose

Este sistema es la última palabra en OOP para Perl.

En particular voy a mostrar como sería el programa utilizando herencia múltiple y composición (roles, rasgos, mixins, ...), yo me estoy volviendo un fanático de la última, pues permite implementar objetos como jugar con LEGO evitando algunos problemas comunes de la herencia múltiple. Sin embargo, primero el ejemplo con herencia múltiple.

Estilo 7: Moose con herencia múltiple

game.pl:

 1 #!/usr/bin/env perl
 2 package Game;
 3 use Moose;
 4 
 5 extends qw(AnimalsGame ConsoleGame);
 6 
 7 __PACKAGE__->meta->make_immutable;
 8 no Moose;
 9 
10 Game->new->run;

AnimalsGame.pm:

 1 package AnimalsGame;
 2 use Moose;
 3 use QuestionNode;
 4 
 5 has tree => (
 6     is      => "ro",
 7     isa     => "QuestionNode",
 8     default => sub {
 9         QuestionNode->new(
10             { pregunta => 'vive en el agua', no => 'tigre', si => 'tiburón' } );
11     }
12 );
13 
14 sub play {
15     my $self  = shift;
16     my $guess = $self->tree;
17     my ( $node, $branch );
18     while ( ref($guess) ) {
19         $node   = $guess;
20         $branch = $self->si( $node->pregunta ) ? "si" : "no";
21         $guess  = $node->$branch;
22     }
23     return if $self->si("Es un(a) $guess");
24     my $animal = $self->prompt("Nombre del animal: ");
25     my $diff   = $self->prompt(
26         "Una pregunta cierta para $animal pero falsa para $guess: ");
27     $node->$branch(
28         QuestionNode->new( { pregunta => $diff, no => $guess, si => $animal } ) );
29 }
30 
31 __PACKAGE__->meta->make_immutable;
32 1;

ConsoleGame.pm:

 1 package ConsoleGame;
 2 use Moose;
 3 use Term::ReadLine;
 4 use IO::Handle;
 5 
 6 has title => ( is => "ro", isa => "Str", default => "El juego de los animales" );
 7 has term  => ( is => "ro", isa => "Object", lazy_build => 1,
 8                handles => { prompt => "readline" } );
 9 
10 sub _build_term {
11     my $self = shift;
12     Term::ReadLine->new( $self->title );
13 }
14 
15 sub si {
16     my $self   = shift;
17     my $prompt = shift;
18     while (1) {
19         my $answer = $self->prompt("$prompt? (y/n): ");
20         return ( $2 ? 1 : 0 ) if $answer =~ /^\s*((si|s)|(no|n))\s*/i;
21         $self->term->OUT->print("Responde 's' o 'n'\n");
22     }
23 }
24 
25 sub run {
26     my $self = shift;
27     $self->play;
28     $self->play while $self->si("Quieres jugar de nuevo");
29 }
30 
31 __PACKAGE__->meta->make_immutable;
32 1;

QuestionNode.pm

1 package QuestionNode;
2 use Moose;
3 
4 has pregunta => ( is => "ro", isa => "Str", required => 1 );
5 has [ "si", "no" ] => ( is => "rw", isa => "Str|QuestionNode", required => 1 );
6 
7 __PACKAGE__->meta->make_immutable;
8 1;

Moose es capaz de generar una cantidad de código muy superior a la de herramientas anteriores, que se limitaban a generar las clases y los accessors para los atributos, en Moose se pueden especificar restricciones de tipo, que pueden llegar a ser complejas. Así en QuestionNode "pregunta" es un "Str" (cadena de caracteres), mientras que "si" y "no" pueden ser "Str" o un objeto "QuestionNode", Moose se encarga de implementar todo el código para garantizar ese contrato.

A continuación el ejemplo utilizando composición de objetos, una de las características más resaltantes de este ejemplo es que casi no hay que cambiar nada para utilizar la composición de objetos, lo que habla bastante bien de las capacidades de abstracción de Moose para la reutilización de código.

En este caso la clase Game se arma agregando una clase ConsoleGame (con sus atributos) y una clase AnimalsGame que a su vez usa objetos del tipo QuestionNode.

Estilo 8: Moose con Roles.

en game.pl solo cambia en la línea 5, "extend" por "with":

 
 5 with qw(AnimalsGame ConsoleGame);

en AnimalsGame.pm y ConsoleGame.pm solo se cambia la línea 2 para convertir las clases en roles y se elimina la línea 31 que solo tiene sentido para las clases (solo las clases necesitan hacerse inmutables para tener un mejor rendimiento).

 2 use Moose::Role;

Espero que este artículo te ayude a establecer similitudes y paralelos entre las técnicas que actualmente usas y Moose, que es básicamente el futuro de la programación orientada a objetos en Perl5, pero que además es la manera más fácil de aprender y afianzar conceptos que te serán útiles cuando quieras comenzar a utilizar Perl6.

Otra ventaja (quizás más importante) de programar en Moose, es lograr un estándar de OOP que todos puedan aprender fácilmente, la diversidad de sistemas de OOP, no le hace del todo bien al lenguaje, ya que por alguna razón la gente quiere una sola interfaz, Moose hace esto posible ya que es lo suficiente flexible y potente para implementar cualquier cualquier cosa que se te ocurra.

No esperes más. usa Moose. ¡YA!

Atributos con rasgos en Moose.

2010-01-04T03:40:00.003-04:30

[Google translation]
En el articulo anterior vimos lo más básico de Moose, sin embargo una vez que comiences a conocer este sistema de OOP verás que tiene un monton de mecanismos (y conceptos) que facilitan muchas cosas, uno de los más útiles son los rasgos (traits), que permiten aplicar comportamientos a una clase o atributo con mucha facilidad.

Una característica de los rasgos en los atributos es que facilitan el uso de los mismos y permiten operaciones más eficientes.

Veamos un ejemplo, tomando la clase Point del artículo anterior, a la cual le agregaré el método translate, que traslada un punto:

23 sub translate {
24     my ($self, $x_delta, $y_delta) = @_;
25     $self->x( $self->x + $x_delta );
26     $self->y( $self->y + $y_delta );
27 }

Como puedes ver, el manejo de los atributos es fastidioso, aquí es donde los rasgos comienzan a ser útiles, en particular las coordenadas de un punto tienen rasgos numéricos, veamos como mejora el código cuando los aplicamos:

 1 package Point;
 2 use Moose;
 3 
 4 has 'x' => (
 5     traits  => ["Number"],
 6     is      => 'rw',
 7     isa     => 'Int',
 8     default => 0,
 9     handles => { translate_x => "add", }
10 );
11 
12 has 'y' => (
13     traits  => ["Number"],
14     is      => 'rw',
15     isa     => 'Int',
16     default => 0,
17     handles => { translate_y => "add", }
18 );
19 
20 sub clear {
21     my $self = shift;
22     $self->x(0);
23     $self->y(0);
24 }
25 
26 sub distance_sqr {
27     my ( $self, $point ) = @_;
28     return ( $self->x - $point->x )**2 + ( $self->y - $point->y )**2;
29 }
30 
31 sub distance {
32     my ( $self, $point ) = @_;
33     return sqrt $self->distance_sqr($point);
34 }
35 
36 sub translate {
37     my ( $self, $x_delta, $y_delta ) = @_;
38     $self->translate_x( $x_delta );
39     $self->translate_y( $y_delta );
40 }
41 
42 1;

Las líneas 5 y 13 declaran los rasgos (traits) del atributo, es una arreglo porque se pueden agregar tantos rasgos como quieras a un mismo atributo. Las líneas 9 y 17 generan métodos en la clase para representar el comportamiento del rasgo en el objeto, por ejemplo en la línea 9 se define translate_x como el método que implementa la operación add sobre el atributo x.

El rasgo "Number" provee métodos como add, sub, set y otros que puedes consultar en Moose::Meta::Attribute::Native::Trait::Number, que es la clase que los hace disponibles en Moose.

El uso de rasgos no solamente es cómodo, también es más eficiente que utilizar directamente los accesors, en el primer ejemplo se accede al valor de una coordenada, que se suma y se accede nuevamente (para escribirla), en el segundo caso translate_x suma directamente el argumento al atributo.

Estas diferencias se pueden hace más notorias si usamos tipos de datos más complejos, por ejemplo en el caso de las cadenas de caracteres una modificación mediante un accessor puede resultar muy costosa, supongamos un cadena de caracteres:

1 has text => (is => "rw", isa => "Str");

Si queremos afectar la cadena, digamos haciendo una substitución:

1 my $temp = $self->text;
2 $temp =~ s/java/perl/;
3 $self->text($temp);

Esto además de ser incomodo, poco claro y realmente feo (hasta parece Java), puede llegar a ser bastante ineficiente, sobre todo si las cadenas son largas, pues se estan copiando dos veces (cuando se obtienen y cuando se guardan).

En este caso se puede declarar el atributo con un rasgo "String" y usar la operación "replace":

 1 has 'text' => (
 2     traits  => ['String'],
 3     is      => 'rw',
 4     isa     => 'Str',
 5     default => q{},
 6     handles => {
 7         replace_text => 'replace',
 8     },
 9 );

y luego la usas así:

11 $self->replace_text( qr/java/, "perl" );

Cuando se usan arreglos y hashes los rasgos son realmente muy útiles, y lo mejor es que además te puedes hacer tus propios rasgos, aunque esto será para otro artículo.

Por ahora puedes ver los rasgos que ofrece Moose para los tipos de datos nativos de Perl leyendo la documentación de: Moose::Meta::Attribute::Native. Puede que consigas código donde se implementan los rasgos utilizando: MooseX::AttributeHelpers, sin embargo es mucho mejor (y más fácil) usar Moose::Meta::Attribute::Native que ahora es parte de Moose.

Conociendo al alce (Moose)

2009-12-24T02:26:00.006-04:30

En otras ocasiones les he hablado de de Moose, hoy voy a explicar lo más básico de este nuevo sistema de programación orientada a objetos que ha tomado por asalto al CPAN y que muchos desarrollos están adoptando como plataforma oficial de programación orientada a objetos.

Todo este ruido es porque Moose ofece mecanismos únicos de reutilización de código y polimorfismo que además son muy fáciles de utilizar. Así que ahora además de la herencia podrás utilizar roles (también conocidos como mixins), tendrás la capacidad de alterar fácilmente el comportamiento de una clase desde un rol, podrás delegar la de una clase en otra de manerá mágica, establecer contratos, inicialización perezosa, verificación de tipos y docenas de nuevas características que te harán reflexionar sobre como has podido programar toda tu vida sin ellas.

Directo del manual de Moose un ejemplo sencillo de implementación de herencia:

 1 package Point;
 2 use Moose;
 3 
 4 has 'x' => ( is => 'rw', isa => 'Int', default => 0 );
 5 has 'y' => ( is => 'rw', isa => 'Int', default => 0 );
 6 
 7 sub clear {
 8     my $self = shift;
 9     $self->x(0);
10     $self->y(0);
11 }
12 
13 sub distance_sqr {
14     my ($self, $point) = @_;
15     return ($self->x - $point->x)**2 + ($self->y - $point->y)**2;
16 }
17 
18 sub distance {
19     my ($self, $point) = @_;
20     return sqrt $self->distance_sqr( $point );
21 }
22 
23 1;

La línea 2 usa Moose, lo que ejecuta un compilador que transforma el programa, y que de paso activa el modo estricto (use strict) y las advertencias (use warnings).

Luego decimos que nuestro objeto tiene dos atributos (líneas 4 y 5) llamados x y y, estos atributos permiten la escritura y la lectura (is => "rw") y son de enteros (isa => "Int") y tienen un valor por defecto de 0 (default => 0), estas dos líneas generan los métodos de acceso a los atributos que además verifican la validez de los datos que se asignen a dichos atributos, también crean el código necesario para incializar los valores de los atributos en 0.

Luego se implementa una operación que borra el punto, es decir lo pone en (0,0) y otros que calculan la distancia y la distancia al cuadrado de este punto a otro.

Hasta ahora, puede parecer que Moose ahorra trabajo, sin embargo, siguiendo con el ejemplo veamos como sería un punto en 3 dimensiones:

 1 package Point3D;
 2 use Moose;
 3 
 4 extends 'Point';
 5 
 6 has 'z' => ( is => 'rw', isa => 'Int', default => 0 );
 7 
 8 after 'clear' => sub {
 9     my $self = shift;
10     $self->z(0);
11 };
12 
13 around 'distance_sqr' => sub {
14     my ($orig, $self, $point) = @_;
15     return  $self->$orig($point) + ($self->z - $point->z)**2;
16 };
17 
18 1;

Hacer una subclase es realmente simple solo se dice que esta clase extiende a otra (línea 4), se agrega un nuevo atributo y se agregan los métodos. Sin embargo Moose tiene interesantes capacidades que facilitan la reutilización del código, y es aquí donde se le empiza a ver el queso a la tostada.

En vez de escribir un nuevo método clear que sobreescriba el heredado, podemos agregarle un comportamiento al existente, así ni siquiera tenemos que invocar el método de la super clase.

En el caso de distance_sqr envolvemos el código de la super clase con nuestro método, lo que se parece un poco más a la manera tradicional de sobreescribir métodos para luego invocar al código de la super clase utilizando SUPER, sin embargo, estas operaciones le dan una gran potencia a un nuevo mecanismo de polimorfismo: los roles (también conocidos como mixins), del que hablaré en el próximo artículo.

Los objetos creados con Moose se utilizan como cualquier otro objeto, tomando en cuenta que los parámetros del constructor ahora son estilo hash:

1 use Point3D;
2 use Modern::Perl;
3 
4 my $p1 = Point3D->new;
5 my $p2 = Point3D->new( x => 1, y => 1, z => 1 );
6 
7 say "Distance: ", $p1->distance($p2);

Notese que la invocación $p1->distance($p2) invoca el método distance heredado de Point, que a su vez utiliza la envoltura distance_sqr de Point3D, que internamente invoca al método distance_sqr de Point.

Rendimiento en PSGI/Plack

2009-12-07T08:36:00.002-04:30

[English translation]
En mi articulo sobre PSGI aseveré que Plack era rápido, para demostrarlo comparé la velocidad del programa ejecutándose como CGI en apache (ACGI), como un servidor standalone en CGI::Emulate::PSGI (CEP) y como una aplicación nativa de PSGI.

La prueba no fue muy rigurosa, porque en realidad solo quería confirmar lo que había leído.

El comando para reportar la velocidad fue:

$ ab -n 1000 -c 10 -k "http://localhost:5000/cgi-bin/perldocweb?pod=PSGI&format=source"

Los resultados obtenidos fueron:

	ACGI	CEP	PSGI
Peticiones/seg.	10.57	267.17	512.31
Tiempo de ejecución (ms)	94.618	3.743	1.952
Rata de transf. (kBps)	179.52	4539.79	8686.67

Solo por ver la velocidad cruda, me hice un pequeño programa para servir archivos de texto y comparar el rendimiento contra apache sirviendo archivos estáticos:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use IO::File;
 5 
 6 my $dir = "/home/jrey/htdocs";
 7 
 8 my $app = sub {
 9     my $env      = shift;
10     my $filename = $dir . $env->{'REQUEST_URI'};
11     return [ '200', ['Content-Type' => "text/plain"], IO::File->new($filename) ];
12 };

Los resultados para el comando:

$ ab -n 1000 -c 10 -k "http://localhost:5000/PSGI.pod"

Fueron:

	Plackup	Apache
Peticiones/seg.	614.69	3217.03
Tiempo de ejecución (ms)	1.627	0.311
Rata de transf. (kBps)	10425.21	55133.41

Como dije antes, Plack es muy rápido, y en particular esta prueba muestra que el rendimiento es aceptable incluso para contenido estático, así que podremos desplegar las aplicaciones directamente en perl, sin necesidad de un servidor web adicional, excepto para circunstancias especiales, como alta disponibilidad y balanceo de carga, en cuyo caso también hay algunas soluciones en Perl como perlbal. ¿ya les mencioné existe PSGI para perlbal?

Error en CGI::Emulate::PSGI

2009-12-06T19:26:00.002-04:30

Mientras trabajaba con el código del articulo anterior, me dí cuenta de que en realidad el ejemplo sobre CGI::Emulate::PSGI no funcionaba correctamente, debido a que no reinicié las variables globales de CGI.

1 use CGI::Emulate::PSGI;
2 use CGI;
3 
4 my $app = CGI::Emulate::PSGI->handler(sub {
5     CGI::initialize_globals();
6     do "perldocweb";
7 })

De otro modo los parámetros del primer request se quedan fijos para siempre.

PSGI y Plack: el futuro de las aplicaciones web

2009-11-30T01:19:00.006-04:30

[English translation]
Hace unas semanas le mostraba a mi amigo Joel un one-liner de Perl que implementaba un servidor web, tal vez tenía mucho trabajo que hacer porque no pareció sorprendido por esta fantástica línea de perl que usa el módulo IO::All:

perl -MIO::All -e 'io(":8080")->fork->accept->(sub { $_[0] < io(-x $1 ? "./$1 |" : $1) if /^GET \/(.*) / })'

Pero además sorprendentemente (sobre todo para un fanático de Perl) su respuesta fue: "Sabes que la gente de Python tiene software para implementar servidores web con muchísima facilidad, aunque no se cuál es", ahí me dí cuenta de que no entendió el punto, tal vez lo agarre en un mal momento así que lo deje ir.

Pero ya me había intrigado, aunque estaba seguro que se refería a WSGI (también conocido como el PEP-333): una especificación para un API de aplicaciones web, permitiendo la separación e responsabilidades entre la interfaz (política) y su implementación (mecanismos), de manera que los desarrolladores se pueden preocupar por desarrollar y optimizar los mecanismos independientemente de las aplicaciones que los utilizan.

En Perl ese era el trabajo de HTTP::Engine utilizado entre otros por Catalyst.

Sin embargo, me quedó la curiosidad y me puse a buscar en CPAN, ¿habría algo nuevo por allí?. Encontré módulos como Mojo, que utilizan internamente una interfaz similar a WSGI, sin embargo lo más interesante que conseguí fue PSGI y Plack.

Al parecer HTTP::Engine está lejos de ser una solución ideal. Según he leído es monolítico, difícil de adaptar y no muy eficiente, para ambientes integrados (embedded) supongo. Lo cierto es que Miyagawa decidió separar HTTP::Engine en tres partes:

La Especificación: PSGI
Una implementación de referencia: Plack::Server
Herramientas: Plack::*

Lo más interesante de PSGI y Plack es la rapidez con la que se implementó, hace solo semanas era una idea y ya están disponibles desde hace algún tiempo implementaciones de referencia que permiten ejecutar aplicaciones Plack por si mismas (standalone) en un solo hilo o con perfork, también hay interfaces para FastCGI, CGI y por supuesto mod-perl, y como si esto fuera poco, PSGI tiene la capacidad trabajar con sin bloqueo de entrada/salida (non blocking I/O), así que se hicieron servidores basados en POE, AnyEvent y Coro, incluso ya está disponible un módulo de PSGI para Apache (mod-psgi).

Por otra parte, de la nada aparecieron adaptadores de PSGI para frameworks como Catalyst (Catalyst::Engine::PSGI), Squatting (Squatting::On::PSGI), CGI::Application (CGI::Application::PSGI), Dancer y hasta para WebGUI (PlebGUI), también hay herramientas para facilitar la migración de otras tecnologías a PSGI, por ejemplo si tienes alguna aplicación escrita para HTTP::Engine, puedes utilizarla prácticamente sin modificación en PSGI con HTTP::Engine::Interface::PSGI , si tienes alguna aplicación CGI tienes la oportunidad de migrarla con muy pocas modificaciones con CGI::PSGI, y si aún esto es demasiado trabajo puedes usar CGI::Emulate::PSGI que permite ejecutar los CGI como un servidor desde la línea de comandos!.

En el articulo anterior hice un servidorcito de documentos POD que implementé como CGI, seguramente más de uno tuvo problemas para hacerlo funcionar, porque hay que montar el web server y configurar el CGI entre otros. Usando CGI::Emulate::PSGI solamente escribimos un programa que inicie el servidor (perldocweb_starter):

1 use CGI::Emulate::PSGI;
2 my $app = CGI::Emulate::PSGI->handler(sub { do "perldocweb" })

y luego ejecutamos el comando plackup:

$ plackup perldocweb_starter
Plack::Server::Standalone: Accepting connections at http://0:5000/

y ahora tenemos nuestro servidor de documentación ejecutándose en el puerto 5000, así que al visitar:

http://localhost:5000/perldocweb?PSGI

Debería aparecer la especificación de PSGI en el navegador, fácil ¿no?.

Ahora si estamos dispuestos a tocar el código del programa, no necesitaremos el emulador y podremos ejecutar la aplicación directamente con plackup, lo cual es mucho más eficiente.

La primera modificación es cambiar la línea 4 para usar CGI::PSGI, además ya no se usa CGI::Carp, porque Plack tiene una manera mucho más elegante de mostrar los errores utilizando Devel::StackTrace::AsHTML.

Cuando usamos CGI::PSGI el programa debe crear (y retornar) una clausura que será nuestra aplicación así que el código principal entre las líneas 20 y 50 debe encerrarse en una clausura, además la línea 20 ahora debe inicializar un objeto CGI::PSGI, así que la reemplazamos por las líneas 20 a 22 de en la nueva aplicación:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use CGI::PSGI;
 5 use IO::File;
 6 use Pod::Simple::Search;
 7 use Pod::Simple::HTML;
 8 
 9 my %content_types = (
10     RTF   => "application/rtf",
11     LaTeX => "application/x-latex",
12     PDF   => "application/pdf",
13 );
14 my @wikis   = qw(Usemod Twiki Template Kwiki Confluence Moinmoin Tiddlywiki Mediawiki Textile);
15 my %formats = (
16     ( map { $_ => "Pod::Simple::$_" } keys %content_types ),
17     ( map { $_ => "Pod::Simple::Wiki::$_" } @wikis )
18 );
19 
20 my $app = sub {
21     my $env      = shift;
22     my $q        = CGI::PSGI->new($env);
23     my $filename = Pod::Simple::Search->new->inc(1)->find( $q->param("pod") );
24     my $format   = $q->param("format") || "HTML";
25     given ($format) {
26         when ("source") {
27             return [ $q->psgi_header("text/plain"), IO::File->new($filename) ];
28         }
29         when ('HTML') {
30             my $parser = Pod::Simple::HTML->new;
31             $parser->perldoc_url_prefix( $q->url( -path_info => 1 ) . "?pod=" );
32             my $footer = "<hr>"
33                 . join( " ", map { make_link( $_, $q ) } "source", keys %content_types )
34                 . " | Wiki formats: "
35                 . join( " ", map { make_link( $_, $q ) } @wikis );
36             $parser->html_footer(qq[\n<!-- end doc -->\n\n$footer</body></html>\n]);
37             $parser->output_string( my $output );
38             $parser->parse_file($filename);
39             return [ $q->psgi_header("text/html"), [$output] ];
40         }
41         when (%formats) {
42             my $class = $formats{$format};
43             eval "require $class";
44             my $parser = $class->new;
45             $parser->output_string( my $output );
46             $parser->parse_file($filename);
47             return [ $q->psgi_header( $content_types{$format} || "text/plain" ), [$output] ];
48         }
49         default {
50             die("Formato desconocido '$format'");
51         }
52     }
53 };
54 
55 sub make_link {
56     my $fmt = shift;
57     my $q   = shift;
58     $q->a( { href => $q->url( -path_info => 1, -query => 1 ) . "\&format=$fmt" }, $fmt );
59 }

La clausura recibe como parámetro el ambiente de PSGI (21) y lo utiliza para crear el objeto $q que usaremos como si fuera un objeto CGI. Esta clausura debe retornar un arreglo de dos elementos:

Los encabezados: un arreglo de nombres y valores alternados
El cuerpo: que debe ser un arreglo de líneas o un objeto IO::Handle

Una diferencia fundamental entre CGI::PSGI y CGI es que en el segundo se envía al navegador la salida estándar (STDOUT), mientras que en el primero, se retorna el cuerpo.

Así que la generación del contenido en la aplicación debe ser modificada. En el caso del código fuente (línea 26) ha quedado más simple, solo se retornan los encabezados junto con un objeto IO::Handle (creado con IO::File). y CGI::PSGI se encarga de leer los datos del objeto y enviarlos al navegador, de hecho en el caso de que sea un archivo real (como en este caso) y que el sistema operativo implemente sendfile(2) (como en mi caso que uso linux), el envío de los datos se realiza completamente en el kernel así que no habrá diferencia de eficiencia entre este programa y uno optimizado hecho en C (como apache).

En el caso de HTML (línea 29) he cambiado el uso de output_fh por output_string para que el contenido generado por Pod::Simple quede en $output, que se retorna en línea 39.

Como ya no se puede usar el STDOUT para enviar el contenido al navegador tampoco podemos utilizar el atajo $class->filter de Pod::Simple, así que lo he reemplazado por su equivalencia en las líneas 44 a 46 de la nueva aplicación.

Aunque tal vez no es obvio, el código retorna la clausura (línea 20) porque es el último valor que se calcula, ya que lo que sigue es una declaración.

Si llamamos a nuestro nuevo programa "server_pod" podremos arrancarlo con plackup de la siguiente manera:

$ plackup server_pod
Plack::Server::Standalone: Accepting connections at http://0:5000/

y podemos visualizar el contenido de los POD utilizando el navegador como ya se indicó, el servidor que utiliza plackup por defecto (Plack::Server::Standalone) es de un proceso de un solo hilo así que es ideal para el desarrollo o para una aplicación personal, pero si necesitas un servidor con calidad de producción debes ver otras opciones, la más recomendable para código que viene de CGI es probablemente Plack::Server::Standalone::Prefork, que puedes arrancar así:

$ plackup -s Standalone::Prefork server_pod
Plack::Server::Standalone: Accepting connections at http://0:5000/

Eso fue fácil, se utilizan valores por defecto para todo, pero si necesitas entonar el rendimiento del servidor puedes hacerlo dado opciones en la línea de comandos, las opciones generales se documentan en plackup y las de cada servidor en su clase respectiva.

Finalmente este código es mucho más eficiente que el del emulador del primer ejemplo porque no se necesita utilizar archivos temporales para capturar la salida estándar, aún así puede ejecutarse bajo Apache en modo CGI, FastCGI o incluso en mod-perl.

En una próxima ocasión mejoraré la aplicación utilizando directamente Plack y su middleware.

Procesando POD con Pod::Simple

2009-11-21T08:20:00.001-04:30

[English translation]
En el artículo anterior logramos convertir POD a HTML con relativa facilidad para un minúsculo servidor de documentos hecho con CGI, hoy voy a expandir el programa, permitiendo la visualización de documentos POD en una docena de formas diferentes.

Una opción útil cuando veo la documentación del CPAN, es la capacidad de mostrar las fuentes de los módulos, así que voy a agregar un enlace que permita visualizar la fuente de un documente, voy a poner el enlace al final del documento, configurando el footer de la conversión HTML, también debo agregar lógica para reconocer el nuevo tipo de enlaces.

Agregaré un parámetro de formato (format) al query, y lo interpretaré con el given de la línea 12, además para ser compatible con la versión anterior, permitiré que el formato sea opcional, y su valor por omisión será HTML (línea 11):

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use CGI;
 5 use CGI::Carp 'fatalsToBrowser';
 6 use Pod::Simple::Search;
 7 use Pod::Simple::HTML;
 8 
 9 my $q        = new CGI;
10 my $filename = Pod::Simple::Search->new->inc(1)->find( $q->param("pod") );
11 my $format   = $q->param("format") || "HTML";
12 given ($format) {
13     when ("source") {
14         print $q->header("text/plain");
15         open POD, $filename;
16         print $_ while (<POD>);
17     }
18     when ('HTML') {
19         my $parser = Pod::Simple::HTML->new;
20         print $q->header("text/html");
21         $parser->perldoc_url_prefix( $q->url( -path_info => 1 ) . "?pod=" );
22         my $footer = "<hr>" . make_link("source");
23         $parser->html_footer(qq[\n<!-- end doc -->\n\n$footer</body></html>\n]);
24         $parser->output_fh(*STDOUT);
25         $parser->parse_file($filename);
26     }
27     default {
28         die("Formato desconocido '$format'");
29     }
30 }
31 
32 sub make_link {
33     my $fmt = shift;
34     $q->a( { href => $q->url( -path_info => 1, -query => 1 ) . "\&format=$fmt" }, $fmt );
35 }

Más del doble de las líneas de la versión anterior, sin embargo esta arquitectura muy pronto mostrará ser flexible en combinación con Pod::Simple y sus amigos. Mostrar las fuentes, en realidad es una tontería, solamente se envía un encabezado (línea 14) y luego el resto del archivo sin transformar.

La rutina make_link, facilita la creación de enlaces con el nuevo parámetro (format), a partir de la dirección que estamos visitando (ahora incluye también el query), y aunque solo se usa una vez (línea 22), la usaremos más a medida que agreguemos formatos de conversión a la aplicación.

Otro módulo que usé fue CGI::Carp con la opción "fatalsToBrowser", esto sirve para que los errores del programa se puedan ver en el navegador, si quieres probarlo, solo debes poner un parámetro format con algo desconocido para el programa y verás el mensaje de error en el navegador.

Una vez dicho esto voy a transformar POD a Wiki, para ello usaré "Pod::Simple::Wiki" que tiene conversores para al menos 9 formatos de wiki diferentes, así que sin importar si usas Mediawiki o Twiki, siempre puedes escribir tus artículos en POD :-)

Como Perl es dinámico, versatil y fácil voy a agregar todos los formatos de una vez, para lo cual requiero un arreglo con los formatos que voy a soportar (línea 9) y un mapa que me permita asociar cada formato con algún traductor de POD (línea 10):

 1 #!/usr/bin/perl
 2
 3 use Modern::Perl;
 4 use CGI;
 5 use CGI::Carp 'fatalsToBrowser';
 6 use Pod::Simple::Search;
 7 use Pod::Simple::HTML;
 8 
 9 my @wikis   = qw(Usemod Twiki Template Kwiki Confluence Moinmoin Tiddlywiki Mediawiki Textile);
10 my %formats = (
11     ( map { $_ => "Pod::Simple::Wiki::$_" } @wikis )
12 );
13 
14 my $q        = new CGI;
15 my $filename = Pod::Simple::Search->new->inc(1)->find( $q->param("pod") );
16 my $format   = $q->param("format") || "HTML";
17 given ($format) {
18     when ("source") {
19         print $q->header("text/plain");
20         open POD, $filename;
21         print $_ while (<POD>);
22     }
23     when ('HTML') {
24         my $parser = Pod::Simple::HTML->new;
25         print $q->header("text/html");
26         $parser->perldoc_url_prefix( $q->url( -path_info => 1 ) . "?pod=" );
27         my $footer = "<hr>" . make_link("source")
28             . " | Wiki formats: "
29             . join( " ", map { make_link($_) } @wikis );
30         $parser->html_footer(qq[\n<!-- end doc -->\n\n$footer</body></html>\n]);
31         $parser->output_fh(*STDOUT);
32         $parser->parse_file($filename);
33     }
34     when (%formats) {
35         my $class = $formats{$format};
36         eval "require $class";
37         print $q->header( "text/plain" );
38         $class->filter($filename);
39     }
40     default {
41         die("Formato desconocido '$format'");
42     }
43 }
44 
45 sub make_link {
46     my $fmt = shift;
47     $q->a( { href => $q->url( -path_info => 1, -query => 1 ) . "\&format=$fmt" }, $fmt );
48 }

Todo el trabajo se hace al reconocer alguno de los nuevos formatos en la línea 34, allí obtenemos la clase de "Pod::Simple::Wiki" que implementa la conversión y la cargamos dinámicamente con require dentro de un eval (línea 36), de esta manera no tendremos que cargar todas las clases al principio de nuestro programa, utilizando sólo lo necesario para la conversión deseada, luego se envía el tipo de contenidos al navegador y se hace la conversión según clase de wiki deseado.

Ahora solo queda incluir los enlaces a los diferentes formatos en el footer, lo que se hace durante la generación de la página en HTML (líneas 27 a 29).

Si quisieras incluir parte de la documentación en un manual impreso probablemente querrás convertir POD, para las herramientas más adaptadas a este trabajo, vamos a generar RTF y LaTeX a partir de POD, no debe ser muy difícil porque ya existen las clases en el CPAN, lo primero es generalizar el tipo de contenido enviado al navegador, permitiendo usar el mismo código para diversos formatos:

37         print $q->header( $content_types{$format} || "text/plain" );

Esto asume que existe un hash que tiene los formatos que manejaremos asociados a sus tipos de contenido, utilizaremos también este mapa para generar los enlaces a los nuevos tipos de contenido:

27         my $footer = "<hr>" . make_link("source")
28             . join( " | ", map { make_link($_) } keys %content_types )
29             . " Wiki formats: "
30             . join( " | ", map { make_link($_) } @wikis );

El mapa de formatos y tipos de contenido se puede agregar al principio:

 9 my %content_types = (
10     RTF    => "application/rtf",
11     LaTeX  => "application/x-latex",
12 );

y no olvidemos que todo formato debe estar asociado a la clase que hace la conversión en %formats, de lo contrario el formato no será reconocido en el given:

14 my %formats = (
15     ( map { $_ => "Pod::Simple::$_" } keys %content_types ),
16     ( map { $_ => "Pod::Simple::Wiki::$_" } @wikis )
17 );

Ahora podemos convertir a RTF, lo que seguramente arrancará tu suite de oficina favorita, y en el caso de LaTeX probablemente se descargará el archivo.

Para cerrar, voy a incluir un último formato: PDF, este será más complejo porque no hay un módulo en el CPAN que transforme POD a PDF, por ello voy a hacerme uno, basado en Pod::Simple (línea 5), que use LaTeX como formato intermedio para crear los PDF.

 1 package Pod::Simple::PDF;
 2 
 3 use Modern::Perl;
 4 use Pod::Simple::LaTeX;
 5 use base "Pod::Simple";
 6 
 7 use File::Temp;
 8 use File::Spec::Functions;
 9 use IO::File;
10 use IO::Handle;
11 
12 sub new {
13     my $class = shift;
14     return bless { output_fh => \*STDOUT }, ref $class || $class;
15 }
16 
17 sub parse_file {
18     my $self = shift;
19     my $file = shift;
20 
21     my $dir      = File::Temp->newdir();
22     my $tex_name = catfile( $dir, "pod.tex" );
23     my $texf     = IO::File->new( $tex_name, "w" );
24     my $parser   = Pod::Simple::LaTeX->new;
25     $parser->output_fh($texf);
26     $parser->parse_file($file);
27     $texf->close;
28     `cd '$dir'; pdflatex '$tex_name'; pdflatex '$tex_name'`;
29     my $in = IO::File->new( catfile( $dir, "pod.pdf" ), "r" );
30     $self->{'output_fh'}->print($_) while readline($in);
31 }
32 
33 1;

Tal vez la razón por la cual no hay conversor a PDF es porque no hay una manera muy portable de hacerlo, yo voy usar la herramienta pdflatex que es parte de TeX Live, porque supongo que se puede instalar tanto en Unix como en Windows, sin embargo cualquier distribución moderna de TeX en unix debería incluir esta herramienta.

El método parse_file crea un directorio temporal usando File::Temp->newdir
para luego crear el archivo pod.tex dentro del directorio, que se usa para almacenar el resultado de la conversión realizada con Pod::Simple::LaTeX, este archivo ahora se procesa con el comando 'pdflatex' (línea 27) que produce el archivo 'pod.pdf' (y uno que otro archivo inútil) en el directorio temporal.

Muchas cosas pueden salir mal durante en la línea 27 porque el método simple que estoy ofrece muy poco control sobre lo que allí sucede, en una implementación mejorada habría que usar módulos como IPC::Run3 para controlar la ejecución de las herramientas y actuar correctamente ante las diversas fallas que pudieran ocurrir, sin embargo una de las caracteristicas interesantes de Perl es que se pueden hacer prototipos como este rápidamente y después se pueden refinar.

En las líneas 28 y 29 se transmite 'pod.pdf' al navegador, y al terminar el método parse file, la variable $dir sale de contexto y el objeto File::Temp se destruye, eliminando el directorio temporal y todo lo que este dentro del mismo.

Una vez que este módulo se guarda en el lugar apropiado, lo que hace automáticamente el CPAN si el módulo esta empaquetado según las instrucciones de perlmodlib (aunque ahora solo para probar puedes poner el archivo PDF.pm en el mismo directorio donde se encuentra el archivo HTML.pm que contiene Pod::Simple::HTML).

Finalmente hay que agregar el nuevo tipo de contenido (PDF) a la aplicación lo cual es tan simple como agregar una sola línea al hash %content_types (línea 12) sin necesidad de tocar mas nada, ya tenemos un servidor capaz de mostrar POD en mas de una docena de formatos:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use CGI;
 5 use CGI::Carp 'fatalsToBrowser';
 6 use Pod::Simple::Search;
 7 use Pod::Simple::HTML;
 8 
 9 my %content_types = (
10     RTF    => "application/rtf",
11     LaTeX  => "application/x-latex",
12     PDF    => "application/pdf",
13 );
14 my @wikis   = qw(Usemod Twiki Template Kwiki Confluence Moinmoin Tiddlywiki Mediawiki Textile);
15 my %formats = (
16     ( map { $_ => "Pod::Simple::$_" } keys %content_types ),
17     ( map { $_ => "Pod::Simple::Wiki::$_" } @wikis )
18 );
19 
20 my $q        = new CGI;
21 my $filename = Pod::Simple::Search->new->inc(1)->find( $q->param("pod") );
22 my $format   = $q->param("format") || "HTML";
23 given ($format) {
24     when ("source") {
25         print $q->header("text/plain");
26         open POD, $filename;
27         print $_ while (<POD>);
28     }
29     when ('HTML') {
30         my $parser = Pod::Simple::HTML->new;
31         print $q->header("text/html");
32         $parser->perldoc_url_prefix( $q->url( -path_info => 1 ) . "?pod=" );
33         my $footer = "<hr>"
34             . join( " ", map { make_link($_) } "source", keys %content_types )
35             . " | Wiki formats: "
36             . join( " ", map { make_link($_) } @wikis );
37         $parser->html_footer(qq[\n<!-- end doc -->\n\n$footer</body></html>\n]);
38         $parser->output_fh(*STDOUT);
39         $parser->parse_file($filename);
40     }
41     when (%formats) {
42         my $class = $formats{$format};
43         eval "require $class";
44         print $q->header( $content_types{$format} || "text/plain" );
45         $class->filter($filename);
46     }
47     default {
48         die("Formato desconocido '$format'");
49     }
50 }
51 
52 sub make_link {
53     my $fmt = shift;
54     $q->a( { href => $q->url( -path_info => 1, -query => 1 ) . "\&format=$fmt" }, $fmt );
55 }

Herramientas de documentación en Perl

2009-11-15T18:47:00.004-04:30

[English translation]
Perl tiene su propio formato de documentación llamado POD (del inglés Plain Old Documentation), este formato es estructurado y fué específicamente diseñado para ser manipulado fácilmente. POD se usa no solo como herramienta para la documentar Perl, sino como lenguaje de Wiki y hasta para escribir libros.

En perl la herramienta más conocida para leer la documentación es perldoc, que funciona de manera muy similar al manual de unix man(1), así cuando queremos ver la documentación de un módulo podemos hacer:

$ perldoc IO::Handle

Lo que nos mostrará el manual de IO::Handle, también podemos obtener el manual del módulo en otra variedad de formatos, por ejemplo, lo podemos guardar en formato "man", HTML o incluso LaTeX:

$ perldoc -T -o LaTeX IO::Handle > IO::Handle.tex
$ perldoc -T -o html IO::Handle > IO::Handle.html

Si vemos el HTML generado nos daremos cuenta que los enlaces generados al resto de la documentación se refieren al CPAN, pero esto es solo la forma en la que funciona perldoc, existen cientos de módulos para procesar POD, que permiten manipulaciones avanzadas y convertirlo a HTML, XML, LaTeX, texto y DocBook, entre otros.

Cuando se necesita mas control sobre la generación de los documentos, puedes usar otras herramientas como: pod2html y pod2latex que permiten crear documentos basados en varios archivos POD que se procesan en conjunto, por ejemplo para hacer un libro, donde cada capítulo se guarda en un POD diferente.

Si necesitas control total sobre la conversión de POD, siempre puedes programar utilizando los módulos disponibles en el CPAN, y uno de los más fáciles de usar es Pod::Simple, que ofrece varias conversiones predefinidas, por ejemplo si quieres generar HTML en una aplicación CGI, puedes hacerlo con facilidad:

1 use CGI;
2 use Pod::Simple::HTML;
3 
4 my $q = new CGI;
5 my $parser = Pod::Simple::HTML->new;
6 $parser->output_fh(*STDOUT);
7 
8 print $q->header("text/html");
9 $parser->parse_file("/usr/share/perl/5.8/IO/File.pod");

Este programa inicializa los objetos CGI y Pod::Simple::HTML (líneas 4 a 6), envía los encabezados de HTTP (línea 6) y finalmente envía el documento en HTML (línea 9).

En este caso debes conocer el nombre exacto del POD que deseas enviar, sin embargo si quieres saber el nombre de un archivo que contiene información sobre un módulo en particular, debes buscarlo, ¿donde?, pues lo más recomendable es buscarlo en los mismos sitios donde perl buscará los módulos y los ejecutables.

La variable @INC contiene los lugares donde perl busca los módulos que usamos en nuestros programas, esta es una combinación de lugares predefinidos al momento de compilar perl , el contenido de la variable de ambiente PERL5LIB y los lugares epecificados con "use lib" en el código de programas y módulos. Por otra parte cuando perl debe ejecutar un programa lo busca en la variable de ambiente PATH, así que para encontrar el archivo que contiene el POD de un módulo o programa en Perl podemos usar una función como find_pod que se muestra a continuación:

 1 use Modern::Perl;
 2 use Env::Path;
 3 use File::Spec::Functions;
 4 
 5 sub find_pod
 6 {
 7     my $module = shift;
 8     my @module_path = split("::", $module);
 9     for my $dir ( @INC, Env::Path->PATH->List ) {
10         for my $ext ( '', '.pod', '.pm', '.pl' ) {
11             my $name = catfile($dir, @module_path) . $ext;
12             return $name if -e $name;
13         }
14     }
15     return undef;
16 }
17 
18 print "Nombre: ", find_pod(@ARGV), "\n";

Esta función recibe el nombre del módulo o programa, y lo separa por "::", luego itera todos los directorios que se encuentran en @INC y el PATH del sistema que convertimos en una lista con "Env::Path->PATH->List" en la línea 9, para cada directorio se buscan los nombres y los nombres aumentados con las extensiones: pod, pm y pl, el primer nombre encontrado es retornado, y si no se consigue nada se retorna undef.

Nótese el uso de "Env::Path" para obtener el path del sistema de manera portable y "File::Spec::Functions" que importa la función "catfile" para generar los nombres de archivo permite concatenar un nombre de archivo de manera portable, haciendo que esta subrutina funcione en unix y windows.

Sin embargo, hice esto solo por diversión, porque en CPAN ya hay algo mucho mejor: "Pod::Simple::Search", que está bien hecha, se puede instalar en cualquier lado y es mucho más flexible que la subrutina de juguete del ejemplo anterior, así que nuestro CGI para mostrar documentación en POD queda así:

 1 #!/usr/bin/perl
 2 use CGI;
 3 use Pod::Simple::HTML;
 4 use Pod::Simple::Search;
 5 
 6 my $q = new CGI;
 7 my $parser = Pod::Simple::HTML->new;
 8 $parser->output_fh(*STDOUT);
 9 
10 my $filename = Pod::Simple::Search->new->inc(1)->find($q->param("pod"));
11 print $q->header("text/html");
12 $parser->parse_file($filename);

Si tenemos un servidor web configurado, solamente copiamos el programa en el directorio apropiado para ejecutar CGI con el nombre perldocweb, lo marcamos como ejecutable, y todo debería funcionar, para probarlo podemos visitar:

http://localhost/cgi-bin/perldocweb?pod=IO::File

lo que muestra el manual de IO::File en el navegador, aunque todavía los enlaces apuntan al CPAN, si quieres que los enlaces apunten al mismo servidor de documentación hay que establecer el prefijo para generar los enlaces (perldoc_url_prefix), para ello utilizaré el método url() de CGI, que usado como se muestra en la línea 12 retorna el URL completo del script sin el query:

 1 #!/usr/bin/perl
 2 use CGI;
 3 use Pod::Simple::HTML;
 4 use Pod::Simple::Search;
 5 
 6 my $q = new CGI;
 7 my $parser = Pod::Simple::HTML->new;
 8 $parser->output_fh(*STDOUT);
 9 
10 my $filename = Pod::Simple::Search->new->inc(1)->find($q->param("pod"));
11 print $q->header("text/html");
12 $parser->perldoc_url_prefix($q->url(-path_info=>1) . "?pod=");
13 $parser->parse_file($filename);

Nada mal, un servidor de documentación sencillo en 13 líneas, en el próximo artículo veremos como convertir POD a otra cantidad de formatos, mientras tanto pueden instalar Pod::Server y ver como se hace esto con mucha más elegancia.

Manejando errores en Perl

2009-11-04T23:55:00.004-04:30

[English Translation]

En Perl el manejo de excepciones es un poco diferente al que probablemente estamos acostumbrados, en particular Perl no tiene try/catch/throw como algunos otros lenguajes, pero no quiere decir que no hay manejo de excepciones, Perl puede capturar y manejar las excepciones tan bien como cualquier otro lenguaje solo que las estructuras son ligeramente diferentes.

El manejo de excepciones en Perl se basa en el uso del operador eval, que permite evaluar código y capturar errores, cuando eval recibe una cadena de caracteres, compila el código que esta en la cadena y lo ejecuta, sin embargo cualquier error que suceda en este código, desde la compilación hasta la ejecución abortará únicamente el eval y nuestro programa seguirá funcionando, por ejemplo:

1 use Modern::Perl;
2 my $result = eval( "5 / 0" );
3 say "El resultado es: $result";

Aunque el programa funciona, el resultado del eval es undef, porque la división por cero evitó que se retorne algún valor, esto además causa una advertencia en la línea 3 sobre la concatenación con una variable indefinida.

Lo que necesitamos es saber si el eval fué exitoso o no, y eso esta en la variable especial $@ (tambien conocida como $EVAL_ERROR si usamos el módulo English).

Así que para capturar la excepción solo verificamos $@ después del eval:

1 use Modern::Perl;
2 my $result = eval( "5 / 0" );
3 if ( $@ ) {
4     say "Ooops: $@";
5 }
6 else {
7     say "El resultado es: $result";
8 }

Lo que captura el error, el problema con esta solución es que el código que está dentro del string no se verifica a tiempo de compilación, sino que se compila al momento de ejecutarse, y aunque esto es sumamente poderoso, en la mayoría de los casos lo que nos interesa de eval es la capacidad de capturar errores, para ello la segunda forma de eval, recibe un bloque de código que se verifica durante la compilación del programa, y la podemos usar así:

2 my $result = eval { 5 / 0 };

En esta forma de eval las llaves ({}) marcan el bloque donde se requiere capturar excepciones y retorna la última expresión del bloque, o undef si sucede algún error de ejecución (porque los errores de sintaxis ya fueron capturados durante la compilación del programa).

La ultima primitiva que necesitamos para completar el sistema de excepciones de Perl es die, que permite lanzar una excepción, esta rutina recibe un valor que se asigna a la variable especial $@, así que podríamos hacer un programa que lanza una excepción así:

 1 use Modern::Perl;
 2 use IO::File;
 3 
 4 eval {
 5     my $fh = IO::File->new("AlgunArchivo.txt", "r");
 6     die("No se puede abrir") unless $fh;
 7 };
 8 if ( $@ ) {
 9     say "Ooops: $@";
10 }

Para algunos esta forma de capturar excepciones puede parecer arcáica, sin embargo, es tan buena como cualquier otra y con las facilidades de Perl podríamos utilizarla como base para implementar una estructura similar a la de otros lenguajes, es decir algo como try/catch. Como ya he comentado en otras oportunidades Perl es un lenguaje excelente para implementar nuevas características en base a las primitivas del lenguaje, y para divertirnos un rato podemos hacernos nuestra propia versión de try/catch:

 1 use Modern::Perl;
 2 use IO::File;
 3 
 4 sub try(&amp;) {
 5     eval { shift-&gt;() };
 6 }
 7 
 8 sub catch(&amp;) {
 9     if ( $@ ) {
10         local $_ = $@;
11         shift-&gt;();
12     }
13 }
14 
15 try {
16     my $fh = IO::File-&gt;new( "AlgunArchivo.txt", "r" );
17     die("No se puede abrir") unless $fh;
18 };
19 catch {
20     say "Ooops: $_";
21 };

Aquí el prototipo & de Perl permite hacer que las subrutinas try y catch reciban una clausura, pero el prototipo permite eliminar la declaración sub, aparentando que try y catch son estructuras de control que tiene bloque de código asociado.

Como en realidad son subrutinas cuyo primer parámetro es una clausura, se pueden invocar y así en la línea 5 se extrae el primer argumento (con shift) y se ejecuta la calusura (con ->()), todo dentro de un eval, si ocurre alguna excepción, se aborta el eval y se termina el try.

Cuando se usa catch después de un try, cualquier valor de $@ se localiza en $_ y se ejecuta la clausura, en la cual se puede usar $_ como valor de la excepción.

Para hacer una extensión que permita utilizar las primitivas recién creadas, solo tenemos que hacer un nuevo módulo, al que llamaré MyTryCatch y que debe estar en el archivo "MyTryCatch.pm":

 1 package MyTryCatch;
 2 
 3 use Exporter;
 4 
 5 our $VERSION = "1.000";
 6 our @EXPORT_OK = qw( try catch );
 7 our @EXPORT = @EXPORT_OK;
 8 
 9 sub try(&) {
10     eval { shift->() };
11 }
12 
13 sub catch(&) {
14     local $_ = $@;
15     shift->();
16 }
17 
18 1;

Luego cada vez que necesite usar la nueva estructura de control solo tengo que incluirla en un programa, por ejemplo:

 1 package MyTryCatch;
 2 
 3 use Exporter;
 4 
 5 our $VERSION = "1.000";
 6 our @EXPORT_OK = qw( try catch );
 7 our @EXPORT = @EXPORT_OK;
 8 
 9 sub try(&amp;) {
10     eval { shift-&gt;() };
11 }
12 
13 sub catch(&amp;) {
14     if ( $@ ) {
15         local $_ = $@;
16         shift-&gt;();
17     }
18 }
19
20 1;

Las primitivas de que acabamos de crear tienen algunos defectos, por ejemplo puede usarse catch sin try, y una instrucción return dentro de un bloque try o catch, se sale del bloque y no de la subrutina donde se declara la estructura de captura de excepciones, entre otros. Sin embargo con algo más de esfuerzo podríamos hacer una extensión que declare una estructura que se comporte mejor.

En el CPAN hay varios módulos que permiten manejar errores con estructuras similares, desde los más sencillos como Try::Tiny, que sufre de algunos de los inconvenientes de MyTryCatch hasta los más complejos como TryCatch que usa magia de la buena como Devel::Declare para hacer una estructura de manejo de excepciones con casi cualquier cosa que se te pueda imaginar.

Si tus requerimientos no son muy exigentes mi recomendación es utilizar Try::Tiny, es realmente minúscula, casi no tiene dependencias y es muy fácil de instalar, por otra parte si quieres un sistema de manejo de excepciones que hace de todo, no te importa mucho el consumo de recursos y tienes la paciencia para instalar docenas de módulos, puedes usar TryCatch.

Evolución de lenguajes

2009-10-24T10:01:00.002-04:30

[English translation]
Tal vez se ha notado que no he escrito mucho últimamente, la razón fue que tuve que dedicarme por completo una migración de emergencia.
El sistema en cuestión pertenece al cliente que me contrató para desarrollar una aplicación web, que casualmente fue mi primera aplicación de este estilo allá por 1998.

En aquella época estaba dando mis primeros pasos con Perl, pero de alguna manera me convencieron de que la aplicación debía desarrollarse en PHP, poco a poco me dí cuenta que PHP no era lo suficientemente flexible y termine haciendo varios programas en Perl que implementaban la mayor parte de la funcionalidad, aún así toda la interfaz de la aplicación se quedó en PHP.

Durante este proyecto aprendí que Perl era mucho más versátil, poderoso y divertido que PHP, y si no me hubiera dejado convencer, probablemente hubiera conseguido CGI.pm, toda la aplicación estaría en Perl y no tendría una historia para contar.

Al comenzar la migración se me ocurrió que sería más fácil poner a funcionar primero la interfaz, ya que pensé que siendo la parte más simple de la aplicación podría migrarla fácilmente a PHP5, nada más alejado de la realidad, nada funcionaba como debía.

Entiendo que todo evoluciona, pero es que los programas ni siquiera compilaban, algunos APIs han cambiado lo suficiente como para necesitar una completa revisión de todo el código fuente, y por supuesto el programa era un asco, ¿que otra cosa podría ser?, en aquella época no había una librería de templates, el acceso a la base de datos se hacía con las horribles funciones de la librería de PHP3, y toda la aplicación es un monumento a la programación estilo ASP, donde la vista, el modelo y los controladores estaban completamente integrados, como si los hubieran pasado por una licuadora.

Lo cierto es que fue más fácil compilar PHP3 en el nuevo sistema operativo que intentar migrar el código a PHP5, por lo que doy gracias a Debian y particularmente a archive.debian.org, que debe ser uno de los pocos sitios en el planeta que todavía guardan las fuentes de eso (PHP3), porque la comunidad del lenguaje tiene una política de retirarlas de internet.

Una vez superado el problema (es decir PHP), tenía pesadillas sobre el montón de código Perl 5 que no funcionaría para nada en el nuevo Perl 5.10, así que comencé resignado a copiar todos los archivos.

Lo primero en fallar fue DBI, en efecto la cadena de conexión a la base de datos utilizaba un formato que ni recordaba que existió:


  DBI->connect("dbi:Pg:dbname=mydb@myhost.com", "user", "pass");

una vez que la cambié por la sintaxis actual:


  DBI->connect("dbi:Pg:dbname=mydb;host=myhost.com", "user", "pass");

Probé nuevamente el programa y todo funcionó, procedí a probar otro programa y todo funcionó, así seguí programa por programa sin encontrar ninguna falla, ni una más.

Una década de evolución del lenguaje y del CPAN y casi todo funcionó a la primera, estaba asombrado (y por supuesto complacido).

Al contrastar la evolución de Perl y PHP en el tiempo puedo apreciar que mientras el primero ha adquirido una gran cantidad de características, como nuevas construcciones del lenguaje, varios sistemas de implementación de concurrencia, desde la programación orientada a eventos hasta los threads pasando por las corrutinas, nuevas abstracciones para facilitar y mejorar la OOP que permiten al programador elegir entre varios sistemas de orientación a objetos, avances importantes en el área de meta programación, y algunos otros, el segundo básicamente ha obtenido un sistema de OOP, y aún así es más incompatible que Perl.

La pregunta es: ¿por qué esta diferencia radical?, sobre todo cuando se dice que hay muchas más soluciones listas en PHP que en Perl y se supone que debería haber un mayor desarrollo para el primero.

Puede dar la impresión de que lo que digo pretende hacer leña de PHP, pero no es así, PHP fue solo el disparador que me hizo pensar en el problema, si tomáramos otros lenguajes, probablemente llegaría a conclusiones similares, por ejemplo: ¿cuanta evolución ha tenido Python en la última década?, y ¿será que un programa de hace 10 años funciona en el ambiente actual?, ¿y en Java?. Yo apuesto a que Perl les gana a ambos en estos frentes.

Aunque Perl es una solución New Jersey, el lenguaje en sí está muy influenciado por Lisp que es una solución MIT, y aunque se puede argumentar sobre la complejidad de la sintaxis de Perl, lo cierto es que la semántica de sus operaciones es bastante consistente y sumamente versátil, además se puede extender el lenguaje con módulos, permitiendo la experimentación sin necesidad de modificar el interprete.

Otros ambientes de programación tienen herramientas muy buenas que facilitan enormemente la realización de compiladores, pero el nivel de complejidad en la implementación de alguna extensión, que en general se deben implementar como preprocesadores, limitan el desarrollo de este tipo de extensiones.

Por otra parte la falta de integración con el compilador obliga al usuario a introducir complejidad en la construcción del software, ejecución de precompiladores, manejo de archivos temporales, y otros, que se convierten en una pesadilla sobre todo en ambientes dinámicos, imaginemos que para para cargar un módulo en Moose, se necesitara ejecutar el precompilador de Moose y luego cargar el módulo resultante de la compilación, sería realmente fastidioso, sin embargo en Perl existen mecanismos que permiten que se ejecute automáticamente el compilador de Moose, que accede al código fuente e ingresa el resultado automáticamente al compilador de Perl para su fase final de compilación, y el usuario lo único que debe hacer es: use Moose; al comenzar un programa.

Los problemas anteriormente descritos limitan la adopción de extensiones externas al lenguaje, coartando la evolución por la vía de la extensión, que es la manera más fácil de evolucionar un lenguaje. En este sentido Perl se parece mucho a Lisp, y la mayor parte de la evolución del lenguaje se logra agregando módulos externos en el CPAN. Hoy en día existen extensiones que implementan diversas estructuras de control como try/catch, también hay módulos que permiten declarar los parámetros de las subrutinas y los métodos, y muchas otras cosas que no son parte integral del lenguaje.
Con respecto a la compatibilidad, hay dos factores a tomar en cuenta: la compatibilidad de las librerías y la del lenguaje.

La compatibilidad del lenguaje se mantiene utilizando los pragmas, que en Perl son prácticamente lo mismo que cualquier otro módulo del CPAN (o al menos eso parecen desde la perspectiva de un programador), así que cuando el lenguaje cambia simplemente se introducen pragmas. Un ejemplo son las nuevas características de Perl 5.10 que se activan usando un pragma.
La mayor incompatibilidad que ocurrió en la ultima década es la eliminación de los pseudohashes en Perl, y para minimizar los problemas se crearon mecanismos para facilitar la migración del código existente (use fields) y se mantuvieron los pseudohashes como una característica obsoleta por unos 5 años, lo que ilustra cuan comprometida está la comunidad a mantener la compatibilidad con el código existente.

La comunidad ha adoptado recientemente el término DarkPAN, que es todo el código que esta escrito en Perl, pero no está a la vista del público, sino que reside escondido en miles de sistemas que la gente ni siquiera sabe que han sido escritos en Perl (el que originó esta historia aparenta estar escrito en PHP), y aunque hay gente que prefiere que la plataforma de Perl se modernice obviando el DarkPAN, la comunidad en general piensa que esa no es la mejor política.

En el universo la materia obscura es la mayoría de la masa, y aunque no sabemos si el DarkPAN tiene más peso que el CPAN, podemos observar algunos efectos colaterales, por ejemplo: aunque parece haber más sistemas escritos en PHP y Python, se consiguen más ofertas de trabajo en Perl y probablemente la causa sea el DarkPAN.

Lo cierto es que todo ese código que mueve infinidad de negocios está allí porque funciona y porque se puede mantener en el tiempo con menos esfuerzo que el código desarrollado en otras plataformas.

Lo más impresionante es que hoy en día tengamos en la misma plataforma compatible con el código de hace una década, librerías tan fáciles de usar, modernas y poderosas como Moose, Devel::Declare y Catalyst, que son la envidia de los desarrolladores de otros lenguajes.

Así que si quieres programar en un ambiente fácil, moderno, poderoso y perdurable, la elección es clara usar Perl.

Calculadora Estadística: Toques finales

2009-10-05T10:17:00.001-04:30

[English translation]
En el artículo anterior. dejamos pendiente lograr que el interpretador reconociera parámetros y fuera capaz de escribir cualquier valor de retorno de las funciones en Statistics::Descriptive.
Primero debemos definir como se separarán los comandos de los parámetros, y como se separarán los parámetros entre sí, y la manera más fácil es hacerlo como el shell, es decir usando espacios en blanco para ambos, así una vez que se obtiene una línea de comandos:

34     $command =~ s/^\s+//; $command =~ s/\s+$//;
35     my @args = split /\s+/, $command;
36     my $oper = looks_like_number( $args[0] ) ? "add_data" : shift @args;

se eliminan los espacios al principio y al final (34), se separan todos los elementos separados por uno o más blancos (35), y se obtiene la operación a realizar (36) que en general es el primer elemento, excepto en el caso de números en que la operación es "add_data". Luego de estas operaciones tenemos la operación a realizar en $oper y sus argumentos en @args, por lo que solamente resta aplicarlos:

38         when (%FUNCS)               { apply( $oper, @args ) }

La rutina a cargo de la aplicación de la operación debe obtener los argumentos (26), evaluar la operación en contexto lista (27), ¿por qué en contexto lista?, para permitir operaciones como "percentile" que produce múltiples valores.
Una vez obtenido el valor calculado, hay que verificar si vale la pena imprimirlo, así que retornamos si @result está vacío (28), o si tiene un solo elemento pero no esta definido o es una cadena vacia (29).
Para desplegar valores complejos utilizaré el formato YAML, porque es muy legible y tengo a disposición el módulo YAML del CPAN.
Así que dependiendo del número de elementos en @result convertiré el primer escalar o todo el arreglo en un texto en YAML antes de imprimirlo (30).
La calculadora de consola finalmente luce así:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 use Pod::Perldoc;
 7 use Term::ReadLine;
 8 use YAML;
 9 
10 my $term = new Term::ReadLine 'Statistic Calculator';
11 
12 my %FUNCS = map { $_ => 1 } qw( sum mean count variance standard_deviation
13     min mindex max maxdex sample_range median harmonic_mean geometric_mean
14     mode trimmed_mean clear add_data percentile quantile least_squares_fit
15     frequency_distribution_ref frequency_distribution);
16 
17 my @COMMANDS = qw( exit quit help man );
18 
19 sub help { say "Comandos: " . join( ", ", sort @COMMANDS, keys %FUNCS ) }
20 
21 sub man { Pod::Perldoc->new( args => \@_ )->process }
22 
23 my $s = Statistics::Descriptive::Full->new();
24 
25 sub apply {
26     my ( $oper, @args ) = @_;
27     my @result = $s->$oper(@args);
28     return unless @result;
29     return unless @result > 1 or (defined $result[0] and $result[0] ne "");
30     say YAML::Dump( @result == 1 ? $result[0] : \@result );
31 }
32 
33 while ( defined( my $command = $term->readline("Listo> ") ) ) {
34     $command =~ s/^\s+//; $command =~ s/\s+$//;
35     my @args = split( /\s+/, $command ) or next;
36     my $oper = looks_like_number( $args[0] ) ? "add_data" : shift @args;
37     given ($oper) {
38         when (%FUNCS)               { apply( $oper, @args ) }
39         when ("man")                { man "Statistics::Descriptive" }
40         when ( [ "exit", "quit" ] ) {last}
41         when ("help")               {help}
42         default                     { say "Error: tipee 'help' para ayuda" };
43     }
44 }

Después de está serie de artículos, espero que puedas apreciar, lo rápido que se puede trabajar en Perl, usando los mecanismos que ofrece el lenguaje y la inmensa cantidad de herramientas disponibles en el CPAN.
En futuras ocasiones utilizaré este ejemplo para ilustrar otras técnicas como la programación web, la orientación a objetos de Perl y por supuesto más módulos del CPAN.

Calculadora Estadística: Consola Amigable

2009-09-27T18:29:00.001-04:30

[English translation]
Una de las características que hacen agradable el uso de una aplicación de consola es la capacidad de editar la linea de comandos y de reutilizar los comandos anteriores, estas dos características hacen la aplicación mucho más amigable. Así que vamos a agregarlas a la calculadora del artículo anterior.
Este es uno de esos trabajos donde el CPAN demuestra porque es la mejor ventaja de Perl, voy a usar Term::ReadLine, una interfaz unificada para lectura de consola, esta librería permite el uso de varios backends que son los que implementan la funcionalidad, y para que nuestro ejemplo funcione yo instalé Term::ReadLine::Perl, aunque supongo que Term::ReadLine::Gnu debería funcionar igual. Ambas son interfaces de la librería readline(3) que usan muchas aplicaciones, incluyendo bash.
Para tener una interfaz similar a la de bash solo tenemos que cambiar las líneas 27 y 28 de nuestro programa anterior por:

28     my $command = $term->readline("Listo> ") // last;

como siempre, se debe declarar el uso del módulo, e inicializar el terminal creando un objeto $term que usaremos para invocar el método readline:

 7 use Term::ReadLine;
 8 
 9 my $term = new Term::ReadLine 'Statistic Calculator';

usamos Term::ReadLine y no alguna de las variantes específicas, porque este se encarga de ejecutar las versiones específicas de manera automática, aunque permite también que el usuario mantenga control en caso de ser necesario. La librería tiene funciones que permiten adornar el prompt, autocompletar y algunas otras cosas, de nuevo el CPAN salva el día sin hacer más que leer la documentación de un módulo.
Voy a aprovechar para reparar algunas otras cosillas que andan molestando por allí (léase bugs), primero el más fastidioso y fácil de resolver: cuando damos un comando vacío sale un mensaje de error, porque una línea vacía no es capturada por ninguna clausula when, así que el remedio es fácil, agregamos:

when ("")  {  } # si el comando es vacío no hacer nada

y listo.
Otro problema más difícil de resolver son los comandos que no devuelven nada, como "clear", que nos dan un advertencia, gracias al use warnings implícito en Modern::Perl:

Listo> clear
Use of uninitialized value in concatenation (.) or string at calc1.pl line 32.
clear =

Para resolver este problema voy a crear una subrutina que aplique las funciones e imprima el resultado, para mantener el ciclo de despacho lo más claro posible, así que:

32   when (%FUNCS)  { say "$command = " . $s->$command }

pasará a ser esto:

32   when (%FUNCS)  { apply $command }

y luego implementaremos la subrutina apply, que recibe un comando, lo ejecuta y captura el resultado, pero se retorna a menos que el resultado esté definido y no sea una cadena vacia:

26     return unless defined $result and $result ne "";

La calculadora ahora esvmás amigable, sin embargo todavía tiene problemas, si ejecutan trimmed_mean se darán cuenta de que da un error, en el manual está la causa, la función trimmed_mean recibe 1 o 2 parámetros, pero por ahora la calculadora solo acepta comandos sin parámetros, en el próximo artículo veremos como agregarle parámetros y también desplegar resultados no escalares, como arreglos y hashes.
Nuestro programa completo ahora luce así:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 use Pod::Perldoc;
 7 use Term::ReadLine;
 8 
 9 my $term = new Term::ReadLine 'Statistic Calculator';
10 
11 my %FUNCS = map { $_ => 1 } qw( sum mean count variance standard_deviation
12     min mindex max maxdex sample_range median harmonic_mean geometric_mean
13     mode trimmed_mean clear );
14 
15 my @COMMANDS = qw( exit quit help man );
16 
17 sub help { say "Comandos: " . join( ", ", sort @COMMANDS, keys %FUNCS ) }
18 
19 sub man { Pod::Perldoc->new(args => \@_)->process }
20 
21 my $s = Statistics::Descriptive::Full->new();
22 
23 sub apply {
24     my $command = shift;
25     my $result = $s->$command;
26     return unless defined $result and $result ne "";
27     say "$command = $result";
28 }
29 
30 while (defined(my $command = $term->readline("Listo> "))) {
31     $command =~ s/^\s+//; $command =~ s/\s+$//;
32     given ($command) {
33         when ( looks_like_number($_) ) { $s->add_data($command) }
34         when (%FUNCS)                  { apply $command }
35         when ("man")                   { man "Statistics::Descriptive" }
36         when ( [ "exit", "quit" ] )    { last }
37         when ("help")                  { help }
38         when ("")                      { }
39         default                        { say "Error: tipee 'help' para ayuda" }
40     }
41 }

Calculadora Estadística: Usando el sistema

2009-09-23T10:10:00.006-04:30

[English translation]
En el artículo anterior dejamos pendiente agregar un manual a nuestra calculadora, veamos algunas maneras de interactuar con el sistema de documentación en Perl para lograrlo.
El comando para ver la documentación en la calculadora sera "man" y como asumo que la mayoría debe haber interactuado con perldoc, voy a comenzar utilizando directamente este comando para mostrar un manual.
Perl desde hace mucho tiene la capacidad de ejecutar comandos del sistema de varias formas, una de ellas es el operador "`", si escribimos algo como:

1  my @out = `ls -l`

el arreglo @out terminará con cada una de las líneas de la salida del comando, también se pueden ejecutar comandos con open y utilizar su salida como entrada para un programa:

1 open $fd, "-|", "ls -ls" or die "Error: $!"
2 while ( readline $fd ) {
3     # $_ contiene una línea de la salida del comando
4 }

lo cual es sorprendente, aunque no muy recomendado en estos días, pero lo uso una y otra vez en el trabajo, donde arreglo montones de cosas con microprogramas en Perl.
Sin embargo hoy estoy interesado en la función "system" que voy a usar en la primera forma de agregarle un manual a la calculadora.
Como no quiero complicarme mostrando como se escribe un manual, por ahora usaré el manual del módulo Statistics::Descriptive, la solución es simplemente agregar una línea al programa del artículo anterior:

21  when ("man")  { system("perldoc Statistics::Descriptive") }

y eso eso es todo, así es Perl, no hay nada más fácil, algunos podrán decir que es sucio, pero definitivamente fue fácil. Cuando usamos "system" de esta manera perl envía el comando directamente al shell, así que es mejor usarlo así:

21  when ("man")  { system("/usr/bin/perldoc", "Statistics::Descriptive") }

al pasarle a system una lista de argumentos perl ejecuta directamente el comando, evitando algunos problemillas de seguridad que podrían ocurrir, pero el comando no se busca en el PATH, así que debes pasar la ruta completa al ejecutable.
No es una gran sorpresa que el comando perldoc está escrito en Perl, así que probablemente podemos reutilizar el código de este programa en nuestra calculadora, mirando dentro del programa te darás cuenta que perldoc es un programa muy simple, en efecto, las dos líneas importantes son:

1 use Pod::Perldoc;
2 Pod::Perldoc->run();

Asi que toda la funcionalidad de perldoc está metida dentro de un objeto de Perl!, esto es un patrón importante de la cultura Perl, pues permite reutilizar fácilmente cualquier aplicación en otra, que es exactamente lo que queremos hacer, desafortunadamente alguien olvidó documentar Pod::Perldoc así que me metí a ver como lo puedo integrar en mi programa, el resultado fue cambiar la línea 21:

21  when ("man") { Pod::Perldoc->new(args => ["Statistics::Descriptive"])->process }

y por supuesto declarar el uso de la clase al principio del programa:

 6 use Pod::Perldoc;

El único trabajo real fue aprender como funcionaba Pod::Perldoc y me tomó menos de 2 minutos (usando el excelente depurador de perl).
Finalmente me tomé el tiempo para refactorizar un poquito el programa, mejorar el comando "help" y al final que quedó así:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 use Pod::Perldoc;
 7 
 8 use constant SYNTAX_ERROR => "Error: tipee 'help' para ayuda";
 9 
10 my %FUNCS = map { $_ => 1 } qw( sum mean count variance standard_deviation
11     min mindex max maxdex sample_range median harmonic_mean geometric_mean
12     mode trimmed_mean clear );
13 
14 my @COMMANDS = qw( exit quit help man );
15 
16 sub help {
17     say "Comandos: " . join( ", ", @COMMANDS );
18     say "Funciones: " . join( ", ", keys %FUNCS );
19 }
20 
21 sub man {
22     Pod::Perldoc->new(args => \@_)->process
23 }
24 
25 my $s = Statistics::Descriptive::Full->new();
26 while (1) {
27     print "Listo> ";
28     my $command = readline(STDIN) // last;
29     $command =~ s/^\s+//; $command =~ s/\s+$//;
30     given ($command) {
31         when ( looks_like_number($_) ) { $s->add_data($command) }
32         when (%FUNCS)                  { say "$command = " . $s->$command }
33         when ("man")                   { man "Statistics::Descriptive" }
34         when ( [ "exit", "quit" ] )    { last }
35         when ("help")                  { help }
36         default                        { say SYNTAX_ERROR }
37     }
38 }

En el próximo articulo seguiremos agregando características a la calculadora para hacerla más amigable.

Perl inteligente

2009-09-18T09:31:00.003-04:30

[English translation]
En el artículo anterior vimos un ejemplo de Perl moderno, hoy vamos a profundizar un poquito más en la comparación inteligente de Perl 5.10 y como al combinarla con las características dinámicas del lenguaje obtenemos un programa ridículamente pequeño, pero más fácil de comprender y mantener.
Alguna vez leí (creo que de Paul Graham) que cuando alguna sección de código parece duplicada generalmente hace falta un nivel de abstracción, claro que él programa en Lisp, y tiene defmacro. Sin embargo Perl también tiene lo suyo, y en este caso nuestra primera solución podría basarse en un hash que incluya las funciones permitidas en nuestra calculadora:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 
 7 use constant SYNTAX_ERROR => "Error: tipee 'help' para ayuda";
 8 
 9 my %FUNCS = (
10     sum                => 0,
11     mean               => 0,
12     count              => 0,
13     variance           => 0,
14     standard_deviation => 0,
15     min                => 0,
16     mindex             => 0,
17     max                => 0,
18     maxdex             => 0,
19     sample_range       => 0,
20     median             => 0,
21     harmonic_mean      => 0,
22     geometric_mean     => 0,
23     mode               => 0,
24     trimmed_mean       => 0,
25 );
26 
27 my $s = Statistics::Descriptive::Full->new();
28 while (1) {
29     print "Listo> ";
30     my $command = readline(STDIN) // last;
31     $command =~ s/^\s+//; $command =~ s/\s+$//;
32     given ($command) {
33         when ( looks_like_number($_) ) { $s->add_data($command) }
34         when (/^(exit|quit)$/)         {last}
35         default {
36             if   ( exists $FUNCS{$command} ) { ... }
37             else                             { say SYNTAX_ERROR}
38         }
39     }
40 }

Esto es un avance importante, porque estamos simplificando el código en la parte complicada del programa, y reemplazándolo por una simple declaración de un hash, donde incluir una nueva función es tan simple como agregar una línea.
Claro que cualquier lector astuto se ha dado cuenta de que hago trampa porque el programa está incompleto; la línea 36 necesita una acción, nuestro problema ahora es como ejecutar el método correcto para la operación, y en Perl como de costumbre hay varias formas de hacerlo, una de ellas (la peor) podría utilizar referencias a las funciones de la clase en el hash, así:

10     sum  => \&Statistics::Descriptive::sum,

Para luego hacer algo como:

36     if ( exists $FUNCS{$command} ) { say "$command = " . $FUNCS{$command}($s) }

Digo que esa es la peor forma porque hay que saber mucho Perl para entender como funciona eso, y Perl tiene la capacidad de despachar métodos simbólicamente haciendo que nuestra intención quede perfectamente clara:

36     if ( exists $FUNCS{$command} ) { say "$command = " . $s->$command }

El costo de esta operación es mayor que el de la alternativa anterior, sin embargo es un precio que se paga con gusto, porque el programa es mucho más fácil de entender, y últimamente la gente es mucho más cara que las máquinas.
Finalmente si la flojera es uno de tus principios fundamentales, puedes reescribir la asignación del hash así:

 9 my %FUNCS = map { $_ => 0 } qw( sum mean count variance standard_deviation
10     min mindex max maxdex sample_range median harmonic_mean geometric_mean
11     mode trimmed_mean );

Lo que particularmente aprecio, porque ahorro puntuación (lo que parece abrumar a mucha gente) y tengo menos probabilidad de cometer un error de sintaxis.
Básicamente estoy construyendo una lista de palabras (los nombres de los métodos) con "qw", a partir de esta lista construyo otra (usando map) que contiene cada elemento de la lista original ($_) acompañado del número 0, perl convierte automáticamente esta lista en un hash donde cada nombre tiene asociado 0 como valor.
Si la explicación anterior te parece complicada o incomprensible, puedes ver la documentación de map en Perl, lo que te vendrá de maravilla porque además podrás aprender algo de programación funcional que de seguro te será muy provechoso.
Ahora me voy a deshacer del "if", prefiero los condicionales de múltiples vias, son más planos y se ve mejor el flujo, por eso opino que el given/when es lo mejor que le ha pasado a Perl en mucho tiempo, además me voy a deshacer de la expresión regular en la línea 34 por algo que tenga más sentido para un extraño a Perl:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 
 7 use constant SYNTAX_ERROR => "Error: tipee 'help' para ayuda";
 8 
 9 my %FUNCS = map { $_ => 1 } qw( sum mean count variance standard_deviation
10     min mindex max maxdex sample_range median harmonic_mean geometric_mean
11     mode trimmed_mean );
12 
13 my $s = Statistics::Descriptive::Full->new();
14 while (1) {
15     print "Listo> ";
16     my $command = readline(STDIN) // last;
17     $command =~ s/^\s+//; $command =~ s/\s+$//;
18     given ($command) {
19         when ( looks_like_number($_) ) { $s->add_data($command) }
20         when ( ["exit", "quit"] )      {last}
21         when (%FUNCS)                  { say "$command = " . $s->$command }
22         default                        { say SYNTAX_ERROR }
23     }
24 }

Ahora se ve mucho mejor (hasta parece Erlang).
Me estoy valiendo de algunas funciones del smart matching que explicaré a continuación.
En la línea 20 se compara un valor contra un arreglo:

$command ~~ ["exit", "quit"]

Cuando se compara un escalar (a la izquierda) contra un arreglo (a la derecha) el efecto es equivalente a lo siguiente:

sub match_scalar_arrayref {
    my ($scalar, $arrayref) = @_;
    for my $item ( @$arrayref ) {
        return 1 if $scalar eq $item;
    }
    return undef;
}

Ya no recuerdo cuantas veces he escrito código como ese, o como este:

if ( grep { $scalar eq $_ } @$arrayref ) ...

Y que ahora podré escribir con mas claridad y menos esfuerzo:

if ( $scalar ~~ $arrayref ) ...

Probablemente ya adivinaste que en la línea 21, el smart match entre un escalar y un hash es equivalente a:

if ( exists $hash{$scalar} ) ...

Un poco de tentación

Una sugerencia que recibí de un lector daba una solución todavía más corta y fácil de mantener, la idea era cambiar la línea:

21    when (%FUNCS) { say "$command = " . $s->$command }

por:

21    when ($s->can($command)) { say "$command = " . $s->$command }

El método can es provisto por la clase UNIVERSAL, de la cual derivan todos los objetos en Perl, y el propósito de este método es averiguar si un objeto o clase tiene un método determinado.
Al utilizar esta mejora ni siquiera necesito el hash %FUNCS, y además nuestro interpretador se actualizará automáticamente con nuevos comandos a medida que evolucione Statistics::Descriptive, lo cual suena muy bien desde el punto de vista de mantenibilidad, sin embargo, tiene un problema fatal para mí: no es seguro.
El problema es que pierdo el control sobre lo que Perl ejecuta automáticamente, y aunque probablemente este módulo no pueda hacer mucho daño, esta misma técnica utilizando algún otro módulo, podría ser peligrosa. Así que prefiero la seguridad y me quedo con el hash como mecanismo de despacho (y autorización de uso).
La moraleja es que se debe terner cuidado al utilizar mecanismos de control de ejecución dinámicos, sobre todo cuando se utilizan datos de fuentes externas no confiables en estos mecanismos de control de ejecución.

Completando el programa

La línea 22 da un error cuando no se conoce un comando, el mensaje dice que use "help" para obtener ayuda, pero el comando "help" todavía no está implementado, una manera rápida de implementarlo es:

23         when ("help") {
24             say "Los comandos válidos son: "
25                 . join( ", ", qw(exit quit help), keys %FUNCS )
26         }

Guau, eso fue fácil, lo mejor es que además de fácil es consistente, porque se utiliza la misma estructura de datos para informar los comandos, para seleccionarlos y para autorizarlos.
Una de las funciones que se me olvidó incluir en la calculadora en el artículo anterior fue "clear", agregar esta función ahora es tan sencillo como poner una nueva palabra en la definición de %FUNCS:

 9 my %FUNCS = map { $_ => 1 } qw( sum mean count variance standard_deviation
10     min mindex max maxdex sample_range median harmonic_mean geometric_mean
11     mode trimmed_mean clear );

Fue fácil, ¿o no?. Lo mejor es que el nuevo comando aparece automáticamente en la ayuda porque el programa es consistente.
Recapitulemos los logros del día, tenemos un programa:

Muy compacto
Fácil de comprender
Fácil de mantener
Consistente
Seguro

Perl tan válido como cualquier otro lenguaje, pero además, muy pocos lenguajes brindan mecanismos similares a los aquí expuestos para lograr un programa con estas características.
En el próximo artículo veremos como agregarle el manual de funciones estadísticas a nuestra calculadora con mucha facilidad.
A continuación los dejo con la versión final del programa:

 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 
 7 use constant SYNTAX_ERROR => "Error: tipee 'help' para ayuda";
 8 
 9 my %FUNCS = map { $_ => 1 } qw( sum mean count variance standard_deviation
10     min mindex max maxdex sample_range median harmonic_mean geometric_mean
11     mode trimmed_mean clear );
12 
13 my $s = Statistics::Descriptive::Full->new();
14 while (1) {
15     print "Listo> ";
16     my $command = readline(STDIN) // last;
17     $command =~ s/^\s+//;
18     $command =~ s/\s+$//;
19     given ($command) {
20         when ( looks_like_number($_) ) { $s->add_data($command) }
21         when (%FUNCS)                  { say "$command = " . $s->$command }
22         when ( [ "exit", "quit" ] )    {last}
23         when ("help") {
24             say "Los comandos válidos son: "
25                 . join( ", ", qw(exit quit help), keys %FUNCS )
26         }
27         default { say SYNTAX_ERROR };
28     }
29 }

Perl en cinco oraciones

2009-09-16T18:06:00.001-04:30

Generalmente cuando escribo promoviendo Perl, lo hago a la defensiva, porque el estigma que le tienen encima es como exagerado, sin embargo me encontre este artículo y no pude resistir la tentación de copiar las oraciones, porque estan muy buenas.

Perl:

Tiene una librería gigantesca de código reutilizable
Tiene una cultura de mejores prácticas y pruebas de calidad
Tiene una comunidad en crecimiento en la que todo el mundo es bienvenido
Tanto Perl5 como Perl6 tienen un gran futuro.
Durante los últimos 20 años ha sido un gran lenguaje para terminar los trabajos rápidamente y lo seguirá siendo por los próximos 20 años

Voy a sacarle punta a ese resumen ;-)

Usando Perl Moderno

2009-09-15T14:37:00.004-04:30

[English translation]
Voy a intentar escribir una serie de artículos sobre Perl donde se pueda apreciar lo fácil y rápido que se pueden crear soluciones en esta plataforma.
Para ello elegí un diseño simple que me permite ilustrar una cantidad de técnicas y mejores prácticas, con un algoritmo accesible para cualquier programador aunque sea novato.
El programa de ejemplo será una calculadora estadística que en primera instancia utilizará un estilo tradicional, pero que se transformará poco a poco, haciéndose más flexible y fácil de mantener, mientras se aplican algunos mecanismos únicos del lenguaje y algunas librerías del CPAN.
El gran final es hacer que la calculadora sea una aplicación web utilizando un mecanismo sorprendente desarrollado sobre Perl. Una vez dicho esto comenzaré a usar Perl Moderno.
Haciendo honor al título del artículo, lo primero que hace nuestro programa es usar el módulo Modern::Perl, que es un atajo para decir:


use feature ':5.10';
use strict;
use warnings;
use mro 'c3';

Es decir, activa todas las características introducidas en Perl 5.10, también activa el modo estricto y las advertencias, y finalmente activa el orden de resolución de métodos utilizando el algoritmo C3. Como es de esperarse todos los ejemplos que veremos a lo largo de esta serie de artículos, solo funcionarán en Perl 5.10, porque intentare promover la mayor cantidad de características de esta nueva versión del lenguaje, así que: a instalar Perl 5.10.
Al usar Perl Moderno, se recomienda enfáticamente el uso de strict porque captura muchos errores comunes, entre ellos el uso accidental de referencias simbólicas, y los errores de tipográficos en las variables, al costo de que ahora deben ser declaradas con our (globales) ó my (léxicas), antes de usarse.
Por otra parte las advertencias permiten que perl nos informe acerca de posibles errores en la codificación. En perl 5.10 strict es más estricto y warnings tiene muchas advertencias nuevas, así que capturan más problemas que antes, lo que suele mejorar la calidad general del código y ahorrar tiempo de depuración.
En mi caso particular, cuando quise leer un comando y terminar el ciclo en caso de un fin de archivo escribí:


my $comando = readline(STDIN) or last;

Perl inmediatamente me advirtió que en algún caso podría confundirse undef (que denota el fin de archivo) con un "0" (cero), porque en perl "0" y undef se interpretan como falso. Una manera de escribir correctamente la instrucción sería:


defined (my $comando = readline(STDIN)) or last;

Pero aproveché para utilizar el nuevo operador // (defined or), con el que puedo escribir simplemente:


my $comando = readline(STDIN) // last;

El orden de resolución de métodos C3, resuelve algunos problemas existentes con el orden de resolución original de Perl, y lo recomendable es usarlo siempre en el nuevo código, esto no es del todo nuevo, hay módulos que usan este orden de resolución desde hace unos 4 años, solo que antes era un módulo del CPAN (Class::C3) y ahora tiene soporte nativo en el lenguaje.
Así que el primer consejo es usar Modern::Perl, porque activa una cantidad de características útiles y recomendadas de Perl.
Volviendo al programa, lo siguiente después de usar Modern::Perl es importar la subrutina looks_like_number() de Scalar::Util, que además de ahorrarme el trabajo de escribir las expresiones regulares para reconocer números, ahorra una buena cantidad de pánico de los lectores que podrían bloquearse de solo ver esas expresiones regulares.
El último módulo que se usa es el ingrediente principal de la calculadora, porque nunca pasó por mi mente escribir algoritmos de estadística, para eso existe el CPAN, que tiene de todo. En este caso usé Statistics::Descriptive, que sirve perfectamente a mi propósito.
En la línea 7 se declara una constante con un mensaje de error y en la 9 se define una variable con un objeto de la clase Statistics::Descriptive::Full, que será el estado de nuestra calculadora estádística, durante el ciclo de interpretación.
El ciclo principal es simple: lee un comando o se termina (last) si llegó el fin de archivo [línea 12], seguidamente se eliminan los espacios por la izquierda y la derecha del comando [línea 13], si el comando es un número se agrega al conjunto de datos del objeto Statistics::Descriptive::Full [línea 15] y si no, se selecciona y ejecuta un comando del interpretador.
La selección se hace con la nueva estructura de control de Perl 5.10 given/when [líneas 18-36] que efectúa smart matching entre el valor dado (given) y las clausulas de comparación (when). Como la comparación es "inteligente" depende de los operandos, y en general funciona como uno se lo imagina, sin embargo hay algunos casos rebuscados y nunca está de más leer los manuales.
Finalmente el nuevo operador say, que no es más que un print que emite un fin de línea, ayudando a evitar un montón de concatenaciones con "\n" y por ello contribuye con la claridad del código.


 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 
 7 use constant SYNTAX_ERROR => "Error: tipee 'help' para ayuda";
 8 
 9 my $s = Statistics::Descriptive::Full->new();
10 while (1) {
11     print "Listo> ";
12     my $command = readline(STDIN) // last;
13     $command =~ s/^\s+//; $command =~ s/\s+$//;
14     if ( looks_like_number($command) ) {
15         $s->add_data($command);
16     }
17     else {
18         given ($command) {
19             when ("sum")                { say "$command = " . $s->sum() }
20             when ("mean")               { say "$command = " . $s->mean() }
21             when ("count")              { say "$command = " . $s->count() }
22             when ("variance")           { say "$command = " . $s->variance() }
23             when ("standard_deviation") { say "$command = " . $s->standard_deviation() }
24             when ("min")                { say "$command = " . $s->min() }
25             when ("mindex")             { say "$command = " . $s->mindex() }
26             when ("max")                { say "$command = " . $s->max() }
27             when ("maxdex")             { say "$command = " . $s->maxdex() }
28             when ("sample_range")       { say "$command = " . $s->sample_range() }
29             when ("median")             { say "$command = " . $s->median() }
30             when ("harmonic_mean")      { say "$command = " . $s->harmonic_mean() }
31             when ("geometric_mean")     { say "$command = " . $s->geometric_mean() }
32             when ("mode")               { say "$command = " . $s->mode() }
33             when ("trimmed_mean")       { say "$command = " . $s->trimmed_mean() }
34             when (/^(exit|quit)$/)      {last}
35             default                     { say SYNTAX_ERROR }
36         }
37     }
38 }

Para usar la calculadora simplemente ejecutamos el archivo, aquí les muestro una corrida de prueba:


opr@toshi$ perl stat.pl

Listo> 19
Listo> 45
Listo> 24
Listo> 15
Listo> 39
Listo> 48
Listo> 36
Listo> count
count = 7
Listo> 10
Listo> 28
Listo> 30
Listo> count
count = 10
Listo> mean
mean = 29.4
Listo> standard_deviation
standard_deviation = 12.685950233756
Listo> salir
Error: tipee 'help' para ayuda
Listo> help
Error: tipee 'help' para ayuda
Listo> exit
opr@toshi$

Una mejora sencilla

Una mejora de estilo podría ser eliminar el if de la línea 15 y hacer la comparación en el given, esto además me permite mostrar que given topicaliza $_ al valor dado y que las clausulas when no solo comparan cadenas (usando eq) y expresiones regulares (usando =~), sino que permiten, entre otros, escribir expresiones booleanas utilizando $_ como un alias al valor dado en el given.


 1 #!/usr/bin/perl
 2 
 3 use Modern::Perl;
 4 use Scalar::Util qw( looks_like_number );
 5 use Statistics::Descriptive;
 6 
 7 use constant SYNTAX_ERROR => "Error: tipee 'help' para ayuda";
 8 
 9 my $s = Statistics::Descriptive::Full->new();
10 while (1) {
11     print "Listo> ";
12     my $command = readline(STDIN) // last;
13     $command =~ s/^\s+//; $command =~ s/\s+$//;
14     given ($command) {
15         when ( looks_like_number($_) ) { $s->add_data($command) }
16         when ("sum")                   { say "$command = " . $s->sum() }
17         when ("mean")                  { say "$command = " . $s->mean() }
18         when ("count")                 { say "$command = " . $s->count() }
19         when ("variance")              { say "$command = " . $s->variance() }
20         when ("standard_deviation")    { say "$command = " . $s->standard_deviation() }
21         when ("min")                   { say "$command = " . $s->min() }
22         when ("mindex")                { say "$command = " . $s->mindex() }
23         when ("max")                   { say "$command = " . $s->max() }
24         when ("maxdex")                { say "$command = " . $s->maxdex() }
25         when ("sample_range")          { say "$command = " . $s->sample_range() }
26         when ("median")                { say "$command = " . $s->median() }
27         when ("harmonic_mean")         { say "$command = " . $s->harmonic_mean() }
28         when ("geometric_mean")        { say "$command = " . $s->geometric_mean() }
29         when ("mode")                  { say "$command = " . $s->mode() }
30         when ("trimmed_mean")          { say "$command = " . $s->trimmed_mean() }
31         when (/^(exit|quit)$/)         {last}
32         default                        { say SYNTAX_ERROR }
33     }
34 }

Pienso que casi cualquier programador habituado a lenguajes dinámicos como Python o Ruby puede comprender sin dificultad código en Perl Moderno y sentirse cómodo trabajando con este.
Los programadores de lenguajes como C, C++,C# o Java, después de adaptarse a algunos conceptos deberían sentir una especie de experiencia liberadora, porque seguramente en cualquiera de ellos cuesta mucho más escribir un programa como este.
En el próximo artículo veremos algunas características dinámicas de Perl, que hacen el programa más corto, flexible y fácil de mantener.

Los Perleros no usan IE

2009-09-08T20:59:00.002-04:30

Divertida conclusión de las estadísticas que me da Google
Analytics, aunque más 33% de los visitantes del blog, utilizan
Windows como sistema operativo, solo el 7% llega navegando con IE,
a continuación las estadísticas.

Sistemas Operativos

Pos	Sistema	Rata
1.	Linux	56,18%
2.	Windows	33,71%
3.	Macintosh	8,24%
4.	FreeBSD	1,12%
5.	SunOS	0,37%
6.	SymbianOS	0,37%

Navegadores

Pos	Navegador	Rata
1.	Firefox	44,94%
2.	Mozilla	30,71%
3.	Chrome	8,24%
4.	Internet Explorer	7,12%
5.	Safari	5,99%
6.	Opera	3,00%

Ojalá que mas gente aprenda Perl ;-)

El renacimiento de Perl

2009-09-05T19:40:00.005-04:30

[Google English Translation]
En el año 2006 estaba coordinando 2 proyectos, uno de ellos era una aplicación web (obviamente en Catalyst), y parte de mi trabajo es buscar mejores herramientas para facilitar la labor de los programadores, así fue como me topé por primera vez con Moose, que aunque incipiente, captó mi atención de inmediato, así seguí los enlaces hacia Class::MOP, donde me hablaban del Meta Object Protocol, y por terminé aprendiendo algo de Common Lisp y particularmente CLOS.
Más o menos al mismo tiempo estaba coordinando el desarrollo de un sistema distribuido para Linux (en C++ por requerimiento del cliente), y también estaba en la búsqueda de alguna herramienta que aliviara el dolor de que nos causaba ese desarrollo, conocí Erlang y redescubrí la programación funcional, que me llevaron finalmente a OCaml, Haskell y Scheme.
Así que el 2006 y 2007 fueron años de diversión, aprendiendo nuevos lenguajes, mecanismos y paradigmas de programación, lo interesante es que a pesar de adquirir pericias en herramientas tan bien hechas y con una potencia impresionante como las mencionadas, todavía hoy, quien me ayuda a poner la comida en la mesa es principalemente Perl.
Algunos profetas del desastre predicen periódicamente la muerte de Perl, sin embargo, todavía se consigue más trabajo en Perl que en otros lenguajes similares, como se aprecia haciendo una búsqueda en indeed. Cuando les vengan con el cuento de que Perl está muerto no caigan por inocentes, porque en realidad está vivo y tomando impulso nuevamente. Algunos argumentarán que el crecimiento de los otros es más rápido, pero Perl tiene una base de muy grande de código en producción, y le es más difícil crecer, pero ya cruzo la línea de la inmortalidad.
Perl6, al que perdí de vista en el 2005, siguió su avance y logró renovar el interés en Perl5, cuya evolución reciente esta muy influenciada por el desarrollo de su sucesor. Por ejemplo: el sistema de OOP de Perl6 se implementó en Perl5 (Moose), instrucciones como el given/when, que aparece en Perl 5.10 y reemplazan al módulo Switch, vienen directamente de la sintaxis de Perl6.
Perl5 también evoluciona en la dirección del paradigma funcional, hace unos días leí la presentación Functional Pe(a)rls, dictada en el YAPC::EU::2009, así descubrí Foose: un proyecto que intenta introducir en Perl las características importantes de los lenguajes funcionales (principalmente Haskell), tales como listas flojas, mónadas y currificación, siempre cuidando la compatibilidad y la interacción con Moose.
Todos estos cambios interactúan y se retroalimentan del CPAN, la cantidad de módulos que utilizan Moose ha ido en aumento y ya Moose es una dependencia común para muchos módulos, incluyendo Catalyst.
Foose a su vez usa nuevos módulos como Devel::Declare, un módulo casi mágico que permite introducir nuevos elementos sintácticos en Perl, llevando la meta-programación en este lenguaje a un nuevo nivel de abstracción.
El excelente libro Perl Best Practices, ha sido un factor determinante en un cambio cultural de la comunidad, que ahora se enfatiza el buen estilo, la claridad del código y las interfaces, mientras se intenta dejar atrás en la historia a los JAPHs y la mala fama de lenguaje ilegible, por demás injustificada.
Haciendo alarde de su capacidad, la comunidad de Perl va mucho más allá que la de otros lenguajes, y elabora herramientas que permiten evaluar la calidad del código que se genera, así nacieron módulos como Perl::Critic y Test::Kwalitee, que evalúan las prácticas de programación y las critican permitiendo al programador elevar la calidad de su código, y como consecuencia la mejora global de las librerías del CPAN.
En resumen, desde hace algún tiempo hay un proceso de renovación tecnológica y cultural que por definición son el Renacimiento de Perl.

La magia de Perl

2009-08-31T21:29:00.002-04:30

[Google english translation]
Una de las características que hacen de perl una navaja suiza (por cierto afilada) son las construcciones mágicas del lenguaje, que permiten escribir micro programas rápida y fácilmente, y es una de las razones por las cuales el lenguaje tiene fama de incomprensible.
Aunque el uso de estas construcciones están contraindicadas en la programación de sistemas, son de gran utilidad en el día a día de los administradores de sistemas y programadores, por ello voy a explicar las más comunes, para que puedas apreciar su potencia y entender los scripts que se crucen en tu camino.

El operador de lectura

En Perl se puede leer una línea de la entrada estándar de la siguiente manera:


my $linea = readline(STDIN);

Sin embargo también existe el operador de lectura <ARCHIVO> que permite leer una línea así:


my $línea = <STDIN>;

adicionalmente si el archivo es STDIN se puede omitir el nombre en el operador, quedando simplemente:


my $linea = <>;

Cuando enfaticé "una línea" en los párrafos anteriores lo hice porque en Perl no se leen líneas, en realidad se leen registros, claro que por defecto los registros están definidos como texto terminado por fines de línea, que a su vez tienen un significado diferente en cada plataforma, por ejemplo en Unix el fin de línea es "\n", mientras que en Windows es "\r\n".

El acumulador o Variable Implícita ($_)

Es una variable global que se utiliza implícitamente, sobre todo en las operaciones mágicas, su nombre viene de la similitud con el acumulador en Ensamblador que se utiliza implícitamente, aunque es mejor llamarla "Variable Implícita", el nombre de esta variable en Perl es: "$_".
Uno de los usos más comunes de la variable implícita es en la prueba de expresiones regulares, normalmente cuando quieres saber si el contenido de una variable concuerda con una expresión regular haces:


if ( $texto =~ m/lo que se busca/ ) { ...

Pues bien, si el texto se encuentra en $_ entonces se puede hacer:


if ( m/lo que se busca/ ) { ...

Además $_ se utiliza en algunas funciones de la librería como

split y print, por ejemplo:


@campos = split( /,/, $texto );
@campos = split /,/;

La primera línea pica el contenido de la variable $texto (por las comas) mientras la segunda hace lo mismo utilizando implícitamente el contenido de $_. Algo similar sucede con print. Por cierto, ¿se notó que la segunda llamada no tiene paréntesis?, eso es producto de que en Perl esos paréntesis son opcionales (pero dejaré eso para otro artículo).

El ciclo mágico

Cuando se combina $_ el operador de lectura <> y un ciclo while tenemos el ciclo mágico de Perl:


while ( <> ) {
    print;  # se imprime $_ implícitamente 
}

Este ciclo lee de la entrada estándar mientras haya líneas que leer, y el resultado de cada lectura queda en $_, en efecto el programa anterior se parece mucho a cat(1) de Unix, supongamos que tenemos este programa instalado con el nombre plcat, entonces:


$ plcat < archivo.txt
$ plcat < fuente.txt > destino.txt
$ ls -R / | plcat

Hacen exactamente lo mismo que cat(1), pero además hace más magia, así que:


$ plcat archivo.txt
$ plcat archivo.txt otro.txt

Incluso el argumento "-" de cat funciona igual!:


$ plcat archivo.txt - otro.txt

El ciclo mágico implícito

El ciclo mágico puede omitirse si perl se invoca con alguna de las opciones -p ó -n, la primera envuelve todo el código de Perl en el ciclo que antes vimos, con el print al final, la segunda hace lo mismo pero omite el print. Así que el programa anterior se puede escribir en una sola línea de perl:

$ perl -ne 'print' archivo.txt

Aunque como -p también incluye el print podemos hacer:

$ perl -pe '' archivo.txt

Un ejemplo práctico

Una forma de escribir grep en Perl sería:

#!/usr/bin/env perl
my $patron = shift(@ARGV);
while (<>) {
    print "$ARGV:$.: $_" if m/$patron/; 
}

La variable $ARGV contiene el nombre del archivo actualmente abierto por el ciclo mágico, y la variable $. contiene el número de la última línea leída. Todo esto se puede hacer directamente desde la línea de comandos:

$ perl -ne 'print "$ARGV:$.: $_" if m/lo que busco/'

Y después de saber como funcionan los operadores lógicos en Perl, puedo hacerlo así también:


$ perl -ne '/lo que busco/ && print "$ARGV:$.: $_"'

El separador de registros

Ya mencione que el concepto de línea en Perl en realidad significa registro, y que los registros se definen por defecto para coincidir con el fin de línea del sistema operativo. La variable global que configura como se interpretan los registros en Perl es $/, así que si se necesita procesar un archivo separado por una cadena particular solamente se asigna esa cadena a $/.
Esta variable tiene valores especiales para lograr diversos efectos, el primer valor especial es indefinido, cuando $/ = undef, el registro es todo el archivo, así que:

$todo = readline(STDIN);

Lee todo el archivo en la variable, se imaginarán que si el archivo es un DVD probablemente te quedarás sin memoria antes de que el programa termine.
Otro valor interesante es la cadena vacía, que permite leer registros de varias líneas delimitados por líneas en blanco, el siguiente programa lee un archivo de paquetes de Debian paquete por paquete imprimiendo el nombre de cada paquete:

#!/usr/bin/env perl
$/ = '';
while (<>) {
    /^Package:\s+(.*)/m or die "Error de sintaxis";
    print "$1\n";
}

Y por supuesto su correspondiente programa de una línea:

$ perl -ne '/^Package:\s+(.*)/m && print "$1\n"'

Recomendaciones finales

El propósito de este artículo es dar a conocer técnicas importantes que ayudan a resolver problemas puntuales, sin embargo, casi todo lo aquí expuesto debe evitarse para programas que sean de más de una docena de líneas o cuando se pretenda instalar un programa como herramienta en una organización.
Para programas grandes ó duraderos:

Evita $_ excepto cuando no haya más remedio, o en pequeños trozos de código donde esté topicalizada y aún así es mejor usar una variable local (declarada con my), si no sabes que es eso de la topicalización no uses $_.
Usa preferiblemente readline() en vez del operador de lectura, porque hay mas chance de que un novato entienda el programa.
No uses $/ pues cambia el comportamiento de todos los archivos abiertos en perl, esto es común para algunas otras variables que configuran el ambiente operativo en perl y que puedes consultar con el comando: perldoc perlvar

Suficiente magia por hoy.

Perl arcaico

2009-08-24T11:56:00.005-04:30

[English translation]
Hace un par de dias me tocó atender un proveedor que vino a ofrecer sus servicios para el desarrollo de una aplicación web.
Como alguno de los participantes de la organización tuvo que manejar un imprevisto aproveché para iniciar un pequeña investigación durante la charla informal: "¿Que herramientas de desarrollo utilizan en su empresa?".
En un mundo ideal la respuesta hubiera sido: "Perl", pero me informaron que ellos trabajan principalmente en Python, aunque pueden trabajar en otros ambientes, incluyendo Perl.
Después de informarles que en la organización preferimos Perl para el desarrollo de nuestras aplicaciones, y después de un micro debate religioso, uno de ellos (Juan) concluyó:

En definitiva cualquier cosa que se puede hacer en un lenguaje se puede hacer en el otro, solo que en Perl la programación es más arcaica

en aquel momento casi me altero, pero en vista de que llegó el que faltaba y que lo importante era la reunión, me quedé tranquilo.
Ahora en retrospectiva me pregunto: ¿a qué se refería con eso de que Perl es arcaico?, tal vez, Juan se refería a Perl 1 (1987), que era una especie de Shell Script con grep, sed y awk incluido, incluso pudiera pensar que dijera eso hasta de Perl 4 (1991, un poco después de Python 1.0), sin embargo la era actual de Perl es 5 (1994) y en vista de la edad del personaje, creo que en realidad Juan no encontró una palabra que describiera todos los míticos defectos de Perl y terminó usando la palabra incorrecta.
Si Perl fuera arcaico, probablemente la programación orientada a objetos y la programación funcional también lo sean, sin embargo son las dos tecnologías con más impulso en la actualidad, y dado que incluso el sistema de orientación a objetos de Perl fue copiado de Python, asumiré que quiso decir alguna de las siguientes:

Perl es feo
Perl es desordenado
Perl es ilegible
Perl es incomprensible

Voy a responder brevemente a estos prejuicios que se han difundido ampliamente por Internet y para los cuales no hay un sustento real, y mucho menos después del renacimiento de Perl (del que hablaré en otro artículo).

Perl es feo

Como eso es cuestión de gustos, lo que es feo para algunos puede ser muy atractivo para otros. Pero suponiendo que Perl es uno de los lenguajes más feos, tiene características que lo hacen un lenguaje único para resolver una gran cantidad de problemas con facilidad.
Una de las características que hacen la sintaxis de Perl recargada (no necesariamente fea) son los sellos (sigils) que indican el tipo de cada variable, sin embargo esto facilita la extensibilidad del lenguaje y permite la interpolación en las cadenas, y cuando me refiero a que Perl es extensible quiero decir que se puede intervenir en el proceso de compilación para cambiar la sintaxis original, una característica de muy alto nivel que comparte con muy pocos lenguajes, y que es el fundamento de los lenguajes de dominio específico (o DSLs por sus siglas en inglés) que son muy útiles y populares. Perl ofrece al menos tres mecanismos diferentes para lograr este objetivo.
Otra característica es la práctica integración de las expresiones regulares en el lenguaje, logrando el uso extensivo de las mismas, lamentablemente dichas expresiones son feas sin importar el lenguaje. Tomemos como ejemplo el reconocimiento de una instrucción específica de LaTeX:


\begin{document}

En Perl se vería algo como:


if ( $latex =~ m/\\begin\{[a-z]+\}/ ) ...

En Python:


patron = re.compile(r'\\begin\{[a-z]+\}')
if

patron.match(latex)

:
...

En realidad ninguno de los dos es bonito, pero realmente en Perl es más sucinto y hasta más fácil de entender, y eso que no muestro lo tedioso que es usarlas en Java.
Finalmente está el bendito argumento sobre el estilo y todo aquella tontería de que el compilador obliga a indentar correctamente. Lo digo porque aún cuando es cierto que uno termina acostumbrándose, también es cierto que a veces es un fastidio y estorba, y en esos casos no hay remedio. Mas adelante hay un ejemplo de Python que no es fácil de formatear por lo inflexible de la sintaxis.
Cuando se requiere un estilo de código en particular, se usan herramientas de formateo, por ejemplo para C yo uso indent, y para Perl uso perltidy, últimamente el código que escribo suele estar en el siguiente estilo:


perltidy -l=99 -sbl

No importa como me entreguen el código o como lo transcriba yo mismo, porque lo puedo poner en mi estilo estándar con un solo comando, incluso antes de salvarlo (porque además uso vim).

Perl es desordenado

Los lenguajes no son desordenados, la gente lo es.
Sin embargo hay lenguajes que tienen más mecanismos que otros para organizar un proyecto, en particular Perl ofrece varias formas de organizar el código que se adaptan a muchas necesidades, que van desde la programación en una sola línea (de comandos), hasta la construcción de aplicaciones grandes y complejas.
El lenguaje permite la creación de módulos procedimentales con sus propios espacios de nombres, que incluso se pueden organizar en multiples archivos para ser cargados "on demand", bien enterprise, ¿cierto?.
Perl tiene un sistema básico de orientación a objetos que permite implementar OOP de muchas maneras diferentes, porque mientras muchos lenguajes solo hay una forma fija de manejar objetos, en Perl: "hay más de una forma de hacerlo".
Lo que no hace perl es obligar al programador a seguir una estructura determinada, sin importar si eso se adapta a las necesidades de un programa específico, porque si hiciera eso se parecería a Java.

Perl es ilegible

Esto es solo una combinación particular de los dos mitos que le preceden, aunque también se usa el argumento de que no se puede leer el código que se escribío hace 15 min. y eso bajo ciertas circunstancias es bueno, porque permite escribir programas rápidamente aunque sean sucios, después de todo nadie quiere ponerse a diseñar y documentar siguiendo los principios de ingeniería de software para comprender el último programa que escribí hace unas horas, únicamente porque necesitaba una pista sobre la frecuencia de aparición de los caracteres en una docena de archivos:


perl -MYAML -ne '$c{$_}++for split//;END{print Dump\%c}' datos.txt

Es más fácil escribirlo nuevamente que intentar comprenderlo, claro que el programa es una tontería en Perl porque tiene ciertas construcciones mágicas, pero no intenten algo así con otro lenguaje, porque su mejor escenario es lograr que funciona, pero garantizo que va a ser mucho más largo y difícil.
Sin embargo Perl también permite escribir el código mas bonito si eso fuera lo necesario:


use YAML;
use IO::File;
use strict;

my %cuentas;
my $fd = new IO::File $ARGV[0], "r";
while ( my $line = readline($fd) ) {
    for my $letra ( split( //, $line ) ) {
        $cuentas{$letra}++;
    }
}
print YAML::Dump( \%cuentas )

Estoy seguro de que no es muy difícil para un programador de Python o Ruby comprender lo que hace ese código ¿o sí?, luego la cuestión no es que el lenguaje sea ilegible, sino la motivación para escribir el programa y en todo caso la inteligencia del programador para escribir código legible o fácilmente mantenible aún por compañeros poco experimentados.
Finalmente la menor de mis preocupaciones fue el formato del código, pues la mayoría del trabajo lo hace mi editor automáticamente, pero por si acaso también lo pase por perltidy para que vean lo bien formateado que queda.

Perl es incomprensible

¿Para quién?, por ejemplo, el japonés es incomprensible para mi, pero dudo que lo sea para la mayoría de la gente que vive en Tokio, de igual manera Perl es incomprensible para alguien que no este entrenado para comprenderlo. En la sección anterior di un ejemplo de que se puede trabajar en Perl escribiendo el código de manera tan clara como en Python o en Java.
Ciertamente hay mucho código Perl que es prácticamente incomprensible excepto para los gurúes del lenguaje, pero eso no significa que los programas deban escribirse de esa manera.
Lo que si es cierto es que la forma sucinta que permite ofuscar el código hace de perl, no solo un interpretador sino una herramienta de uso común en la línea de comandos y al mismo tiempo permite la expresión del ingenio y maestría en el dominio del lenguaje. Hay muy pocos lenguajes que permitan hacer los JAPHs como Perl.
La falacia aparece cuando se dicen cosas como: "Perl es maligno porque permite esas cosas", "En Python es imposible hacer programas incomprensibles", ¿ah si?, a ver quien entiende este programita en Python:


for n in range(12):
    exec("abcdefghijkl"[n]+"=lambda x=0,y=0: "+filter(
        lambda x:x not in "\n$\r","""(x*y#x/x!range(x,
y#x+y!b(1,1#d(e~,e~#d(f~,f~#c(e~,e~+d(g~,d(g~,g~))#"%4
d" % a(x,y#map(lambda y:i(x,y),h~#" ".join(j(x)#"\\n".
join(map(k,h~))""".replace("~","()").replace("#",")!")
        ).split("!")[n])
print l()

Y puedo buscar cosas mucho más feas en Java, lo que significa que se pueden escribir programas incomprensibles en cualquier lenguaje, y un novato probablemente lo pueda hacer simplemente aprovechando su ignorancia. Por ello la importancia del personal calificado sin importar cual sea el lenguaje.
Sin embargo no se aprovechará todo el potencial de los programadores a menos que el lenguaje provea mecanismos de abstracción del más alto nivel, y es en este caso que lenguajes como Java y PHP son bastante malos mientras Perl supera a Python y a Ruby con holgura, descalificando completamente cualquier posibilidad de catalogar a Perl como un lenguaje arcaico.
Perl puede ser tan corporativo como cualquier otro lenguaje, y dominar este lenguaje en una organización, supone una inversión donde el código se puede utilizar y reutilizar de muchas maneras: desde los administradores de sistemas hasta los desarrolladores, pasando por los administradores de base de datos, etc.; en soluciones que van desde una simple operación de línea de comandos hasta la programación de una gran aplicación corporativa.