Journées Perl 2012

Avec Julien, nous sommes allés aux journées Perl (http://journeesperl.fr/fpw2012) à Strasbourg. Voici un petit compte rendu de cette suite de conférence (si je dis des bêtises ou si j'oublie des trucs, il faut m'excuser) :

Arrivée à Strasbourg

Arrivés un peu en retard à cause de la SNCF, nous avons loupé l'ouverture et sommes passés directement aux conférences.

Le développement de Perl 5 - Philippe Bruhat (BooK)

Un petit historique des versions de Perl 5, où l'on apprend que Perl 5.8 a connu un sacré paquet de releases. Cependant, le cycle de développement 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 appelée les Perl5 Porters (p5p) qui utilisent entre autres :
- une mailing list
- un pumpking (jeu de mot historique) qui tranche les questions si besoin est. Il est réélu tous les ans et s'entoure depuis quelques temps de release managers, 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 (personnellement, j'adore les jeux de mots foireux des informaticiens)
pour rapporter des bugs, il y a perlbug, mais pour remercier les p5p, il y a aussi perlthanks
pour utiliser les nouveautés apportés par une nouvelle version (par exemple, la 5.16), on utilise le pragma use 5.16
les dépréciations se feront (ou se font déjà ?) en une release : on annonce que ça va être déprécié, l'année d'après, c'est déprécié, l'année suivante, ça disparaît.

Quelques nouveautés de Perl 5.16 : voir la conférence suivante

Les nouveautés de Perl 5.16 - Sébastien Aperghis-Tramoni (Maddingue)

Comme dit dans la configuration précédente :

