Les Mongueurs de Perl / Groupe de travail Articles / Conférences Perl

Nous rejoindre / SVN / Relecture / Rédaction / Planning / Liens /

Publications : Linux Magazine France, Perles, Brèves, Production, Comptes-Rendus, Interviews, Traductions, Spoofathon

En exemple, il propose IO::All (http://search.cpan.org/dist/IO-All) ou Perl6::Say (http://search.cpan.org/dist/Perl6-Say).

Il détaille un peu Perl6::Say, qui exporte une fonction, say, un print avec un \n à la fin). Curieusement le code de la fonction est un peu plus compliqué que ce que j'aurais pensé (pas trop, juste un peu), ce qui montre bieng que perl cache bien des choses sous son capot. Au passage perl 5.10 aura la fonction say, et d'autres (switch!).

Sur CPAN, les modules Perl6::* sont souvent de ce type.

Pour lui, toute séquence d'instructions souvent répétée devrait se retrouver dans une fonction, elle-même stockée dans un module.

Il a écrit un module, Toolkit, qui permet de mettre un paquet de modules dans un répertoire, et use Toolkit les charge d'un coup (http://search.cpan.org/dist/Toolkit)

Exemple: Regexp::Common (http://search.cpan.org/dist/Regexp-Common): "Who do you want to write your regular expressions? Abigail!".

Il explique comment il est passé d'une interface où la regexp était renvoyée par une fonction, à un simple hash (qui masque une... certaine complexité, qu'il explique). C'est pas mal, ça complète bien la présentation d'Abigail que j'avais vu à Londres l'an dernier à la London Perl Workshop (c'est masculin ou féminin Workshop ?).

Au passage, une théorie de Larry Wall: certaines tâches ont une complexité intrinsèque, le code de toute façon sera compliqué. Par contre on peut distribuer cette complexité, et en l'occurence la cacher dans les couches basses de l'application. Du coup ça permet d'avoir des couches hautes simples, qui peuvent être écrites par des codeurs moins expérimentés.

Puis un conseil : quand on écrit une suite de if, TOUJOURS, avoir le else à la fin, même si le else ne doit jamais arriver. Dans ce cas, lui faire émettre un message adéquat car prendre cette habitude permet de détecter pas mal de bugs, quand le cas impossible se produit !

Puis il décrit l'interface de Contextual::Return (http://search.cpan.org/dist/Contextual-Return) (il note que wantarray en fait ne dit pas si l'appelant veut un tableau, juste s'il veut une une liste!).

Le code de Contextual::Return est assez chiadé par contre, un peu trop pour que je puisse l'expliquer ici (la marge de ma fenêtre n'est pas assez large).

