l faut avouer que si je suis sensibilisé aux problèmes d’accessibilité sur le web et que j’ai adopté les règles simples sur ce sujet, je fais « trop » souvent l’impasse sur cette problématique quand il s’agit d’intégrer l’interface d’une application web. En effet, si rendre une simple page web accessible relève surtout de la bonne pratique, sa se complique assez vite lors qu’on se retrouve dans une interface riche et bien qu’il existe des parades elles ont comme effets, au mieux, de rallonger le temps de développement, au pire de le compliquer grandement.

Pour parer à ce problème, il existe une spécification, la WAI-ARIA (Web Accessibility Initiative – Accessible Rich Interactive Applications). Cette spécification permet à une page web (ou à une partie de celle-ci) d’être considéré comme une application en ajoutant aux éléments des rôles, propriétés ou états.

Cette spécification est supportée par Opera 9.5+ et Firefox 1.5+ et le sera dans IE8. Quant à Webkit (Safari, Google Chrome) l’implémentation est en cours. L’adoption de ARIA se fait également largement dans les technologies d’assistances.

Pour plus d’information sur le sujet je vous conseil de lire la traduction d’un article Gez Lemon publié à l’origine sur Dev Opera. Merci à Tristan Nitot pour l’info.

Après la migration de Ruby on Rails depuis Subversion vers Git, un grand nombre de plugins ont suivi ce chemin (y compris Globalize dont la migration est aussi effective). Si, dans un premier temps, je n’étais pas très chaud pour utiliser ce gestionnaire de source, l’ouverture de GitHub et un petit peu de pratique m’ont fait réviser mon jugement (sans oublier le fait qu’il y a maintenant une solution facile d’installation sous Windows). Je ne vais pas débattre du choix de Git plutôt que Mercurial ou un autre gestionnaire de la même famille, ni du bien fondé d’abandonner Subversion. Un mouvement est initié dans la communauté Rails, ce n’est sûrement pas un hasard, alors essayons d’en comprendre les avantages et d’en profiter s’ils nous conviennent.

Avant d’entrer dans le vif du sujet, je rappelle que je découvre Git actuellement, et que cet article peut contenir des imprécisions, voir quelques âneries (ne pas hésiter à me les signaler). Cependant, il ne contient aucun Troll, ce n’est pas parce que je décris quelques choses que je prétends que c’est la solution parfaite ou qu’elle n’est pas disponible ailleurs, c’est simplement un choix.

Git ?

Linus Torvalds, créateur de Linux, a commencé l’écriture de Git en avril 2005 afin de remplacer le logiciel BitKeeper. Cet outil propriétaire étais utilisé jusque là pour la gestion des sources du Kernel Linux, jusqu’à ce que la possibilité d’utiliser gratuitement le logiciel soit révoqué par son auteur, Larry McVoy (les raisons de cet événement sont assez controversées, je n’entrerais donc pas dans les détails ici). La première version a été publiée le 7 avril 2005, en juillet Linus annonçais que le Kernel serait dorénavant développé avec Git et que la maintenance de ce nouvel outil était confié à Junio Hamano. La première version stable (1.0) est quant à elle sortie le 21 décembre 2005.

Git fait partie de la famille des gestionnaires de sources décentralisée, tout comme BitKeeper ou Mercurial par exemple et au contraire de Subversion ou CVS. Le principe consiste à permettre à chacun de travailler à son rythme, de façon désynchronisée des autres, puis d’inclure leurs modifications dans son travail et mettre les siennes à leur disposition. Un dépôt de référence est en général défini (par convention, pas pour des raisons techniques), depuis lequel chacun peut partir afin de faire ces développements, avant de les y faire éventuellement intégrer.

Comment ça marche ?

La plupart des distributions Linux doivent contenir un package avec Git, sinon vous pouvez le télécharger et le compiler vous-même (je ne vais pas entrer dans les détails, si vous devez le faire, c’est que vous êtes un grand garçon ou une grande fille ;-)). Sous Windows il existe MSysGit, celui-ci permet d’installer tout ce qu’il faut pour que ça marche (vous aurez une console comme avec CygWin et un outil GUI), lisez bien les informations lors de l’installation afin de faire les choix qui sont le mieux adapté à votre utilisation (en cas de doute choisissez la solution la moins intrusive pour votre système).

Avant toute chose, une petite opération simple de configuration afin de vous identifier correctement lors de vos commit. L’option –global permet de définir ces informations pour tout votre système, si vous utilisez les mêmes commande dans un dépôt sans cette option vous pouvez définir un nom et une adresse spécifique pour celui-ci. Vérifier que tout est en ordre avec l’option –get.