il existe maintenant 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 maintenant en unicode. Il faut utiliser evalbytes pour faire un eval en octets
meilleur support de l'unicode :
Unicode 6.1.0
charnames est maintenant automatiquement chargé au 1er N{}
apparition de la fonction fc : quand on doit comparer deux chaînes de caractères sans faire attention à la casse, les fonctions uc et lc ne sont pas forcément la solution (ß par exemple n'a ni majuscule, ni minuscule). Il suffit maintenant d'utiliser fc (http://perldoc.perl.org/functions/fc.html)
certaines choses sont plus rapides (glob, ||, &&…)

Introduction aux expressions régulières de Perl 5 et PCRE 7 - Sébastien Aperghis-Tramoni (Maddingue)

Le conférencier a eu la bonne idée de commencer à expliquer les regexp pour les newbies avant de partir dans le bien barbu. Ça nous a permis de suivre un petit cours de rattrapage.

Petit historique :

les regexp ont commencé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 transposer 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 beaucoup de différences
avec Perl6, Larry Wall veut repenser les regexp

Il existe deux grammaires de regexp :

NFA : Nondeterministic finite automata, plus lent mais plus modulable
DFA : Deterministic finite automata; plus rapide mais plus limitée

Quantifieurs :

non avides : *?, +?, ??
=> s'arrêtent au plus tôt

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

possessif : *+, ++, ?+
=> 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 capturant : m/(?:…)/
réutilisation 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érencement : \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éutilisera dans le motif avec
- \g{name}
- \k{name} (pour la compatibilité avec les regexp .Net)
- \k<name> (pour la compatibilité avec les regexp .Net)
- \k'name' (pour la compatibilité avec les regexp .Net)
et dans le remplacement avec $+{name}
récursivité dans le motif : (?PARNO)
=> (?1) : pattern suivant, (?-1) : pattern précédent, (?name) : pattern nommé
conditionnalité dans le motif : (?(condition)yes-pattern|no-pattern)

définition d'un pattern à réutiliser 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 intelligente 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 fonctionne le moteur de regex sur nos motifs.
Regexp::Optimizer => optimise les regexp (http://search.cpan.org/~dankogai/Regexp-Optimizer-0.15/lib/Regexp/Optimizer.pm)
Regexp::Assemble => fusionne plusieurs regexp en une.

DBIx::DataModel vs DBIx::Class - Laurent Dami (dami)

Slides : http://www.slideshare.net/ldami/dbixclass-vs-dbixdatamodel

Deux ORM reposant sur SQL::Abstract, mais assez différents. Si vous ne connaissez ni l'un ni l'autre, le gain risque de ne pas vous sauter aux yeux.

DBIx::DataModel (DBDM) regroupe la description de la base de données dans un seul fichier, contre un par table pour DBIx::Class (DBIC). Tout comme il existe dbicdump pour créer les fichiers des tables pour DBIC à partir d'une base de données existante, DBDM possède lui aussi une commande kivabien pour se simplifier la vie (http://search.cpan.org/~dami/DBIx-DataModel-2.28/lib/DBIx/DataModel/Schema/Generator.pm)

À la différence de DBIC, DBDM n'oblige pas l'utilisateur à spécifier chaque colonne de chaque table de la base de données. Il est possible de les spécifier (pour, par exemple, indiquer le type de la colonne) et de spécifier les relations entre les tables, même pour une base non relationnelle (comme MyIsam), à l'instar de DBIC. Le fait de ne pas obliger de décrire les colonnes peut être vu comme une fonctionnalité formidable : en cas d'ajout de colonnes dans une table, on n'est pas obligé de modifier le fichier de description du schéma, on n'a qu'à se servir directement de l'accesseur créé automatiquement.

DBDM permet d'inclure des hooks dans la recherche, et ce à différents moments (post_SQL, pre_exec, post_exec, post_bless)

DBDM permet de spécifier la forme voulue du résultat avec pas mal de choix (arrayref, single row object, hashref…)

DBIC possède un argument prefetch, permettant de charger en mémoire une autre table reliée à celle sur laquelle on fait la recherche. Cela permet d'aller chercher des informations liées plus rapidement : $dist->author->fullname => avec prefetch, cela est déjà en mémoire, sinon cela fait une requête supplémentaire.

Le join est bien plus simple avec DBDM :

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

En terme de performances, DBDM est bien meilleur, sauf pour des insert en mode populate pour DBIC (voir slides 38 et suivantes)

Bailador -- A Perl 6 port of Dancer - Tadeusz Sośnierz (tadzik)

Ne connaissant pas Dancer, qui est un framework web MVC, je n'ai pas été frappé par la présentation, mais je retiendrais toutefois sa conclusion : il n'est pas si difficile que ça de porter une application Perl5 en Perl6.

Ligne de commande avec classe en Perl - Vincent Bachelier (geistteufel)

Slides : http://perltalks.celogeek.com/slides/2012/03/command-line-tools-in-style-slide3d.html

Au-delà de l'utilisation des arguments 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 apprenons à utiliser une classe pour garder les paramêtres, puis à utiliser Moo pour faire cette classe de façon plus simple et enfin (effectivement, ça donne un code TRÈS classe) à utiliser Moox::Options pour simplifier le tout.

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

Les outils autour du cpan: partagez et deployez du code Perl - Marc Chantreux (eiro)

Là, ma foi, je dois avouer que la fin de journée et la chaleur étouffante ont fait leur œuvre… J'étais un peu endormi, mais nous avons eu droit à quelques pro tips concernant l'installation de modules : l'utilisation de local::lib (http://search.cpan.org/~apeiron/local-lib-1.008004/lib/local/lib.pm) permet d'installer des modules Perl via le CPAN dans des répertoires locaux, et non là où ils se placent tout seuls (cela peut permettre de différencier les modules CPAN et ceux installé via les paquets Debian)

Die hard perl - Marc Chantreux (eiro)

Là par contre, c'est la chartreuse et les discussions jusqu'à 3h du matin qui font que je n'ai pas retenu grand chose.

Je retiendrais tout de même certaines choses :

Perl est rétrocompatible depuis 18 ans !
5.16 induit certains changements au comportement 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'arrête tout seul. Cela peut paraître léger comme ça, mais cela s'applique sur un paquet d'instruction (http://search.cpan.org/~pjf/autodie-2.12/lib/autodie.pm#CATEGORIES) et si je peux gagner de l'écriture de code, je ne m'en prive pas !
use Carp; Ce module permet d'avoir une stacktrace lors d'une erreur fatale de Perl, comme Python le fait par défaut (ce qui peut avoir pour effet d'embrouiller le noob avec des messages ésotériques)
Perl 5.8 est obsolète. Vraiment.

Retours d'experience sur une utilisation avancée du MetaCPAN - Erwan Ben Souiden (Labynocle)

Là, il s'agit d'un retour d'Antepedia (http://www.antepedia.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 collecter les informations des modules Perl. Intéressant en soi, mais pas pour le codage.

Des outils et des hommes - Nils Grunwald

Linkfluence a utilisé le site http://usesthis.com pour récolter des statistiques assez surprenantes sur les outils utilisés par les figures du Logiciel Libre et du Web, grâce au module Web::Scraper.

Les résultats 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'expliquer en partie par différents paramétres, mais tout de même (une personne peut appartenir à plusieurs catégories et donc gonfle les stats de façon artificielle, quand on a un mac, on veut le montrer à la face du monde, etc.)

De RackTables à rack, grâce au CPAN - Sébastien Aperghis-Tramoni (Maddingue)

Avec Moose et DBIx::Class, Sébastien Aperghis-Tramoni, co-auteur du livre Perl moderne (http://perlmoderne.fr/) réussit à récupérer des configurations de matériels (routeurs, switchs, serveurs…) enregistrées dans RackTables (http://www.racktables.org/) pour ensuite les pousser vers les matériels.

L'outil pour cela s'appelle rack et l'auteur est en négociations pour le libérer.

Latex -O fun - Jean Forget

Slides : https://github.com/jforget/metaperlualatex

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 possibilité de faire du MetaPost.

Solution : utiliser Metaperlualatex. Le principe est simple : perltex --latex=lualatex $*

Un peu tordu, mais bien pensé.

La solution polyglotte pour accéder aux API REST - Camille Maussang (cmaussan) - SPORE

De plus en plus de sites web (Amazon, Twitter…) propose une API REST pour accéder à leurs services depuis un autre programme. Le problème est que ces différentes nécessitent de tout redévelopper à chaque fois, et c'est là qu'intervient SPORE.

SPORE est une spécification pour décrire des API. Après avoir décrit une API, il suffit d'utiliser alors un client SPORE (pour Perl : http://search.cpan.org/~franckc/Net-HTTP-Spore-0.04/lib/Net/HTTP/Spore.pm) pour écrire de façon simple et rapide un programme utilisant l'API en question. Des clients SPORE existent pour bien d'autre langages.

Une bibliothèque d'API au format SPORE est disponible sur https://github.com/SPORE/api-description/.

Postmodern deconstructionism - 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 malheureusement pas beaucoup de souvenirs, si ce n'est qu'il a écrit un certain nombre de modules avec des exemples et que ces exemples sont finalement devenus des références… et finalement presque les seules implémentations 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éressant mais un peu brouillon et trop rapide, d'où mon amnésie.

Conclusion

Les journées Perl sont un très bon ensemble de conférences sur Perl, accessibles à chacun, le newbie comme le vieux barbu. Le nombre peu élevé de participants (entre 40 et 50, à la louche) permet d'aborder très facilement les conférenciers, sans compter sur le repas du soir, suivi du bar et de la chartreuse dans un parc.

C'était tellement bien que ça m'a donné envie d'organiser les journées Perl de l'année prochaine à Nancy. Des volontaires ?