Le blog de Yaal

Bruno Voisin: La quête d'un nouveau lecteur de flux

2013-05-17T16:00:00+00:00

Comme tout le monde le sait maintenant, Google Reader ferme le 1^er juillet. Pour moi ce n'est pas vraiment une mauvaise nouvelle mais plutôt l'occasion de trouver une alternative libre à héberger moi même. Je pense qu'il est important de ne pas être dépendant d'un service fermé et de garder ses propres données pour soit.

Si vous aussi vous pouvez héberger un site web, n'hésitez pas à installer votre propre lecteur de flux RSS web (web based RSS reader).

Une liste des solutions existantes est disponible sur sebsauvage.net. Dans ma recherche, je me suis concentré sur les besoins suivants.

Je veux un affichage adapté à mon smartphone.
Je veux ranger mes flux dans des catégories ou dossiers.
Je veux voir la liste de mes flux pour afficher les articles d'un seul flux.
Je veux importer mes flux de Google Reader (import OPML)
Je veux une authentification pour accéder à mon lecteur de flux.
Je veux pouvoir marquer un article comme favoris ou suivi.
Je veux pouvoir mettre des étiquettes (tag) aux articles.

J'ai donc testé quelques solutions et voici ci-dessous un tableau récapitulatif.

Nom	Langage	BDD	Mobile	Catégories	Liste des flux	Import OPML	Mot de passe	Favoris / Suivi	Tags articles	Démo
Leed	PHP 5.3	MySQL	Oui	Oui	Oui	Oui	Oui	Oui	Non	Oui
Selfoss	PHP 5.3	MySQL, PostgreSQL, SQLite3	Oui	Oui	Oui	Oui	Oui	Oui	Non	Non
Miniflux	PHP 5.3	SQLite	Oui	Non	Oui	Oui	Oui	Non	Non	Non
RSS Lounge	PHP 5.2	MySQL	Non	Oui	Non	Oui	Oui	Oui	Non	Non
FeedHQ	Python 2.7	PostgreSQL	Oui	Oui	Non	Oui	Oui	Oui	Non	Version d'essai sur le site

S'il y a une erreur dans ce tableau ou si vous voulez y ajouter des lignes, n'hésitez à m'en parler dans les commentaires.

Je trouve dommage que la majorité des solutions soient en PHP et que les offres mutualisés des hébergeurs se limitent souvent à PHP. J'aurais bien essayé une solution en Python.

À ce jour, je n'ai trouvé aucune solution avec la fonctionnalité des tags sur les articles comme le fait Google Reader.

Les deux qui correspondent le mieux à mes besoins sont Leed et Selfoss. Pour l'instant mon choix se porte sur Selfoss. Je le trouve assez simple et esthétique. Si vous aussi vous voulez installer Selfoss, alors la suite vous intéressera sûrement. Pour Leed, lisez plutôt le tutoriel sur Geek De France.fr.

Selfoss

Selfoss est responsive, il s'adapte aux écrans de toutes tailles. Il y a trois affichages différents en fonction de la largeur disponible.

Lorsqu'on clique sur un article, il se déplie. J'aime bien la disposition en trois colonnes pour lire les articles sur un grand écran.

Pour l'installer il vous faut un espace d'hébergement avec PHP 5.3. Commencez par télécharger les sources de Selfoss sur le site officiel. Après avoir extrait l'archive, copiez le fichier defaults.ini vers config.ini et personnalisez votre configuration en fonction de vos besoins en modifiant ce nouveau fichier. Tous les paramètres sont décrit sur le site de Selfoss.

Personnellement, j'utilise une base MySQL (mais SQLite et PostgreSQL sont disponibles). Pour ça il faut saisir la valeur des paramètres suivants.

db_type=mysql
db_host=domaine ou IP de votre serveur de base de données
db_database=Nom de la base de données
db_username=Nom de l'utilisateur MySQL
db_password=Mot de passe de l'utilisateur

Par défaut l'accès à Selfoss n'est pas protégé par un mot de passe. Pour en ajouter un, saisissez votre nom d'utilisateur et votre salage pour le hachage de votre mot de passe. Selfoss possède un générateur de hash pour mot de passe. Vous saisirez donc sa valeur après son installation.

username=hiko
password=
salt=une chaîne aléatoire de caractère

Si comme moi vous voulez que les articles soient automatiquement marqués comme lus à la consultation, changer le 0 en 1 pour le paramètre auto_mark_as_read.

auto_mark_as_read=1

Maintenant que votre config.ini est prêt, transférez le répertoire selfoss sur votre serveur par FTP par exemple. Demander à votre navigateur d'accéder à cet espace et si tous va bien quelque chose qui ressemble à la capture d'écran plus haut devrait s'afficher.

Pour ceux qui on opté pour un mot de passe doivent ajouter /password à leur URL pour générer le hash du mot de passe voulu. Ensuite retour au fichier config.ini pour y coller la chaîne générée dans le paramètre password. Bien sûr n'oubliez pas de le transférer sur votre serveur.

Il ne reste plus qu'à ajouter vos sources. Pour les utilisateurs de Google Reader, rendez-vous sur la page /opml de Selfoss (en cliquant sur l'icône en forme de nuage en bas à droite puis sur « ou importer un fichier opml ou google reader »). Un lien vous propose d'exporter vos sources de Google Reader. Enregistrez le sur votre disque puis importez le dans Selfoss.

C'est terminé. Vous pouvez utiliser Selfoss depuis n'importe quel appareil à condition d'avoir accès à Internet.

Stéphane Blondon: Évolution du nombre de messages sur debian-l10n-fr et debian-users-fr avec pychart

2013-05-02T08:34:34+00:00

Pychart est une bibliothèque Python permettant des graphiques directement en python. Un paquet Debian est disponible (nommé python-pychart) avec la dernière version 1.39 (qui date de 2006).

Debian utilise massivement des listes de diffusion pour la collaboration de ses membres. Parmi les nombreuses listes existantes, trois sont francophones :

debian-users-fr, dédiée aux questions des utilisateurs ;
debian-l10n-fr, dédiée aux traductions en français ;
debian-news-french, dédiée aux communiqués officiels. Elle est exclue du graphique car elle ne représente pas vraiment l’activité des listes de diffusion.

Pychart est utilisé pour créer un graphique montrant l’évolution du volume de messages postés sur ces deux listes pendant une année glissante (soit d’avril 2012 à avril 2013).

Le graphique

Le graphique représente le nombre de messages électroniques envoyés sur les deux listes par jour.

On constate que les pics et les creux se font sur les mêmes mois. Par contre, les tendances générales sont inversées : en hausse pour la liste utilisateur, en baisse pour la liste dédiée aux traductions.

Réalisation

Le code Python est fourni à la fin de l’article. Pychart s’appuie sur de nombreuses inventions anciennes mais solidement éprouvées :

Invention de la poubelle (1884)

Toute la documentation fait des imports globaux (from pychart import *), comme beaucoup d’exemples disponibles sur le web. Pour éviter de polluer l’espace de nom, il suffit d’importer les différents sous-modules de manière classique (import pychart.sousmodule). Je n’ai pas eu besoin d’importer certains sous-modules bien qu’ils soient utilisés dans le script.

Création de postscript (1982)

Plusieurs formats de sortie sont disponibles (ps, pdf, png et svg). Par défaut, le fichier sera en PostScript.
Pour le changer vers le format png :

pychart.theme.output_format = "png"

Pour avoir une sortie en png, ghostscript doit être installé sur le système. PIL n’est pas nécessaire.

Invention de la télévision couleur (1938)

Par défaut, les graphiques seront uniquement en nuances de gris. Si on souhaite avoir plein de couleurs, il faut le déclarer de la manière suivante :

pychart.theme.use_color = True

Invention de l’écriture de travers (-3400)

Il est possible d’orienter le texte affiché (que ce soit pour les axes ou des boîtes de texte ad-hoc). Pour cela, il faut définir l’angle d’orientation (« /a » pour définir que l’on modifie l’angle, « -20 » pour baisser de 20 degrés par rapport à l’horizontale dans l’exemple ci-dessous) :

pychart.axis.X(label="Date", format="/a-20/hL%s")

La définition du formatage de la chaîne à afficher utilise le caractère « / » pour introduire un contrôle. Il est nécessaire de le doubler lorsque l’on souhaite l’afficher (pour une date par exemple).

Invention du dessin (Paléolithique)

pychart.line_plot.T(label=u"debian-user-french", #sert pour la légende
                    data=stats, #la structure des données à afficher
                    ycol=2, #la troisième colonne dans les données
                    line_style=_blue_line #le rendu des données
                    )

Invention du papier (IIième siècle avant JC)

La méthode draw() permet d’afficher les données sur la sortie standard. Il suffit simplement de la rediriger vers un fichier grâce au shell :

$ python volume.py  > volume.png

Code source et références

Le code qui a permis de créer le graphique :

# -*- coding: utf-8 -*-

import pychart.area
import pychart.line_plot
import pychart.theme


pychart.theme.output_format = "png"
pychart.theme.use_color = True
pychart.theme.default_font_size = 14
pychart.theme.title = "14"


stats = (("04//2012", 12.27, 14.43),
        ("05//2012", 10.71, 14.42),
        ("06//2012", 11.77, 13.10),
        ("07//2012", 10.19, 8.55),
        ("08//2012", 11.65, 14.68),
        ("09//2012", 13.00, 18.33),
        ("10//2012", 10.32, 15.06),
        ("11//2012", 6.87, 14.90),
        ("12//2012", 5.48, 10.48),
        ("01//2013", 5.29, 20.58),
        ("02//2013", 10.25, 22.39),
        ("03//2013", 9.74, 24.00),
        ("04//2013", 8.3, 19.80))


_area = pychart.area.T(size = (700, 450),
            y_grid_interval=5,
            x_coord=pychart.category_coord.T(stats, 0),
            x_axis=pychart.axis.X(label="Date", format="/a-20/hL%s"),
            y_axis=pychart.axis.Y(label="Nombre de messages par jour"),
            legend=pychart.legend.T(),
            y_range=(0, None))

_red_line = pychart.line_style.T()
_red_line.width = 2
_red_line.dash = (5, 5)
_red_line.cap_style = 2
_red_line.join_style = 2
_red_line.color = pychart.color.red
_blue_line = pychart.line_style.T()
_blue_line.width = 2
_blue_line.color = pychart.color.royalblue
_l10n_plot = pychart.line_plot.T(label=u"debian-l10n-french", data=stats, line_style=_red_line)
_user_plot = pychart.line_plot.T(label=u"debian-user-french", data=stats, ycol=2, line_style=_blue_line)
_area.add_plot(_l10n_plot, _user_plot)

_area.draw()

Les moyennes journalières ont été calculées préalablement. Elles sont exclues du code source pour ne pas l’alourdir inutilement. Voici les données brutes qui ont servi aux calculs des moyennes :
date debian-l10n-french debian-user-french nbre_jours 2012/04 368 433 30 2012/05 332 447 31 2012/06 353 393 30 2012/07 316 265 31 2012/08 361 455 31 2012/09 390 550 30 2012/10 320 467 31 2012/11 206 447 30 2012/12 170 325 31 2013/01 164 638 31 2013/02 287 627 28 2013/03 302 744 31 2013/04 190 594 30

Les données ont été récupérées à partir des versions publiques des archives des listes de traductions.

La documentation de pychart est disponible à http://home.gna.org/pychart/doc/pychart.html ou dans le paquet python-pychart-doc.

Enfin, Matplotlib répond au même besoin et semble être un projet plus vivant.

ascendancesVolume des messages sur les listes de diffusion Debian francophones

Stéphane Blondon: Cohabitation Jinja et AngularJS

2013-04-15T22:38:23+00:00

Jinja2, un moteur de templates en Python, et AngularJS, un framework web côté client en Javascript, utilisent tous les deux les accolades pour indiquer une variable ou une structure à interpréter.
Par exemple {{ choucroute }} pour une variable qui a du goût.

D’où conflit.
Pour résoudre ce problème, trois possibilités :

Diviser les fichiers pour régner

Séparer l’utilisation de chaque template :

variables Jinja uniquement dans les fichiers html fournis directement par l’application Python ;
variables AngularJS uniquement dans les fichiers chargés dynamiquement (par exemple /partials/detail-choucroute.html).

Simple à mettre en place mais limité.

Commenter les accolades

Protéger le code AngularJS sensible en empêchant son interprétation par Jinja :

{{ '{{' }} pour ne pas interpréter des accolades ;
{% raw %} pour un code plus long.

Changer les délimiteurs Jinja

Redéfinir les délimiteurs dans l’environnement de Jinja :

jinja_env = jinja2.Environment(...)
jinja_env.block_start_string = '(%'
jinja_env.block_end_string = '%)'
jinja_env.variable_start_string = '(('
jinja_env.variable_end_string = '))'
jinja_env.comment_start_string = '(#'
jinja_env.comment_end_string = '#)'

L’ensemble des caractères accolades ont été remplacés par des parenthèses pour une raison de cohérence. Limiter la redéfinition des délimiteurs à variable_start_string et variable_end_string devrait suffire.

Bien évidemment, libre à chacun de choisir d’autres délimiteurs.

À noter qu’il est possible d’obtenir un résultat similaire avec Django.

ascendances

Colin Garriga-Salaün: AgileFrBot, propulsé par rss2reddit !

Colin Garriga-Salaün — 2013-04-07T11:42:04+00:00