$ git config --global user.name "Yann Lugrin"
$ git config --global user.email "yann.lugrin@..."
$ git config --get user.name
Yann Lugrin
$ git config --get user.email
yann.lugrin@...

Pour créer un nouveau dépôt, rien de plus simple. Déplacez-vous dans le répertoire de votre application (ou créez-en un) et tapez la commande suivante :

$ cd ./MyApp
$ git init
Initialized empty Git repository in .git/

Comme vous pouvez le constater, votre répertoire de travail et votre dépôt ne font qu’un, vous allez donc commiter toutes vos modifications en local. Nous verrons plus tard (avec GitHub) comment utiliser un dépôt distant. Mais attention, dans tous les cas vous aurez cette configuration, vous n’enverrez jamais vos modifications directement vers un autre dépôt.

Petite précision sur les commandes, une commande notée git init est un « proxy » vers la commande git-init, si vous voulez de l’aide sur une commande, utilisez cette seconde notation avec man afin de l’obtenir.

$ git status
# On branch master
#
# Initial commit
#
nothing to commit (create/copy files and use "git add" to track)

Notre dépôt est créé, mais ne contient naturellement encore rien.

$ touch README
$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       README
nothing added to commit but untracked files present (use "git add"
to track)

$ git add README
$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#       new file: README
#

Le fichier README est créé, noté que nous avons dû explicitement l’ajouter avec la commande git add et qu’il existe également les commande git rm et git mv.

$ git commit -a -m "Initial commit"
Created initial commit b3037e7: Initial commit
0 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 README

$ git status
# On branch master
nothing to commit (working directory clean)

$ git log
commit b3037e7f45f65d1003eada3248e8541f459085ac
Author: Yann Lugrin <yann.lugrin@...>
Date:   Mon May 5 15:29:01 2008 +0200

    Initial commit

L’option -a pour la commande git commit permet de tout envoyer, l’option -m permet d’écrire un commentaire. Si vous ne la spécifiez pas, l’éditeur par défaut du système sera ouvert afin de vous permettre de le faire. On peut ensuite vérifier le résultat avec la commande git log.

Si vous êtes un utilisateur de SVN, vous pouvez jeter un œil à ce guide afin de faire le pont avec les commandes de Git. Vous pouvez aussi lire la Cheat Sheet (SVG, Medium PNG, Large PNG).

Ceci était une introduction basée sur ma courte expérience, dans le prochain article je parlerais de GitHub, un service d’hébergement pour Git. Si vous avez des compléments d’informations à donner sur Git elles sont les bienvenues.

TServer est une librairie en Ruby permettant d’implémenter un serveur multi-thread, c’est une alternative à GServer de la librairie standard.

J’ai sorti la version 0.2.0 aujourd’hui, voici les nouveautés :

• Utilisation de la class ‘Logger’ pour le système de log (la sortie standard est utilisé par défaut, mais lors des tests un fichier de log est utilisé).
• Ajout de callbacks lors des événements.
• Ajout d’une tâche ‘server’ au Rakefile afin de lancer le serveur d’exemple.
• Plurialisation du nom des méthodes ‘Tserver.listeners’ et ‘TServer.waiting_listeners’.
• Une méthode ‘reload’ a été ajouté afin de permettre de redémarrer le serveur sans coupure du service.
• ‘TServer.process’ ne prend plus d’argument et les méthodes suivantes sont maintenant disponibles : ‘TServer.connection’, ‘TServer.connection_addr’ et ‘TServer.terminate_listener?’.
• Un certain nombre de corrections ont étés faites et les tests améliorés.

Les sources et un gem sont disponibles depuis le trac du projet, j’espère pouvoir ajouter le gem à rubyforge bientôt.

Le serveur fonctionne bien, bien que je ne l’ai pas encore testé dans des conditions réels. Je pense que je devrais faire une class pour les Listener, ceci permettrais d’être plus facilement « thread  safe » en plus d’un certain nombre davantage pour l’implémentation je pense. Par contre, j’ai de la peine à évaluer les incidences sur les performances. Ce changement serais important, je vais y réfléchir et décider si je prends cette option dans le but de sortir une version 1.0.

Naturellement tout commentaire est le bienvenu.

Suite à une discussion avec un ami, qui voulait une estimation du coût de développement d’une petite application permettant de recevoir des données par une simple connections TCP ne demandant pas d’implémenter un protocole « complexe » dans le client, j’ai effectué quelques recherches sur l’implémentation d’un serveur TCP en Ruby.

