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.

• http://lists.debian.org/debian-l10n-french/
• http://lists.debian.org/debian-user-french/

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.

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…

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;
}

• 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.

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 :

1. « Vote » : paquet récemment utilisé
2. « Old » : paquet qui n’a pas été utilisé depuis longtemps
3. « Recent » : paquet récemment mis à jour
4. « 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()