Je suis heureux de vous présenter rss2reddit et AgileFrBot ! Reddit est un excellent outil pour l'intelligence collective. Il permet notamment d'ouvrir des espaces thématiques et d'y accumuler des liens vers des articles. Ces liens peuvent être qualifiés et commentés par les usagers, et sont ainsi exploitables selon les appréciations de la communauté. rss2reddit est un outil -- réalisé par

Colin Garriga-Salaün: Agile Tour Bordeaux 2012

Colin Garriga-Salaün — 2013-04-06T23:37:28+00:00

Cette année encore toute l'équipe de Yaal a participé à l'Agile Tour Bordeaux ! Merci aux organisateurs, aux orateurs, aux sponsors et partenaires, tout s'est parfaitement déroulé ! Nous sommes très heureux d'avoir pu apporter notre pierre à l'édifice en tant que partenaire technique avec la billetterie en ligne yuticket.com, et d'avoir pu y donner notre propre retour d'expérience ! J'ai

Stéphane Blondon: Se connecter et connaître les schémas de tables MySQL, PostgreSQL ou SQLite

2013-03-10T19:38:55+00:00

Il arrive parfois que l’on doive jongler entre différentes bases de données, chacune ayant une syntaxe légèrement différente des autres. Voici un petit résumé de ce cirque pour éviter de passer pour un clown…

Entrée des artistes : se connecter au serveur

MySQL :

$ mysql -u utilisateur_avec_les_droits -p

Il faut alors saisir le mot de passe pour accéder à l’interpréteur. Il est aussi possible de saisir le mot de passe directement après le paramètre -p mais dans ce cas, le mot de passe est lisible dans l’historique de connexion de l’utilisateur (dans le fichier .bash_history si le shell utilisé est bash).

PostgreSQL :

$ psql -U utilisateur_avec_les_droits

SQLite :

$ sqlite3 cirque.db

Pour les bases de données créées avec la version 2 de SQLite, il faut utiliser la commande sqlite et non sqlite3.

Voir les bases de données disponibles

MySQL: SHOW DATABASES;
PosgreSQL : \l
SQLite : .databases

Choisir la base de données à utiliser

Supposons qu’il existe une base nommée « cirque ».
MySQL : USE cirque;
PostgreSQL : \c cirque
sqlite : rien à faire, la base est déjà sélectionnée.

Lister les tables de la base

MySQL : SHOW TABLES;
PostgreSQL : \d
SQLite : .tables

Voir le schéma d’une table

Supposons qu’il existe une table nommée « spectacles ».
MySQL : DESC spectacles;
PostgreSQL : \d spectacles
SQLite : .schema spectacles

Aide en ligne

Si vous pensez que ce sera plus rapide que de chercher dans la première réponse trouvée par votre moteur de recherche préféré, vous pouvez utiliser l’aide en ligne de l’outil.

MySQL : help
PostgreSQL : help
SQLite : .help

Le salut des artistes

Les versions utilisées pour ce tour de piste :
MySQL : 5.1.66
PostgreSQL : 8.4.16
SQLite : 3.7.13

ascendances

Stéphane Blondon: Déterminer quelle est la meilleure distribution grâce à Python et PIL

2013-01-12T09:39:02+00:00

N’avez-vous jamais discuté des mérites de telle ou telle distribution Linux (ou BSD) avec d’autres personnes (chacun essayant de démontrer que celle qu’il utilise au quotidien est la meilleure) ? Grâce à cet article, vous n’aurez toujours pas La réponse mais vous aurez une réponse indiscutable : il s’agit de la jouer aux cartes. Les cartes sont créées avec Python Imaging Library, une bibliothèque Python de manipulation d’image. L’article explique la façon de les réaliser.

Chaque carte possède un ensemble de caractéristiques, la plus forte remporte le pli. Ce principe de jeu existe depuis les années 70 (Ace_Trumps, Super Top Ass). L’ensemble des 26 cartes créées est visible ici.

L’objectif de l’article est de montrer comment on peut concevoir la création de la carte, pas le détail des paramètres de chaque fonction. Pour cela, la documentation et de nombreuses explications foisonnent déjà sur le web. C’est pourquoi, par exemple, les calculs de dimensionnement ne seront pas expliqués.

Prérequis : installer PIL (ou Pillow)

Deux possibilités :

utiliser le système de paquet de votre distribution (python-imaging pour Debian) ;
utiliser Pypi : PIL n’est pas disponible, il faut installer Pillow. Cela ne change pas la façon d’utiliser la bibliothèque :
```
from PIL import Image, ImageDraw, ImageFont
```

Image sert à instancier une image, ImageDraw à la modifier, ImageFont à choisir une police de caractère.

Créer une carte

La base consiste à instancier un objet image sur lequel les modifications vont être apportées. Une fois les modifications réalisées, on enregistre le résultat sur le disque :

def draw_card(distrib):
    img = Image.open(BACKGROUND_PATH)
    #ajout des textes, images, etc.
    img.save(distrib["img_name"] + ".png")

La carte est une superposition de couches, qui sont toutes fusionnées en une seule image. On a donc un fond sur lequel les autres éléments sont superposés.
Parmi les éléments remarquables :

Textes dans un cartouche

Le titre et les caractéristiques des distributions sont faits de la même manière. Il n’existe pas d’effet avec PIL pour dessiner automatiquement une bordure. Elle est réalisée en plaçant deux rectangles l’un sur l’autre, celui de dessous étant plus large et haut.

def draw_title(img, title):
    """
    pour dessiner le titre avec le fond et la bordure autour

    img est l'image PIL
    title est la chaine de caracteres a afficher ("Distribution")
    """
    draw = ImageDraw.Draw(img)
    draw_cartouche(draw, 25, 55)
    font = ImageFont.truetype(FONT_PATH, TITLE_FONT_SIZE)
    width, height = draw.textsize(title, font=font)
    x = center(width)
    draw.text((x, 29), title, font=font, fill=TEXT_COLOR)

def draw_cartouche(draw, upper_height, lower_height):
    """pour dessiner les deux rectangles"""
    draw.rectangle(((MARGIN_LEFT, upper_height), (CARD_WIDTH - MARGIN_RIGHT, lower_height)),
                   fill="#8e6f32")
    BORDER = 5
    draw.rectangle(((MARGIN_LEFT + BORDER, upper_height + BORDER), (CARD_WIDTH - MARGIN_RIGHT - BORDER, lower_height - BORDER)),
                   fill="#e9b654")

draw.textsize() permet de connaître les dimensions que prendrait la chaîne passée en paramètre. Cela permet de faire un calcul (dans la fonction center(), omise dans l’extrait ci-dessus) pour centrer le texte.

Le logo de la distribution

L’affichage du logo suit la même logique en intercalant une image (nommée supernova.png) entre le fond et le logo de la distribution. Pour avoir un joli rendu , on décale simplement en hauteur l’image (y) car les deux images n’ont pas la même taille.

def draw_logo(img, filename):
    """on colle supernova
       puis le fichier correspondant au parametre filename"""
    image_path = SRC_IMGS_DIR + "supernova.png"
    nova = Image.open(image_path)
    nova_width, nova_height = nova.size
    x = center(nova_width)
    y = 60
    img.paste(nova.convert("RGBA"),
              (x, y, x + nova_width, y + nova_height),
              mask=nova.convert('RGBA'))
    image_path = SRC_IMGS_DIR + filename + ".png"
    distro = Image.open(image_path)
    distro_width, distro_height = distro.size
    x = center(distro_width)
    y = 90
    img.paste(distro.convert("RGBA"),
              (x, y, x + distro_width, y + distro_height),
              mask=distro.convert('RGBA'))

L’exercice de factorisation de cette fonction est laissé aux lecteurs qui s’ennuient et qui ne sont pas partis faire autre chose (ce que je ne comprend pas d’ailleurs).

Le numéro de la carte

Le numéro de la carte en bas à gauche est affiché de biais. Si les images peuvent subir une rotation, les textes ne sont affichés qu’horizontalement. La solution est donc de coller le texte dans une image intermédiaire. Cette image subira une rotation puis sera collée sur l’image finale de la même manière que précédemment :

def draw_card_index(img, number):
    """pour dessiner 'number' de biais"""
    HEIGHT = WIDTH = 19
    num_img = Image.new("RGBA",
                        (WIDTH, HEIGHT),
                        (0, 0, 0, 0))
    num_draw = ImageDraw.Draw(num_img)
    font = ImageFont.truetype(SANS_PATH, TEXT_FONT_SIZE)
    num_draw.text((0, 0), number, font=font, fill="brown")
    n = num_img.rotate(-45)
    X, Y = 7, 378
    img.paste(n, (X, Y, X + WIDTH, Y + HEIGHT), mask=n)

À noter que la rotation faite ici prend peu de précaution et les nombres à deux chiffres sont légèrement tronqués. Le paramètre expand peut être ajouté à rotate() pour éviter la perte, mais l’image est automatiquement agrandie.

Code source et ressources

La documentation de PIL est précieuse.
Un tutoriel dont certains effets ont été réutilisés pour les cartes.

Les données sur les cartes proviennent principalement de Distrowatch. Les logos des distributions sont aussi ceux affichés sur Distrowatch. « first stable » représente la première version stable avec le nom actuel de la distribution ou ce qui pourrait être considéré comme équivalent. « based on » indique le nom de la distribution parente. La valeur « Indep. » signifie qu’elle n’est basée sur aucune autre distribution. Si elle est suivie d’une étoile, cela signifie qu’elle est maintenant indépendante mais a été basée sur une autre distribution par le passé.

Le fond de carte et l’effet supernova ont été réalisés avec The Gimp.

L’archive contenant le code source du script au cas où quelqu’un voudrait le réutiliser, ainsi que les logos et les cartes générées est fournie au format .tar.xz. Le code a été écrit dans un but de démo. Il est bien perfectible…

ascendancesCarte de jeu pour DebianMontage du titreMontage du logo

Aurélien Biedermann: Retour sur le TEDxBordeaux 2012

2013-01-03T15:13:05+00:00

Le 1er décembre dernier, la deuxième édition du TEDxBordeaux ouvrait ses portes au TNBA. Nous étions impatient de participer à cet évènement et nous n’avons pas été déçus.

Les participants nous ont ouvert l’esprit pendant toute une après midi. Tous avaient pour objectif de changer le monde et notre vision des choses. Que ce soit Karim qui nous propose du biomimétisme pour trouver des solutions naturelles pour un développement propre, ou Halim qui propose de hacker son corps pour se sentir mieux et réfléchir plus efficacement, en passant par Irina et son reportage sur les différentes signification du « chez soi », nous en sommes sortis grandis. La magie a opéré, et une partie d’entre nous a déja approfondi quelques sujets qui les tenaient à cœur.

Au niveau de l’organisation, il n’y a rien à redire : la scène était sobre et efficace (ce fauteuil avait quelque chose d’hypnotisant), les speakers même s’ils ne sont pas professionnels se sont très bien débrouillés, les bénévoles et partenaires ont rempli leur rôle pour que tout ce passe bien. Le maître de cérémonie François Xavier Bodin peut en être fier. Yaal remercie l’ensemble des personnes présentes pour cette superbe après-midi.

Nous espérons très franchement que la prochaine édition du TEDxBordeaux arrive très rapidement et Yaal sera très certainement encore partenaire de l’évènement.

yaalblog

Stéphane Blondon: HMAC Paybox en Python

2012-12-02T22:40:16+00:00

Paybox est une solution de paiement électronique que nous avons utilisé plusieurs fois.

Pour se connecter avec le service Paybox (en version 5.08), il est nécessaire de produire une empreinte HMAC des données du serveur que le client va envoyer vers le serveur Paybox pour payer. L’objectif est d’empêcher toute falsification car elle serait détectée grâce à l’empreinte qui ne correspondrait plus.

La documentation fournit une implémentation d’exemple en PHP :

<?php
 $key = 
 "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
 $msg = "FORMULAIRE";
 $binkey = pack("H*", $key);
 $hmac = strtoupper(hash_hmac('sha512', $msg, $binkey));
 ?>

Voici l’équivalent en Python :

import binascii
import hashlib
import hmac


PRIVATE_KEY = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
msg = "FORMULAIRE"
binary_key = binascii.unhexlify(PRIVATE_KEY)
hmac = hmac.new(binary_key, msg, hashlib.sha512).hexdigest().upper()

Les deux codes fournissent le même résultat pour des couples (clé privée, message) identiques. Charge à vous de mettre les bonnes valeurs.

ascendances

Stéphane Blondon: Processus de traduction au sein de debian-l10n-fr

2012-10-25T20:56:52+00:00

L’équipe debian-l0n-fr est l’équipe de francisation des fichiers spécifiques à Debian. Il en existe pour de nombreuses autres langues (de l’afrikaan au zoulou en passant par le népalais), certaines étant bien plus complètes que d’autres.

Les équipes de traduction Debian ne s’occupent pas des projets qui ont déjà leur propre équipe de traduction comme GNOME, KDE, Mozilla, etc. Elles se limitent aux outils spécifiques à Debian (apt-get, aptitude, etc.), la documentation de ces outils, le site web, les nouvelles du projet, …

Chacune d’entre elle est libre de s’organiser en interne comme elle l’entend. Pour l’équipe francophone, il ne suffit pas de traduire un fichier et de passer immédiatement au suivant car un processus de relecture prend le relais. L’objectif est de chasser les dernières erreurs typographiques, d’alléger les constructions de phrase, d’éliminer les contre-sens et faux-amis. En réalité, il n’y a souvent pas grand chose à modifier mais cela permet d’obtenir un résultat mieux fini.

