ingénieur système et développeur

utilisateur de Perl depuis 15 ans

contributeur Perl et CPAN (33 modules)

participant à de nombreuses conférences en France et en Europe

auteur de plusieurs articles parus dans Linux Magazine France

Practical Extraction and Report Language

langage interprété et dynamique

libre : GNU GPL et Artistic License

créé en 1987 par Larry Wall

Caractéristiques :

• lunettes carrées

• moustache

• chemise hawaïenne

≠ Weird Al Yankovic :

Perl 1.000 - 1987

Perl 3.000 - 1989

Perl 4.000 - 1991

Perl 4.036 - 1993

Perl 5.000 - 1994

Perl 5.001 - 1995

Perl 5.002 - 1996

Perl 5.003 - 1996

Perl 5.004 - 1997

Perl 5.005 - 1998

Perl 5.6 - 2000

Perl 5.8 - 2002

...

Perl 5.10 - 2007

Perl 5.12 - 2009 ou 2010

à l'origine, langage de glue

intermédiaire entre le shell, awk, sed d'un côté et C de l'autre

ajouts de langages fonctionnels comme Lisp

maintenant, langage dynamique généraliste

extrêmement portable

très stable

TIMTOWTDI

• There is more than one way to do it

les trois vertus du programmeur :

• paresse

• impatience

• orgueil

multi-paradigmes : impératif, fonctionnel, orienté objet

types de base : scalaire (chaîne, nombre), tableau, hash

gestion de mémoire par ramasse-miettes

expressions régulières

OO : multi-héritage, surcharge d'opérateur, fermetures

Unicode

faiblement typé

très (trop) permissif

paradigme objet très (trop) simple

ramasse-miettes par comptage de références

syntaxe devenue lourde pour certaines opérations

    print "Hello, world\n";

    $var = "du texte au hasard";
    print "var=$var\n";     # "var=du texte au hasard"

    $var = 42;
    print "var=$var\n";     # "var=42"

    @array = ( 1, 2, 3, 4, 5 );
    @array = ( "abc", "def", "ghi" );

TIMTOWTDI :

    @array = ( 1 .. 5 );
    @array = ( "a" .. "z" );
    @array = qw( abc def ghi );

valeurs et tranches :

    $var = $array[2];           # 3
    @values = @array[1, 3];     # (2, 4)

opérateurs push, pop, shift, unshift, delete :

    @array = ( 1 .. 5 );

    push @array, 6, 7;          # (1, 2, 3, 4, 5, 6, 7)
    $var = pop @array;          # (1, 2, 3, 4, 5, 6)

    $var = shift @array;        # (2, 3, 4, 5, 6)
    unshift @array, 0;          # (0, 2, 3, 4, 5, 6)

    $var = delete $array[3];    # (0, 2, 3, 5, 6)

opérateur sort :

    @array = ( 4, 8, 5, 3, 0, 2 );

    @array = sort @array;       # (0, 2, 3, 4, 5, 8)

    @array = sort { $b <=> $a } @array;

opérateur reverse :

    @array = ( 1 .. 5 );

    @array = reverse @array;    # (5, 4, 3, 2, 1)

    %hash = (
        laz     => "Linux Azur",
        jm2l    => "Journée Méditerranéenne des Logiciels Libres",
        42      => "la réponse",
    );

valeurs et tranches :

    $var = $hash{jm2l};
    $var = $hash{"jm2l"};

    $var = $hash{42};

    @values = @hash{42, "laz"}; # ("la réponse", "Linux Azur")

opérateurs keys, values, delete :

    @keys = keys %hash;     # ( 42, "laz", "jm2l" )

    @values = values %hash;

    delete $hash{42};

    %machine = (
        profane => {
            hostname  => "profane.mongueurs.net",
            addresses => [
                { type => "ipv4", addr => "81.80.147.194" },
            ],
            status    => "up",
            services  => [ "http", "svn", "smtp" ],
        },
        sferics => {
            hostname  => "sferics.mongueurs.net",
            addresses => [
                { type => "ipv4", addr => "81.80.147.197" },
            ],
            status    => "down",
            services  => [ "http", "cvs", "smtp" ],
        },
    );

    print $machine{profane}{addresses}[0]{addr};    # "81.80.147.194"

Perl has often been tagged as a language in which it's easy to write programs that are difficult to read, and it's no secret that regular expression syntax that has been the chief culprit. Funny that other languages have been borrowing Perl's regular expressions as fast as they can...

-- Larry Wall, Apocalypse 5

m// - recherche de correspondances

    $text = "whack zlott ooooff kraaack zzzzzwap";

    $text =~ /(kra+ck)/;

    print $1;               # "kraaack"

    $line = "peer_list = host1 host2 host3";

    $line =~ m/^(\w+) *= *(.*)$/;

    print $1;               # "peer_list"
    print $2;               # "host1 host2 host3"

s/// - recherche et remplacement

    $text = <<'TEXT';
    Les ordinateurs à base de processeurs Alpha, fabriqués par la
    société Digital, permettent d'exécuter le système Open VMS.
    TEXT

    $text =~ s/Digital/Compaq/g;

    $text =~ s/Compaq/HP/g;