Bien sur créer un serveur TCP acceptant des connections tient en 2 lignes :

server = TCPServer.new(’127.0.0.1′, 10001)
socket = server.accept

Mais un serveur comme celui-ci est un peu limité (surtout quand il doit accepter 2000 connections toutes les deux minutes), la suite est logiquement de trouver une solution multithread permettant de recevoir plusieurs connections simultanément. On trouve GServer dans la libraire standard de Ruby qui permet d’implémenter ceci très facilement (exemple tiré de la documentation) :

require ‘gserver’

#
# A server that returns the time in seconds since 1970.
#
class TimeServer < GServer
def initialize(port=10001, *args)
super(port, *args)
end

def serve(io)
io.puts(Time.now.to_i)
end
end

# Run the server with logging enabled (it’s a separate thread).
server = TimeServer.new
server.audit = true # Turn logging on.
server.start
server.join

# *** Now point your browser to http://localhost:10001 to see it working ***

Si cette solution fonctionne mais j’ai tout de même rencontré quelques problèmes, pour commencer la méthode « shutdown » ne fonctionne pas correctement et ce serveur crée un nouveau Thread à chaque connexion et le détruit une fois les traitements de celle-ci terminé. Et vu que j’étais intéressé par faire quelques expériences avec les Thread de Ruby j’ai décidé de créer mon propre serveur multithread avec les spécifications suivantes :

• Thread persistants en attente de connexions.
• Gracefull shutdown.

Ce petit teste à finalement donnée naissance à une librairie complète, la classe TServer permet maintenant de créer un serveur multithread pouvant être arrêté en douceur et dont les listener (Thread traitant les connections) sont persistants. Lors de l’initialisation il est possible de configuré le nombre maximum de connections que le serveur peut traiter en même temps et le nombre de listener qui doivent toujours être à l’écoute (il est possible de configurer cette variable à 0 pour avoir un comportement identique à GServer).

L’utilisation des Thread est intéressant, mais demande de faire attention à ce qu’on fait (le contenu des variables n’est pas toujours celui auquel on s’attend) et à bien utiliser les outils de synchronisation à notre disposition (Monitor, Mutex, ConditionVariable, Queue). Faire des testes unitaires n’est pas évident puisqu’il est difficile de tester un serveur dont on ne connait pas l’état actuel. J’ai pu m’en sortir en contrôlant l’évolution du serveur avant de faire certains testes et en utilisant la classe Timeout pour m’assurer que son état change dans un temps raisonnable. Je ne suis pas complètement satisfait du résultat et j’ai probablement encore des choses à découvrir pour le faire correctement (pour l’instant je n’arrive pas a faire passer les testes sous Windows, apparemment ils attendent sur quelque chose lors d’un test et je doit tuer le process).

Mon prochain objectif est de remplacer le système de log (utilisation de la librairie logger et utilisations de diverses méthodes afin de permettre la collecte de stats plus complète comme dans GServer), mais également de permettre un reload du serveur sans interruption du service. En attendant, voici un exemple d’implémentation de TServer (tiré de la documentation) dont j’ai mis les sources et un gem à disposition ici :

require ‘tserver’

# A server can return
class ExempleServer < TServer
def serve(conn)
conn.each do |line|
break if line =~ /(quit|exit|close)/

log ‘> ‘ + line.chomp
conn.puts Time.now.to_s + ‘> ‘ + line.chomp
end
end
end

# Create the server with logging enabled (server activity is displayed
# in console with received data)
server = ExempleServer.new
server.verbose = true

# Shutdown the server when script is interupted
Signal.trap(‘SIGINT’) do
server.shutdown
end

# Start the server (joined is set to true and the line wait on server
# thread before continue, the default values of this parameter is set to
# false, you can also use ‘server.join’ after server.start)
server.start(true)

# Now you can open a telnet connection to 127.0.0.1:10001 (telnet 127.0.0.1 10001)
# and send text (use exit to close the connection)

Il était temps pour moi de mettre un peu à jour mon environnement de développement, c’est-à-dire installer ce qui me manquait, mettre à jour ce que j’avais et pour finir faire le ménage dans ce que je n’utilisais pas. Je développe principalement en Ruby et pour Ruby on Rails, mais fait également du PHP et ai parfois un script en Perl ou Python ; sans oublier le Javascript et le XHTML / CSS. Il faut ajouter à cela une base de donnée (MySQL) et quelques besoins particuliers en matière de communication réseau.

