Aujourd'hui je voudrais partager avec vous un petit soft que je viens de découvrir : ditaa.

Qu'est-ce que ça fait ?

C'est un outil très simple qui vous permet de faire des diagrammes en ascii art. Non pas de les dessiner comme le ferait emacs artist-mode mais de les transformer en un vrai png propre et beau.

Exemple : Je dessine ceci (par exemple avec asciio)

    +--------+   +-------+    +-------+
    |        | --+ ditaa +--> |       |
    |  Text  |   +-------+    |diagram|
    |Document|   |!magic!|    |       |
    |cRED {d}|   |cBLU   |    |cRED   |
    +---+----+   +-------+    +-------+
        :                         ^
        |       Lots of work      |
        +-------------------------+

Cela devient automatiquement ceci :

Intégration

C'est tellement magique que je n'ai pas hésité et je l'ai intégré à mon site directement. En effet avant à chaque fois que je devais faire un diagramme il fallait que je sorte inkscape, que fasse attention à caler correctement les cases et les flèches et que je pense à sauvegarder l'image et l'uploader sur le serveur.

Maintenant j'intègre tout simplement le code dans le texte de mon article et ca marche !

Je n'ai pas trouvé de code qui faisait cela, je l'ai donc fait moi-même. Un peu rapidement il est vrai, il n'y a pas de gestion des différents cas d'erreur. Mais je vous laisse le code au cas où vous voudriez faire de même chez vous.

    function __macroDITAA($s)
    {
        $base=$_SERVER['DOCUMENT_ROOT']."/public/ditaa";
        $tmp="/tmp/ditaa";

        # first line of code is for ditaa parameters
        $p = strpos($s, "\n");
        $args = substr($s, 0, $p-2);
        $data = substr($s, $p+1 );

        # md5sum to generate a unique id
        $id = md5($data);

        # file test
        if(!file_exists("$base/$id.png")) {
            # create tmp
            $f = fopen("$tmp", "w");
            fwrite($f, $data);
            fclose($f);

            # call ditaa (beware of safe mode)
            system("ditaa $args $tmp > /dev/null");

            # move file
            rename("$tmp.png", "$base/$id.png");
        }

        return "<img src='/public/ditaa/$id.png'>";
    }

Puisque ditaa est malgré tout un peu lourd, on crée un identifiant d'image avec le md5 de la ligne de commande et le contenu. Et on ne fait l'appel qu'une fois (attention je n'ai pas de safe_mode ici), lorsque le fichier n'existe pas encore. Ensuite le serveur web l'utilise le fichier directement comme n'importe quel autre.

Sur mon site, j'ai une syntaxe dotclear2, j'ai donc dû enregistrer un nouveau mot clé pour la syntaxe ditaaa "///ditaa" :

# dans class.wiki2xhtml.php / class wiki2xhtml / function __construct()
$this->registerFunction('macro:ditaa','__macroDITAA');

A vous de faire de même pour la syntaxe wordpress !

Si vous avez aimé, il y a aussi :

1. Prompt String

La vie des huîtres selon saint Larry (soûlant ...).

Aujourd'hui il est sujet d'un livre. Un livre dont le titre est "Perl moderne", tout simplement. Je ne vais pas vous le cacher, si je vous en parle c'est que je connais un des auteurs. Remarquez que c'est peut-être l'occasion de commencer une section recommandations de bouquins.

L'acheter ou pas ?

Alors pourquoi acheter ce livre ? Pour les arguments commerciaux, je vous laisse aller voir le site de l'éditeur. Pour les vraies raisons ...

• parce qu'il fait 450 pages et que c'est beaucoup
• parce qu'il est assez petit pour tenir dans la poche (enfin avec un bon treillis)
• parce que comme moi vous avez appris Perl en lisant du code Perl
• parce que vous ne savez pas qu'il est possible d'écrire du Perl orienté objet

Mais pourquoi je vous déconseillerais d'acheter ce livre ?

• parce que vous aimez Python et que vous voulez considérer les espaces de fin de ligne comme des erreurs de code
• parce que pour vous le seul code lisible c'est du code C façon K&R
• parce que vous êtes Larry Wall et que vous n'allez rien apprendre

Le contenu du livre

La première partie ravira les débutants en Perl qui apprendront que contrairement à la croyance populaire "$^£¨%*" n'est pas un code Perl valide. Remarquez que même moi, qui sais que "Perl '-sp0777i<X+d*lMLa^*lN%0]dsXx++lMlN/dsM0<j]dsj'" est une ligne de commande valide en Perl, j'y ai appris des choses.