s/// - recherche et remplacement

    $text = "The quick quick brown fox jump jump over the lazy dog.";

    $text =~ s/(\w+) +\1/$1/;

split, join :

    $line = "saper:500:500:Sébastien Aperghis-Tramoni:/home/saper:/bin/bash";
    @fields = split /:/, $line;
    print $fields[5];       # "/bin/bash"

    $fields[3] = "Groucho Marx";
    $line = join ":", @fields;
    print $line;    # "saper:500:500:Groucho Marx:/home/saper:/bin/bash"

    @flags = qw( UP BROADCAST SMART RUNNING SIMPLEX MULTICAST );
    print join ", ", @flags;
                # "UP, BROADCAST, SMART, RUNNING, SIMPLEX, MULTICAST"

    while (defined ($line = <$in>)) {
        next if $line =~ /^\s*$/ or $line =~ /^#/;
        last if $line =~ /^__END__$/

        chomp $line;

        if ($line =~ /\\$/) {
            $line .= <$in>;
            redo;
        }
        
        # process $line
        # ...
    }

    continue {
        # do a bit more with $line
    }

    sub fib {
        my ($n) = @_;
        return 1 if $n == 1 or $n == 2;
        return fib($n-1) + fib($n-2);
    }

    print fib(7);       # 13

    {
        my $seq = 42;
        sub next_seq { return ++$seq }
    }

    print next_seq() for 1..3;      # "43 44 45"

    sub curry_mult {
        my $num = shift;
        return sub { return $_[0] * $num }
    }

    *times_two   = curry_mult(2);
    *times_three = curry_mult(3);

    print times_two(5);     # 10
    print times_two(7);     # 14
    print times_three(5);   # 15
    print times_three(7);   # 21

    package Tree;

    sub new {
        my ($class, %args) = @_;
        my $self = bless {}, $class;
        # init $self using %args
        return $self
    }

    sub add_node {
        # ..
    }

    use Tree;

    my $tree = Tree->new;

    $tree->add_node(...);
    $tree->add_node(...);

    print $tree->render(as => "text");

Comprehensive Perl Archive Network

collection centralisée et distribuée de modules

http://www.cpan.org/

6.0 Go, plus de 17 000 modules, plus de 4 000 auteurs

243 miroirs

« CPAN is the language, Perl is just its syntax » - Audrey Tang

véritable richesse de Perl

ciment de la communauté

des dizaines de nouveaux modules chaque jour

de nouvelles idées chaque semaine

des conférences chaque mois

• 27 en 2008, 25 en 2009, déjà 10 prévues en 2010

de nouveaux paradigmes chaque année

shell, gestion de programmes

• Getopt::Long, Pod::Usage

• Proc::Daemon

• Proc::Background, IPC::Run

expressions régulières

• Regexp::Common, Regexp::Assemble

• Text::Match::FastAlternatives

analyse

• Parse::Yapp, Parse::RecDescent

• Regexp::Grammars

date et heure

• Time::HiRes

• Date::Parse

• DateTime

• DateTime::Set, DateTime::Span

• DateTime::Calendar:: Chinese, Christian, Coptic, FrenchRevolutionary, Hebrew, Japanese, Mayan, Pataphysical

nombres

• bignum, bigint, bigrat

• PDL (Perl Data Language == MatLab en Perl)

fichiers - archivage

• Archive::Tar, Archive::Zip, Compress:Zlib, Compress:Bzip2

fichier - chemins

• File::Spec, Path::Class

• File::Find::Rule, File::Wildcard

fichiers - contenu

• File::Slurp, File::Tail, File::Temp

objets

• Class::Accessor

• Class::Std, Class::InsideOut, Object::InsideOut

• Møøse, Coat, Mouse

programmation événementielle/asynchrone

• POE (Perl Object Environment)

• AnyEvent, EV

XML

• XML::LibXML, XML::LibXSLT, XML::Twig, XML::SAX, XML::Tiny

sérialisation

• Storable, Data::Dumper, Data::Dump::Streamer

• YAML, YAML::XS

• JSON, JSON::XS

protocoles réseau

• HTTP, FTP, SSH, SCP, LDAP, NNTP, RADIUS, TacacsPlus, SIP, STOMP, AMQP...

• DNS, Ping, DHCP

réseau bas niveau

• Net::Pcap, Net::Frame, Net::Packet

courriel

• MIME::Lite, MIME::Parser

• Net::SMTP, Net::POP3

• Email::Simple, Email::MIME, Email::Folder et tous les modules du Perl Email Project

• Mail::IMAPClient, Mail::Box

web, côté client

• LWP::UserAgent, LWP::Simple

• WWW::Mechanize

• WWW::Scripter

analyse HTML

• HTML::Parser, HTML::TreeBuilder, HTML::DOM

web, côté serveur

• CGI, CGI::Simple, CGI::Application

• mod_perl

• HTTP::Engine