À la pause je croise Mister Cholet, un couple de fervent Pythoniste et Nat qui devient "corporate" (il porte des tongues au lieu de se promener pieds-nu comme d'hab).

À la reprise, c'est l'heure pour Damian de parler de IO::Prompt (http://search.cpan.org/dist/IO-Prompt), dont l'interface "Does The Right Thing". Comme Contextual::Return, il est base sur Want (http://search.cpan.org/dist/Want), qui est un super wantarray, mais donne beaucoup plus d'infos sur le contexte dans lequel une fonction est appelée.

IO::Prompt exporte une unique fonction, qui fait pleing de choses différentes, en fonction des options qui lui sont passées.

Exemple: Exporter, avec ses EXPORT, EXPORT_OK et autres variables. Perl6::Export::Attrs (http://search.cpan.org/dist/Perl6-Export-Attrs) est plus naturel:

  sub toto :Export( :DEFAULT :ALL ) { ... }

On voit bien que c'est au niveau de la fonction, on déclare l'export, pas loin de là. en plus le module offre quelques fonctions que Exporter n'offre pas, comme des fonctions qui sont exportées quoique l'utilisateur dise (dans le use). Il semble que Damian lui même (qui a écrit le module) ne sait pas exactement à quel point le module est magique: aprês une question, il découvre dans le code du module que si on fait use :ALL toutes les fonctions sont exportées (sauf celles qui commencent par _ je suppose).

Un autre module qui montre l'intérêt des interfaces déclaratives: Getopt::Euclid (http://search.cpan.org/dist/Getopt-Euclid) (Euclid est un acronyme, mais il le dit tellement vite que je ne saisis pas tout. Dans le POD du code on rajoute la description de l'interface de l'outil, avec une syntaxe simple... et ça marche.

Exemple: Config::Std (http://search.cpan.org/dist/Config-Std), qui préserve les commentaires dans un fichier de configuration quand il est mis à jour. Ça n'est pas très compliqué (pour Damian!), ça suppose juste d'avoir un parser qui garde tout, commentaires et ordre des options dans le fichier, et de ruser un peu avant de sauver le fichier.

Oh, et quand on sauve le fichier, pas besoin de redonner le nom du fichier, par défault c'est le même. Ça évite souvent de devoir passer le nom du fichier partout dans le code où la config peut être mise-à-jour.

Si on fait ce genre de chose à la maison, le comportement exact dépend du type de fichier: on peut vouloir par exemple "comment out" (comment ça se dit en français?) les options qu'on a enlevé.

Exemple: Log::StdLog (http://search.cpan.org/dist/Log-StdLog). L'interface est la même que... print! Au niveau de log près. Comme ça l'utilisateur n'a pas trop de problème à savoir comment utiliser le module.

  if( $verbose) {
      local *STDOUT = *STDLOG;
      print debug => "coucou";
      print info  => "rmatique";
      print fatal => "Aaaarrrrrgghhh!";
  }

Bon, pour les explications techniques sur comment ça marche, j'écoute, donc pas de commentaires.

Il a regardé sur CPAN, les 30+ modules qui font du log. Son commentaire est que quand il n'y a qu'un ou 2 modules sur CPAN qui font un truc, en général c'est qu'il y a consensus sur la manière de résoudre le problème. Par contre Il admet que Log4Perl est pas mal, mais un peu compliqué. Pourquoi avoir un module OO pour du log? Commentaire de mon voisin dans la salle: Log4Perl a un "easy" mode qui évite de devoir se trimballer un objet partout dans le code. Damian recommande d'y jeter un œil.

Oops, son micro le lâche. Il va devoir crier, ce qui ne le dérange pas trop!

Citations: "This is maintenance by complaint" à quelqu'un qui demande une option supplémentaire, je ne saisis pas laquelle.

Exemple: Object::Dumper (http://search.cpan.org/dist/Object-Dumper)

    use Object::Dumper;
    my $object = MyClass->new(...);
    print $obj;

Et ça marche! Ca dumpe le contenu de l'objet, au lieu du classique HASH[0x12a8f2] Au passage ça fait aussi un die si on essaye de se servir de l'objet dans un contexte numérique, sauf bieng sûr si on overloade la numérification de la classe.

• W/B

  font la même chose que w/b, mais en prenant l'espace comme séparateur de mots.

• ^

  debut du premier mot de la ligne

• gg

  debut du fichier

• g<CTRL-G>

  comme G, mais avec plus de détails.

• set

    set matchpair <:> # < et > sont maintenant des délimiteurs (% va de l'un à l'autre)

• mL (m avec une lettre majuscule)

  même chose que ml, mais global, permet de naviguer entre différents fichiers.

• :marks

  montre tous les marqueurs

• utiliser les marqueurs avec d'autres commandes

  d'a efface toutes les lignes du curseur au marqueur

• ``

  retour au dernier endroit, couplé avec l'utilisation de marqueurs, permet de sauter facilement entre 2 régions d'un fichier.

• "

  le dernier endroit ou on était la dernière fois qu'on a édité le fichier.

• <CTRL-O> <CTRL-I>

  navigue vers l'avant et l'arrière dans l'historique des sauts entre marqueurs

• <n>s

  remplace <n> caractères par le texte tapé ensuite.

• c<déplacement>

  remplace depuis le curseur jusqu'à la fin du déplacement

• :set backspace=indent,eol,start

  delete efface maintenant tout, sans s'arrêter

• <CTRL-Y>

  insère le caractère de la même colonne de la ligne au-dessus <CTRL-E> pareil avec la ligne au-dessous.

• <CTRL-R>=

  évalue une expression et insère le résultat

• <CRL-O>

  repasse en mode normal (d'un autre mode) pour une seule commande

• f<char>

  trouve le caractère, intéressant couplé à d par example

• t<char>

  trouve le caractère, et se positionne devant

• set ignorecase

  search devient non case-sensitive

  set smartcase: case-sensitive seulement si le pattern est tout en minuscule.

• \c \C

  case-sensitivity on/off dans un pattern

• :set nohlsearch

  annule le highlighting du search (utile surtout si mappée sur une touche)

• 10,+33s/<pattern>/<replacement>

  dans le genre:

  le + veut dire 33 lignes après la ligne 10

  . est la ligne courante .+1 est la ligne d'après

  <n>: initialise le range à .,+<n>

  %s: initialise le range à 1,$

  on peut utiliser des searches dans le range: /<body>/;<\/body>/s/<I>/<EM>/

  wahouh!

  Ça marche aussi avec des marqueurs. Damian ne le savait pas. Il essaye, ça marche avec ', pas avec `

  Ne pas oublier le g à la fin du s.

  Un c à la fin du pattern demande confirmation de toutes les substitutions

  :s ou & refait la dernière substitution (pratique si on traite plusieurs fichiers à la file)

• yap iap

  "yanke" le paragraphe courant (la version avec i ne prends pas les espaces avant/après) (je crois, mon Mac a crashé depuis la dernière phrase.

• ]p/]P

  paste en respectant le niveau d'indentation. Cool pour bouger du code.

• :<range>copy <target>

  devinez ce que ça fait?

• <CTRL-R>n

  insère (en fait tape) le contenu du registre n. <CTRL-R><CTRL-R>n fait un vrai insert (les charactères de contrôle sont vraiment insérés).

• :set autowrite

  après ça :next sauve le fichier courant

• gf

  ouvre le fichier dont le nom est sous le curseur

• :read <filename>

  insère le contenu du fichier :read !<commande shell>

  marche aussi avec un préfixe: :Gread <filename> insère à la fin du fichier

  on peut aussi remplacer du contenu :%!sort Très utile pour trier un paragraphe par exemple (au passage :sort est aussi une commande de vim, avec diverses options (n numériquement, u unique, i case-insensitive...) sort! trie en ordre inverse.

• auto-complétion

  on peut donner des fichiers qu'on ne veut pas auto-completer: :set ??? (j'ai pas saisi)

  Ça marche aussi en mode commande

  En mode perl (ou si on le définit soi-même) <CTRL-X><CTRL-D> auto-complète un nom de fonction.

  <CTRL-X><CTRL-N> auto complète un nom (un mot en fait). On peut même avoir un fichier avec une liste de noms standards ( set complete+=k~/data/my_std_identifiers)

  <CTRL-X><CTRL-L> complète avec une ligne (du fichier) qui commence comme la ligne courante.

• configuration

  faire :options choisir parmis les milliers d'options possibles, puis faire :mkvimrc (dans $HOME)

• indentation

  ma config de choix, si je suis bien

    :set shiftround
    :set expandtab
    :set tabstop=4

• substitutions

  Il y a un moyen (par une variable magique) de configurer le moteur d'expressions régulières pour qu'il soit plus proche des regexp de Perl.

  D'une manière générale, sauts à marqueurs et recherches peuvent toujours être utilisés comme modificateurs de commandes: d/__END__ efface tout jusqu'au __END__

• registres

  Les registres sont sauvés entre session, donc on peut s'en resservir.

  "A3yy ajoute les 3 liges à la fin du registre a

• undo/redo

  En vim 7 g- et g+ permettent de naviguer entre les branches de l'edition. les commandes :earlier et :later permettent de se retrouver dans un état différent (genre :earlier 10mn).

  On peut éditer normalement (avec les commandes de vim) l'historique des commandes ':' en faisant q:

• visual mode

  V met en mode visuel. Tout déplacement sélectionne le texte, ensuite les commandes normales s'appliquent.

  v est similaire, mais sélectionne des lignes entières

  <CTRL-v> fait pareil, mais sur un block rectangulaire de texte. mega-funky comme dit Damian, que je ne sais pas expliquer proprement en 3 mots.

  vip> sélectionne le paragraphe et l'indente

  vipJ sélectionne le paragraphe et joint les lignes

• abréviations

    :abbreviate <abbreviation> <texte>

  Par exemple :abbreviate =i =item pour ce pod

  À noter qu'on peut par exemple avoir <CTRL-O> pour avoir des commandes dans les abréviations.

  :iabbrev marche en mode insert et :cabbrev uniquement en mode commande (et :abbrev dans les 2 modes)

• map

    :imap <abbreviation> <text>

  Les abréviations sont insérées uniquement si l'abbréviation est suivi d'un caractère non-mot, les maps sont insérées dès que les caractères sont tapés.

  On peut programmer les maps pour avoir encore plus de possibilités.

  :help :map-modes décrit d'autres modes (xmap pour mode visual, omap pour operator-pending mode...)

• Commandes pas très utiles:

    23% envoie à 23% du fichier...

Il avoue qu'il a couvert à peu près 10% de ce que peut faire vim.

Au final un tutorial très dense, avec pleins de trucs. Les notes sont très complètes. Ça va me prendre quelques temps pour digérer tout ça. Mais déjà j'ai utilisé pas mal de ses trucs en tapant ce CR, donc j'ai espoir.

Désolé pour le franglais dans la liste au dessus, mais ça va assez vite, et j'ai pas toujours le temps de traduire tout comme il faut ;--( En plus, du coup j'ai sauté presque tout ce que je connaissais déjà, ça m'a laissé le temps de respirer un peu. Ah! oui, en plus j'ai sauté tout ce qui causait C.

Bon, fini pour la partie sérieuse d'aujourd'hui, à demain !

Oh, et désolé pour le manque de g à la fin des mots, je crois que je suis en train de perdre mon assent :--(.

http://www.davisworld.org/presentations/handsOnWebServices.pdf est une partie de la présentation.

Et oui, c'est l'année du ouèbe tout poynt ziro, donc je m'intéresse aux technologies de l'an dernier... mais vous inquiétez pas, O'Reilly donne un livre gratuit aux participants, et j'ai choisi "Ajax Hacks".

Il commence par un peu de pub pour sa boite, dont je tairais le nom parce que je suis méchant et rancunier.

Au passage, pour taper les compte-rendus en français sur un clavier US, quelques imap en vi comme :imap e' é évitent de taper <CTRL-K> avant... bien pratique, et ça me donne l'impression de pas avoir perdu mon temps hier. Ca donne juste des trucs un peu bizzare avec le curseur, après une voyelle il se positionne _devant_ la lettre pendant 1 seconde, mais on s'y habitue. Remapper <CTRL-N> sur <TAB> est aussi excellent, ça auto-compléte les mots si je les ai déja utilisés dans le fichier (ça tombe bien, je me repète souvent et j'ai un vocabulaire limité). Je ne peux plus taper de tabs, mais de toute façon j'aime pas les tabs, et ça sert à rieng en POD.

Maintenant une longue liste d'acronymes... beurk!

Bonne idée, il donne les définitions des acronymes tirées de Wikipedia.

http://en.wikipedia.org/wiki/Service-oriented_Architecture

Il parle beaucoup, vite, donc ça va être dur de tout retranscrire, je pense que je vais devoir me limiter à vous donner les liens vers les définitions.

http://en.wikipedia.org/wiki/Web_service

Un truc : un web service n'est pas forcément en XML, le plus important c'est qu'il soit "remote", et "message-oriented". En plus il devrait être "platform-independant", "vendor-neutral" et "internet-based".

Pour l'instant c'est un peu du vent quand même, beaucoup de "c'est super" et pas beaucoup de détails technique.

 L<http://en.wikipedia.org/wiki/Ajax_%28programming%29>.

http://en.wikipedia.org/wiki/Client/SOA

Mash-ups : pour ceux qui vivent dans une grotte, c'est la combinaison de données venues de plusieurs sources. Exemples http://www.chicagocrime.org/map/.

Au passage, en cherchant autre chose, je tombe sur un catchpa sympa: http://www.hotcaptcha.com/ (pas forcément un truc à voir au boulot)

http://en.wikipedia.org/wiki/SOAP

Avant SOAP il y avait XML-RPC, qui une fois trituré par un commité est devenu SOAP (la trituration à été assez importante !).

http://en.wikipedia.org/wiki/WSDL

SOAP est le format du message, WSDL décrit l'interface du WS.

Il y a plein d'outils pour générer au moins un squelette de code à partir du WSDL... en Java. En Perl je sais pas, les spécialistes peuvent nous dire.

http://en.wikipedia.org/wiki/UDDI

Pas vraiment utilisé, au contraire des 2 précedentes technologies. Ca permet de faire des répertoires de WS, mais en pratique on récupère le WSDL directement, sans passer par une étape intermédiaire.

http://en.wikipedia.org/wiki/Representational_State_Transfer

Plus simple (mais il y a quand même une thèse par Roy Fielding dessus (http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm)

Il y a 2 types d'applications REST : pur REST, qui suit les principes développés par Fielding, et "popular REST", en fait tout ce qui est WS mais pas SOAP.

Il explique l'origine du terme "cargo-cult" (http://en.wikipedia.org/wiki/Cargo_cult)

Le principe c'est de faire des requêtes simplement avec une URL et des paramêtres, et de récupérer le résultat en simple XML (ou en fait autre chose, genre JSON). Ce qui est cool c'est qu'en regardant la requête on la comprend. Par contre il faut lire la définition de l'API pour pouvoir l'utiliser, il n'y a pas l'équivalent de WSDL (encore qu'il semble qu'il y ait un projet pour ça).

http://awszone.com présente un peu toutes les possibiltés offertes par Amazon. Je peux pas trop tester le site, la connexion wireless est pas terrible ici (pour une raison à laquelle je n'aurais pas pensé : http://radar.oreilly.com/archives/2006/07/oscon_kicks_off.html#comments), mais le site a l'air assez impressionant : il présente aussi la version SOAP du service, génére du code si on veut... la totale ("really cool stuff" d'après le speaker).

Il fait une erreur en tapant le critère de tri dans une requête, récupère un message d'erreur : avec SOAP il aurait utilisé le WSDL et n'aurait pas eu ce problème (mais bon, s'il avait lu la doc du service REST non plus, et pis les tests devraient révéler l'erreur assez tôt dans le processus de développement).

Je vois qu'il recommande de jeter un oeil à http://www.xml.com/pub/a/2004/12/01/restful-web.html (et aux autres articles du même auteur (http://xml.com/pub/at/34).

Une des forces du "popular REST" est qu'en utilisant GET, ça permet de bookmarker facilement le résultat d'une requête. Bien sûr ça limite aussi la taille des donnés passées entre le client et le serveur. Il n'y a pas de règles qui force à utiliser GET, mais c'est recommendé pour respecter l'esprit REST.

Par exemple je suis là : http://maps.google.com/maps?f=q&hl=en&ie=UTF8&t=k&om=1&ll=45.529508,-122.663008&spn=0.001853,0.003573

Atom suit aussi les principes REST (et au passage, je trouve Atom bien mieux fait que RSS, c'est plus logique, ça permet de mettre à peu près tout ce que je veux dans le feed... recommandé !)

2 frameworks pour faire la même chose: MapBuilder (http://mapbuilder.sourceforge.net/) et OpenLayers (http://www.openlayers.org)

Donc attaquons la partie pratique : créons notre propre appli !

Le code est disponible pour les participants au cours, il sera disponible pour le public dès que le livre qu'il est en train d'écrire sera publié. Donc vous n'aurez pas le code aujourd'hui, juste la description de la démarche qu'il utilise.

Version 1 : d'abord on crée une image avec des "tiles", dans une table, 3 lignes, 4 colonnes.

Version 2 : il crée 2 divs autour de la table: une qui définit la table entière, et une qui définit la partie affichée de la table. Il utilise CSS pour que la partie affichée soit plus petite que la table entière.

Version 3-5 : Il commence à écrire le js qui fait bouger la table entière. Du coup la table affichèe montre une autre partie de la table. Il assigne ça au drag-n-drop de la souris (entre mouseDown et MouseUp il "dragge"). Il utilise prototype (librairie javascript).

Un truc qui me plaît : dans son script il écrit Event.observe( window, 'load', myscript, false); au lieu de mettre le script dans l'attribut onload du tag body. Je débute en js, et c'est le genre d'info que j'apprécie (je sais pas si c'est spécifique à prototype ou si ça marche de base en js, j'essaierai plus tard). Le false empêche l'évênement de "bubbler".

Version 6 : il ajoute un peu de code pour empêcher l'utilisateur de dragger trop loin, pour bloquer le déplacement de la table entière.

Version 7-8 : Il se débarasse de la table, et commence à faire des calculs (semi-)sophistiqués pour savoir quelles sont les lignes/colonnes affichées et ajuster le positionnement de la carte entière avec CSS, puis il télécharge les images (toujours de fausses images à lui.

Bon, en fait ce tutorial me fait quand même un peu chier. Ce genre d'exercice, pour moi, ça marche si c'est un TP. Mais suivre un mec qui explique son code au podium pendant 3 heures, ça commence à me fatiguer. Donc je suis pas sûr de rentrer aprés la pause...

Ma conclusion perso sur ces 2 cours est que Web Services ou Google maps ou Ajax bidule... au bout d'un moment, c'est plus la peine de lire des papiers ou d'aller à des cours, il faut se poser devant le clavier et JFDI ("Just Fucking Do It!").

Doc... ce soir il y a la soirée MySQL au bar d'un des hotels de la conf, puis le State of The Onion de Larry Wall, donc c'est l'heure d'aller faire la sieste et de prendre des forces.

Ciao

• Encourager la participation (avec Web 2.0, la marotte de Tim), en utilisant "l'effet réseau".
• Open-Source licenses are obsolete

  Quelques notes au passage: pour lui, avec les nouvelles architectures basées sur le réseau, toutes les licenses libres sont dépassées. Du code sur un serveur distant n'est pas soumis à la license GNU par exemple.

• Frameworks

  Une nouvelle tendance pour les projets Open-Source: les Frameworks, qui commencent comme applications propriétaires, d'oû est extrait ensuite une partie générique qui est Open-Sourcée (Ruby on Rails, Django...)

• Operations as Competitive Advantage
• What freedom matters

  Regarder movemydata.org

http://radar.oreilly.com/archives/2006/07/four_big_ideas_about_open_sour.html développe ces idées.

Puis un gars de greenplum, qui sponsorise la conférence, nous compare l'Open-Source et le Rock'n Roll.

C'est assez rigolo, un point qu'il développe : keep it real. Le but n'est pas forcément de récupérer pleing de pognon, et d'essayer d'être le projet le plus téléchargé au monde, mais de rester fidèle à nous-mêmes, à être dangereux, au sens de révolutionnaire.

Puis Anil Dash, de Six Apart (Movable Type), nous cause de "Making Web 2.0 Mean Something", également intitulé "Trying to Suck Less". C'est pas hyper-passionant, il nous montre les trucs OS que sa boîte fait. Ca rappelle le talk de Tim plus haut, au sens que ce sont des trucs que Six Apart a développé pour leur produit, puis Open-Sourcé un fois stable et working like crazy. On peut les récupérer chez Six Apart (un balanceur de charge, un serveur Jabber...).

Pour finir : interview du fondateur de Sleepycat (Berkeley DB), récemment acquis par Oracle. Il parle des relations entre Oracle et Sleepycat (et ses 25 employés). Il souligne que Oracle a une longue tradition d'aider des projets OS, quoique ça ne se sache pas trop (Linux, Perl...). Il reste très politiquement correct, dit que Oracle n'a pas de problème avec MySQL ou PostgreSQL. Il insiste sur le fait que one size doesn't fit all : différents SGBD sont adaptés a différents problèmes (sur O'Reilly Radar il y avait une série de posts de Tim O'Reilly sur le fait que pas mal de gros, en fait énormes, projets n'utilisent pas de SGBD, et pourquoi (http://radar.oreilly.com/archives/2006/04/web_20_and_databases_part_1_se.html).

Donc pour résumer, les keynotes c'est super énervant : la plupart du temps elles sont pas terrible, mais de temps en temp il y en a une géniale. En général le jour oû je n'y vais pas ;--(

Ensuite un petit tour a l'exposition. Je récupère un T-Shirt du labo Open-Source de Microsoft, portant l'inscription Reports of Snowballs Seen in Hell. Pour me rattraper j'achète un T-Shirt Firefox, et je renouvelle mon inscription à l'EFF. Je me sens moins sale.

  rule if_statement {
  if [ <expression> | <die: Expression expected> ]
     [ then         | <die: then expected>       ]
     [ <block>      | <die: Block expected>      ]
  }

• le parseur Perl

  Intervient quand on lit du code. Assez primitif, c'est pour ça que les variables doivent être déclarées localement, les fonctions doivent être courtes...

  Le module Smart::Comments, qui met des instructions de debug en commentaires, ce qui fait qu'elles sont assez différentes du code pour qu'on ne les voit plus.

• le programmeur impatient

  Veut juste coder, déteste conception, docs, planning, réunions, travail en équipe...

• le "Glory Hunter"
• le bon samaritain

On a tous ces différents types en nous, arriver à les intégrer nous rend meilleurs programmeurs.

Arriver à les intégrer toutes permet de. Historiquement les programmeurs étaient plutôt de type "Glory Hunter" dominant. Maintenant l'aspect bon samaritain est plus mis en valeur. Ce qui au passage satisfait aussi souvent le Glory Hunter.

• Minimiser les distractions
• Utiliser un bon éditeur (par exemple en emacs on peut avoir le délimiteur fermant apparaître quand on entre le délimiteur ouvrant).
• Utiliser les modules de test
• Automatiser toute tâche répétitive

  Par exemple module-starter pour commencer à écrire un module

• Ne pas hésiter à dire qu'on ne sait pas,
• Lire le code des autres
• Travailler sur ce qu'on aime
• Ne pas admettre la défaite trop tôt,
• être patient
• essayer de toujours apprendre, et pas forcément ce que les autres apprennent,
• ne pas lutter contre le langage
• poser des questions... et écouter la réponse
• essayer les choses, si ça marche, pourquoi ne pas les essayer dans d'autres contextes
• have fun! (les conférences Java ne sont PAS fun!)
• prendre des bonnes habitudes, les garder même dans des programmes jetables

Apprendre, être curieux, essayer avant de demander de l'aide sont des thêmes récurrents.

Au final une présentation intéressante, mais, comme promis, pas très technique.

D'où orz.pm, sur CPAN, (orz: http://www.boingboing.net/2005/02/07/all_about_orz.html).

Il se sert d'une vieille fonction de Perl, qui, quand il charge un module, cherche un fichier .pmc avant de chercher un .pm (un reste de vieilles expérimentations avec le compilateur Perl). Donc vous l'avez deviné, Ingy applique une transformation à un module, typiquement un filtre, et stocke le résultat dans un fichier .pmc. En fait, ça marche même avec perl -c <fichier>. Ah ah !

Ca permet des trucs sympa : on peut donc utiliser les modules perl v6 sans avoir pugs installé, vu qu'on se sert des versions compilées de ces modules.

Ca a l'air kewl. Dans XML::Twig, pour prendre un exemple au hasard, j'ai effectivement une phase de pré-compilation du module, pour laquelle je pourrais utiliser Module::Compile (si je ne voulais pas être toujours compatible avec perl 5.004).

Je me rends compte que je n'ai rien compris au rapport entre Module::Compile et orz, mais bon, faudra que je creuse.

Filter::Simple::Compile peut remplacer Filter::Compile et génère le .pmc (qu'on peut aller vérifier).

Donc Ingy a encore été occupé cette année.

• subscription: Subscription::Config pour les cas simples, Subscription::OPML pour manager des centaines (ou milliers de feed), Subscription::Bookmarks pour utiliser directement les bookmarks d'un browser.
• navigation: Aggregator::** (pas le temps de noter)
• custom feeds (pas en RSS/Atom) CustomFeed::*
• filter: permet de modifier ou réparer un feed, par exemple virer la pub
• publish: Publish::Feed publie en RSS/Atom, Publish::MT publie dans Movable Type, Publish::Excel (! pour le chef?)
• search
• notify: Notify::Campfire Notify::Balloon Notify::Eject (ejecte un CD du drive), Notify::Pizza (si on blogge I am hungry le système notifie la pizzeria du coin).

Il nous montre comment il archive ses feeds sur son compte gmail : les mails pour chaque feed se retrouvent dans la même thread ils sont taggés (plagger) donc il peut les chercher très facilement, et en plus il a configuré pour les archiver dans un répertoire séparé.

Il a aussi un bot qui l'informe des feeds mis-à-jour sur IRC.

Plaggnet lui est sa réponse à planet (écrit en Python): il aggrège une série de feed et les filtre par mot-clefs. Vous pouvez le voir en action à http://oscon2006.plagger.org/ (et en plus il peut utiliser les fichiers de config de planet, donc switcher est très facile!).

Enfin, en 8 lignes de config, il crée un moteur de recherche de blogs, utilisant Subscription::PingServer, Aggregator::Xango et Search::Estraier.

Les configs qu'il nous montre sont effectivement très simple.

Bien cool!

Au rayon, pas si cool : la doc n'est pas super, Plagger dépends de 73 modules, pour l'installer il faut vraiment charger la version du repository de subversion (sinon, par CPAN, il ne crée pas tous les répertoires nécessaire).

Mais bon, c'est Open Source, donc tout le monde peut se mettre à l'améliorer. Dans le futur il veut ajouter des back-end DB, un meilleur support pour le contenu multimedia, support pour les calendriers...

Un excellent talk, je pense que je vais jouer avec ça quand je rentre à la maison.

• use ack

  ack remplace grep: fait -r par default, utilise les regexps de perl, color-code les résultats, ignore les fichiers CVS, permet d'inclure/exclure des fichiers par type (par langage)

• use Perl::Critic

  Qui suit religieusement "Perl Best Practices"? 3 mains se lévent. Ah ah!

  Il recommende Perl::Critic qui est extrêmement configurable et extensible (les siennes sont dans Perl::Critic::Bangs)

• Aidez Perl6!

  C'est le plus important pour le futur de Perl. Tout le monde pense que Perl est sur le déclin parce que Perl6 traîne. Donc il organise les volontaires pour participer, même si on n'est pas très fort (genre nettoyer la doc, passer lint sur le C de Parrot...)

• Real life social networking

  Pour lui, social networking ça n'est pas Orkut, LiveJournal... c'est email, aim, IRC, le téléphone (il donne son numéro), la conf ici

  Son téléphone sonne !

http://stubmail.com

Pour moi ça ressemble à PYX (jetez un oeil à XML::PYX). En plus pour grepper du XML il y a xml_grep (distribué avec... XML::Twig) ou xml_grep2 (basé sur XML::LibXML et libxml2), disponible à http://xmltwig.com/tool/.

Ceci dit son projet a l'air assez complet.

Comme chacun sait il est fan de baseball (http://bumppo.net/lists/macperl/1999/07/msg00113.html). Donc il génère ses fiches de score en Perl (un truc imbitable, qui permet de retranscrire exactement ce qui s'est passé pendant une partie).

Bien sûr il nous montre la feuille du dernier match des World Series de 2004 (gagnée par les Red Sox).

Zut, j'ai raté le nom du module... je suis pas sûr que ça intéresse trop de monde de l'autre côté de l'océan.

http://en.wikipedia.org/wiki/APL_programming_language vous fera peur si vous ne connaissez pas. C'est un langage ou le _code_ est en unicode, mais pas les données. Au passage ça les a fait progresser pas mal sur l'aspect unicode de Parrot.

C'est vraiment un des aspects d'OSCON que j'aime: je ne cause quasiment pas de Perl, mais j'ai droit à une description de zimbra et de leurs buts (virer Outlook), de openId, une comparaison de divers téléphones portables, je tire sur le hookah de Josh, je vois mon premier canadien en colère, c'est une canadienne, et j'admire Portland la nuit (si j'avais porté le chargeur de la batterie de mon appareil photo vous auriez une photo :--( heureusement, flickr à la rescousse: http://www.flickr.com/photos/80818705@N00/197831169/

• Pourquoi faire compliqué quand on peut faire simple
• Ne pas utiliser la magie quand on peut utiliser quelque chose d'implicite (tied variables...)
• Ne pas rendre le code plus compliqué juste pour avoir une certaine syntaxe (ex: prototypes)
• Suivre les conventions quand on peut

  Il a un exemple ou il dit que s/foo/far/ est mieux que s{foo}{bar} (je ne suis absolument pas d'accord, j'utilise _toujours_ la deuxième syntaxe)

• Ne pas utiliser des fonctionnalités obscures de perl (plus risqué, moins testées..)

Il n'utilise _jamais_ les formats, les variables de ponctuations, les fonctions import qui n'importent pas (genre use Catalyst qw/-Debug/;), la vieille syntaxe d'appel des méthodes (new Class), ajouter des méthodes à UNIVERSAL, re-blesser des objets existants, filtre source, use constant.

Il recommende aussi de s'en tenir aux objets basés sur des hash (curieux... tiens au passage je jette un oeil à Moose http://search.cpan.org/dist/Moose/ qui à l'air sympa).

Il essaye d'éviter: DESTROY, AUTOLOAD, wantarray (je suis etie`rement d'accord avec celui là, je suis pas assez fort pour toujours réaliser dans quel contexte j'appelle une fonction (si j'y pense).

Il évite de trop utiliser les closures, string eval, sub attributes, coderefs, fonctions exportées par un package (il préfère utiliser des classes), map/grep enchaînés, opérateur ternaire (? :) pour lui c'est juste un if/else plus court (Damian intervient pour dire que l'intérêt est que ça force à avoir un else).

Questions (de lui):

Est ce que ça rend la programmation chiante? Pour lui non, ça permet de se concentrer sur le niveau plus général, on peut s'amuser lors de la conception.

Mais AUTOLOAD est super-cool (awesome)! Ouaip, mais pas forcément dans un gros projet.

Pourquoi ne pas utiliser Java? Qui a laissé rentrer ce gars dans la salle?

A part le code: penser au contrôle de conf, utiliser les branches dans le systême de versionnement, écrire des tests.

Un talk un peu bizarre, qui me semble un peu "Perl Best Practices 2001". Il refuse pas mal des récents développements dans et autour du langage.

• commentaires en ligne #{ commentaire } ou même sur plusieur lignes (on peut utiliser d'autres crochets)
• whitespace comments: \ et des espaces fait disparaitre le tout: var\ .methode
• pipe operators: maintenant il s'appellent feed (pour éviter de confondre avec |)
• une parenthèse fermante à la fin de la ligne terme l'instruction

    my $sub= sub { return "foo"; } # pas besoin de mettre un ; à la fin de la ligne

  A tribute to python

• repeat

    repeat { ... } while condition();
    repeat while condition() { ... }

  A tribute to Pascal

• le metaopérateur de négation

    !< ou !> ou !~~ ...

• paires: beaucoup utilisées en perl6

    key => $value

  peut aussi être écrit

    :key($value)

  avec pleins de ruses: on a pas besoin de virgules :key est équivalent à key(1), :!key est :key(0), key<Damian>> est key("Damian") key<<Damian is $old>> est key( "Damian is $old"), et :$age est age($age) (marche aussi avec tableaux et hash.

• captures

  Une liste d'arguments, sans fonction: \($obj: $pos, $pos2, :opt2), qui est un vrai objet

• ranges

    my @range= $ok ..^ $trop_grand; # ^ marche avant, aprés ou avant et aprés le ..
    my@range = $min..$max :by(2);
    for ^4 { ... } # parcourt la boucle 4 fois

• nombres non-décimaux

    my $i=03; # n'est plus un nombre octal
    my $i= 0o05; # octal
    my $i= 2<101001>; # toute base est autorisée

  On peut aussi mettre des fractions

• type whatever

  Le sigil est *

    my @endlessly_true = "true" xx *
    @positives = 1 .. *; # 1 .. infini
    @numbers= *..*; 
    my( *, $file, *, $name)= func( $arg); # * au lieu de undef

• multi-dimensional array and hashes

  indices séparés par des ;

Conclusion: on y est presque!

La présentation devrait être a http://www.slash7.com

Il va présenter 2 modules: List::Maker (http://search.cpan.org/dist/List-Maker) et Contextual::Return (http://search.cpan.org/dist/Contextual-Return)

• List::Maker

  Quelques exemples où l'utilisation des tableaux (ou listes) en Perl, n'est pas complètement naturelle. Bien sûr Perl 6 a des solutions pour tous ces cas.

  Mais en attendant... List::Maker

  En surchargeant la notation pour les file globing (< ... >) il offre la syntaxe de Perl 6 pour des listes... en Perl 5.

  Plus quelques extras:@list= <4d6>; jette 4 d6 et retourne la liste (en contexte scalaire ça retourne le total des 4 jets). On peut étendre la syntaxe pour ajouter ses propre délires. La seule limitation est que les 2 crochets doivent être sur la même ligne.

  Le module est sur CPAN, mais ne semble pas faire tout ça encore, il promet de poster une version complète dans les jours qui viennent.

  Curieusement, Ingy et Audrey on aussi surchargé < ... > pour XML::Literal (http://search.cpan.org/dist/XML-Literal), qui semble aussi diabolique.

• Contextual::Return

  J'en ai déjà parle à l'occasion du tutorial sur les API, donc je vais pas trop insister.

  Je suis pas sûr que ça soit vraiment utile en fait. C'est un peu trop rusé pour moi. Ca revient à avoir plusieurs fonctions différentes... mais avec le même nom. Donc ça veut dire qu'il faut se rappeler de ce que fait la fonction dans chaque contexte, sans que le nom ne soit une aide.

Ce soir petit repas dans un bar à vin, ou nous apprécions le magnifique slogan des tee-shirts de Best Practical (http://www.flickr.com/photos/mirod/200428767/), puis soirée Six Apart, ou j'utilise tout mon Japonais (en 20s), apprends qu'avec MySQL préparer les statements en fait diminue les performances dans beaucoup de cas (si on lit toujours les mêmes choses, le fait que la requête soit préparée invalide la mise en cache de résultats), que PostgreSQL est mieux que MySQL pour les données géographiques... entre autres.

On rigole bien de l'histoire d'un pauvre dévelopeur dont la boîte a été rachetée par une énorme boîte, qui veut leur imposer un langage différent de celui qu'ils utilisent habituellement et qui leur va trè bieng. On rigole parce que sa boite fait du Java, et qu'ils ont été rachetés par TicketMaster qui est à fond Perl. Ca change du schéma habituel. En plus le povre garçon ne reconnaît pas Nat, qui pourtant est sur scène tous les matins en tant que chair de la conf), ça fait bien rire les perleurs, nombreux à descendre les bières sixapartiennes.

Finalement vers 2 heures j'en ai marre qu'on se moque de ma françaiserie, en plus l'occupant de la suite nous mets dehors, donc au dodo.

Interfaces: le plus simple (quand on l'a encore): le port prallèle. Il est simple et demande peu d'infracstructure. Par contre il dit qu'il faut une librarie C pour y accéder, il nous code en direct live un petit programme qui fait ça. Bien sûr en Perl on a Device::ParallelPort (http://search.cpan.org/dist/Device-ParallelPort).

Il nous montre ensuite la grille de son jardin.

D'abord il nous montre la boîte au lettres: un contact l'informe quand le facteur dépose une lettre. Il invite quelqu'un à venir sur scène pour souder le circuit qui fait ça. Il a aussi divers senseurs pour lui dire si quelqu'un pousse la grille, comme ça il peut allumer la lumière si il fait sombre.

Il a aussi un radar RFID pour détecter les gens qui approchent la porte de la maison.

Il utilise un petit utilitaire, qui lit le port USB et le fait apparaître comme une socket sur le système. Là il peut utiliser PHP, Perl (il avoue ne pas trop connaître Perl, mais Larry est dans la salle (et dit qu'il y a sûrement un module sur CPAN pour faire ça)) ou Tcl (il nous montre les 3 bouts de code).

Il approche un transmetteur RFID (de la taille d'un grain de riz) du récepteur, qui l'identifie, yipee!

Dans la chambre de son fils il a un petit contrôleur qui lui permet d'ouvrir et fermer les rideaux avec une télécommande. Il a ajouté la télécommande lui même. Larry commente que pour ça il doit utiliser Ruby (on Rail... celui du rideau). Il nous montre comment faire, fer à souder en main.

Dans sa cuisine, un lecteur de code barre. Il suppose qu'il pourrait l'utiliser pour gérer ses courses.

Son système d'arrosage automatique est fait maison, pour 1/10 du prix d'un vrai.

Dans son bureau, un téléphone portable, relié à un ordinateur sur lequel il fait tourner un programme qui entre autre stocke les SMS dans une BD. Encore une fois il nous montre le code. Il envoie un sms a son portable, qui le notifie en faisant sonner un portable dans la salle! Yipee.

Sa conclusion: beaucoup hardware peut être détourné et utilisé de facon créative. Tous à vos fers à souder.

Un excellent talk pour le vendredi matin.

Copyright © Les Mongueurs de Perl, 2001-2011 pour le site.
Les auteurs conservent le copyright de leurs articles.