Perl es dificil de leer

Ok. Hemos de aceptarlo. Lo del título es cierto

Perl es un lenguaje con un montón de virtudes, pero la legibilidad de su código no es una de ellas. De hecho, suele decirse que Per es un lengiaje Script Only (solo escritura).

He aquí algunas notas al respecto, para que te hagas una idea:

Esto es lo que opinan los programadores de Python (que, dicho sea de paso, son unos disidentes que han abandonado el camino de los auténticos lenguajes de programación). Este texto, de autor desconocido, ha circulado mucho por diversos foros, Y yo solo me he ocupado de traducirlo al español:

EXTERIOR: DAGOBAH -- DIA

Con Yoda atado a su espalda, Luke sube por una de las gruesas lianas que abundan en el pantano,
hasta que alcanza el laboratorio de estadística de Dagobah.
Jadeando pesadamente, continúa sus ejercicios, instalando nuevos paquetes, entrando como root, y escribiendo los sustitutos para los scripts en python de hace dos años.

YODA: ¡Programa! Sí. La fuerza de un programador de su capacidad de mantener el código fluye.
Pero guárdate de Perl. Sintaxis concisa... más de una forma de hacerlo... variables por defecto.
El lado oscuro de la capacidad de mantenimiento del código es en él.
Fluye fácilmente, rápido ensambla cuando código escribes.
Una vez que caigas en el lado oscuro, su voluntad por siempre tu destino dominará, consumido serás.

LUKE: ¿Es Perl mejor que Python?

YODA: No... no... no. Más rápido, más fácil, más seductor.

LUKE: Pero cómo sabré que Python es mejor que Perl?

YODA: Lo sabrás. Cuando tu código intentes leer dentro de seis meses.

Esto otro son un par de ejemplos de lo que opinan en la Tira ECOL (de periodicidad mensual y muy recomendable).

Un ejemplillo:

Chiste de la Tira ECOL

Y otro:

Chiste de la Tira ECOL

Para que te vayas haciendo una idea más concreta, esto es un (peculiar) programa en Perl:

#!/usr/bin/perl -w                                    
use strict;
                                           $_='ev
                                       al("seek\040D
           ATA,0,                  0;");foreach(1..2)
       {<DATA>;}my               @camel1hump;my$camel;
  my$Camel  ;while(             <DATA>){$_=sprintf("%-6
9s",$_);my@dromedary           1=split(//);if(defined($
_=<DATA>)){@camel1hum        p=split(//);}while(@dromeda
 ry1){my$camel1hump=0      ;my$CAMEL=3;if(defined($_=shif
        t(@dromedary1    ))&&/\S/){$camel1hump+=1<<$CAMEL;}
       $CAMEL--;if(d   efined($_=shift(@dromedary1))&&/\S/){
      $camel1hump+=1  <<$CAMEL;}$CAMEL--;if(defined($_=shift(
     @camel1hump))&&/\S/){$camel1hump+=1<<$CAMEL;}$CAMEL--;if(
     defined($_=shift(@camel1hump))&&/\S/){$camel1hump+=1<<$CAME
     L;;}$camel.=(split(//,"\040..m`{/J\047\134}L^7FX"))[$camel1h
      ump];}$camel.="\n";}@camel1hump=split(/\n/,$camel);foreach(@
      camel1hump){chomp;$Camel=$_;tr/LJF7\173\175`\047/\061\062\063
      45678/;tr/12345678/JL7F\175\173\047`/;$_=reverse;print"$_\040
       $Camel\n";}foreach(@camel1hump){chomp;$Camel=$_;y/LJF7\173\17
        5`\047/12345678/;tr/12345678/JL7F\175\173\047`/;$_=reverse;p
         rint"\040$_$Camel\n";}#japh-Erudil';;s;\s*;;g;;eval;   eval
           ("seek\040DATA,0,0;");undef$/;$_=<DATA>;s$\s*$$g;(   );;s
             ;^.*_;;;map{eval"print\"$_\"";}/.{4}/g; __DATA__   \124
               \1   50\145\040\165\163\145\040\157\1 46\040\1  41\0
                    40\143\141  \155\145\1 54\040\1   51\155\  141
                    \147\145\0  40\151\156 \040\141    \163\16 3\
                     157\143\   151\141\16  4\151\1     57\156
                     \040\167  \151\164\1   50\040\      120\1
                     45\162\   154\040\15    1\163\      040\14
                     1\040\1   64\162\1      41\144       \145\
                     155\14    1\162\       153\04        0\157
                      \146\     040\11     7\047\         122\1
                      45\15      1\154\1  54\171          \040
                      \046\         012\101\16            3\16
                      3\15           7\143\15             1\14
                      1\16            4\145\163           \054
                     \040            \111\156\14         3\056
                    \040\         125\163\145\14         4\040\
                    167\1        51\164\1  50\0         40\160\
                  145\162                              \155\151
                \163\163                                \151\1
              57\156\056

# camel code, copyright 2000 by Stephen B. Jenkins
# The use of a camel image with the topic of Perl 
# is a trademark of O'Reilly & Associates, Inc. 
# Used with permission.

Y puedes darle un vistazo a la bonita salida de este programa

Vale, este programa es ilegible.

También es bastante inútil.

Pero ¿A que es bonito?

Otro precioso ejemplo de código Perl es este encantador programa que aplica el algoritmo RSA para encriptar/desencritar y generar claves (Al estilo PGP, para que te hagas una idea):

#!/usr/bin/perl -s
                                                    @x=qw/e n d/;if(
                             $kg){$e=13;$_="setrand(@{[int((rand)*90)]})
                         ;K=vector(2,g,nextprime(random(10^$s)));e=$e;n=K[1]*
                             K[2];d=e^-1%((K[1]-1)*(K[2]-1));";s/\s//sg;for(
                              `echo "$_ e\nn\nd\n"|gp -q`){print$x[$j++]
                            ,"=",`echo "10i16o$_ p"|dc`}exit}$t=
                           unpack'H*',join'',<>;$l=length$n;$y
                        =$e?$l-2:$l;$i="16dio";while  (){$M=
                    ($e&&1+int(rand 8)).(substr     $t,$p
                 ,$y or last);$i.="\U$M $k        $n\E|
              pc";$p+=$y}for(reverse
         `echo "$i"|dc`){chop
 ;$d&&s/^(.)//||($_=
   sprintf"%0${l}s"
    ,$_); $f
    .=$_}#
    print
    pack
   'H*'
 ,$f
#  RSA Encryption, Decryption and Key Generation with Perl/dc/gp.
#  Copyright (c) 1998-2000, Vipul Ved Prakash. 
#  http://munitions.vipul.net/documents/rsafin.html
#  $Id: fin,v 0.10 1999/01/25 23:24:37 root Exp root $
#  Syntax:
#  To generate 1024-bit key: fin -kg -s=155
#  To generate 2048-bit key: fin -kg -s=309 (Takes a while.)
#  To encrypt/decrypt: fin -k=key -n=rsa_modulus [-e/-d] files.

También es ilegible, pero es bonito (Y, hasta hace poco, estaba considerado como un arma por las leyes estadounidenses, prohibiendose su exportación).

Regresar