Les étapes de traduction et relecture

La succession d’étapes est représentable par un graphe orienté non cyclique :

Les nœuds d’entrée sont le signalement d’une nouvelle traduction à faire (taf) ou à mettre à jour (maj). Un volontaire signale sa volonté de faire cette traduction (itt) puis la soumet à relecture (rfr). Après quelques temps et quelques relectures, une nouvelle étape de relecture est franchie (lcfc). La traduction est potentiellement terminée mais les dernières relectures sont encore possibles. Enfin la traduction est envoyée vers le système de rapport de bogue (bts) ou simplement déclaré comme terminé (done). L’état terminal choisi est fonction du type de fichier traduit.

Parfois le nombre de relectures est plus important et il est nécessaire de faire des étapes supplémentaires. Dans ce cas, des états officieux sont utilisés (rfr2, rfr3, lcfc2, lcfc3, etc.). Cela permet d’éviter des retours en arrière (par exemple si le passage de rfr à lcfc s’est fait trop vite). C’est cette stratégie qui permet d’éviter l’existence de cycle. La situation reste ainsi plus facilement compréhensible par les humains qui participent (et aussi par ceux qui ne participent pas même si c’est moins crucial).

Article [done]

Le graphe a été réalisé avec l’outil dot, disponible dans le paquet graphviz (version 2.26.3).

La commande utilisée :

$ dot -Tpng process_debian_l10n_fr.gv -o process_debian_l10n_fr.png

Le script process_debian_l10n_fr.gv :

digraph G {
        taf [color=navyblue, fontcolor=navyblue];
        maj [color=navyblue, fontcolor=navyblue];

        bts [color=darkgreen, fontcolor=darkgreen];
        done [color=darkgreen, fontcolor=darkgreen];

        rfr2 [color=antiquewhite, style=filled];
        "rfr…" [color=antiquewhite, style=filled];
        "lcfc2" [color=antiquewhite, style=filled];
        "lcfc…" [color=antiquewhite, style=filled];

        taf -> itt;
        maj -> itt;
        itt -> rfr;
        rfr -> lcfc;
        rfr -> rfr2;
        rfr2 -> "rfr…";
        rfr2 -> lcfc;
        "rfr…" -> lcfc;
        lcfc -> done;
        lcfc -> lcfc2;
        lcfc2 -> bts;
        lcfc2 -> done;
        lcfc2 -> "lcfc…";
        "lcfc…" -> done;
        lcfc -> bts;
        "lcfc…" -> bts;
}

ascendancesÉtapes d'une traduction

Colin Garriga-Salaün: « Livrez fréquemment un logiciel opérationnel... » 1

Colin Garriga-Salaün — 2012-10-14T15:45:59+00:00

73 jours après notre rencontre avec un porteur de projet dynamique et 89 déploiements en plateforme de recette2, le service yuticket.com est sortie en bêta privée ! 17 jours plus tard, grâce aux retours de nos 3 premiers courageux utilisateurs, nous comptons 42 nouvelles livraisons en recette, 21 livraisons en production3, et nous ouvrons la création d'événements pour tous ! 3ème

Stéphane Blondon: États des paquets Debian chez les utilisateurs (selon PopCon) – 2

2012-08-07T12:20:44+00:00

Lors du précédent article, nous avions conclu que les paquets étaient surtout dans la catégorie « pas utilisé récemment ». Cependant, l’analyse ne prenait pas en compte deux cas :

les paquets non Debian
les bibliothèques

Éliminer ces incertitudes va-t-il changer quelque chose au résultat ? C’est ce que vous saurez à la fin de cet article dont les rebondissements rendraient jaloux un kangourou sous amphétamines ! (Ou pas.)

Sans paquet non officiel

Les statistiques fournies par PopCon incluent certains paquets avec des noms bizarres. Ainsi, on peut trouver des noms tels que « 204c45e1756d0aaff35eea07ac2a52a4.784[…]32.1 » ou « 0xffff » ainsi que d’autres plus ou moins expressifs (surtout plus de moins et moins de plus). On ne comprend pas bien ce que le nom signifie, mais comme lorsqu’il y a plein de câbles, ça impressionne toujours.

En réalité, la partie cliente de PopCon (celle qui est exécutée sur la machine des utilisateurs) renvoie les statistiques de tous les paquets installés, même s’ils n’existent pas dans les dépôts Debian (main, contrib, non-free). Les statistiques incluent donc les paquets que les utilisateurs ont installés ou développés pour leur propre usage. L’idée sous-jacente est que cela sert aussi d’indice pour inclure de nouveaux paquets qui seraient nécessaires au plus grand nombre. Ce n’est donc pas un bogue mais une fonctionnalité… Il y a maintenant une ligne de plus dans la base de données de bogues souhaitant la possiblité de désactiver cette fonctionnalité (bogue n° 681721).

Si l’on filtre de nouveau les données pour se cantonner uniquement aux paquets officiels, on obtient un résultat globalement équivalent :

Le nuage de points a la même forme, la moyenne reste comparable bien qu’il y ait un transvasement de l’état « peu utilisé » vers l’état « récemment installé » de 5 points.

La liste des paquets sélectionnés est celle fournie dans l’archive des binaires pour l’architecture AMD64 dans la version testing/main (téléchargeable à une adresse du type votre_protocole_préféré://votre_serveur_préféré/debian/dists/testing/main/binary-amd64/Packages.bz2).

Sans les bibliothèques

PopCon détermine la date d’utilisation du logiciel avec la date d’accès sur le disque (l’information atime du fichier) . Comme précisé dans la documentation (cf. /usr/share/doc/popularity-contest/README.gz), cela fonctionne bien avec les exécutables mais pas avec les bibliothèques partagées. Il semble donc souhaitable de visualiser le résultat en enlevant aussi les bibliothèques. En supprimant tous les paquets commençant par le terme « lib » (par exemple lib32bz2-dev ou libc6), nous obtenons un nouveau graphique :

La suppression des bibliothèque ne change rien en comparaison avec le filtre précédent. C’est à se demander pourquoi je pers mon temps à écrire cet article et pourquoi vous perdez votre temps à le lire !

En moyenne, seulement 20 % des paquets sont donc considérés comme utilisé fréquemment.

Sources

La moulinette qui filtre les données a été écrite en Python :

#! /usr/bin/env python

POPCON_FILE = "filtered_popcon.csv"
MAIN_PACKAGES_FILE = "Packages"
POPCON_FOR_MAIN_PACKAGES_FILE = "filtered_popcon_for_main_without_libs.csv"

WITH_LIBS = False

def get_main_packages():
    with open(MAIN_PACKAGES_FILE) as f:
        return [extract_package_name(line)
                for line in f.readlines()
                if is_package_name(line)]

def is_package_name(line):
    return line.startswith("Package: ")

def extract_package_name(line):
    return line.split()[1]

def get_popcon_stats():
    with open(POPCON_FILE) as f:
        if WITH_LIBS:
            _filter = is_official_package
        else:
            def _filter(line):
                return is_official_package(line) and not is_lib(line)

        return [line 
                for line in f.readlines()
                if _filter(line)]

def is_official_package(line):
    package_name = line.split(",")[0]
    return package_name in main_packages

def is_lib(line):
    return line.startswith("lib")

def write_filtered_popcon(stats):
    with open(POPCON_FOR_MAIN_PACKAGES_FILE, "w") as f:
        for stat in stats:
            f.write(stat)

main_packages = get_main_packages()
write_filtered_popcon(get_popcon_stats())

Le code produisant les graphiques est le même que dans l’article précédent, sauf pour les noms de fichier et la chaîne de caractère « Peu utilisé (« old ») » qui est suffixé par des espaces supplémentaires pour éviter de chevaucher la moyenne. L’intérêt étant proche de zéro, je préfère faire économiser quelques paquets TCP/IP à tout le monde en ne l’incluant pas.

ascendancesStatistiques des paquets Debian selon PopCon pour testing/mainStatistiques des paquets Debian selon PopCon pour testing/main

Stéphane Blondon: États des paquets Debian chez les utilisateurs (selon PopCon)

2012-07-09T12:16:11+00:00

PopCon (pour Popularity contest) permet d’obtenir des statistiques d’utilisation de paquets Debian. La soumission des statistiques est facultative. Si le participant accepte l’envoi des statistiques, chaque semaine, une notification anonyme sera automatiquement envoyée vers Debian contenant les statistiques d’utilisation des paquets. L’état agrégé est visible sur popcon.debian.org et mis à jour quotidiennement.

L’évolution globale de l’utilisation des paquets est visible sur une page dédiée (par exemple, la page de Flobopuyo).

Si un paquet est installé sur une machine, alors il sera considéré dans l’un des quatre états suivants :

« Vote » : paquet récemment utilisé
« Old » : paquet qui n’a pas été utilisé depuis longtemps
« Recent » : paquet récemment mis à jour
« No Files » : informations insuffisantes pour statuer sur son utilisation

La somme des 4 états envoyés par les participants fournit le nombre de machines sur lequel ce paquet est installé. S’il n’est pas installé, il n’est pas comptabilisé.
Sur l’échantillon des paquets que j’ai consulté, les trois premiers états sont largement représentés. Le quatrième est peu courant, probablement car c’est quasiment un cas pathologique (les dates d’accès aux fichiers sont incorrects). Si on néglige ce dernier cas, il est possible de représenter quel est la proportion des trois états d’un paquet pour l’ensemble des participants avec un graphique triangulaire.

Résultat sur un échantillon (15 paquets)

Les paquets affichés dans le graphique :

plusieurs logiciels couramment installés et utilisés (directement ou à l’insu de l’utilisateur) : bash, dash, initramfs-tools et anacron ;
des navigateurs web : iceweasel (un renommage de Firefox), chromium-browser (la version libre de Google Chrome) et epiphany (le navigateur fourni par Gnome) ;
des serveurs web : aolserver4 (les statistiques montrent qu’il est installé sur au moins 47 machines !), apache2, lighttpd et nginx ;
deux logiciels de bureautique : libre-office et koffice ;
deux jeux équivalents : amoebax (capture d’écran) et flobopuyo (capture d’écran). À titre indicatif, Amoebax est plus installé qu’Aolserver…

Limites

Ignorer l’état No Files

Le fait de négliger le quatrième état n’est pas forcément pertinent pour tous les paquets. Tous les paquets présentés précédemment ont un taux inférieur à 1 % pour le cas de dates invalides à deux exceptions près : libreoffice-common et nginx.

Proportion de l’état No Files

0 % pour amoebax, flobopuyo et aolserver4-daemon
0,025 % pour iceweasel
0,026 % pour initramfr-tools
0,027 % pour anacron et bash
0,031 % pour dash
0,037 % pour apache2.2-bin
0,043 % pour lighttpd
0,126 % pour koffice-libs
0,149 % pour epiphany
0,696 % pour chromium-browser
4,90 % pour libreoffice-common
38,25 % pour nginx

Vu l’écart, je me demande s’il n’y a pas un problème avec les fichiers surveillés par PopCon pour nginx.

Cas des logiciels séparés en plusieurs paquets

Pour faciliter la maintenance, certains logiciels sont découpés en plusieurs paquets. Dans ce cas, le fait de choisir l’un ou l’autre de ces paquets pour le représenter modifie le résultat : par exemple apache2.2-common (absent du graphique) se situe au même endroit que bash et anacron alors qu’apache2.2-bin est plus près d’anacron. De même pour nginx-common (absent du graphique) qui est placé à côté d’iceweasel alors nginx est situé en dessous d’initramfs-tools.

Il est étonnant que l’ensemble des paquets choisis se situent tous dans la partie basse du graphique. Cependant, l’échantillon est-il vraiment représentatif ?

Résultat sur l’ensemble des paquets

Debian fournit une archive avec les statistiques de l’ensemble des paquets. Après son téléchargement, reformatage et suppression des lignes malformées, voici le graphique que l’on peut obtenir :

Les noms des paquets ne sont pas affichés car ils recouvrent entièrement le graphique, le rendant complètement illisible. Chaque point représente un paquet. L’influence moyenne des trois facteurs considérés est ajouté.

L’état « Recent » ne représente que 10 % des paquets. À mon avis, c’est dû au fait que c’est un état transitoire, les paquets étant considérés par la suite comme utilisé ou pas. La majorité d’entre eux sont considérés comme peu utilisés (le gros pâté noir dans le sommet en bas à droite du triangle). Quels sont les types de logiciels considérés comme peu utilisé, et pour quelles raisons ?

Dans mon cas personnel, en regardant la liste de ces paquets (visible grâce à popularity-contest | grep '<OLD>' en tant que superutilisateur), je constate la présence de logiciels (et de bibliothèques) :

que je n’utilise plus et dont j’avais oublié l’existence (fontmatrix) ;
que j’utilise rarement mais que je ne veux pas désinstaller car ils peuvent me servir à l’avenir (gftp, traceroute, …) ;
qui viennent automatiquement avec des meta-paquets mais que je n’utilise pas (gnome-power-manager, xserver-xorg-video-pleindepucesquinexistentpassurmacartemere, …).

Sources

Les informations concernant le fonctionnement de PopCon proviennent principalement du README et la FAQ fournie par les pages web de popcon elle-même (ou dans le répertoire /usr/share/doc/popularity-contest/ si vous n’avez pas d’accès web actuellement).

Les graphiques ont été réalisés en R (version 2.15.1 (2012-06-22) — « Roasted Marshmallows », disponible dans le paquet r-base), grâce à une bibliothèque externe à R, nommée ade4.
Il est nécessaire d’installer cette bibliothèque sur le système car elle est absente avec les paquets R de base). Le mode d’installation de la bibliothèque ressemble à celui de pip pour Python.
La commande est install.packages("ade4", dep=TRUE).