Hé oui, le Perl a bien évolué depuis la première version 5. La partie 2 m'a d'ailleurs appris qu'il y avait une nouvelle façon d'écrire de l'objet en Perl. Moi bêtement je pensais que Perl avait fait les choses super bien en n'ajoutant qu'un mot clé "bless" pour devenir orienté objet. Mais en fait non, il paraît qu'il en faut un peu plus pour entrer proprement dans le paradigme objet. Qu'a cela ne tienne, on utilisera Moose, l'héritage, des setter, des getter et du typage.

Ça vous parait compliqué ? Mais pas du tout le livre contient des exemples simple pour chaque mot clé présenté.

Pour résumer cette partie, ce que j'ai découvert de plus utile ce sont les trigger sur propriétés d'un objets et les méthodes pour intercepter d'autres méthodes.

La troisième partie assez classique avec ce qu'on peut trouver dans les bibliothèque Perl pour traiter les données. Elle parle entre autre de l'infernal problème des dates ...

Passons à un chapitre bien plus passionnant pour qui s'y connaît déjà un peu en Perl, POE. Intuitivement j'aurais dit quelque chose comme "Perl orienté évènement", perdu, il s'agit de "Perl Object Environment". En fait c'est un système puissant de gestion d'évènements et d'états. Le but étant de passer à une programmation événementielle. C'est très pratique lorsque vous codez un serveur, d'autant qu'il existe déjà un grand nombre de méthodes existantes qui vous éviteront de réinventer la roue (la POE::Wheel pour ceux qui connaissent).

Enfin la dernière partie traite d'une chose qui sera bien plus utile à ceux qui ne connaissent pas encore bien Perl, le framework web de Perl. Il permet de parser du HTML, de lire des formulaires, de jouer des séquence complètes de requêtes pour vous faire passer pour un navigateur auprès de votre serveur préféré (pensez-y vous qui devez remplir toutes les semaines le même formulaire dans votre boite ...).

Pour conclure, je dirais que c'est un bon bouquin. Dommage qu'il n'y ait pas un petit site depuis lequel on puisse faire copier/coller des exemples du livre. Heureusement, ils sont assez courts en général. Il y a maintenant un site dédié à ce livre et les exemple y sont disponibles au téléchargement

Allez, soyez gentil, achetez-le, si vous en prenez 2000, je vous promet de faire un article par jour !

Si vous avez aimé, il y a aussi :

1. #!/usr/bin/gcc (bis)
2. Le perl complètement inutile
3. Perles

Vous essayez de développer une expression régulière mais vous ne savez pas pourquoi ça ne marche pas ?

Tester une expression

Je vous propose le petit programme suivant qui vous aidera dans la compréhension du fonctionnement de votre regex. Son usage est simple :

./regtest.pl <regex> <chaine>

Exemple :

./regtest.pl "(\d+7)\.1\." "127.127.1.12"
127.127.1.12 : \d+
127.127.1.12 : \d+7
127.127.1.12 : (\d+7)
127.127.1.12 : (\d+7)\.1\.
    127      : $1

Le programme découpe l'expression en éléments syntaxiquement corrects et les applique à la chaine pour voir ce qui matche et le met en évidence. A la fin la liste des groupes qui ont matchés est affiché.

Il est aussi possible de remplacer une des paramètres (la chaine ou la regex) par un '-'. Le programme boucle alors sur l'entrée et vous permet d'entrer une ligne à chaque fois. Vous pouvez donc faire un test en continu. L'avantage et surtout pour les regexp, cela permet de s'affranchir des caractères spéciaux qui pourraient être interprétés par le shell.

Notez que vous aurez besoin de Regexp::Parser qui n'est pas installé par défaut. Pour cela le plus simple est de se connecter en root puis de faire

$ perl -e shell -MCPAN
install Regexp::Parser

Et oula, maintenant plus de problème, vous pouvez tester vos expression régulières facilement !

Comment ca marche ?

En écrivant ce petit programme, voici quelques petites astuces que j'ai utilisé.

Écrire en couleur dans le terminal de façon portable :

use Term::ANSIColor;
print colored("string", 'red');

Parser une expression régulière perl dans une structure lisible (arbre) :

use Regexp::Parser;
my $parser = Regexp::Parser->new;
$parser->parse($reg);

Récupérer 3 parties d'une chaine lors d'un matching :

