Mois : juillet 2012

Avec Julien, nous sommes allés aux jour­nées Perl (http://jour­nees­perl.fr/fpw2012) à Stras­bourg. Voici un petit compte rendu de cette suite de confé­rence (si je dis des bêtises ou si j’ou­blie des trucs, il faut m’ex­cu­ser) :

Arri­vée à Stras­bourg

Arri­vés un peu en retard à cause de la SNCF, nous avons loupé l’ou­ver­ture et sommes passés direc­te­ment aux confé­rences.

Le déve­lop­pe­ment de Perl 5 – Philippe Bruhat (BooK)

Un petit histo­rique des versions de Perl 5, où l’on apprend que Perl 5.8 a connu un sacré paquet de releases. Cepen­dant, le cycle de déve­lop­pe­ment a été réduit à un an depuis la version 5.12.

On y apprend d’autres petites choses :

• le cœur de Perl est fait par une équipe appe­lée les Perl5 Porters (p5p) qui utilisent entre autres :
  • une mailing list
  • un pump­king (jeu de mot histo­rique) qui tranche les ques­tions si besoin est. Il est réélu tous les ans et s’en­toure depuis quelques temps de release mana­gers, histoire de ne pas porter tout seul son fardeau
  • des smokers, qui font du smoke testing. En gros, il s’agit de gens qui écrivent des tests qui font fumer Perl
  • git (http://perl5.git.perl.org/perl.git et un miroir sur github : http://github.com/mirrors/perl)
  • plein de jeu de mots (person­nel­le­ment, j’adore les jeux de mots foireux des infor­ma­ti­ciens)
• pour rappor­ter des bugs, il y a perl­bug, mais pour remer­cier les p5p, il y a aussi perl­thanks
• pour utili­ser les nouveau­tés appor­tés par une nouvelle version (par exemple, la 5.16), on utilise le pragma use 5.16
• les dépré­cia­tions se feront (ou se font déjà ?) en une release : on annonce que ça va être dépré­cié, l’an­née d’après, c’est dépré­cié, l’an­née suivante, ça dispa­raît.

Quelques nouveau­tés de Perl 5.16 : voir la confé­rence suivante

Les nouveau­tés de Perl 5.16 – Sébas­tien Aper­ghis-Tramoni (Maddingue)

Comme dit dans la confi­gu­ra­tion précé­dente :

•  il existe main­te­nant un mot-clé __SUB__ qui permet de se réfé­rer à la sous-routine dans laquelle on est même si elle est anonyme.
• l’eval évalue main­te­nant en unicode. Il faut utili­ser eval­bytes pour faire un eval en octets
•  meilleur support de l’uni­code :
• Unicode 6.1.0
• charnames est main­te­nant auto­ma­tique­ment chargé au 1er N{}
• appa­ri­tion de la fonc­tion fc : quand on doit compa­rer deux chaînes de carac­tères sans faire atten­tion à la casse, les fonc­tions uc et lc ne sont pas forcé­ment la solu­tion (ß par exemple n’a ni majus­cule, ni minus­cule). Il suffit main­te­nant d’uti­li­ser fc (http://perl­doc.perl.org/func­tions/fc.html)
• certaines choses sont plus rapides (glob, ||, &&…)

Intro­duc­tion aux expres­sions régu­lières de Perl 5 et PCRE 7 – Sébas­tien Aper­ghis-Tramoni (Maddingue)

Le confé­ren­cier a eu la bonne idée de commen­cer à expliquer les regexp pour les newbies avant de partir dans le bien barbu. Ça nous a permis de suivre un petit cours de rattra­page.

Petit histo­rique :

• les regexp ont commen­cées avec UNIX, ce qui a donné la norme POSIX des regexp. Perl a étendu la norme POSIX puis le moteur PCRE a repris les regexp Perl pour les trans­po­ser en dehors de Perl. Depuis, PCRE et le moteur de regexp de Perl se suivent en copiant l’un sur l’autre, sans jamais avoir beau­coup de diffé­rences
• avec Perl6, Larry Wall veut repen­ser les regexp

Il existe deux gram­maires de regexp :

• NFA : Nonde­ter­mi­nis­tic finite auto­mata, plus lent mais plus modu­lable
• DFA : Deter­mi­nis­tic finite auto­mata; plus rapide mais plus limi­tée

Quan­ti­fieurs :

• non avides : *?, +?, ??
  => s’ar­rêtent au plus tôt

  my $s = "aaaa";
  $s =~ m/(a+)/;
  say $1; # print 'aaaa'
  $s =~ m/(a+?)/;
  say $1; # print 'a'

• posses­sif : *+, ++, ?+
  => empêchent le retour en arrière

  my $s = "aaaa";
  say ($s =~ m/a+a/); # say '1' (match)
  say ($s =~ m/a++a/); # say '' (doesn't match)

Groupes :

• non captu­rant : m/(?:…)/
• réuti­li­sa­tion d’une capture dans le motif : /(\w+)\1/
• remise à zéro d’une branche : (?|…)

  # before ---------------branch-reset----------- after
  / ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
  # 1           2         2  3        2     3     4

• nouvelle syntaxe de réfé­ren­ce­ment : \g{n} n = numéro de la capture, \g{-1} => capture précé­dente, \gn (par ex : \g1)
• capture nommée : (?<name>pattern) qu’on réuti­li­sera dans le motif avec
  • \g{name}
  • \k{name} (pour la compa­ti­bi­lité avec les regexp .Net)
  • \k<name> (pour la compa­ti­bi­lité avec les regexp .Net)
  • \k'name' (pour la compa­ti­bi­lité avec les regexp .Net)
• et dans le rempla­ce­ment avec $+{name}
• récur­si­vité dans le motif : (?PARNO)
  => (?1) : pattern suivant, (?-1) : pattern précé­dent, (?name) : pattern nommé
• condi­tion­na­lité dans le motif : (?(condition)yes-pattern|no-pattern)
• défi­ni­tion d’un pattern à réuti­li­ser avec (?(DEFINE)) et (&PATTERN-NAME):

  /(?<NAME>(?&NAME_PAT))(?<ADDR>(?&ADDRESS_PAT))
  (?(DEFINE)
  (?<NAME_PAT>....)
  (?<ADRESS_PAT>....)
  )/x

En vrac :

• Regexp::Keep, de la bombe (http://search.cpan.org/~pinyan/Regexp-Keep-0.02/Keep.pm) : permet de virer tout un pan de la chaîne de façon intel­li­gente et rapide grâce à \K

  use Regexp::Keep;
  # slow and inefficient
  my $r = "abc.def.ghi.jkl";
  $r =~ s/(.*)\..*/$1/;
  # fast and efficient
  my $s = "abc.def.ghi.jkl";
  $s =~ s/.*\K\..*//;

• use re 'debug';
  => permet de voir comment fonc­tionne le moteur de regex sur nos motifs.
• Regexp::Optimizer => opti­mise les regexp (http://search.cpan.org/~dan­ko­gai/Regexp-Opti­mi­zer-0.15/lib/Regexp/Opti­mi­zer.pm)
• Regexp::Assemble => fusionne plusieurs regexp en une.

DBIx::DataMo­del vs DBIx::Class – Laurent Dami (dami)

Slides : http://www.slide­share.net/ldami/dbix­class-vs-dbix­da­ta­mo­del

Deux ORM repo­sant sur SQL::Abstract, mais assez diffé­rents. Si vous ne connais­sez ni l’un ni l’autre, le gain risque de ne pas vous sauter aux yeux.

DBIx::DataModel (DBDM) regroupe la descrip­tion de la base de données dans un seul fichier, contre un par table pour DBIx::Class (DBIC). Tout comme il existe dbic­dump pour créer les fichiers des tables pour DBIC à partir d’une base de données exis­tante, DBDM possède lui aussi une commande kiva­bien pour se simpli­fier la vie (http://search.cpan.org/~dami/DBIx-DataMo­del-2.28/lib/DBIx/DataMo­del/Schema/Gene­ra­tor.pm)

À la diffé­rence de DBIC, DBDM n’oblige pas l’uti­li­sa­teur à spéci­fier chaque colonne de chaque table de la base de données. Il est possible de les spéci­fier (pour, par exemple, indiquer le type de la colonne) et de spéci­fier les rela­tions entre les tables, même pour une base non rela­tion­nelle (comme MyIsam), à l’ins­tar de DBIC. Le fait de ne pas obli­ger de décrire les colonnes peut être vu comme une fonc­tion­na­lité formi­dable : en cas d’ajout de colonnes dans une table, on n’est pas obligé de modi­fier le fichier de descrip­tion du schéma, on n’a qu’à se servir direc­te­ment de l’ac­ces­seur créé auto­ma­tique­ment.

DBDM permet d’in­clure des hooks dans la recherche, et ce à diffé­rents moments (post_SQL, pre_exec, post_exec, post_bless)

DBDM  permet de spéci­fier la forme voulue du résul­tat avec pas mal de choix (array­ref, single row object, hash­ref…)

DBIC possède un argu­ment prefetch, permet­tant de char­ger en mémoire une autre table reliée à celle sur laquelle on fait la recherche. Cela permet d’al­ler cher­cher des infor­ma­tions liées plus rapi­de­ment : $dist->author->full­name => avec prefetch, cela est déjà en mémoire, sinon cela fait une requête supplé­men­taire.

Le join est bien plus simple avec DBDM :

 Schema->join(qw/table1 table2/)->select(…)

En terme de perfor­mances, DBDM est bien meilleur, sauf pour des insert en mode popu­late pour DBIC (voir slides 38 et suivantes)

Baila­dor—A Perl 6 port of Dancer – Tadeusz Sośnierz (tadzik)

Ne connais­sant pas Dancer, qui est un frame­work web MVC, je n’ai pas été frappé par la présen­ta­tion, mais je retien­drais toute­fois sa conclu­sion : il n’est pas si diffi­cile que ça de porter une appli­ca­tion Perl5 en Perl6.

Ligne de commande avec classe en Perl – Vincent Bache­lier (geist­teu­fel)

Slides : http://perl­talks.celo­geek.com/slides/2012/03/command-line-tools-in-style-slide3d.html

Au-delà de l’uti­li­sa­tion des argu­ments de la ligne de commande (my ($user,$passwd) = split(/,/,$ARGV[0]) if @ARGV > 0;) et d’un module, certes toujours utile et éprouvé comme Getopt::Long ou Getopt::Long::Descriptive, nous appre­nons à utili­ser une classe pour garder les para­mêtres, puis à utili­ser Moo pour faire cette classe de façon plus simple et enfin (effec­ti­ve­ment, ça donne un code TRÈS classe) à utili­ser Moox::Options pour simpli­fier le tout.

Ce rapport est très court, mais tout est expliqué dans les slides.

Les outils autour du cpan: parta­gez et deployez du code Perl – Marc Chan­treux (eiro)

Là, ma foi, je dois avouer que la fin de jour­née et la chaleur étouf­fante ont fait leur œuvre… J’étais un peu endormi, mais nous avons eu droit à quelques pro tips concer­nant l’ins­tal­la­tion de modules : l’uti­li­sa­tion de local::lib (http://search.cpan.org/~apei­ron/local-lib-1.008004/lib/local/lib.pm) permet d’ins­tal­ler des modules Perl via le CPAN dans des réper­toires locaux, et non là où ils se placent tout seuls (cela peut permettre de diffé­ren­cier les modules CPAN et ceux installé via les paquets Debian)

Die hard perl – Marc Chan­treux (eiro)

Là par contre, c’est la char­treuse et les discus­sions jusqu’à 3h du matin qui font que je n’ai pas retenu grand chose.

Je retien­drais tout de même certaines choses :

• Perl est rétro­com­pa­tible depuis 18 ans !
• 5.16 induit certains chan­ge­ments au compor­te­ment par défaut (avec use 5.16.0;), je ne saurais plus dire lesquels
• use autodie; Au lieu de faire un open FILE, "< truc" or die; Perl s’ar­rête tout seul. Cela peut paraître léger comme ça, mais cela s’ap­plique sur un paquet d’ins­truc­tion (http://search.cpan.org/~pjf/auto­die-2.12/lib/auto­die.pm#CATEGORIES) et si je peux gagner de l’écri­ture de code, je ne m’en prive pas !
• use Carp; Ce module permet d’avoir une stack­trace lors d’une erreur fatale de Perl, comme Python le fait par défaut (ce qui peut avoir pour effet d’em­brouiller le noob avec des messages ésoté­riques)
• Perl 5.8 est obso­lète. Vrai­ment.

Retours d’ex­pe­rience sur une utili­sa­tion avan­cée du MetaCPAN – Erwan Ben Soui­den (Laby­nocle)

Là, il s’agit d’un retour d’An­te­pe­dia (http://www.ante­pe­dia.com/, base de données de projets libres et open source) sur la façon dont ils ont utilisé MetaCPAN plutôt que CPAN pour collec­ter les infor­ma­tions des modules Perl. Inté­res­sant en soi, mais pas pour le codage.

Des outils et des hommes – Nils Grun­wald

Link­fluence a utilisé le site http://uses­this.com pour récol­ter des statis­tiques assez surpre­nantes sur les outils utili­sés par les figures du Logi­ciel Libre et du Web, grâce au module Web::Scraper.

Les résul­tats font un peu peur car le maté­riel Apple est le plus cité, et de loin. Sur un top 20, il est arrivé qu’il y ait 17 objets Apple cités ! Ceci peut s’ex­pliquer en partie par diffé­rents para­métres, mais tout de même (une personne peut appar­te­nir à plusieurs caté­go­ries et donc gonfle les stats de façon arti­fi­cielle, quand on a un mac, on veut le montrer à la face du monde, etc.)

De RackTables à rack, grâce au CPAN – Sébas­tien Aper­ghis-Tramoni (Maddingue)

Avec Moose et DBIx::Class, Sébas­tien Aper­ghis-Tramoni, co-auteur du livre Perl moderne (http://perl­mo­derne.fr/) réus­sit à récu­pé­rer des confi­gu­ra­tions de maté­riels (routeurs, switchs, serveurs…) enre­gis­trées dans RackTables (http://www.rack­tables.org/) pour ensuite les pous­ser vers les maté­riels.

L’ou­til pour cela s’ap­pelle rack et l’au­teur est en négo­cia­tions pour le libé­rer.

Latex -O fun – Jean Forget

Slides : https://github.com/jfor­get/meta­per­lua­la­tex

Avec MetaPost, on peut faire des dessins avec du code MetaPost dans le code LaTeX. Soit.
Avec LuaTex, on peut inclure du Lua dans du code LaTeX. Soit.
Avec PerlTex, on peut inclure du code Perl dans le LaTeX, mais en perdant la possi­bi­lité de faire du MetaPost.

Solu­tion : utili­ser Meta­per­lua­la­tex. Le prin­cipe est simple : perltex --latex=lualatex $*

Un peu tordu, mais bien pensé.

La solu­tion poly­glotte pour accé­der aux API REST – Camille Maus­sang (cmaus­san) – SPORE

De plus en plus de sites web (Amazon, Twit­ter…) propose une API REST pour accé­der à leurs services depuis un autre programme. Le problème est que ces diffé­rentes néces­sitent de tout redé­ve­lop­per à chaque fois, et c’est là qu’in­ter­vient SPORE.

SPORE est une spéci­fi­ca­tion pour décrire des API. Après avoir décrit une API, il suffit d’uti­li­ser alors un client SPORE (pour Perl : http://search.cpan.org/~fran­ckc/Net-HTTP-Spore-0.04/lib/Net/HTTP/Spore.pm) pour écrire de façon simple et rapide un programme utili­sant l’API en ques­tion. Des clients SPORE existent pour bien d’autre langages.

Une biblio­thèque d’API au format SPORE est dispo­nible sur https://github.com/SPORE/api-descrip­tion/.

Post­mo­dern decons­truc­tio­nism – Matt S Trout (mst)

Une confé­rence assez speed (il paraît que Matt S Trout boit ÉNORMÉMENT de café) dont je n’ai malheu­reu­se­ment pas beau­coup de souve­nirs, si ce n’est qu’il a écrit un certain nombre de modules avec des exemples et que ces exemples sont fina­le­ment deve­nus des réfé­ren­ces… et fina­le­ment presque les seules implé­men­ta­tions des modules de départ. Si je ne dis pas de bétises, ce doit être le cas de DBIx::Class. Sur le coup, c’était très inté­res­sant mais un peu brouillon et trop rapide, d’où mon amné­sie.

Conclu­sion

Les jour­nées Perl sont un très bon ensemble de confé­rences sur Perl, acces­sibles à chacun, le newbie comme le vieux barbu. Le nombre peu élevé de parti­ci­pants (entre 40 et 50, à la louche) permet d’abor­der très faci­le­ment les confé­ren­ciers, sans comp­ter sur le repas du soir, suivi du bar et de la char­treuse dans un parc.

C’était telle­ment bien que ça m’a donné envie d’or­ga­ni­ser les jour­nées Perl de l’an­née prochaine à Nancy. Des volon­taires ?