Voici les données utilisées pour le premier graphique :

Fichier pkgs_deb.csv :

name,vote,old,recent,no_files
epiphany,58,563,47,1
iceweasel,32573,14605,12272,15
chromium-browser,6188,3212,876,72
anacron,52840,2723,4104,16
bash,110628,6120,5826,33
dash,92687,2388,3751,31
initramfs-tools,52369,56181,12319,31
amoebax,11,43,0,0
flobopuyo,26,201,12,0
aolserver4-daemon,30,15,2,0
apache2.2-bin,53491,6032,7339,25
lighttpd,1304,857,173,1
nginx,814,809,109,1073
koffice-libs,431,1122,36,2
libreoffice-common,14696,740,4718,1039

Commandes R :

library(ade4)
pkgs <- read.csv("popcon_pkgs_deb.csv", header=TRUE)
quantites <- data.frame(pkgs$vote, pkgs$old, pkgs$recent)
colnames(quantites) <- c("Utilisé (« vote »)", "Peu utilisé (« old »)", "Mis à jour (« recent »)")
png(file = "popcon_pkgs_deb.png", width = 700, height = 600)
triangle.plot(quantites, label=pkgs$name, clab=0.6, show.position=FALSE)
dev.off()

Pour le second graphique, les données proviennent des statistiques fournies par Debian, reformatées et filtrées car certaines ont des données bizarres. (Bonjour bugreport !)

wget http://popcon.debian.org/all-popcon-results.txt.gz
tar xzvf all-popcon-results.txt.gz
grep « ^Package: » all-popcon-results.txt | sed -e « s/ \+ /,/g » | cut -d » » -f2 | grep -v « ,0,0,0, » | grep « .*,.*,.*,.*,.* » >filtered_popcon.csv

Commandes R :

popcon <- read.csv("filtered_popcon.csv", header=FALSE)
quantites <- data.frame(popcon$V2, popcon$V3, popcon$V4)
colnames(quantites) <- c("Utilisé (« vote »)", "Peu utilisé (« old ») ", "Mis à jour (« recent »)")
png(file = "all_popcon_pkgs_deb.png", width = 700, height = 600)
triangle.plot(quantites, show.position=FALSE, addmean=TRUE, cpoint=0.1)
dev.off()

ascendancesQuelques paquets selon PopConTous les paquets selon PopCon

Colin Garriga-Salaün: Hop ! Une bouteille à la mer...

Colin Garriga-Salaün — 2012-07-07T15:12:03+00:00

Il m'a fallu du temps pour rassembler mon courage et ordonner mes réflexions, je me lance enfin et hop ! une première bouteille à la mer !

Ce qui m'a le plus longtemps retenu a été la peur d'énoncer un programme, une ambition que je n'aurais pas pu honorer... je n'en publierai donc pas et me bornerai à donner un point de départ.

Je suis aujourd'hui accompagnateur agile et créateur de logiciel chez Yaal, membre associatif actif sur Bordeaux avec Okiwi et Agile Tour, je cherche de nouvelles manières d'apprendre et travailler ensemble.

J'espère que ces réflexions en amèneront d'autres !

Request for comments...

Colin Garriga-Salaün: Coding Dojo Extreme Programming bordelais

Colin Garriga-Salaün — 2012-07-07T15:11:23+00:00

Je suis très heureux du démarrage réussi cette année du Coding Dojo Extreme Programming dans le cadre d'Okiwi.

A l'heure où j'écris ce billet, les sessions se tiennent les seconds et quatrièmes lundis du mois de 18h30 à 20h30, dans les locaux de Yaal au 9 rue André Darbon à Bordeaux.

Tout curieux est le bienvenu ! mais attention... si c'est votre premier jour au dojo, vous devez coder !

Que peut-on trouver dans ce coding dojo ? Ce que vous y apporterez bien sûr !

Ensemble, nous cherchons à y apprendre :

à développer du code dirigé par les tests,
à développer en binôme,
de nouveaux langages de programmation,
à coder avec quelqu'un de plus fort que soi,
à coder avec quelqu'un de moins fort que soi,
à réagir lorsqu'on ne sait pas,
à aider le groupe à traverser les moments de doute,
à accueillir de nouveaux entrants,
...

Je suis sûr que nous pourrions nous appuyer sur ces expériences pour apprendre encore d'autres choses... des idées ?

Colin Garriga-Salaün: Promouvoir le changement dans son entreprise

Colin Garriga-Salaün — 2012-07-07T15:10:07+00:00

Je participe à un cercle de coaching par téléphone animé par Yves Hanoulle, et récemment nous nous y sommes posés cette question : comment promouvoir le changement dans son entreprise ?

En tant que coach, il y a des changements que l'on se sent capable de porter directement. On peut alors s'appuyer sur des jeux agiles pour les initier ou mener des expériences sur une durée limitée.

Si le budget de l'entreprise le permet, nous avons aussi la possibilité de faire venir des experts sur des problématiques ponctuelles, et de promouvoir certaines formations.

Mais que faire lorsqu'on est à court de budget ?

Participer à un cercle de coaching par téléphone,
Soutenir les personnes les plus volontaires dans leurs initiatives,
Encourager les personnes à participer à des conférences et à en produire des compte-rendus,
Aménager un créneau horaire hebdomadaire dédié au coapprentissage au sein de l'entreprise,
Participer à un groupe de coapprentissage hors de l'entreprise,
En groupe, chacun explore un livre en une heure pour s'en faire une idée avant d'en rendre compte aux autres,
En groupe, chacun lit un même livre sur une semaine avant d'en débattre,
...

Auriez-vous d'autres idées ?

Colin Garriga-Salaün: Qu'est-ce qu'une décision de groupe ?

Colin Garriga-Salaün — 2012-07-07T15:09:28+00:00

C'est une question qui émergea lors d'Agile Open France 2011. Y réfléchir me paraît essentiel avant de pouvoir s'attaquer à des sujets plus complexes et chers aux agilistes comme l'autoorganisation.

La décision comme illusion

Un point de départ pourrait être de considérer la décision comme simple résolution de contrainte, si simple qu'elle peut être inconsciente.

Si je sors la tête de l'eau pour respirer, on pourra dire que le calcul était vite fait. Parler de décision dans ce cas de figure est discutable, c'est un cas limite. Si l'on refuse de qualifier cet exemple de décision, alors je pense qu'il faut admettre que l'on ne décide pas souvent dans sa journée. Je n'ai pas décidé de prendre tel bus, de relancer tel client, de développer tel logiciel.

J'ai évalué autant que j'ai pu les dénombrer les contraintes qui s'imposaient à moi, et j'ai mathématiquement défini le chemin de moindre difficulté.

La décision comme pari

Mais nos facultés à connaître et à calculer sont limitées, et il faut admettre que ce chemin de moindre difficulté mathématiquement défini recèle en réalité une grande part d'inconnu. La résolution de la contrainte initiale n'est pas garantie : il y a risque, il y a pari.

Ainsi, décider, c'est simultanément s'engager en territoire inconnu et en assumer la responsabilité. C'est à la fois une tentative de prise de contrôle et un abandon au hasard, c'est l'expérience du joueur.

Décider ensemble

Décider ensemble c'est donc, ensemble :

inventorier les contraintes à l'oeuvre et la pression qu'elles exercent,
imaginer des résolutions possibles et en évaluer les risques,
et enfin jeter les dés, en connaissance de cause.

Colin Garriga-Salaün: Course de relais et performance d'équipe

Colin Garriga-Salaün — 2012-07-07T15:08:46+00:00

« Dans une course de relais, ce ne sont pas les vitesses individuelles qui comptent mais la vitesse du bâton de relais. »

Le commentaire vient de Serge Soudoplatoff lors de son intervention à TEDxBordeaux¹ le 28 mai dernier. Il expliquait ainsi comment les sprinteuses françaises gagnèrent le 4x100 mètres en 2003 devant les américaines pourtant plus rapides individuellement : grâce à de meilleurs passages de relais.

On en déduit les pratiques pour une performance collective :

définir le bâton de relais de l'équipe,
visualiser sa progression,
travailler la coordination,
faciliter la performance de ses coéquipiers,
...

... et être efficace soi-même ? oui ! mais cette valeur dégringole bien bas dans la hiérarchie des pratiques depuis la démonstration de l'équipe féminine 4x100m de 2003... révolutionnaire dans une société qui espère que la performance collective émergera de la somme des performances individuelles.

http://www.tedxbordeaux.com/intervenants/serge-soudoplatoff/

Colin Garriga-Salaün: Interprétation généreuse

Colin Garriga-Salaün — 2012-07-07T15:08:18+00:00

Peu citée, peu commentée, la pratique de l'interprétation généreuse me paraît être une des rares pratiques fondamentales de l'agilité. Invitant à la pensée systémique et à l'action congruente, elle peut être considérée comme le moteur de l'adaptation continue.

Une formulation courante de l'interprétation généreuse est celle de la Directive Première des rétrospectives agiles : « Quel que soit ce que nous découvrons, nous devons comprendre et croire sincèrement que chacun a fait du mieux qu'il a pu, en fonction de ses connaissances d'alors, de ses compétences, des ressources disponibles et de la situation. »

Il existe aussi cet exercice difficile lorsque les émotions prennent le dessus : « Puis-je trouver trois interprétations généreuses de la situation ? »

Cette pratique a ces grandes vertus :

d'une part de se construire une représentation d'une situation dans laquelle le ressentiment et la culpabilité n'ont pas leur place,
d'autre part de mettre en lumière comment les actions des uns et des autres sont sur-déterminées de manière systémique.

Il s'agit donc de lever un brouillard d'émotions ou d'interprétations hâtives sur les événements pour essayer de n'en garder que des ressorts vertueux, et de communiquer ainsi sur une représentation à même d'être entendue le plus largement et de créer le consensus.

Il s'agit enfin de se poser la question de l'action, sur un terrain constructif.

C'est du pragmatisme, pas du bisounoursisme :)

Colin Garriga-Salaün: Agilité : désir et responsabilité

Colin Garriga-Salaün — 2012-07-07T15:07:52+00:00

Qualité logicielle et organisationnelle : des notions fuyantes

Innover suppose de sortir de la re-production, de la copie, pour imaginer et réaliser quelque chose de radicalement nouveau.

Mais le terrain est fuyant :

ce que l'on juge être de valeur évolue dans le temps et selon les événements,
décrire un résultat à produire est un exercice d'imagination et de communication difficile,
planifier efficacement suppose d'anticiper l'arrivée d'évènements inconnus.

Ainsi ni la qualité du logiciel, ni la qualité de l'organisation qui le produit ne sont évaluables a priori : il faut que le logiciel soit réalisé pour estimer sa valeur, et dans le même temps pour évaluer l'organisation qui l'a produit.

Stratégies légères

A ces difficultés les agilistes répondent en stratèges et se dotent d'heuristiques selon les situations. Communément, ils réalisent le logiciel petit à petit sous les yeux et dans les mains des utilisateurs, qui sont alors mis en situation d'évaluer ce qui est produit aussitôt que possible.

Les utilisateurs sont mis en situation de réactualiser leur désir, et les développeurs leur organisation.

Désir et responsabilité

Réactualisant à volonté leur organisation, les développeurs agiles deviennent des acteurs responsables et désirants. Désirants parce qu'ils évaluent leur organisation, en imaginent et mettent en oeuvre d'autres possibles. Responsables parce que leur organisation n'est plus choisie pour eux, mais choisie par eux.

Cette condition du développeur agile peut s'avérer nouvelle et déroutante : désirants et responsables, les développeurs peuvent éprouver soit un réel plaisir à mettre en oeuvre les organisations qu'ils imaginent, soit une grande frustration en cas d'empêchement.

Organisation désirante

La réussite d'une équipe de développement agile est donc fortement liée à la culture de son entreprise, et de ses réactions face à l'expression des désirs de ses membres, et de leurs propositions de ré-organisation.

Vous êtes peut-être un artisan logiciel, êtes-vous aussi un artisan de votre organisation et de ses objectifs ?

Colin Garriga-Salaün: Mur d'organisation agile

Colin Garriga-Salaün — 2012-07-07T15:07:14+00:00

Après quelques billets un peu abstraits, voici un sujet qui se voit et se manipule : le mur d'organisation de notre entreprise. Il est de conception très émergente, et les dimensions des fenêtres y sont sûrement pour beaucoup dans sa structure actuelle, mais il est aujourd'hui redoutablement efficace !

Il est composé de 4 zones principales qui sont de gauche à droite :

nos forces, nos pratiques, et nos métriques,
nos backlogs de produits,
notre champ de bataille de la semaine,
nos réalisations de la semaine.

Nous avons aussi deux zones intermédiaires :

entre les zones 2 et 3, lorsqu'on ne sait pas choisir entre une zone et l'autre, et que l'on veut en parler avec l'équipe,
entre les zones 3 et 4, pour indiquer les réalisations de la journée.

Zone 1 : nos forces, nos pratiques, et nos métriques

Nos forces, c'est ce dont nous sonmes fiers, c'est ce que nous avons construit jusque là, et sur quoi nous pouvons nous appuyer pour construire encore.