Pour rappel mon desktop professionnel est sous Linux / Gentoo et celui que j’ai chez moi sous Windows (j’apprécie pouvoir jouer à des jeux vidéo dans de bonnes conditions) ; j’essaie dans la mesure du possible d’avoir les mêmes outils sur les deux machines bien que ma console et tous les outils que j’y trouve me manque quand je suis chez moi.

Pour commencer le gestionnaire de version. Tous mes projets sont gérés avec subversion, ce logiciel est pour moi indispensable au bon déroulement du développement, premièrement pars qu’il me permet de synchroniser correctement mes deux postes de travail (bureau et domicile) quand je suis seul sur un projet et de même quand on est plusieurs (même si ce n’est qu’un développeur et un graphiste). Je n’entrerai pas dans le détail de l’utilisation d’une application de ce type qui apporte aussi bien d’autres avantages (suivi des modifications, possibilité de revenir en arrière, gestion de différentes branches de développements, …).

J’ai adopté Eclipse comme IDE car il offre des plugins qui intègrent les différents langages dont j’ai besoin. Il est agréable de ne pas changer de logiciel et donc de méthode de travail à chaque fois qu’on passe d’un projet à un autre (ou d’un système d’exploitation à un autre) et l’environnement de base est très bien foutu. J’ai bien réduis le nombre de plugins que j’utilise en installant Aptana (attention il y a actuellement deux plugins à installer : Base + Ruby & Rails). Celui-ci offre donc tout ce dont j’ai besoin pour PHP, Ruby, Rails, HTML, CSS et Javascript. A ceci il faut ajouter subclipse pour gérer mes projets sous subversion, EPIC pour l’intégration de Perl (je viens de l’installer, je n’ai donc pas plus d’avis que ça dessus) , PyDev pour Python (que j’ai déjà utilisé par le passé et que je viens d’installer à nouveau) et Mylar.

Il me faut naturellement un Navigateur web et j’utilise donc principalement Firefox. J’y ai ajouté quelques extensions qui vont bien tel que Web Developer et Firebug (j’ai enfin cherché pourquoi il ne fonctionnait pas sur ma machine et en fait il faut compiler Firefox avec le USE Flag « mozdevelop » ) ainsi que Tab Mix Plus (dont certaines options sont bien agréables) et le dictionnaire MySpell en français ;-). J’en ai d’autres, mais elles ne sont pas là pour le développement (FlashGot, Google Brower Sync, Google Gears, Google Reader Notifier, coComment).

Enfin j’ai un serveur Apache et MySQL qui tournent et PhpMyAdmin pour gérer les bases de données.

Ma machine sous Linux m’offre également une flopée d’outils bien utile que je regrette quand je suis sous Windows. Il faudrait également que je prenne parfois le temps de me tenir au courent afin d’éventuellement pouvoir adopter de nouveaux outils… Si vous avez des suggestions n’hésitez pas :-)

J’ai du créer un patch pour faciliter le déploiement de quelques modifications mineurs sur le site web d’un client par leur technicien. J’ai finalement trouvé quelques exemples de l’utilisation de diff et de patch. Je cherche ces informations à chaque fois que j’en ai besoin car je n’utilise pas cette technique très souvent.

Donc pour faire un patch il faut évidement avoir gardé une version du contenu avant les modifications, se contenu étant le répertoire old, le nouveau contenu étant le répertoire new (ces noms ont aucune importance, il faut simplement avoir ces deux répertoires). Donc nous créons le patch à partir de ceux-ci.

diff -urN ./old ./new > file.patch

-u : le format du patch est unified
-r : créer le patch récursivement
-N : Les fichiers absents sont considérés comme des fichiers vides

Nous allons le tester en faisant une copie du répertoire old vers test par exemple et y appliquer le patch de la manière suivante.

patch -p1 -d --dry-run ./test < file.patch

-p1 : afin d'ignorer le nom du premier répertoire (en effet, celui utiliser
      pour créer le patch n'est pas forcément le même que celui où il doit
      être appliqué)
-d : spécifie le répertoire où le patch doit être appliqué
--dry-run : n'applique pas réellement le patch mais retourne tout les messages
           et donc les éventuelles erreurs généré lors de son application

Si il n’y a pas d’erreur, lancer la même commande sans —dry-run puis contrôler que tout s’est bien passé avec la commande diff.

diff -urN ./new ./test

Si elle ne retourne aucune différence s’est que tout va bien.

Lors de l’application final il est conseillé de faire une copie des données pour commencer, de lancer patch d’abord avec —dry-run, et si tout se passe bien de le lancer sans après.