• $` : avant le match
• $& : tout le match
• $' : après le mach

Récupérer les position des éléments matchés et des groupes dans la chaine en question :

• @- : tableau des positions de début de chaque groupe
• @+ : tableau des positions de fin de chaque groupe

Vous trouverez le code ici.

Si vous avez aimé, il y a aussi :

1. En vrac (14)
2. Soyez réguliers (1)
3. Lignes de commande en sed

Voici quelques ordre de grandeur qui vous permettront d'avoir les idées un peu plus claires sur les performances de votre système. Imaginez que le swap est 100 000 fois plus lent que la mémoire du processus ! Qu'un algorithme de création d'arbre peut être plus lent qu'un algorithme linéaire si chaque nœud de l'arbre se retrouve sur une page différente (pensez à vos centaines de malloc pour remplir un arbre) !

Notez que l'important ce sont les ordres de grandeur, vous pouvez facilement trouver des éléments qui font le double ou la moitié de ces performances.

Interprétations

Sérieusement, pas besoin de giga de swap sur votre serveur. Mettez un tout petit peu et vous monitorez dès que ca dépasse, imaginez la division par un nombre à 5 chiffres du nombre de pages vues sur votre serveur ! Pour ma part je préfère répondre à moins de requêtes par seconde et garder un serveur utilisable.

Mais sur votre station de travail vous faites ce que vous voulez, on est en général plus patient :-)

Pas de gettime à gogo dans votre code pour mesurer les perf, ça tue les perfs ...

Le réseau fait a peu près aussi bien que votre disque.

Pas de malloc à gogo pour des structures morcelées et très utilisées. faites une structure unique si vous devez en avoir beaucoup.

Le SSD c'est bien mais ca vaut pas l'accès direct au flash.

Étant donné la vitesse de compression un swap compressé peut vraiment valoir le coup.

Le cache processeur sert vraiment à quelque chose ... si on sait coder pour qu'il soit utilisé (ou laisser le compilateur faire).

Le fork c'est un peu lent, prévoyez un prefork correct sur vos applications fréquemment appelées.

Avoir beaucoup de processus n'est pas si coûteux en soi (context switch).

PS : Si vous avez des données pour compléter ce tableau, n'hésitez pas à me laisser des commentaires.

Si vous avez aimé, il y a aussi :

1. Que faire et ne pas faire en raid

Aujourd'hui un thème un peu polémique mais pas trop quand même.

Le XML est un descendant du SGML. C'est un format structuré de données comme l'est l'ASN1 ou le LDIF.

Tous ces formats ont été inventés dans une seule optique : être facile à parser par une machine. Et pourtant quand on voit les subtilités du XML et les difficultés à faire un parseur, on peut avoir des doutes... Mais de ce fait ils sont peu lisibles.

Ne vous méprenez pas, le XML a tout à fait sa place dans les échange de données, dans la communication entre machines. Le format est bien défini et fonctionne quel que soit le type de machine. Il est d'ailleurs très utilisé car on trouve des parseurs partout, dans presque tous les langages, et dans presque tous les frameworks.

Mais à force d'en user on en abuse.

Non le XML n'est PAS fait pour les humains ! Le xml n'est pas à sa place dans les fichiers de configuration, à moins que vous n'ayez pour objectif que l'utilisateur ne touche jamais à ces fichiers et que vous ayez le temps de développer une interface entre l'utilisateur et la modification (texte ? graphique ? sonore ?).

Le XML est pratique car il permet au développeur d'éviter l'usage de protocoles binaires incompréhensibles et mal parsés entre deux applications. Il est pratique car un autre développeur peut lire ce protocole sans l'avoir appris. Mais vous remarquerez que je ne parle que de développeurs, pas d'utilisateurs.

Alors par pitié arrêtez le XML dans les fichiers destinés aux HUMAINS. Il existe bien d'autres formats ayant des parseurs et tout aussi lisibles :

• le format INI
• le format YAML
• le format JSON

Mieux, il existe LUA qui vous permet à la fois d'avoir un fichier de configuration simple et lisible, mais qui en plus autorise l'utilisateur à faire des choses que vous n'auriez pas prévu, comme des configuration conditionnelles !

Maintenant que nous savons nous servir d'un interpréteur postscript, nous allons pouvoir développer. Postscript est un langage complet au sens de Turing. C'est à dire qu'on peut tout faire avec, même faire décoller une fusée. Mais bon, avant d'en arriver là, on va essayer de faire quelque chose d'utile.

Pour vous présenter le langage, je vous propose un exemple basé sur la fourmi de Langton. C'est une fourmi qui a ceci de particulier qu'elle ne sait que tourner. Son univers ressemble beaucoup à celui du jeu de la vie, c'est-à-dire une grille infinie de cases noires ou blanches. Lorsque la fourmi est sur une case noire, elle tourne à droite, lorsqu'elle est sur une case blanche, elle tourne à gauche. De plus elle inverse la couleur de la case sur laquelle elle se trouve.

Le concept est assez simple, et lorsqu'on lance la fourmi sur une grille blanche, son comportement a l'air aléatoire. Et pourtant au bout d'un moment elle fabrique ce qui ressemble à une autoroute.

Tout ça pour dire que le postscript c'est bien. C'est un langage à pile, qui fonctionne en notation inversée. Les possesseurs de HP48 et amateurs de RPL y retrouveront leurs petits (ou de vieux souvenirs). Les développeurs forth (faite sous savoir si vous êtes dans la salle) apprécieront aussi probablement.

La base

Les commentaires

Toute ligne commençant par un % est un commentaire. Exemple :

% Rien

Les commandes

Les commandes sont des mots simples. Étant donné la notation inversée, la commande se trouve après ses arguments. Par exemple une addition :

5 9 add

A cette notation est associée une pile. 5 pose 5 sur la pile, 9 pose 9 sur la pile, add retire les 2 derniers éléments (donc 9 et 5) puis additionne et repose le résultat sur la pile. D'où la représentation de la pile :

    %avant la ligne de commande
5   % 5 
5 9 % 9
    %pendant le add (invisible)
14  % après le add 

Les commandes peuvent être séparées par des espaces ou des retours à la ligne.

Les variables

Les variables sont définie avec la commande def. Un nom de variable se pose sur la pile avec le préfixe /. Donc pour définir la variable pi

/pi 3.1415 def

Une variable se lance ou se pose sur la pile avec son nom dans préfixe. Donc pour poser pi sur la pile :

pi

Les fonctions

Une fonction est tout simplement un ensemble d'instruction placées entre { }. Une fonction toute seule n'a que peu d'intérêt, mais une fonction peut être mise dans une variable avec la commande def ce qui permet de la réutiliser autant de fois que voulu.

Exemple une fonction qui incrémente un élément de la pile de 1 :

/incremente { 1 add } def

Manipulation de la pile

La pile étant un élément central, il existe des opérateurs pour la manipuler. Le principaux sont :

• pop : retire un élément de la pile
• dup : duplique un élément de la pile
• exch : échange les 2 derniers éléments de la pile
• pstack : affiche le contenu de la pile (utile pour le debug)
• clear : vide la pile

L'affichage

L'affichage étant le but ultime de postscript, vous comprendrez qu'il y a beaucoup de primitives d'affichage, essentiellement vectoriel.

Regardez bien ça vous rappellera le logo. Dessinons un carré :

newpath
0 0 moveto
10 0 rlineto
10 10 rlineto
0 10 rlineto
0 0 rlineto
stroke

Petite astuce si vous testez les commandes, chaque dessin doit se terminer par un showpage (ici par exemple, juste après le stroke), cela affiche le contenu du buffer sur une page et passe à la feuille suivante.

Quelques exemples de commande :

• setlinewidth (un paramètre : la largeur de trait)
• closepath (ferme le dessin)
• fill (remplit un chemin fermé)

Contrôle de flux

Tous comme n'importe quel langage, le postscript permet des boucles et des if sous la forme "booléen méthode if". Par exemple :

% incrémente le dernier élément de la pile s'il est inférieur à 10
dup 10 lt { 1 add } if

Pour une boucle for, même topo. Exemple une somme de 1 à 10 :

% valeur initiale
0 
% début incrément fin méthode for
1 1 10 { add } for

Voilà, je n'ai fait que survoler le langage, vous trouverez plus de détail dans ce livre référence.

Un exemple

Pour continuer, j'ai écrit un petit exemple commenté disponible en téléchargement. Vous pouvez l'ouvrir avec un éditeur de texte ou utilise ps2pdf pour le rendre affichable. Cet exemple génère 75 pages visibles en PDF, chaque page correspond à 150 itérations du mouvement de la fourmi.

Lisez-le vous verrez que finalement le postscript c'est pas trop compliqué quand c'est pas écrit par une machine sur une seule ligne.

Si vous avez aimé, il y a aussi :

1. Postscript est un langage … de script
2. Torture de cerveau
3. Calculatrice en ligne de commande

Vous développez régulièrement vos scripts en perl ? Si oui : lisez ceci ou cela ou encore d'autres choses plus ou moins utiles.

Si oui vous devez faire des tests de temps en temps. Je me suis habitué à faire des perl -e ou perl -pe pour des petites choses. Mais il existe un outil bien plus pratique : perlconsole.

Son usage est simple :

$ perlconsole

Pour le debug, cet outil est sympa puisqu'il permet de taper les commandes une par une et d'en avoir la valeur de retour.

Pour le développement cet outil est parfois un peu lourd puisqu'il renvoie la valeur de retour de toutes les commandes tapées, même si cela ne nous intéresse pas vraiment.

Autre fonctionnalité qui ravira certains, les valeurs de retours peuvent être affichées sous différentes formes. Ce qui veut dire qu'il est possible d'avoir un dump complet du résultat de chaque commande. Il suffit pour cela d'entrer la commande suivante pour les habitués de Data::Dumper :

:set output=dumper

Mais il existe aussi une sortie yaml, que je trouve personnellement plus lisible pour des structures ne dépassant pas une page.

:set output=yaml

Si vous avez aimé, il y a aussi :

1. Le perl complètement inutile
2. Perles
3. Le C est plus lisible que le perl