Nos pratiques, c'est l'ascèse à laquelle nous pensons devoir nous astreindre pour réussir, et ce que nous aimons faire ensemble. Par exemple, nous référençons le développement dirigé par les tests, les prises de décision par Decider, limiter les encours, simplifier, comprendre avant d'être compris, etc.

Nos métriques, c'est ce que nous choisissons de mesurer pour s'assurer de la santé de notre équipe. Par exemple, le nombre de décisions d'équipe par semaine, ou la trésorerie.

Zone 2 : nos backlogs de produits

Cette zone est organisée en lignes, une ligne par produit, et toutes les activités de l'entreprise y sont référencées. Certains de ces produits sont du logiciel pour des clients ou concernent des produits internes comme notre infrastructure de développement et de déploiement. D'autres de ces produits représentent des activités comme le marketing ou la gérance.

Nous utilisons un code couleur pour distinguer les fonctionnalités pour des clients (vert), des décompositions de fonctionnalités clientes ou des fonctionnalités à valeur interne (jaune), des bugs ou des dettes techniques (rose), et des idées hors norme (orange).

Vous remarquerez que cette zone est presque pleine, nous sommes limités en place. Ca nous force à faire des choix, c'est très sain.

Zone 3 : notre champ de bataille de la semaine

C'est ce que dans Scrum nous appellerions le backlog d'itération, s'il ne s'agissait du développement que d'un produit. En effet, si nous cherchons à séquentialiser nos développements pour des raisons d'efficacité, notre activité de la semaine est souvent mixée avec des activités commerciales par exemple. Dans la pratique, nous nous répartissons les rôles pour ne pas avoir à jongler entre plusieurs activités, mais nous restons co-responsables de la réussite globale.

Nous utilisons aussi des mini post-its orange pour indiquer une activité prioritaire, et des mini post-its jaune avec nos noms pour indiquer sur quoi nous travaillons en ce moment.

Nous organisons (et réorganisons à volonté) les post-its en nuage pour faire apparaître ce qu'on veut. Ce qui nous paraît faire sens. Des lots de fonctionnalités à réaliser dans un ordre stratégique par exemple. C'est très libre et ça dépend de la situation.

Zone 4 : nos réalisations de la semaine

Nous gardons le travail réalisé dans la semaine, anticipé ou non. C'est très utile pour notre rétrospective hebdomadaire par exemple. Et puis nous faisons table rase pour démarrer une nouvelle semaine.

Qu'en pensez-vous ? Comment faîtes-vous de votre côté ?

Colin Garriga-Salaün: Nietzsche, coach agile ?

Colin Garriga-Salaün — 2012-07-07T15:06:31+00:00

Au cours d'échanges autour de l'agilité, je me suis souvent pris à faire des rapprochements entre la conception des méthodes agiles et la philosophie nietzschéenne. Cette dernière propose une critique des valeurs pour l'avènement de valeurs joyeuses et créatrices, et montre comment cette critique a jusqu'à présent échoué face aux valeurs tristes et réactives.

Grâce à cet éclairage, je vous propose une re-lecture du manifeste agile et une typologie d'écueils dont pourrait pâtir l'agilité. J'espère que cela sera utile aux agilistes soucieux du devenir du mouvement.

La philosophie de Nietzsche, une affirmation de la volonté ^{1, 2, 3}

Selon Nietzsche, affirmation et négation ne sont pas de même nature. Une affirmation s'affirme elle-même, c'est un acte de volonté, d'auto-détermination. La négation est négation de quelque chose, d'une affirmation par exemple ou d'une autre négation.

Nietzsche affirme la volonté individuelle comme mouvement premier. Il lui oppose ce qu'il nomme les forces réactives -- ou nihilistes --, gouvernées par la peur. Il considère par exemple les valeurs de l'Église catholique comme réactives parce qu'elles conduisent à une vie coupable du péché originel et craintive du jugement de Dieu. Aussi Nietzsche propose-t-il de dépasser les notions de Bien et de Mal, ces notions qui paraissent venir d'ailleurs mais qui ne sont que sournoisement produites par la peur.

Ce dépassement que Nietzsche nomme la Transmutation des valeurs doit avoir quatre composantes :

L'affirmation du multiple et du devenir: C'est l'affirmation de la dynamique du monde, d'un monde ouvert et surprenant.
L'affirmation de l'affirmation: C'est la valorisation de l'affirmation, de l'expression de la volonté, des intentions, du désir.
L'Éternel retour: Pour juger la valeur des valeurs, pour les requalifier et déterminer si elles proviennent de forces actives ou réactives, Nietzsche pose la question : cette chose là, cette valeur, cette pratique, est-ce que j'en veux l'éternel retour ? c'est-à-dire pas pour une fois, pas par compromis, mais avec force :
« Est-ce que j'en veux l'éternel retour ? »
Le surhomme: C'est la figure de l'homme libérée de ses pulsions réactives, c'est l'homme actif et créateur.

Re-lecture du Manifeste Agile

Un manifeste est l'affirmation d'une volonté. Le Manifeste Agile affirme ses valeurs et repousse les valeurs qui leurs sont opposées, jugées nuisibles à la productivité :

« Nous valorisons les individus et leurs interactions plutôt que des processus et des outils »
« Nous valorisons le logiciel qui fonctionne plutôt qu'une documentation exhaustive ».

Le Manifeste Agile apparaît être aussi un transmutateur de valeurs nietzschéen

Affirmation du Multiple et du Devenir :

« Nous découvrons comment mieux développer des logiciels par la pratique et en aidant les autres à le faire. »
« Accueillez positivement les changements de besoins, même tard dans le projet. »
« Les meilleures architectures, spécifications et conceptions émergent d'équipes autoorganisées »
« À intervalles réguliers, l'équipe réfléchit aux moyens de devenir plus efficace, puis règle et modifie son comportement en conséquence. »

Les affirmations -- créations -- sont valorisées :

« Les processus Agiles exploitent le changement pour donner un avantage compétitif au client. »
« Livrez fréquemment un logiciel opérationnel avec des cycles de quelques semaines à quelques mois et une préférence pour les plus courts. »
« Réalisez les projets avec des personnes motivées. Fournissez-leur l’environnement et le soutien dont ils ont besoin et faites-leur confiance pour atteindre les objectifs fixés. »

L'Éternel Retour :

« Les processus Agiles encouragent un rythme de développement soutenable. Ensemble, les commanditaires, les développeurs et les utilisateurs devraient être capables de maintenir indéfiniment un rythme constant. »

Enfin, la figure agile du surhomme -- cette figure de l'homme purement actif -- se dessine dans la première phrase du texte :

« Nous découvrons comment mieux développer des logiciels par la pratique et en aidant les autres à le faire. »

Les écueils à la Transmutations des valeurs

Comme certains agilistes aujourd'hui, Nietzsche constate que la transmutation des valeurs ne se produit pas. De nouvelles valeurs réactives sont affirmées même si nous nous sommes débarrassés d'anciennes, et le mouvement créateur retombe sur lui-même. Nietzsche présente une typologie que je propose de réappliquer à l'agilité. Ces écueils sont dans cet ordre de progression² :

Le ressentiment: C'est accuser autrui de son échec. Ceux qui agissent agissent mal ! Les développeurs ne sont pas à la hauteur ! les managers ne comprennent rien ! les coachs ne sont pas assez pédagogues !
La mauvaise conscience: C'est s'accuser soi-même...
L'idéal ascétique: C'est l'écueil de l'agilité dogmatique. C'est sans doute cette préoccupation qui pousse Rachel Davies à écrire ce billet sur le Shu-Ha-Ri par exemple, craignant l'apparition d'agilistes sans esprit critique, valorisant toujours les processus et les outils d'avantage que les individus et leurs interactions.
La mort de Dieu: C'est le fait de vouloir prendre la place de Dieu après l'avoir tué. Par exemple, les chefs de projets ne sont plus directifs, mais les scrummasters sont certifiés. Les statuts et les places de pouvoir subsistent.
Le dernier homme, et l'homme qui veut périr: Le projet échoue, il est récupéré ; ce n'est pas cela que nous voulions en écrivant le manifeste agile ! Tout est vain, autant ne rien vouloir finalement... C'est ce que j'ai cru lire dans des articles sur l'état du mouvement agile. C'est ce qui m'a poussé à écrire ce billet.

Pour une agilité performante, joyeuse et féconde

Ces écueils sont humains, trop humains, c'est-à-dire réactifs. En lutte avec ces pulsions, il faudra sans doute reconnaître que l'agilité est un mouvement qui n'existera qu'à force de volonté, inlassablement ré-affirmée. Ce mouvement est condamné à évoluer et à se renouveler sans cesse, et on ignore de quoi il sera fait demain.

Pour paraphraser Pina Bausch⁴ : « Créez, créez, sinon tout est perdu ! » ou en repensant à la première phrase du manifeste agile et à la figure du surhomme qu'elle esquisse :

« Pratiquez, découvrez, partagez, sinon tout est perdu ! »

Sources :

Gilles Deleuze, Nietzsche et la Philosophie, puf, 1962
Gilles Deleuze, Nietzsche, puf, 1965
Nietzsche par Deleuze sur Wikipedia
Pina Bausch

Colin Garriga-Salaün: Un aquarium pour votre dojo extreme programming

Colin Garriga-Salaün — 2012-07-07T15:06:07+00:00

Après une courte pause, les dojos de programmation d'Okiwi ont repris cette année. Ils sont maintenant hébergés par Arpinum les seconds lundis du mois et chez Yaal les quatrièmes lundis. Nous étions donc lundi dernier dans les locaux de... l'Auberge Numérique... qui héberge Yaal. Vous suivez ? Pour en savoir plus sur ces dojos, voire vous joindre à nous la prochaine fois, vous pouvez vous

Bruno Voisin: Exemple de présentation en LaTeX

2012-07-01T10:07:00+00:00

J'ai déjà parlé de LaTeX dans un autre article où je présente un exemple de rapport de stage. LaTeX permet aussi de faire des présentations sous forme de diapositives, idéal pour une soutenance de stage. C'est ce que j'ai fait l'année dernière, alors je partage un modèle de présentation en LaTeX qui, je l'espère, servira à des étudiants. LaTeX est particulièrement utile dans les domaines scientifiques notamment pour les formules mathématiques et la coloration de code source.

J'ai utilisé le package Beamer avec son thème Warsaw pour créer cette présentation. Il y a d'autres packages LaTeX mais Beamer est un des meilleurs.

Les prérequis sont les mêmes que pour le rapport avec Ubuntu : installer installer les paquets texlive et texlive-lang-french.

Vous pouvez télécharger le rendu au format PDF et les sources LaTeX en cliquant respectivement sur les images ci-après.

Je rappelle rapidement l'utilisation dans un terminal. Commencez par télécharger les sources et les extraire.

wget http://blog.hikoweb.net/public/doc/slides-latex.zip
unzip slides-latex.zip
cd slides-latex/
chmod +x make.sh clean.sh

Ensuite, compilez et visionnez le rendu.

./make.sh           # générer le fichier PDF
evince slides.pdf & # ouvrir le fichier PDF
./clean.sh          # nettoyer les fichiers temporaires

Vous pouvez modifier cette présentation à votre goût. De nombreuse personnalisations sont possibles. Vous trouverez votre tout ce dont vous avez besoin sur Internet, par exemple sur Devoloppez.com ou sur Tuteurs.ens.fr.

Il est possible d'insérer du code source colorisé dans les diapositives à l'aide de Minted. Référez-vous à mon article sur le sujet. La procédure est la même sauf qu'il faut ici ajouter un paramètre à la frame comme ci-dessous.

\begin{frame}[containsverbatim]{Code colorisé avec Minted}
\begin{minted}[fontsize=\scriptsize]{python}
# le code source ici
\end{minted}
\end{frame}

Vous pouvez télécharger ci-dessous le même modèle de présentation avec une page supplémentaire contenant du code source colorisé.

Stéphane Blondon: Sélectionner des logs Subversion ou Mercurial selon une période de temps

2012-06-03T20:30:29+00:00

Supposons que l’on veuille retrouver les messages de commit selon une date de début et une date de fin. Selon le gestionnaire de version utilisé, les commande diffèrent légèrement.

Dans les exemple suivants, on souhaite récupérer la liste des commit réalisés entre le 20 et le 28 Mai 2012 inclus.

Subversion (SVN)

Voici la syntaxe à utiliser :

Version longue :
svn --revision {2012-05-20}:{2012-05-28} log
Version courte :
svn -r {2012-05-20}:{2012-05-28} log

Le résultat que l’on peut obtenir sur la sortie standard :

r3299 | bob | 2012-05-20 02:14:59 +0200 (dim. 20 mai 2012) | 1 ligne

possibilité de faire la somme de deux entiers
————————————————————————
r3300 | alice | 2012-05-21 12:24:22 +0200 (lun. 21 mai 2012) | 1 ligne

FIX: somme avec une retenue
————————————————————————
r3301 | bob | 2012-05-21 12:54:27 +0200 (lun. 21 mai 2012) | 1 ligne

somme avec des nombres à virgules deviennent possibles
————————————————————————
r3302 | bob | 2012-05-21 18:06:13 +0200 (lun. 21 mai 2012) | 1 ligne

refacto pour recette
————————————————————————
r3303 | bob | 2012-05-22 10:11:53 +0200 (mar. 22 mai 2012) | 1 ligne

le client veut des soustractions plutôt que des additions
————————————————————————
r3304 | alice | 2012-05-22 15:52:48 +0200 (mar. 22 mai 2012) | 1 ligne

