[Toulouse-pm] YAPC::EU Jeudi

[Michel Rodriguez]

Jeudi
    Yipee! Je me suis réveillé à 9h 30, habillé à toute allure, pensé
    que j'allais rater les Lightning Talks... et finalement je suis là à
    l'heure, ça commence à 10h!

    Donc sans tarder:

  Lighning Talks
   Help! Code Overload
    *Nigel Hamilton*

    Il commence par une photo de la Tour de Pise, qui représente l'état
    de son code après quelques années à coder. Les représentants de
    Pisa.pm (Dakkar et moi) sont enthousiastes!

    Extrait: *Don't code in fear* (quand on lui a dit ça, sa première
    réaction a ét'e *shit! How do you know?*)

    Une citation de l'excellentissime Pragmatic Programer: *write code
    that writes code*.

    Donc il nous décrit un système qui documente son code, qui pour
    chaque module lui donne les modules dont il dépend, avec la
    possibilité d'éditer les commentaires.

    C'est la première

   Teaching computer with a Perl based emulator


    Quand il a répété son talk son chat s'est endormi au bout d'une
    minute, donc nous voilà prévenus.

    Extrait: *Computer Architecture is really fun!*

    Donc pour expliquer le fonctionnement d'un processor il a décidé de
    créer un processeur: NICE (Nice Is Charmingly Elegant). Plutot que
    de le faire réellement il a dévelppéun émulateur. La première
    version était en Fortran, pas très pratique, donc il l'a réecrit
    avec Perl/TK.

    Joli, l'émulateur montre l'assembleur en train de s'exécuter.

   Open VMS


    Une photo de sa cave, avec du bon vieux matériel qui tourne sous
    OpenVMS (coucou Tonton Th.): c'est du bon gros matos qui tâche,
    heureusement qu'il a une grande cave. C'est pas facile de porter
    Perl ou des modules sous ça. Donc si quelqu'un est interessé, il
    suffit de lui passer un mail et il peut mettre son équipement

   Buisiness::Worldpay::Junior


    Au début de son business il avait un problème: il avait un "crédit
    rating" horrible. Tous les services de paiement en ligne le
    refusaient. Le seul service qui l'a accepté était World Pay. Il nous
    montre son module qui interface avec World Pay.

    Extrait: *Anybody can download it for free from CPAN, or, if they
    are really stupid, come to my website and pay me $25 to download it*

    Autre extrait: *no one has ever aid me $25*

   Organizing YAPC::Europe
    *Norbert Gruner*

    Il commence par quelques citations d'organisateurs (genre BooK
    *"Plus JAMAIS!"* Il y en a pas mal de parisiens, ils pourront
    compléter, je ne tapes pas assez vite pour les retranscrire (aller,
    si, Eric: *Organiser YAPC c'est comme avoir un bébé...*

    BooK (encore!): *"You could be the next guy in PINK"*

   UTF8 and Perl in 5 minutes
    *Mark Fowler*

    Ca fait rire Dakkar qui cause de Perl et Unicode en 45 minutes
    demain!

    Il nous montre les differentes façons de mettre des caratères
    unicode dans un chaîne.

    Quand on lit depuis un fichier il ne faut pas oublier de le mettre
    en "binmode" (note de mirod: ou utiliser un parseur XML, bieng sûr)

    "Devel::Peek" est très utile pour savoir exactement ce qu'il y a
    dans une chaîne. <Test::utf8>, qu'il vient d'écrire est utile aussi.

   XML::LibXML


    Il a écrit des outils pour faciliter l'utilisation de XML::LibXML.
    Ca doit s'appeler XML::LibXML::Tools (le projecteur ne marche pas et
    je n'ai pas le temps de regarder sur CPAN). Pourquoi est-ce qu'il
    n'utilise pas tout simplement XML::Twig? La vie est pleine de
    mystêres!

   Enterprise Perl
    *Sebastien Aperghis-Tramoni*

    Perl n'est pas considéré comme un langage pour les gros projets.

    Voyons que faire.

    Par exemple quand Java crashe, il génére de vilaines "stack traces",
    il nous montre des exemples. Ca fait trèsprofessionel. Même les
    logiciels libres suivent cet exemple: un exemple, de Jakarta, 3
    pages de stack traces.

    D'où: "Acme::JavaTrace" qui essaye de résoudre ce problème en
    génerant d'énormes traces qui ressemble à du Java.

    Excellent!

   Starting your own company
    *jonasbn*

    Il nous explique la chose.

    Essayer d'avoir plus d'un client, réaliser que la plupart des
    propositions de projets n'aboutissent jamais, ne pas hésiter à payer
    pour des services (avocat, comptable...) être flexible (il fait pas
    mal de PHP ces jours-ci). Essayer de se faire payer à l'heure plutot
    qu'au projet. Avoir un processus pour traiter les affaires (histoire
    de ne pas oublier de se faire payer).

    Pasmal, réaliste.

   Making Perl development easier without using Perl
    *Scott Whriter *

    Il nos enjoint d'utiliser nos outils proprement.

    Par exemple le browser web: il utilise Firefox. Il se lance dans une
    explication de l'architecture de Mozilla.

    Extrait: *creating a plugin is easy!*

    Il nous montre le code... illisible à l'écran. C'est pour ajouter un
    moteur de recherche à boîte qui va bieng.

  How to test everything
    *Casey West*

    La clè c'est d'avoir la couverture de test: "Devel::Cover" Bon, je
    crois que j'ai dejà causé de ce module, excellent.

    Il nous montre comment le faire tourner, les jolis résultats, c'est
    vrai que les sorties sont vraiment complètes et pratiques.

    Des conseils généraux: tester des trucs vraiment stupides, des
    entrès débiles. Un truc rigolo il teste "sqrt": "sqrt(2) * sqrt(2)"
    affiche 2.00000000000001, mais le test "sqrt(2) * sqrt(2)==2" est
    vrai.

    Quelques modules utiles: "DBD::Mock" pour tester l'interface avec
    une BD et casser des choses.

  CPANTS


    CPANTS trace des indicateurs qualité rudimentaires sur les modules
    de CPAN: est-ce que la distribution est complète, est-ce qu'elle a
    des tests...

    On peut récupérer toutes les données, c'est une BD SQLite, d'où on
    peut extraire les chiffres qu'on veut.

    Rigolo: l'auteur avec la moyenne la plus élevée est Maurizio
    deMichelis, dont les modules contactaient le site web et charger du
    code a exécuter dans le "make install" (evil!). Apparement il a
    arrétéde faire ça.

    Futur plans: intégrer les CPAN ratings, les résultats des tests de
    CPAN testers, vérifier que l'auteur n'est pas R.U.Thor (le défaut),
    compter les hits de google sur la distribution, vérifier que le
    module a "use strict"...

    La principale limite est qu'il est impossible de faire tourner le
    code, vu qu'il peut dépendre de n'importe quoi.

  20 things you may not know about Perl
    *Joos Bousman*

    Bon, ça va aller vite, alors j'aurais pas beaucoup de temps pour
    commenter, mais vous pouvez voir des détails sur CPAN

    Inline::C
        ça marche

    YAML
        j'en ai déjà causé

    CLASS::ISA
    diagnostics
    celui là je l'ai raté, ça va trop vite pour moi...
    Benchmark
        La seule façon de savoir si un bout de code est plus rapide
        qu'un autre. Après tout qui (à part Rafael) sait ce que fait
        l'optimiseur?

    Devel::*
        très utile en dévelopement pour savoir ce qui se passe vraiment
        en coulisse (et ce que fait l'optimiseur ;--)

        "Devel::Size" par exemple vous donne la taille d'une structure
        en mémoire.

        "Devel::Peek" affiche comment une variable est stockée

        "Devel::Cover", encore une fois... la star de la conférence,
        dommage que Paul Johnson ne soit pas là

        "B::Deparse" essayez avec $owner='Jack'; print "this is
        $owners's house";

    Parse::RecDescent
        Pour tous vos parseurs

    only
        Pour spécifier la version d'un module à utiliser (et pas une
        plus récente), et pour manager les différentes versions pour
        pouvoir toutes les utiliser.

    memoize
        Ca je m'en sert, c'est super cool, pour cacher les résultats de
        fonctions

    File::Chdir
        Permet de faire des "chdir" avec une portée. Quand on sort du
        bloc où on a fait le "chdir" on retourne dans le répertoire de
        départ

    Config::Auto
        Pour pouvoir travailler avec différents formats de fichiers de
        config. Il lit indifférement du XML, .INI... de manière
        transparente.

    UNIVERSAL::*
        peut être abusé de manière créative. Genre
        UNIVERSAL::AUTOLOAD...

    Hook::Scope
        exécute du code à la sortie d'un block

    Hook::LexWrap
        même chose avec des fonctions

    Flags
        Il nous détaille les flags associés à une variable, je vous
        passe l'explication, il parle trop vite.

    CORE::GLOBAL::*
        permet de réécrire les fonctions de base de Perl.

    No::Die
        "die" ne marche plus!

    Acme::Code::Police
        j'en ai déjà causé l'an dernier il me semble (à l'occasion du
        même talk de Joos dont j'avais manqué le début).

        Si on utilise pas "use strict" ça détruit le fichier. Et bieng
        sûr "Acme::Code::FreedomFighter" détruit "Acme::Code::Police" si
        il essaye d'intervenir.

    le debugger
        Bon, je suis le seul à lever la main 2 fois quand il demande si
        on utilise des "print"s partout ou si on utilise le debugger.

        Un des problèmes est que quand on utlise le debugger,
        l'optimiseur n'est pas utilisé

    if  Un module qui

    Net::*
        Pour remplacer par example "open( "|/usr/bin/sendmail") " par
        Net::Sendmail (nom non garanti, ça va vite...)

    File::*
        File::Spec, File::Path pour être portable, File::Temp pour créer
        des fichiers temporaires de manière sûre

    Acme::Test
        Fait semblant de tester un module, avec des tests qui passent
        toujours.

    Il n'a plus de temps, c'est fini!

  The Good the Bad and the Ugly
    *Marty Pauley*

    Un des organisateurs, qui va râler. Sans slides, ça va être pratique
    pour moi (je peux râler aussi!)

    Donc le point de départ: on veut tous écrire du code plus propre.
    Mais qu'est-ce que ça veut dire écrire du code pplus propre. De la
    salle *you cannot describe it but you know it when you see it!*
    Marty: * thanks for summarizing my all talk, thank you all, good
    bye*.

    Donc il va essayer de nous donner quelques conseils. D'abord du code
    plus ropre ça veut pas dire du code plus rapide ou plus court (et il
    se moque d'un glofeur dans la salle).

    Donc en fait du code plus propre c'est du code plus maintenable.
    Note de Nick Clarke: si vous êtes le seul à comprendre votre code,
    tout va bien jusqu'a ce que posiez vos congés et que le chef les
    refuse...

    Pour savoir qu'est ce que du bon code, il faut voir du bon et du
    mauvais code. Et bien sûr, tout ça c'est sur CPAN! (et sûr Matt's
    Script Archive, au moins pour le mauvais code). Le problème est
    qu'en Perl il y a du bon code, du mauvais code et du vilain (ugly).
    Mais certain code vilain est en fait nécessaire (et certains pensent
    que tout code perl est vilain ;--)

    Si vous avez des problèmes de performances, surtout ne sacrifiez pas
    la maintenabilité. Changez les structures de données, ou les algos,
    ou la machine, ou le langage (à peu près dans cet ordre). Il cite
    MJD qui estime que Perl a quasiment toutes les fonctions de LISP, et
    que on devrait plutot essayer d'écrire du Perl à-la-LISP, pas à-la-C
    (coupable!).

    Et au pire, si Perl ne fait pas ce que vous voulez, parlez à Nick
    (Clarke). Nick conseille plutôt de parler à Larry et Damian pour
    qu'ils l'incluent dans Perl 6 (qui de l'avis de Marty aura plus de
    puissance que LISP).

    Extrait: *don't hesitate to steal things!*

  Essential CPAN modules
    Un panel sur des modules... j'ai raté la première partie, pendant
    les 2 présentations précédentes

    Tim Bunce commence, il prend des questions sur DBI.

    Q: pourquoi le synopsys est-il si long? A: parce des gens se
    plaignent qu'il est trop court ;--(

    Q:DBI asynchrone? A:un jour!

    Un idiot se lève pour râler contre XML::Parser et XML::DOM. Je peux
    pas vraiment vous raconter ce qu'il dit parce que je n'ecoute pas...
    vu que c'est moi qui cause.

    2 minutes et c'est fini.

    Puis Mark Fowler va parler de modules dont il a parlé dans le
    calendrier de l'avent de Perl.

    Il nous donne la liste et on peut choisir le sujet:

    Structures de données

        Tie::IxHash
            permet d'avoir des hash ordonnés (keys retourne les clés
            dans l'ordre d'insertion)

        Scalar::Util
            des fonctions utilies, comme "dualvar" ou "reftype" par
            exemple

        List::Util
            même chose sur des scalaires ("first" est ma préf'érée,
            "reduce" est difficile à expliquer, mais je me souviens
            l'avoir utilisée et elle est bien utile, voir la doc).

        Data::Structure::Util
            des fonctions comme "unbless"

    Attributs
        Il faut que je regarde ça pour un de mes modules (Params::Style)

        Attributes::Handler
            Ca va trop vite!!!!

        Exporter::Simple
            arghh!!!

        Attribute::Tie::Classes
            voir la doc

        Attribute::Overload
            Permet de dire qu'une méthode surcharge un opérateur:

              sub to_string: Overload("") { ... }

    Inline
        Il rapelle que Inline::* permet d'écrire du code dans un autre
        langage, il sera compilé la première fois qu'il sera utilisé, et
        la version compilée sera cachée (dans le répertoire "_Inline").

        "Inline::Files" est un peu différent, j'en ai déjà parlé, je n'y
        reviens pas, les nouveaux peuvent lire la doc, ça roxe!

    Bases de données

        DBD::SQLite
            Pareil, ça roxe! (je me rapelle de Matt demandant si par
            hasard ça serait utile, il était pas sûr!)

        Class::DBI
            Je vous en ait déjà causé dans mon CR de OSCON
            (http://xmltwig.com/report/oscon_2004.html): ça permet de
            mapper des objets dans des bases relationnelles.

        Pixie
            Stocke des objets arbitraires dans une BD. Astucieusement ça
            charge les objets de manière "lazy": les objets contenus
            dans d'autres objets ne sont chargés que quand ils sont
            vraiment utilisés

    Debugging
        Tiens, il parle des mêmes que Joos: "diagnostics",
        "Hook::LexWrap", "Devel::Peek" et autres.

    Date and Time

        DateTime
            Il recommende d'utiliser celui là

        DateParse
            prends une date en format naturel et retourne l'epoch

        Time::Duration
            secondes => format lisible (jj jours, hh heures...)

    Testing
        Quelques modules que je ne connaissais pas:

        Test::Exceptions
            verifie que le code meurt proprement.

        Test::DatabaseRow
            teste qu'une DB contient bien ce qu'on veut.

        Test::MockObject
            Permet de simuler un objet comme un veut

        Test::Inline
            inclue les tests dans la doc (j'aime pas trop,mais ça a
            l'air plus subtil que l'impression que j'en avais, faut que
            je regarde de plus près)

    Templating

        Template Toolkit
            Ca me rapelle qu'il faut que je lise le bouquin sur TT.

            Son avis: on peut utiliser ce qu'on veut, du moment qu'on
            utilise un systême

        Template::Extract
            utiliser des templates TT pour extraire des données! Kewl!

        Voir http://2shortplanks.com/talks