génération de HTML, templating

• HTML::Template, Petal

• Mason, Template Toolkit

bases de données

• DBI

• MySQL, PostgreSQL, SQLite, Oracle, JDBC, ODBC, Sybase, ADO DB, Unify et encore plus...

• DBI::Proxy, DBD::Gofer

• SQL::Abstract

ORM

• Class::DBI, DBIx::Class

• Tangram, Alzabo, Rose::DB::Object, DBIx::DataModel

frameworks web modernes

• Jifty

• Catalyst

documents bureautique

• Spreadsheet::WriteExcel, Spreadsheet::ParseExcel

• OpenOffice::OODoc, Spreadsheet::ReadSXC

• PDF::API2

images

• GD, Image::Magick, Gimp, Imager

langages externes

• Inline : C, Java, Python, Ruby, Tcl, Befunge, Lua

bibliothèques externes

• XS, SWIG, P5NCI

interfaces graphiques

• Tk, Gtk, WxWidgets, Qt, Prima

• GUI natives : Win32, Aqua (Mac OS X), X11

pilotage natif des systèmes

• Mac::Carbon, Mac::Glue

• Win32, Win32::OLE, W2RK::WMI

Rational ClearCase (gestion de configuration) et ClearQuest

SysTran (logiciel de traduction linguistique)

Request Tracker, OTRS, Bugzilla (gestionnaires de bugs)

SlimServer (logiciel pilotant les systèmes musicaux sans fil de Slim Devices / Logitech)

Movable Type (plateforme de publication pour entreprises)

Blosxom (blog et gestion de contenu)

Koha (gestion de bibliothèque)

TWiki, Foswiki, Kwiki, MojoMojo (wikis)

GC Star (gestionnaire de collections)

Swish-e, Plucene (moteurs d'indexation)

Sympa (gestionnaire de listes de diffusion)

SpamAssassin (filtre courriel)

Open Webmail

Webmin (administration de systèmes par interface web)

DrakX, Urpmi (installation et gestion des paquets sous Mandriva)

BackupPC (sauvegarde)

sites web :

• Amazon, eBay, Price Minister, ShopZilla, Ticket Master, Booking, IMDb, Yahoo!, Slashdot, Live Journal, Friendster, Flickr, Google

banques :

• Citigroup, Morgan Stanley, Deutshe Bank, Bank of America, UBS (Union de Banques Suisses), BNP Paribas

médias :

• AFP (Agence France Presse), BBC

organismes gouvernementaux :

• NASA, ESA, Météo France, Institut Météorologique Norvégien

opérateurs réseaux et associés :

• France Télécom - Orange, Free Télécom, Cisco, Vodafone, Sifira, OVH, Gandi, VeriSign

Perl 5.10, 5.12, 5.14...

Perl 6

très (trop) longtemps en développement

à cause de la stabilité de Perl 5.8

5.10.0 publié en décembre 2007

maintenant disponible dans les distributions Linux

installation facile sous Windows

plusieurs parties internes restructurées

ajout de protections préventives

consommation mémoire moindre

certaines fonctionnalités de Perl 6

smart match

• opérateur ~~

• permet de comparer magiquement tout type de données

• cf. perlsyn

given .. when

• basé sur le smart match

    given ($var) {
        when (undef)  { say '$var non défini' }
        when (@array) { say '$var est dans @array' }
        when (%hash)  { say '$var est une clé de %hash' }
        when (\&code) { say 'code($var) est vrai' }
        when (qr/../) { say '$var correspond à la regexp' }
        default       { ... }
    }

Perl à la traîne derrière PCRE

intégration de leurs fonctionnalités

ajout de nouveautés, contribuées à PCRE

nombreuses correction de bugs

nombreuses optimisations (dérécursion, trie, Aho-Corasick)

moteur interchangeable

cycle de développement plus court que pour 5.10

gel des nouvelles fonctionnalités depuis le 21 novembre

publication fin décembre 2009 ou début janvier 2010

un nouveau langage

corrige les bizarreries et lourdeurs de Perl 5

nouvelles inspirations : Ruby, OCaml, Haskell

spécification descriptive (documentation) et validante (suite de tests)

des prototypes : Pugs, NQP

compilateur Perl 6 écrit en Perl 6 (et PIR)

exécuté sur une machine virtuelle, Parrot

exécution de plus de 70% des tests de spécification

machine virtuelle générique

portabilité de Perl

optimisée pour écrire des compilateurs pour langages dynamiques

langage d'assemblage cohérent, sans bizarreries dues à l'architecture

• voir les articles publiés dans Linux Magazine France n°97, 98 et 99, 122, 123, 124

fondamentaux de Perl

• stabilité

• longévité

Perl 5 utilisé depuis 15 ans

Perl 6 conçu pour durer autant

pas d'urgence, Perl 5 stable

langage mature

Perl 5.8 en production massive, stable

Perl 5.10 en cours de déploiement

Perl 5.12 d'ici un an

Rakudo* au printemps 2010

Perl 6 d'ici quelques années