FIX: problème de retenue lors de la soustraction
————————————————————————
r3305 | alice | 2012-05-23 17:16:10 +0200 (mer. 23 mai 2012) | 1 ligne

retouches graphiques selon préférences du client (coins arrondis et texte en #DDDDDD sur fond #EEEEEE)
————————————————————————

Si les deux dates sont inversées, l’ordre des commits est affiché dans l’autre sens.

Mercurial

Voici les commandes équivalentes avec Mercurial :

Version longue :
hg log --date "2012-05-20 to 2012-05-28"
Version courte :
hg log -d "2012-05-20 to 2012-05-28"

Le résultat sur la sortie standard est différent mais affiche globalement les mêmes informations :

changeset: 863:9282710bfded
parent: 856:36ecccd6d084
user: « Alice » <alice@example.com>
date: Mon May 28 22:07:05 2012 +0200
summary: Cloud de calculs hautes performances dispo par webservices

changeset: 862:48757838dcc3
user: « Bob » <bob@example.com>
date: Fri May 25 18:02:47 2012 +0200
summary: FIX: contournement calcul avec oneliner Perl

changeset: 861:556dcf3215e0
parent: 860:64a388d648ea
parent: 859:6a73cea460b3
user: « Alice » <alice@example.com>
date: Fri May 25 17:10:05 2012 +0200
summary: import libsoustraction

Contrairement à Subversion, la liste s’affiche du commit le plus récent au plus vieux. Avec cette syntaxe, il n’est pas possible d’afficher les données dans le sens chronologique (pas de résultat). Il est aussi possible d’ajouter les heures et minutes.
D’autres formats de date sont possibles, mais moins pratiques à mon avis (cf. man hg, section DATE FORMATS).

Versions utilisées

Client :
svn : version 1.6.17 (r1128011)
hg : version 2.2.1

Serveur :
svn : version 1.6.6 (r40053)
hg : version 1.4.3

ascendances

Stéphane Blondon: Nombre de paquets et délai de publication dans Debian

2012-04-05T10:44:04+00:00

Tout philosophe écologiste conviendrait aisément qu’il est plus difficile de bouger une baleine obèse qu’un canari chétif. Il en va des projets informatiques comme de mère Nature : plus la taille augmente et moins l’animal est véloce. Appliqué à une distribution Linux, le problème pourrait se résumer ainsi : plus le nombre de paquets est grand, plus les dépendances sont complexes et plus il y a des chances d’avoir des bugs. Cela provoque des délais de mise au point qui s’allongent. Pour les dernières publications de Debian, le délai entre deux verssions a été en moyenne de 2 ans mais il a grandement varié par le passé.

délai = f(paquets) ?

Voici le nombre de paquets et la temps passé entre la sortie et la sortie de la version suivante :

Buzz (1.1) : 474 paquets – 178 jours
Rex (1.2) : 848 paquets – 175 jours
Bo (1.3) : 414 paquets – 974 jours
Hamm (2.0) : 1.500 paquets – 228 jours
Slink (2.1) : 2.250 paquets – 502 jours
Potato (2.2) : 2.600 paquets – 703 jours
Woody (3.0) : 8.500 paquets – 1053 jours
Sarge (3.1) : 15.000 paquets – 671 jours
Etch (4.0) : 18.000 paquets – 679 jours
Lenny (5.0) : 28.000 paquets – 721 jours

Après le traumatisme de la douloureuse publication de Sarge (la durée de Woody est très importante parce qu’il a été difficile de sortir Sarge), ne pas faire trop durer la préparation des versions futures était dans toutes les têtes. Une image valant mille mots et économisant mon clavier, je vous invite à regarder ci-dessous.

Les croix rouges sont les premières publications (jusqu’à Woody incluse) ; les croix bleues sont Sarge, Etch et Lenny. Les courbes sont des estimations de régression pour chacun des deux ensembles.

Première période :

g(x) = 19,29 * sqrt(x * 0,45) - 113,34

Seconde période :

h(x)= 0,004 * x + 610

(En réalité, le logiciel ayant fait les calculs a ajouté plein d’autres chiffres après la virgule mais c’est probablement pour permettre au processeur de chauffer un peu plus. Ou pour tenter de m’impressionner.)

J’ignore si des résolutions officielles ont été prises après la publication de Sarge. En revanche, la volonté d’améliorer la communication entre des développeurs a été considérée comme une voie d’amélioration par plusieurs chefs de projet Debian successifs : par exemple, la volonté d’avoir des équipes pour maintenir des ensembles de logiciels plutôt qu’un personne seule, la facilitation des NMU. De même, certaines personnes a des postes clé ont été épaulées par d’autres développeurs Debian car c’était un goulot d’étranglement. À ma connaissance (qui est très parcellaire sur le sujet), les réponses se sont concentrées sur l’organisation humaine plutôt que sur les critères techniques, avec succès.

Sources

Le nombre de paquet et le calcul des durées de chaque version a été calculé à partir de l’historique de la distribution sauf pour Lenny. Le nombre de paquet étant absent de l’annonce lors de sa sortie, le nombre de paquets de Lenny a été récupéré en enregistrant la page listant l’ensemble des paquets de Lenny et un bon vieux grep "<dt><a href=" allpackages.htm |wc -l sur le fichier enregistré. Soit 28.057, arrondi à 28.000.

Les calculs de régression et la création du graphique ont été faites avec gnuplot (version 4.4 patchlevel 0, disponible dans testing actuellement) et le contenu des fichiers suivants :

Fichier de données pour la première période (debstat1.dat)

# stats Buzz à Woody
#nbre_paquets	délai_en_jours
474	178
848	175
974	414
1500	228
2250	502
2600	703
8500	1053

Fichier de données pour la seconde période (debstat2.dat)

# stats Sarge Etch Lenny
#nbre_paquets	délai_en_jours
15000	671
18000	679
28000	721

Script Gnuplot

set output "debian_relation_paquets_temps.png"

set xlabel 'Nombre de paquets'
set ylabel 'Délai de publication (en jours)'

g(x)=a*sqrt(x*b)+c
fit g(x) 'debstat1.dat' using 1:2 via a,b,c

h(x)=d*x+e
fit h(x) 'debstat2.dat' using 1:2 via d,e

plot "debstat1.dat" using 1:2 notitle, g(x) notitle, "debstat2.dat" using 1:2 notitle, h(x) notitle

Si certains sont intéressés par des informations supplémentaires sur les résultats de gnuplot (on ne sait jamais, il y a des malades partout) :

Pour la première fonction :
degrees of freedom (FIT_NDF) : 4
rms of residuals (FIT_STDFIT) = sqrt(WSSR/ndf) : 135.908
variance of residuals (reduced chisquare) = WSSR/ndf : 18470.9

Final set of parameters Asymptotic Standard Error
======================= ==========================

a = 19.294 +/- 1.858e+13 (9.629e+13%)
b = 0.453438 +/- 8.735e+11 (1.926e+14%)
c = -113.345 +/- 184.2 (162.5%)

Pour la seconde fonction :
final sum of squares of residuals : 7.61151
rel. change during last iteration : -2.9989e-14

degrees of freedom (FIT_NDF) : 1
rms of residuals (FIT_STDFIT) = sqrt(WSSR/ndf) : 2.7589
variance of residuals (reduced chisquare) = WSSR/ndf : 7.61151

Final set of parameters Asymptotic Standard Error
======================= ==========================

d = 0.00393525 +/- 0.0002866 (7.283%)
e = 610.317 +/- 6.041 (0.9899%)

ascendancesRelation entre le nombre de paquets et le délai entre deux publications

Stéphane Blondon: Comparatif grep, ack et grin

2012-02-17T14:55:57+00:00

Sur le ring, grep dominait et le public l’acclamait. Mais deux petits nouveaux, ack et grin, avaient enfilé leurs plus belles tenues de super-stars du catch pour lui ravir sa ceinture de champion et le cœur des développeurs. Vont-ils y arriver ? C’est ce que vous saurez en lisant cet article !

Parfois, un programmeur veut connaître l’ensemble des occurrences d’un symbole dans un programme (une variable, une classe, etc.). La solution la plus évidente est d’utiliser grep mais, pour peu qu’il y ait d’autres fichiers dans le répertoire du projet, de nombreux faux positifs vont apparaître, rendant le travail d’analyse fastidieux. Par exemple, s’il existe des copies créées automatiquement par un éditeur de texte, les fichiers des dépôts (.svn, .hg, fichier binaire, etc.). À Yaal, nous utilisons Python. Avec virtualenv, les fichiers de dépôt, les fichiers .pyc produits automatiquement, la documentation, etc. les résultats de grep sont plus ou moins truffés de faux positifs.

Il est bien évidemment possible d’exclure ce genre de fichier en multipliant les commandes (| grep -v a_exclure). Mais l’augmentation des lignes à éliminer rend la commande toujours moins pratique. Pour contourner cela, la suite logique est de transformer la commande en un script shell. Cependant, d’autres programmes comme ack et grin visent déjà à résoudre ce problème. L’objectif de cet article est de montrer quelques spécificités de chaque outil.

Les différents outils

Voici une présentation succincte des trois adversaires :

grep : l’outil Unix classique qui servira de référence ;
ack : outil écrit en Perl visant à faire des recherches, orienté pour des développeurs. Ce logiciel est disponible dans Debian et dérivées par l’intermédiaire du paquet ack-grep. La commande est aussi ack-grep. Le changement de nom est dû au fait qu’il existait déjà un paquet du nom de ack. Dans la suite de l’article, on mentionnera simplement ack ;
grin : outil écrit en Python ayant le même but que ack. Il n’est pas disponible dans Debian. Étant donné qu’il est disponible dans Pypi (les dépôts de paquets Python, équivalant au CPAN de Perl), grin peut être installé avec pip install grin. Le paquet python-pip doit être préalablement installé. Puisqu’il n’y a pas de page de manuel, la documentation à utiliser est celle de grin --help et la page de documentation sur le dépôt Python.

Que le match commence !

Usage

Recherche dans un fichier

grep MOTIF FICHIER
ack-grep MOTIF FICHIER
grin MOTIF FICHIER

Dans chaque cas, MOTIF peut être une expression rationnelle (par exemple [fF]év vaut fév ou Fév).

Voici un exemple de résultats que l’on peut obtenir :

stephane@foehn:~/src/strdatetime$ grep [Ff]év translation.py
u"janv", u"févr", u"mars",
u"janvier", u"février", u"mars",
u"Janvier", u"Février", u"Mars",
stephane@foehn:~/src/strdatetime$ ack-grep [Ff]év translation.py
u"janv", u"févr", u"mars",
u"janvier", u"février", u"mars",
u"Janvier", u"Février", u"Mars",
stephane@foehn:~/src/strdatetime$ grin [Ff]év translation.py
translation.py:
   19 : u"janv", u"févr", u"mars",
   26 : u"janvier", u"février", u"mars",
   30 : u"Janvier", u"Février", u"Mars",

La sortie de grep et d’ack sont identiques, alors que grin fournit le nom du fichier et le numéro de lignes.

Recherche récursive

La plupart du temps, l’objectif est de chercher dans tout une arborescence de répertoire. C’est le fonctionnement par défaut pour ack et grin.

grep -r MOTIF . #ou rgrep
ack-grep MOTIF
grin MOTIF

La sortie produite par grep et ack évolue pour ajouter le nom du fichier et les lignes. grep met tout sur une ligne alors qu’ack a une sortie identique à celle de grin. grin produit une sortie toujours structurée de la même manière (cf. l’exemple du paragraphe précédent).

Alors que la différence de vitesse lors de l’analyse d’un seul fichier ne se sent pas, elle devient sensible lors d’une recherche récursive. Quelques tests rapides (et sans prétention d’exhaustivité ou de représentativité) donnent des résultats bien plus lents pour ack et grin.

grep : 0,3 s
ack-grep : 1,7 s
grin : 2,8 s

Cependant, ajouter des tubes pour exclure des résultats obtenus avec grep dans le but d’éliminer des résultats (et donc arriver à un résultat comparable avec ce qui est obtenu avec ack ou grin) augmentera le temps passé et donc réduira l’écart avec les deux autres outils.

Recherche insensible à la casse

grep -i MOTIF FICHIER
ack-grep -i MOTIF FICHIER
grin -i MOTIF FICHIER

Même syntaxe que dans les cas précédents, juste l’option -i en plus. Aucune surprise ici. Pas la peine d’en rajouter. Passez au paragraphe suivant. Faut-il vraiment que j’arrête d’écrire ce paragraphe pour vous arrêtiez de le lire ?!

Recherche en ignorant certains types de fichiers

Cette fonctionnalité est très utile pour ne pas chercher dans des fichiers sans intérêt :

grep -r --exclude=*.sh  --exclude=*.h "interpreted as " .
ack-grep --type=nohh --type=noshell  "interpreted as "
grin --skip-exts .h,.sh  "interpreted as "

Ici, on exclut les fichiers d’en-tête de code C (*.h) et les scripts shell (*.sh). grep et grin recherchent directement une correspondance de motif alors qu’ack permet des exclusions de types ou d’extension. Les types sont basés sur les noms d’extension de fichiers (avec la correspondance de motif). Par exemple, le type shell correspond à .sh, .bash, .csh, .tcsh, .ksh et .zsh. La définition d’un type de fichier est conçu pour être facilement extensible.

Par défaut, ack et grin exclut les répertoires et les fichiers sans intérêt. L’option d’exclusion permet d’en ajouter de nouveaux. La liste des fichiers exclus par défaut n’est pas identique entre ack et grin donc les résultats peuvent différer un peu. Par exemple, c’est le cas des fichiers .texi, exclus par ack, mais pas par grin.

Recherche en ignorant certains répertoires

grep -r --exclude-dir DIR1 --exclude-dir DIR2 MOTIF .
ack-grep --ignore-dir DIR1 --ignore-dir DIR2  MOTIF
grin --skip-dirs DIR1,DIR2 MOTIF

Ces commandes permettent d’exclure DIR1 et DIR2 de la recherche. grin ajoute les répertoires enlevés à la liste des répertoires qu’il exclut automatiquement.

Ajout des lignes de contexte

Les options sont toutes identiques et ont le même comportement.

-A, --after-context 
-B, --before-context
-C, --context  #avant et après

Comme à chaque fois, grin affichage systématiquement le numéro des lignes.

Affichage limité aux fichiers correspondants

grep -r -l MOTIF.
ack-grep -l MOTIF
grin -l MOTIF

C’est donc l’option -l ou --files-with-matches à chaque fois.

Affichage limité aux fichiers non correspondants

grep -r -L MOTIF .
ack-grep -L MOTIF  # = -l -v
#rien pour grin !

L’option -L (ou --files-without-matches) permet de n’afficher que les fichiers sans l’occurence MOTIF pour grep et ack. grin a bien une option de ce nom mais son comportement est complètement différent. L’aide de la commmande signale que ce paramètre permet d’afficher le nom du fichier avec la correspondance. Ce qui est le comportement par défaut. Je ne comprend pas l’intérêt de cette option, trompeuse de surcroît.

Inversion de la sélection

grep -v MOTIF FICHIER
ack-grep -v  MOTIF FICHIER
#rien pour grin !

Pas d’option équivalente à -v pour grin. Rien ! Nada ! Zéro ! Que dalle ! ∅ !

Intégration avec un éditeur

ack dispose d’un paramètre --column pour qu’un éditeur de texte se place directement sur la première occurence.

La documentation d’ack précise que l’outil est intégrable avec Vim, Emacs et TextMate. Je n’ai testé aucune de ces possibilités.

grin dispose d’un paramètre --emacs qui affiche le nom du fichier, le numéro de la ligne et son contenu sur la même ligne pour faciliter l’analyse « par exemple avec emacs » :

stephane@foehn:~/src/strdatetime$ grin Fév
./tests.py:
  122 :         d_fr = strdatetime.strdatetime(u"Févr", "%b", lang="fr")
  136 :         d_fr = strdatetime.strdate(u"Févr", "%b", lang="fr")
./translation.py:
   30 : u"Janvier", u"Février", u"Mars",
stephane@foehn:~/src/strdatetime$ grin --emacs Fév
./tests.py:122:         d_fr = strdatetime.strdatetime(u"Févr", "%b", lang="fr")
./tests.py:136:         d_fr = strdatetime.strdate(u"Févr", "%b", lang="fr")
./translation.py:30: u"Janvier", u"Février", u"Mars",

Je suis très dubitatif sur le choix de nommage des options dans grin mais cette option me semble vraiment intéressante.

Configuration

Il est possible d’enregistrer des préférences pour qu’elles soient utilisées à chaque fois.

grep est le plus limité. Si l’utilisateur enregistre un fichier FICHIER avec tous les motifs de noms de fichier (possibilité d’utiliser les caractères jokers de l’interprète de commande) qu’il veut exclure, il peut les faire prendre en compte en utilisant --exclude-from=FICHIER. C’est limité mais cette fonctionnalité reste probablement sous-exploitée.

ack prend en compte un fichier de configuration .ackrc dans lequel on peut ajouter les options à lancer systématiquement. Simple et efficace. Certains paramètres sont aussi accessibles grâce à des variables d’environnement.

grin utilise une variable d’environnement $GRIN_ARGS. Elle doit valoir une chaîne de caractère qui inclut les paramètres à ajouter par défaut. Fonctionnel mais moins élégant que le fichier de configuration d’ack.

Conclusion

Pour une utilisation dans le cadre de développement logiciel, ack me semble le plus adapté. Par contre, le fait qu’il n’affiche pas toutes les informations sur la même ligne empêche sa sortie d’être réutilisable facilement. grin me semble moins bon mais évite cet écueil (avec --emacs) et affiche toujours les lignes, ce qui peut s’avérer assez pratique.

grep est plus généraliste et possède plus d’options. Il reste donc indispensable et a l’avantage d’être toujours disponible sur le système, ce qui n’est pas le cas des deux autres.

Je n’ai fait qu’aborder les fonctionnalités qui me semblaient les plus courantes, chacun en possède d’autres et sont à portée de man. Explorez-les !

Versions utilisées :
grep (GNU grep) 2.10
ack-grep 1.92
grin 1.2.1

ascendances

Bruno Voisin: Piwik un analyseur web libre

2012-02-12T18:30:00+00:00

Piwik est une alternative libre à Google Analytics en PHP/MySQL qui s'installe sur votre espace web. Je l'ai installé il y a une semaine et je le trouve très simple d'utilisation et complet. Constatez le par vous-même avec cette démonstration en ligne.

Rendez-vous sur le site officiel de Piwik pour lire une description du logiciel et pour le télécharger. Pour l'installer, rien de plus simple, uploadez le par FTP, accédez y via votre navigateur et laissez vous guider.

Il ne reste plus qu'à ajouter un bout de code qui recueillera sur votre site toutes les informations. Ce code vous est fournis à l'ajout de votre site sur Piwik. Il existe des plugins pour de nombreux CMS et des frameworks dans quelques langages.

Contrairement à Google Analytics, vous être sûr que vos données sont utilisées que par vous même.

Bruno Voisin: Colorer du code source dans un rapport LaTeX avec Minted

2012-02-05T13:57:00+00:00

Suite à mon exemple de rapport LaTeX, je vous présente Minted qui permet de colorer du code source dans vos rapports LaTeX. Il supporte de nombreux langages.

Installation

Pour pouvoir utiliser Minted il vous faut quelques prés-requis. Suivez les instructions suivantes pour les installer sous Ubuntu dans un terminal.

Il vous faut le paquet LaTeX ifplatform disponible dans le paquet Ubuntu (ou plutôt Debian) texlive-latex-extra.

sudo apt-get install texlive-latex-extra

Vous avez besoin également de Pygments qui est une bibliothèque de coloration syntaxique de code source et écrite en Python. Pour l'installer utilisez easy_install disponible dans le paquet python-setuptools.

sudo apt-get install python-setuptools
sudo easy_install Pygments

Il ne reste plus qu'à télécharger le fichier minted.sty sur cette page et le placer dans le répertoire où se situ le code LaTeX de votre rapport.

Utilisation

Dans vos source LaTeX, importez le package Minted.

\usepackage{minted}

Ensuite insérez votre code source de la manière suivante.

\begin{minted}[linenos=true,fontsize=\scriptsize]{java}
  votre code source ici
\end{minted}

Ici le langage coloré est Java mais vous pouvez le remplacer par la valeur de votre choix (html, php, python, etc).

La compilation LaTeX doit se faire avec l'option -shell-escape.

pdflatex -shell-escape mydocument.tex

Exemples

Vous pouvez télécharger un exemple que j'ai créé à partir de celui de mon billet précédant. Voici en image respectivement le rendu d'un code Python (extrait de Pygments) et d'un code Java (extrait de JUnit).

Stéphane Blondon: Carte heuristique de commandes unix

2012-01-16T23:06:24+00:00

Voici une carte heuristique (mind map en anglais) de commandes unix.

Évidemment, la carte est loin d’être exhaustive (il n’existe pas d’écran assez grand pour toutes les afficher en même temps). Il s’agit plutôt d’une tentative pour représenter les outils disponibles en partant du besoin de l’utilisateur plutôt que des outils eux-mêmes : il est facile de consulter une page de manuel si l’on sait quelle page consulter. La commande apropos et le web permettent en général de trouver quelle commande utiliser mais cela reste parfois difficile lorsque l’on ne sait pas définir exactement son problème.

Lorsqu’il y a plusieurs commandes sur le même noeud, cela signifie qu’elles peuvent être utilisées dans le même but mais selon les préférences, les habitudes ou leur disponibilité (si elles sont installées ou non sur le système), on pourra préférer l’une ou l’autre d’entre elles. Par exemple, à titre personnel, j’apprécie most comme lecteur de fichier, entre autres pour la coloration des pages de manuel, mais le paquet n’est pas installé par défaut sous Debian et dérivées. Dans ce cas-là, less est la solution. Je ne cite pas more, réservé aux fans de masochisme hardcore. Autant utiliser cat, il y a un caractère de moins à taper.

Parfois des paramètres sont ajoutées à la commande car ils sont nécessaires pour l’obtention du résultat attendu. Pour autant, l’utilisateur ne devrait pas faire l’économie de regarder les autres options s’il désire un résultat un peu différent.

La plupart des outils cités sont très connus. À part peut-être cal (inclus dans le paquet bsdmainutils dans Debian), concalc (paquet concalc), fold (inclus dans le paquet coreutils) ou tree (paquet tree) ?

Rappelons que la puissance du shell ne se résume à des outils mais bien dans leur combinaison. Si elle ne suffit pas, rien n’empêche d’utiliser un langage de script de plus haut niveau (Perl, Python, Ruby, etc.).

Sources

Carte réalisée avec Freeplane v.1.1.3.
D’autres logiciels existent :

Freemind, Vym (directement dans Debian) ;
xmind, labyrinth, etc. (non packagés).

Le fichier source .mm est disponible ici.

D’autres personnes ont déjà réalisés des cartes heuristiques comme ici ou là.

http://screenshots.debian.net est un site regroupant des captures d’écran de logiciels en actions qui sont disponibles comme paquet dans Debian. L’envoi de captures d’écran de paquets pour compléter le site est ouvert à tous. Les captures sont aussi réutilisées ailleurs, par exemple dans synaptic.

ascendancesCarte heuristique de commandes Unix

Stéphane Blondon: Supprimer des lignes identiques réparties dans un fichier

2011-12-20T23:11:06+00:00

Jules et Vincent doivent fournir un fichier texte en supprimant les lignes qui sont plusieurs fois dans le fichier, mais réparties de manière quelconque dans le fichier (par exemple un fichier journal ou une liste de nombres aléatoires). Alors qu’ils descendent de la voiture pour aller sur le lieu de leur mission, ils en discutent nonchalamment :
– Il nous faudrait des outils Unix pour ces affaires-là.
– Y’a combien de lignes ?
– 1.200
– En comptant les doublons ?
– Oui.
– Faudrait des outils Unix…

Après un moment de réflexion plus ou moins court (selon votre taux de caféine), comme eux, vous vous dites que cela ne devrait vous prendre que quelques secondes, le temps de dégainer un terminal et de taper une commande Unix adéquate…

Solutions basées sur le shell

uniq est un outil shell permettant de supprimer des lignes répétées. Voilà qui semble parfait pour ce genre d’affaire. Malheureusement, en lisant un peu plus la page de man, on apprend qu’uniq filtre « les lignes successives identiques ». La page de man propose un contournement en utilisant sort. Avec un fichier de log, cela peut être plus ou moins utilisable en triant d’abord par la chaîne de log puis par la date. En revanche, cela ne peut pas vraiment résoudre le problème de valeurs aléatoires. En revanche, il est possible de combiner plusieurs outils Unix en utilisant un compteur de ligne, qui sera supprimé ensuite.

Soit un fichier nommé pulp.txt et contenant les données suivantes :

1994-10-26
cheese
1994-10-26
1994-10-26
tarte
myrtille
1994-10-26
chalumeau
1994-10-26
1994-10-26
verset
massage

Commençons par ajouter un compteur de ligne :

$ nl pulp.txt
     1	1994-10-26
     2	cheese
     3	1994-10-26
     4	1994-10-26
     5	tarte
     6	myrtille
     7	1994-10-26
     8	chalumeau
     9	1994-10-26
    10	1994-10-26
    11	verset

Puis on trie en fonction des données préalablement fournies, tout en éliminant des chaînes en doubles en même temps :

$ nl pulp.txt | sort --key 2 --unique 
     1	1994-10-26
     8	chalumeau
     2	cheese
     6	myrtille
     5	tarte
    11	verset

On réordonne selon l’ordre précédent :

$ nl pulp.txt | sort --key 2 --unique | sort --key 1 --numeric-sort
     1	1994-10-26
     2	cheese
     5	tarte
     6	myrtille
     8	chalumeau
    11	verset

Pour finir, on supprime la numérotation :

$ nl pulp.txt | sort --key 2 --unique | sort --key 1 --numeric-sort | cut --fields 2
1994-10-26
cheese
tarte
myrtille
chalumeau
verset

Le problème est alors résolu, mais et la mise au point aura probablement pris plus de temps que prévu (selon votre taux d’alcoolémie) :

nl pulp.txt | sort –key 2 –unique | sort –key 1 –numeric-sort | cut –fields 2

Cependant cette succession de commande ne sera directement réutilisable dès que la structure des chaînes variera (même un tout petit peu).

Il est regrettable qu’il y ait pas une option permettant de filtrer l’ensemble des lignes par uniq. Si jamais vous êtes en train de faire une overdose de shell, demandez à votre voisin de vous faire une piqûre d’adrénaline. (Attention, ça ne fonctionne pas à chaque fois.) Le mainteneur d’uniq refuse l’ajout d’une telle fonctionalité à cause de l’augmentation de la complexité que cela provoquerait. Par contre, des solutions bien plus compactes de contournement ont été proposées sur la liste de diffusion de coreutils.

One-liners

On se repoudre le nez et on y retourne !

Les premières solutions ont été à base de Perl :

perl -lne ‘print $_ if ! defined $a{$_}; $a{$_}=$_;’

perl -MDigest::MD5=md5 -lne ‘$m=md5($_); print $_ if ! defined $a{$m}; $a{$m}=1′

$_ représente la ligne en cours de traitement ; elle est affichée si ce n’est pas une clef d’un tableau associatif puis on ajoute la chaîne comme clef. La seconde version reprend ce même principe en utilisant une signature md5. Perl est vraiment adapté à l’écriture de code d’une ligne : c’est compact et illisible. Ce qui est tout de même un grand principe de Perl : « il y a plus d’une façon de le faire », mais on choisira toujours la plus incompréhensible.

Puis une solution en awk a été proposée :

awk ‘!a[$0]++’

La ligne traitée est $0 ; la valeur d’un tableau a ayant pour clé la ligne en cours de traitement est incrémentée. Si c’est la deuxième fois qu’elle est rencontrée, la valeur sera non nulle. Le ! inverse le résultat qui sera donc évalué à faux (la chaîne est déjà présente).

Ces solutions résolvent le problème, de manière plus souple que la suite de commandes précédentes. Par contre, elles ne résolvent pas le problème de complexité. Comme cela est réalisé par un interpréteur plutôt que du code C compilé (pour uniq), il est quasi-certain que la consommation mémoire est plus importante et que la vitesse d’exécution est plus lente… Je ne pense pas que ce soit un problème mais la réponse est pire que le contre-argument de ne pas le réaliser via uniq.
Pour autant, cela ne m’a pas apparu nécessaire de tenter de convaincre à nouveau le mainteneur. C’est comme masser les pieds de la femme du parrain de la pègre locale. Vous le feriez, vous ? Moi non plus.

Mise en place d’un alias

Pour garder le filtre à disposition, il est possible d’en faire un alias. Pour cela, il suffit de copier la ligne suivante in ~/.bash_aliases (si ce fichier est activé dans ~/.bashrc) :

alias uniqall=’awk ‘”‘”‘! a[$0]++’”‘”

Alors qu’ils sont sur la route du retour, Vincent a les mains sur le clavier et un cahot de son fauteuil à roulette fait partir d’un coup une série de caractères supplémentaires !
Vincent : Oh putain le con j’ai ajouté plein d’apostrophes et de guillemets !
Jules : Mais pourquoi t’as fait ça putain ?
Vincent : Mais parce qu’il le fallait, c’est pas un accident !

En effet, Vincent était obligé : la commande awk ou perl fonctionne très bien seule mais elle ne peut pas être insérée directement comme alias. En effet, il faut transformer la commande en chaîne de caractère pour l’insérer dans le fichier .bash_aliases, donc mettre des apostrophes autour de la commande. Or, il y a déjà des apostrophes à l’intérieur de la commande (interpréteur 'code'). On aurait donc des apostrophes incluses entre d’autres apostrophes et le shell interprèterait la seconde apostrophe comme la fin de la première chaîne. Quelques solutions semblent évidentes :

Protéger les apostrophes intérieures avec un antislash (\') ;
Remplacer les apostrophes intérieures par des guillemets ;
Remplacer les apostrophes extérieures par des guillemets.

Ces différentes stratégies vont d’un fonctionnement incorrect (il ne retourne que la première ligne du flux) à une erreur lors de l’ajout de l’alias.

Explication du ‘”‘”‘

La ruse est de découper la commande en plusieurs sous-chaînes qui seront concaténées automatiquement par le shell.

Il est tout à fait possible de mettre des espaces à l’intérieur des chaînes mais pas entre elles. Sinon le shell les interprétera comme des mots différents et ne les concatènera pas.

Générique de fin

Merci aux participants de liste de diffusion bug-coreutils qui ont été très réactifs : Pádraig Brady, Jim Meyering et Bob Proulx (le rapport de bug, début de la discussion).

Merci à Arthur et Colin qui m’ont suggéré d’en faire un article. (Ils ne pensaient pas que j’allais vous faire subir un article de plus de 50 tweets de longueur…)

Les discussions de Vincent et de Jules sont des références à Pulp Fiction. (liste non exhaustive)

Le shell utilisé est bash, version 4.2.20. L’interpréteur Awk est mawk, version 1.3.3.

Aucun compilateur n’a été maltraité durant l’écriture de cet article, ni lors de la mise au point de l’alias final.

ascendancesConcaténation de chaînes avec des guillemets et des apostrophes

Bruno Voisin: Exemple de rapport en LaTeX

2011-11-20T15:44:00+00:00

Il y a presque deux mois j'ai rédigé mon rapport de stage en LaTeX. Si vous ne connaissez pas LaTeX, direction Wikipédia. Je propose dans ce billet uniquement un modèle de rapport qui pourras servir à des étudiants d'informatique (ou autres).

Avant tout, je partage un tutoriel qui m'a bien servi : Tutoriel LaTeX.

Pour pouvoir compiler des fichiers LaTeX sur Ubuntu, il faut d'abord installer les paquets texlive et texlive-lang-french.

sudo apt-get install texlive texlive-lang-french

Il existe certainement un plugin LaTeX pour votre éditeur de texte préféré. Pour gedit installez gedit-latex-plugin, pour vim installez vim-latexsuite et pour emacs installez auctex.

Voici ci dessous le rendu au format PDF du rapport exemple et les fichiers sources LaTeX.

La page titre est très fortement inspiré de celle décrite sur WikiBooks.

Décompressez les sources et vous y trouverez des fichiers textes dont l’extension est .tex. Ce sont ses fichiers qu'il faut éditer. Il faut donner les droits d'exécution aux exécutables.

unzip sample_report.zip
cd sample_report/
chmod +x make.sh clean.sh  # si besoin

Ensuite, vous pouvez compiler et supprimer les fichiers temporaires très simplement.

./make.sh            # générer le fichier PDF
evince rapport.pdf & # ouvrir le fichier PDF
./clean.sh           # nettoyer

Si vous voulez insérer du code source dans votre rapport, lisez mon billet suivant.

Colin Garriga-Salaün: Le vivant post-génomique ou Qu'est-ce que l'auto-organisation ?

Colin Garriga-Salaün — 2011-10-11T11:02:36+00:00

Le journal des Nouveaux Chemins de la Connaissance d'aujourd'hui sur France Culture donne la parole à Henri Atlan, auteur d'un livre à mi-chemin entre sciences et philosophie à propos de l'autoorganisation¹.

Il revient sur une expérience de neurologie qui montre le caractère illusoire des prises de décisions à court terme et non planifiées. Ce sera sans doute ma prochaine lecture. Il me donne du courage pour poursuivre mon exploration de la question de l'autoorganisation telle que je l'avais commencée.

Vous pouvez l'entendre à partir de la 51^e minute du podcast de l'émission.

Henri Atlan, Le vivant post-génomique ou Qu'est-ce que l'auto-organisation ?, Odile Jacob, 2011

Bruno Voisin: Script d'installation de vos applications

2011-04-24T11:11:00+00:00

La sortie d'une nouvelle version d'Ubuntu approche. Après la réinstallation de votre système vous aimerez retrouver facilement les applications que vous utilisez régulièrement. C'est simple, il suffit de se faire un petit script shell qui installe tout ce dont vous avez besoin. On tape une commande, on va faire un tour dehors parce qu'il fait beau et quand on rentre c'est fini.

J'entends déjà certains me dire qu'il y a aussi la mise à niveau qui permet de tout conserver. Mais étant un bidouilleur, j'aime bien retrouver un système propre de temps en temps. C'est comme un nettoyage de printemps qui arrive deux fois pas an.

Attention, une mauvaise utilisation de scripts ou de commandes avec les droits administrateur (sudo) peut endommager la stabilité du système. Soyez sûr de ce que vous faites. De plus, le script suivant installe des dépôts de logiciels non officiels, ce qui est également potentiellement dangereux.

Après les avertissements, assurez vous d'avoir les quelques connaissances techniques nécessaires. Vous devez savoir ce qu'est un terminal puisque le script sera lancé dans ce dernier. Vous devez avoir bien compris la commande apt-get et sudo.

Vous pouvez télécharger mon script en cliquant ici. C'est une nouvelle version de mon dernier script publié. Vous êtes libre de l'adapter à vos besoins.

Avant de l'exécuter, lisez le et modifiez le à votre convenance. Les lignes commençant par le caractère dièse (#) sont ignorées. Il faut rendre le script exécutable avec la commande chmod comme ci-dessous ou graphiquement avec un clic droit sur le fichier > Propriétés > Permissions > cochez Exécution (mais c'est plus long...).

cd repertoire/ou-se-trouve/le-script
chmod u+x postinstall.sh

Maintenant vous pouvez l'exécuter avec les droits administrateur après l'installation du système comme ceci :

sudo ./postinstall.sh

Votre mot de passe vous sera demandé. Le script vérifie s'il possède les droits nécessaires. Une confirmation est demandée avant de lancer l'installation des paquets.

Vous pouvez également faciliter l'installation d'Ubuntu en utilisant une clé USB et conserver vos données et paramètres utilisateur en partitionnant votre disque dur.

Mise à jour du 29/04/2011 :

J'ai remplacé la version 3.2 de VirtualBox par la 4.0.
J'ai ajouté une version anglaise de ce script.
Download this script installation package in English

Mise à jour du 11/05/2011 :

Correction du script après expérimentation.

Le blog de Yaal

Bruno Voisin: La quête d'un nouveau lecteur de flux

Selfoss

Stéphane Blondon: Évolution du nombre de messages sur debian-l10n-fr et debian-users-fr avec pychart

Le graphique

Réalisation

Invention de la poubelle (1884)

Création de postscript (1982)

Invention de la télévision couleur (1938)

Invention de l’écriture de travers (-3400)

Invention du dessin (Paléolithique)

Invention du papier (IIième siècle avant JC)

Code source et références

Stéphane Blondon: Cohabitation Jinja et AngularJS

Diviser les fichiers pour régner

Commenter les accolades

Changer les délimiteurs Jinja

Colin Garriga-Salaün: AgileFrBot, propulsé par rss2reddit !

Colin Garriga-Salaün: Agile Tour Bordeaux 2012

Stéphane Blondon: Se connecter et connaître les schémas de tables MySQL, PostgreSQL ou SQLite

Entrée des artistes : se connecter au serveur

Voir les bases de données disponibles

Choisir la base de données à utiliser

Lister les tables de la base

Voir le schéma d’une table

Aide en ligne

Le salut des artistes

Stéphane Blondon: Déterminer quelle est la meilleure distribution grâce à Python et PIL

Prérequis : installer PIL (ou Pillow)

Créer une carte

Textes dans un cartouche

Le logo de la distribution

Le numéro de la carte

Code source et ressources

Aurélien Biedermann: Retour sur le TEDxBordeaux 2012

Stéphane Blondon: HMAC Paybox en Python

Stéphane Blondon: Processus de traduction au sein de debian-l10n-fr

Les étapes de traduction et relecture

Article [done]

Colin Garriga-Salaün: « Livrez fréquemment un logiciel opérationnel... » 1

Stéphane Blondon: États des paquets Debian chez les utilisateurs (selon PopCon) – 2

Sans paquet non officiel

Sans les bibliothèques

Sources

Stéphane Blondon: États des paquets Debian chez les utilisateurs (selon PopCon)

Résultat sur un échantillon (15 paquets)

Limites

Ignorer l’état No Files

Proportion de l’état No Files

Cas des logiciels séparés en plusieurs paquets

Résultat sur l’ensemble des paquets

Sources

Colin Garriga-Salaün: Hop ! Une bouteille à la mer...

Colin Garriga-Salaün: Coding Dojo Extreme Programming bordelais

Colin Garriga-Salaün: Promouvoir le changement dans son entreprise

Colin Garriga-Salaün: Qu'est-ce qu'une décision de groupe ?

Colin Garriga-Salaün: Course de relais et performance d'équipe

Colin Garriga-Salaün: Interprétation généreuse

Colin Garriga-Salaün: Agilité : désir et responsabilité

Qualité logicielle et organisationnelle : des notions fuyantes

Stratégies légères

Désir et responsabilité

Organisation désirante

Colin Garriga-Salaün: Mur d'organisation agile

Zone 1 : nos forces, nos pratiques, et nos métriques

Zone 2 : nos backlogs de produits

Zone 3 : notre champ de bataille de la semaine

Zone 4 : nos réalisations de la semaine

Colin Garriga-Salaün: Nietzsche, coach agile ?

La philosophie de Nietzsche, une affirmation de la volonté 1, 2, 3

Re-lecture du Manifeste Agile

Les écueils à la Transmutations des valeurs

Pour une agilité performante, joyeuse et féconde

Colin Garriga-Salaün: Un aquarium pour votre dojo extreme programming

Bruno Voisin: Exemple de présentation en LaTeX

Stéphane Blondon: Sélectionner des logs Subversion ou Mercurial selon une période de temps

Subversion (SVN)

Mercurial

Versions utilisées

Stéphane Blondon: Nombre de paquets et délai de publication dans Debian

La philosophie de Nietzsche, une affirmation de la volonté ^{1, 2, 3}