Je Fûte, Tu Fûtes

Je passe à Mercurial

2010-09-18T22:01:00.004+02:00

J'avais des repositories Subversion sur un serveur à la cave, et il a planté hier. Heureusement qu'il y a les backups automatiques journaliers (backup-manager + cron qui envoyait tout ça sur une VM xen sur un serveur distant).

Je vais en profiter pour migrer la totalité de mes projets vers Mercurial, un DVCS bien sympa, même que le Project Hosting de Google Code l'utilise.

L'architecture que j'ai choisie est celle-ci :

hébergement chez Google Code quand le projet a vocation à être open source
hébergement sur une VM sur un serveur dédié loué quand le projet est privé
backups dans tous les sens grâce aux repositories locaux sur mes machines

Simple et pas prise de tête.

Le serveur qui vient de flancher hébergeait déjà quelques repositories Mercurial, histoire de découvrir. J'avais fait ceci :

accès par SSH et clefs publiques (tout comme j'utilisais Subversion)
j'avais installé mercurial-server (mauvaise idée car j'ai dû pour cela passer à la sid (squeeze) au lieu de rester en lenny),
et tout le bataclan des clefs nommées, etc. (cela dit c'est propre)

Maintenant je fais la chose suivante :

Fichier .hgrc sous Windows

[ui]
username = dandriana
ssh="C:\Program Files\Putty\PLINK.EXE" -ssh -l hg -i "D:\Mes Documents\ma_clef.ppk"

J'utilise PAGEANT sous Windows pour ajouter la clef en début de session.

Sur la VM (xen) du serveur distant, j'installe Mercurial et crée un utilisateur Unix hg. Mes projets seront dans /home/hg/projects/

Sur le Dom0 (le serveur distant), je crée un utilisateur Unix hg, mais sans installer Mercurial.

Pour cet utilisateur je crée un exécutable de nom hg, que je mets dans le PATH, et qui contient ceci :

#!/bin/sh
ssh "hg $*"

En effet, quand je ferai sous Windows « hg -v clone ssh:////home/hg/projects/toto » (attention au double slash « // » avant « home » quand il s'agit d'un chemin absolu) pour récupérer le projet « toto », voici ce qui se passera :

le programme hg sous Windows (installation standard de Mercurial) se connectera via SSH au serveur distant avec le nom d'utilisateur hg (voir plus haut, directive « -ssh -l hg » de PLINK),
il essaiera d'y lancer la commande « hg -R /home/hg/projects/toto serve --stdio » (c'est l'option « hg -v » plus haut qui permet d'afficher ce détail),
donc le serveur distant lancera en fait « ssh "hg -R /home/hg/projects/toto serve --stdio" »,
c'est-à-dire se connectera à la VM, où s'exécuteront les opérations Mercurial.

Boah, ça fonctionne bien.

Je trouve deux énormes intérêts à un DVCS :

les commits en mode déconnecté. Je peux poser des savepoints alors que je travaille dans le train, ou que je progresse pas à pas.
le fait de ne pas à faire de choix structurant quant à utiliser un serveur plutôt qu'un autre (à la maison ? loué ? partagé ?…)

Je vais sans doute utiliser hgsvn pour finir la migration.

Formations internet aux associations

2010-09-11T21:50:00.003+02:00

Vu chez Ginisty : Internet sans Frontières lance un programme de formations à destination du monde associatif.

Réorientation professionnelle

2010-08-14T18:29:00.008+02:00

Mes années dans le service informatique…

2000, Sinclair&Partners à Paris (La Défense),

2001, Logica > LogicaCMG > Logica à Bordeaux (Gradignan),

2004, Cap Gemini Ernst & Young > Capgemini à Bordeaux (Pessac > Mérignac),

2006, indépendant sous l'enseigne Avantage Compris à Bordeaux (Pessac > Mérignac),

2010, je signe un nouveau contrat chez Capgemini, cette fois-ci à Paris (Suresnes et La Défense).

Capgemini est un grand groupe, avec qui j'avais déjà pu faire de belles choses en étant basé à Bordeaux, et notamment une petite mission Flying Squad à New York en 2005. Gageons que l'avenir saura se montrer à la hauteur :-)

Je remarque d'ores et déjà les changements sur le marché : dans les cas où l'agilité est une évidence méthodologique elle ne fait plus peur, SOA est une notion intégrée dans le paysage — j'ai même vu des clients parler naturellement de gouvernance —, et les développements offshore maîtrisés semblent être la norme.

Confronté à un nombre réduit de clients, même s'ils étaient souvent prestigieux — technologies obligent —, je n'avais pas forcément en tant qu'indépendant suffisamment de champ de vision pour arriver à cette idée. Le fait de me retrouver dans l'entreprise (80 000 collaborateurs inscrits sur la partie KM d'un intranet, ça calme toujours) est une bonne chose.

Et le statut d'indépendant : plus jamais ? C'était pas bien ? Je dirais au contraire que c'est une excellente expérience, qui outre le fait d'obliger à gérer chacun des aspects de sa structure, rapproche du sens business de notre métier. En tant qu'indépendant on voit mieux ses forces et ses faiblesses… celles des autres aussi. Je pense qu'on est davantage poussé à la coopération. On attache peut-être davantage d'importance à la complémentarité, ce qui est un plus ensuite.

Bref, c'est reparti :-)

Ah, et je laisse mes amis kabbalistes discuter du sens de « Rê-orientation » et de la figure de l'as de pique :-)

Blog de « Création Mohair », à Limoges

2010-08-14T18:21:00.002+02:00

Tiens, du coup « Création Mohair » a mis à jour son blog : http://www.creationmohair.com/blog/

Boutique « Création Mohair », à Limoges

2010-07-02T14:04:00.006+02:00

J'ai découvert tout à l'heure la boutique « Création Mohair », à Limoges.

La boutique expose de nombreuses créations très chouettes, en mohair, mohair et soie, ou coton. J'avoue en être tombé sous le charme, et du coup je me fends d'une petite note.

Les créateurs de « Création Mohair » ont une approche assez sympa et écolo : oui, la matière première vient d'animaux estampillés bio (Ecocert), et les teintes sont naturelles (en tout cas celles que j'ai vues). Mais il y aussi le soin du détail dans toute la chaîne de production, qui se retrouve évidemment dans leurs produits et la finition (eh oui, j'aime bien ceux qui fignolent les détails).

Leur site web permet d'acheter par correspondance.

Leur blog, pas hyper mis à jour, affiche des photos des chèvres et du chien :

Manque de bol, je ne trouve pas sur le site les créations les plus récentes, notamment une petite robe en coton tricotée main assez géniale, et qui à mon avis mériterait un site de vente pour elle toute seule.

Ils ont aussi des petits bonnets pour enfants tout à fait craquants, assez originaux, mais hélas je ne les retrouve pas non plus sur le site (là, j'ai peut-être mal cherché).

Alors, est-ce que c'est vraiment le moment, alors qu'il fait 30°C en ville, de parler mohair ? Eh bien pour l'été ils ont une étole mohair et soie tricotée machine, très légère, euh… enfin à chacun de se faire son idée, bien sûr ! En vitrine en tout cas, elle tape pas mal à l'œil :-)

Quant à la toute récente petite robe en coton, c'est clairement une robe d'été. Il faut demander à la voir, car elle n'est même pas encore exposée !

J'ai beaucoup aimé ce magasin et son esprit :-)

Gilles Lipovetsky

2010-03-28T12:18:00.003+02:00

Chez Nicolas Bordas, un article qui parle de Gilles Lipovetsky intitulé « Et si la culture-monde avait aussi du bon ? ».

Pour reprendre quelques thèmes évoqués dans l'article, je ne crois pour ma part ni à une fin programmée de la morale, ni à une disparition des questions de classes économiques, ni à la possibilité de se démarquer asymptotiquement de l'hyperconsommation.

Le bon point, c'est que se poser ces questions à l'heure où la confirmation affective est accessible, en particulier via le web quand il consolide et nourrit nos réseaux, nous aide à nous considérer de nouveau comme des êtres multidimensionnels.

Application packagée et ressources externes

2010-02-28T10:39:00.017+01:00

Dans le monde J2EE/JEE on déploie une application web sous forme d'archive compressée : l'extension « .war » du fichier signifie « webapp archive ».

Dans le monde PHP, pour ne citer que lui, on peut rencontrer le même fonctionnement, avec les fichiers à déployer fournis sous forme d'archive compressée « .zip » par exemple.

Pourtant, sauf en de rares exceptions, une application ne se limite pas à du code exécutable et à des ressources statiques, mais a besoin de ressources externes telles qu'une base de données, un service de messages, ou des services tiers comme des services web.

La base de données est une ressource externe au code déployé

Prenons le cas le plus courant, où l'application utilise une base de données seulement.

En ce qui concerne ce lien, l'application contient du code exécutable, qui encapsule du SQL, qui attaque base de données.

Pour le déploiement, d'un côté on a créé la structure de la base de données, de l'autre on a déposé l'archive de l'application.

Ces deux déploiements conjoints doivent produire un environnement global cohérent. Penser aux « contrats d'interfaces ».

La correspondance d'interfaces entre le client et la ressource invoquée, est cruciale.

Apporter la cohérence par le déploiement lui-même

L'application qui crée la base de données dont elle a besoin

Une astuce qu'emploient de nombreuses applications destinées au grand public est d'opérer la création de la base de données depuis la base de données elle-même.

(J'ai barré pour dire que cela ne me convient pas)

On met l'accent sur la facilité pour l'utilisateur lambda d'initialiser l'environnement d'exécution.

C'est le modèle choisi pour quasiment toutes les applications PHP. Plusieurs frameworks Java offrent également cette possibilité.

Cette approche est sympathique, mais n'est pas forcément cohérente avec une logique de production, et, surtout, de maintenance.

Je trouve d'autre part que c'est prendre un risque opérationnel, car même en production, le code qui permet de supprimer et de recréer les tables de la base de données est embarqué.

L'outil de déploiement couteau suisse

En posant la distinction entre composants déployés et outillage d'administration, on peut utiliser un outil de déploiement qui saura s'occuper de déployer et d'administrer aussi bien l'application que la base de données.

Même si elle a un très gros intérêt, une faiblesse de cette approche est qu'elle réclame la mise en œuvre d'un outil qui sache tout faire, et surtout son utilisation systématique : que se passe-t-il si un administrateur passe outre la procédure outillée ? Un ALTER TABLE en manuel est si vite arrivé…

Contrôler la cohérence avant le démarrage de l'application

Pour la qualité il n'est souvent pas nécessaire d'engager de grandes manœuvres ou de mettre en place des outils contraignants : il suffit parfois de contrôler quelques critères et de bloquer ou de continuer la procédure en fonction.

Une approche consiste alors à embarquer dans le module applicatif déployé une description du modèle physique de données attendu, et de le comparer avec la structure réelle de la base de données.

On bloque le processus de démarrage de l'application si les deux ne correspondent pas (un simple « hash » peut suffire).

Personnellement j'utilise comme référence du modèle un fichier YAML posé dans le répertoire WEB-INF/ de l'archive déployée, ce qui me permet d'avoir une approche unique pour PHP et J2EE/JEE.
Pour Java, on peut penser à introspecter les classes persistantes afin d'en déduire le modèle attendu.

Une sécurité supplémentaire est d'embarquer dans l'application elle-même, non pas du code de manipulation de base de données, mais l'outil de comparaison. L'application elle-même refuse alors de démarrer si la structure de la base de données n'est pas cohérente avec le modèle attendu.

Autres vérifications

Le fichier de référence qui décrit le MPD cohérent avec l'exécution de l'application peut servir à d'autres contrôles, et notamment les suivants :

cohérence entre le MPD et les requêtes SQL externalisées (penser aux objets PreparedStatement)
cohérence entre le MPD et les classes persistantes des divers frameworks ou approches (Hibernate, JDO…)

Environnements de tests

En phase de tests, on souhaite d'une façon ou d'une autre que l'application soit autoporteuse : à la fois déployer une application et exécuter des scripts SQL de modification de la base de données (de tests), peut être inutilement coûteux.

J'ai parlé plus haut des frameworks qui permettent ça nativement, en disant cependant que l'approche qui mixe modules applicatif et d'administration ne me convenait pas.

Le fait d'embarquer, dans le module applicatif lui-même, une description de référence du modèle attendu, permet de recréer à volonté une base de données de tests cohérente.

Pour ma part je fais cela avec un plugin Maven.

Approche générale, autres ressources

Le point crucial de ce qui précède est de bloquer le démarrage de modules dans le cas où on a décelé que les chaînes de liaison ne sont pas correctes.

Pour cela, l'idée proposée est simplement que le module client sache dire de quelle interface il a besoin, et que la ressource invoquée sache dire au runtime quelle est sa structure.

On obtient une cartographie « à froid » des composants déployés.

On fait ensuite une vérification statique des structures lues, grâce à des outils externes aux modules et ressources déployés.

Aucun outillage lourd n'est nécessaire en amont.

Il faut se rappeler du reste que, dans certains cas réels, l'outillage lourd en amont n'est pas suffisant à assurer la cohérence entre tous les composants déployés, en particulier quand les procédures de déploiement ne sont pas entièrement automatisées.

L'approche pragmatique présentée, complémentaire à l'outillage amont, et qui fait des sanity checks simples, permet de détecter des failles évidentes.

Asso&Co

2010-02-26T10:07:00.002+01:00

Je cite : « La Banque Postale est à l'initiative d'un nouveau site dédié au monde associatif » : http://assoandco.fr/

De bonnes idées. Pas vu si un même compte peut servir à gérer plusieurs associations.

Restauration quotidienne de sauvegardes

2010-02-13T08:57:00.013+01:00

Voici un état de mon architecture de sauvegardes, qui a un peu évolué depuis que j'avais parlé du sujet il y a deux ans (voir : Validation de backups, avril 2008).

Architecture

Les nouveautés concernent essentiellement l'ordonnancement.

Sur le plan fonctionnel, les principes sont :

une sauvegarde complète quotidienne
une restauration complète quotidienne
des tests d'acceptabilité sur les données restaurées (par exemple, vérifier que les données qu'on a restaurées ne sont pas constituées de répertoires vides)

Sur le plan technique, les principes sont :

pour tout ce qui concerne les flux entre machines, l'ordonnancement est centralisé
les flux sont sécurisés (SSH)
les accès sont sécurisés de machine à machine (restrictions des adresses IP autorisées, etc.)
on limite les volumes des transferts réseaux (compression BZ2, regroupement des commandes envoyées par SSH…)

L'architecture se synthétise ainsi :

Légende :

ref — référentiels, « Repositories » : Ce sont les éléments à sauvegarder. En l'occurrence Subversion, un wiki…
m2 — ordonnanceur, « Scheduler »
bkp — espace de sauvegarde, « Archives »
tmp — espace temporaire pour restauration
ci — outil d'intégration continue, « Continuous Integration »

Les machines « ref » et « m2 » sont sur un même réseau local (LAN).

« ref » est visible sur internet, ports 22 et 80. Sur le LAN elle est dans une DMZ, et en particulier n'accède pas à « m2 ».
« m2 » n'est pas visible sur internet.

Les machines « bkp + tmp » et « ci » sont sur internet, avec leurs accès SSH limités à certaines adresses IP.

Les étapes du processus sont les suivantes :

sauvegardes locales sur « ref », par l'outil « backup-manager »
copie vers une machine distante qui stocke les archives, avec éventuellement une copie intermédiaire locale sur l'ordonnanceur lui-même
décompression de la dernière sauvegarde présente dans les archives, restauration, contrôles et mesures
copie des résultats des contrôles et mesures, vers une machine d'intégration continue
analyse des résultats des contrôles et mesures, tests sur des critères d'acceptabilité
[E] si une erreur est décelée, envoi d'un e-mail à l'administrateur

En gros, j'arrête de poser des crontabs partout comme je faisais il y a deux ans (voir article : Validation de backups) ; c'est un plat de spaghetti à administrer, et, quand une machine tombe ou est recyclée, les autres continuent leur semoule sans que ça serve à quoi que ce soit.

L'ordonnancement centralisé facilite les enchaînements.

En revanche, il ne facilite pas forcément la gestion de verrous.

Autre changement par rapport à il y a deux ans, j'écris mes scripts système en Bash et délaisse Ruby, qui n'apportait pas tant que ça.

Contrôles et mesures

Pour un repository Subversion, après restauration des données, les tests d'intégration continue se feront sur les mesures suivantes :

nom et taille du fichier de sauvegarde restauré => la date doit être celle du jour
dates de début et fin de la restauration => le traitement ne doit pas avoir été trop rapide
numéro de version (Revision) => ?
nombre total de fichiers après checkout => il doit être supérieur à telle valeur
nombre de fichiers « pom.xml » après checkout => il doit être supérieur à telle valeur
nombre de fichiers « build.xml » après checkout => il doit être supérieur à telle valeur

L'idée est de repérer les cas de sauvegardes vides, ainsi que les sauvegardes obsolètes.

Quelques idées rejetées

Il est bon de fonder ses choix aussi sur l'historique des choix qui n'ont pas été retenus ;-)

Idée rejetée : copie directe depuis la machine de référentiel vers la machine de backup.

Explication : pourquoi la machine de référentiel devrait-elle avoir connaissance de l'existence d'une machine de backup ? Et en être dépendante ? Et dépenser de la charge et être administrée pour ça ?
L'idée est que les processus de restauration d'archives doivent être vus par ailleurs. La machine à sauvegarder n'a pas elle-même à savoir qu'elle devrait envoyer un e-mail, etc.

Idée rejetée : accès direct depuis la machine de backup à la machine de référentiel.

Explication : on a choisi dans l'architecture de limiter les accès SSH à « ref» depuis l'internet à l'utilisation de Subversion. En particulier, pas d'accès aux utilitaires « ls » et « tar ».

Idée rejetée : stocker les archives sur la machine d'ordonnancement.

Explication : cette machine est dans les mêmes locaux que la machine référentiel. Or on veut évidemment que les données archivées soient physiquement découplées des données d'origine.

Idée rejetée : ordonnancement par cron de la restauration depuis l'espace temporaire.

C'est ce que faisait l'ancienne architecture.

Explication : l'espace temporaire n'a pas à être administré et donc n'a pas à contenir de scripts résiduels ni de crontab.

Idée rejetée : restauration sur la machine d'ordonnancement.

Explication : Il faut que la restauration ait lieu à partir d'un élément archivé (celui qu'on ira réellement chercher en cas de problème), et pas depuis une copie intermédiaire, qui par définition disparaîtra.
De plus, ni la mémoire ni le CPU ne sont suffisants sur cette machine pour une restauration.

Idée rejetée : envoi des résultats directement depuis l'espace temporaire vers la machine d'intégration continue.

Explication : l'espace temporaire n'a pas à connaître la machine d'intégration continue, à y avoir posé sa clef publique, etc.

Idée rejetée : récupération des résultats par la machine d'intégration continue auprès de l'espace temporaire.

Explication : la machine d'intégration continue n'a pas à savoir qu'il existe un espace temporaire (en plus, comment s'y connecter s'il n'est pas résiduel ?)

Variante possible

Une variante qui semble être digne d'intérêt, consiste à stocker les résultats des contrôles et mesures dans les référentiels, et que la machine d'intégration continue y accède.

Quelques avantages :

l'ordonnanceur n'a plus à connaître la topographie de la machine d'intégration continue
les résultats des contrôles et mesures sont archivés
on s'appuie sur le lien de l'ordonnanceur vers la machine référentiel, qui existe déjà
on s'appuie sur le lien de la machine d'intégration continue vers la machine référentiel, qui existe déjà
les tests sur les résultats peuvent être lancés depuis n'importe quel environnement qui a accès au référentiel, pas seulement depuis la machine d'intégration continue (donc, pratique pour développer ces tests)

Quelques inconvénients :

le référentiel augmente de façon automatique et ininterrompue, or ce référentiel est lui-même destiné à être sauvegardé et archivé, donnant lieu à des contrôles, qui seront injectés dans le référentiel, etc.
Certes l'augmentation est d'1 Ko par jour, ce qui est dérisoire, mais techniquement, le principe du mécanisme croissant qui s'alimente lui-même n'est pas bon.
d'un point de vue fonctionnel ce serait mélanger production et décisionnel.
Production = référentiel Subversion.
Décisionnel = tests en intégration continue après extraction de mesures.

Curriculum Vitæ à jour

2010-02-10T20:10:00.004+01:00

Après la compta à jour et même le bilan d'Avantage Compris au clair, voici que je complète mon CV dans les temps !

CV en ligne : http://www.avantage-compris.com/team/dandriana/

J'en ai même fait une version anglaise, mais pour l'instant le site de ma boîte n'est qu'en français :-P

IZI-collecte, plate-forme web pour les associations

2010-02-03T18:30:00.002+01:00

D'après la page d'accueil, IZI-collecte (http://www.izi-collecte.com/) propose :

un paiement sécurisé pour les dons et les cotisations à un tarif bas et fixe, comprenant l’émission du e-reçu fiscal et des fonctionnalités communautaires
une plateforme d’envoi d’e-mailings et d’e-newsletters.
la gestion de base de données adhérents et donateurs

Bonne et heureuse année

2010-01-02T09:44:00.003+01:00

:-)

Book Mark

2009-12-16T11:58:00.003+01:00

Merci à Cristian :-)

Démarrer tftpd

2009-11-01T21:52:00.003+01:00

J'avais parlé d'une net install de Debian sur Mac PowerPC : Mac mini de NetBSD à Debian

Eh bien il se trouve qu'il est parfois difficile de démarrer from scratch un tftpd pour que le Mac l'attaque. Alors voici une façon de faire, sur une Ubuntu 9.04 (eh oui : la 9.10 est d'une discutable stabilité).

$ sudo aptitude install tftpd

inetd ne veut pas démarrer au cours de l'install ? Pas grave, l'idée n'était justement de le rendre résiduel.

Modifier /etc/inetd.conf tout de même, en rajoutant l'option « -s » à : /usr/sbin/in.tftpd -s /srv/tftp

Mettre les fichiers à servir dans /srv/tftp/ : yaboot, etc.

Démarrer inetd :

$ sudo inetd

La persistance applicative comme un aspect

2009-10-11T10:23:00.004+02:00

Dans le développement d'une application on pense souvent très tôt à la solution de persistance. Certains ont même une idée tellement précise du « modèle physique des données » — terminologie qui est une drôle de façon se se rassurer —, qu'ils vont à terme jusqu'à contraindre le comportement de l'application ou du système pour se conformer au schéma de la base. Ainsi du genre de réponses « on ne peut pas faire ce que vous demandez, à cause des clefs étrangères qui sont déclarées dans la base ». Ah… Et pourquoi ne pas faire des batchs d'audit et de rattrapage ? Et pourquoi ne pas gérer des états de mes données ? Et pourquoi ne pas laisser les transitions se faire de façon asynchrone ? Et surtout : si vous vous appuyez sur des clefs étrangères pour assurer l'intégrité métier de mes données, vous me faites plutôt penser que vous n'avez pas compris mon métier !
Quel métier se résume à des contraintes techniques d'intégrité ? (contraintes que du reste les DBAs font la plupart du temps sauter en production afin d'améliorer les perfs).

Cependant je ne veux pas reparler ici de centrer les objectifs du cycle de développement sur les processus métier, je considère que c'est acté.

Non, je voudrais parler de persistance.

Il y a des cas où les processus métier sont suffisamment simples pour être embarqués dans une application transactionnelle, où il n'y a pas ou quasiment pas d'existant, bref, où on a la latitude pour développer. Pléthore de frameworks de persistance viennent en sus à notre rescousse, on peut citer Hibernate (https://www.hibernate.org/) dans les premiers.

Pourtant nombre d'entre nous continuent de vouloir poser le schéma de la base, quand bien même serait-il un mapping naïf des propriétés des objets Java, dès le commencement.

Pourquoi ne pas simplement développer l'application ? On met toutes les données en mémoire, et on optimisera ensuite ! J'ai juste besoin dans un coin d'un compteur transactionnel pour mes états métier (ben, oui), compteur que je peux implémenter par un synchronized tout bête, et je fais mouliner le reste avec des classes ad hoc.

Plus tard, quand j'aurai besoin de partager mes données sur un cluster, ou de performances, ou tout simplement de sauvegardes parce que j'aurai à mettre en place un PRA (Plan de reprise d'activité, en gros comment remettre d'aplomb un deuxième système informatique si le premier vient de calancher, par exemple suite à un incendie), alors là, oui, je me pencherai sur la persistance. Mais c'est un aspect de l'application, au même titre que la sécurité ou les logs. Ce n'en est pas le cœur ni le socle ; ce n'est pas fondamental : l'absence de persistance des données, dans le sens général, n'empêche pas l'application de tourner.

D'ailleurs combien, parmi ceux qui pensent de suite à la solution de persistance, le font réellement parce qu'ils envisagent un PRA ou des performances maximales ? Non, le plus souvent la couche de persistance est envisagée comme une nécessaire façon de réaliser une application. Dans d'autres domaines on sait s'affranchir de ce genre de préjugés : les compilateurs dégagent, avec Ruby ou Groovy et l'aide des IDEs, les descriptions XML sont supplantées par des conventions ou des annotations, le besoin de hardware diminue grâce au cloud, on se fiche de l'OS parce qu'on fait du web, etc.

La couche technique de persistance n'est pas nécessaire dans une application. En revanche la couche logique de manipulation simple des données, notamment avec des verrous voire des états, et des vérifications d'intégrité, oui.
Et il y aura toujours moyen plus tard d'orchestrer tout ça et d'y ajouter les aspects désirés.

Pour finir, l'approche que je décris vise à éjecter la problématique de la persistance lorsqu'on se centre sur du développement applicatif. Pour d'autres types de réalisations, par exemple techniques, la question de la persistance se rencontre évidemment dès le début du chemin.

svn://svn+ssh

2009-10-06T23:34:00.004+02:00

Ceci sera un post légèrement cryptique pour les non informaticiens.

C'est juste pour me rappeler… comment accéder à Subversion par SSH avec clefs…

Sur le serveur : SSH. Permettre l'authentification par clefs.

Dans /etc/ssh/sshd_config :

RSAAuthentication yes

PubkeyAuthentication yes

AuthorizedKeysFile %h/.ssh/authorized_keys

Dans les ~/.ssh/ des intéressés, fichier authorized_keys avec une ligne par clef publique acceptée, du genre :

ssh-rsa AAAAB3Nz(…)PMRJl8=

ssh-rsa AAAAB3Nz(…)PM60l8==

ssh-rsa AAAAB35u(…)rT62zA== dandriana@ordinateur

Pour produire des clefs publiques, ssh-keygen sous Unix et Puttygen sous Windows. Si Puttygen, une fois la clef publique créée, l'exporter au format OpenSSH pour pouvoir l'utiliser sur un serveur Unix.

C'est lors de la génération des clefs qu'est demandée la « passphrase », mot de passe qui active la clef privée.

Sur le serveur : Subversion. Vu qu'on va faire du svn+ssh, pas besoin de lancer svnserve, donc.

Sur le client : SSH.

Sous Unix, clefs privées et publiques à mettre dans ~/.ssh. En général leurs noms respectifs sont « id_rsa » (-rw-------) et « id_rsa.pub » (-rw-r--r--). Connexion en : ssh -l <username> -i </path/to/private/key>

Sous Windows, clefs à mettre chais pas où, tellement c'est sécurisé. Faire pointer Putty dessus.

Rappel : les clefs publiques « xxx.pub » sont destinées à être fournies publiquement : envois par e-mail, publication dans un blog…

En revanche les clefs privées sont à protéger absolument. Elles sont plus précieuses que le mot de passe (« passphrase ») qui les active.

Sur le client : agent SSH. Pour éviter d'avoir à s'authentificer à chaque fois.

Sous Unix, ssh-agent :

exec ssh-agent bash

ssh-add </path/to/private/key>

Sous Windows, Pageant.

ssh-agent et Pageant peuvent être lancés au démarrage pour gagner du temps. Cela dépend de l'usage qu'on en a.

Sur le client : Subversion+SSH.

Sous Unix, déclarer dans son .profile une variable d'environnement SVN_SSH, du genre :

export SVN_SSH="ssh -l <username> -i </path/to/private/key>"

Si ça ne fonctionne pas, voir ~/.subversion/config.

Sous Windows, après une installation de la version de CollabNet de Subversion, j'ai mis ceci dans C:\Documents and Settings\<user>\Application Data\Subversion\config :

[tunnels]
ssh=<C:\path\to\>PLINK.EXE -l <username> -i <C:\path\to\private\key>

Mac mini de NetBSD à Debian

2009-09-11T16:49:00.002+02:00

Après qu'il a déjà fourni trois ans de bons et loyaux services sous NetBSD, dont dix-huit mois à faire silencieusement des backups enfermé dans un carton à la cave, je me suis mis dans l’idée de passer un Mac mini PPC sous Debian.

C’était l’occasion de sortir, de son carton également, un écran cathodique dix ans d’âge, et de dépoussiérer un peu les étagères.

Une fois l’écran et un clavier Dell de base connectés au Mac, enfoncer les touches Windows-Alt-O-F au démarrage pour accéder à Open Firmware.

Pour lancer depuis Open Firmware un netboot d’installation de Debian 5.0.3 (dit « Lenny ») :

ok
0 > boot enet:192.168.0.12,yaboot

Cette ligne nécessite que sur le réseau local :

les adresses IP soient attribuées par un serveur DHCP,
la machine 192.168.0.12 fasse tourner un serveur TFTP,
et serve par TFTP les fichiers d’installation de Debian, dont yaboot, yaboot.conf, vmlinux, etc.

L’installation ensuite se passe sans heurts majeurs, et va chercher sur internet tout ce qu’il convient.

Une fois l’installation terminée, après la configuration de SSH en clefs publiques, puis la mise au jour des postes clients « bureau », « salon » et « salle de jeux » en vérifiant qu’ils savent se connecter au nouveau système, le Mac mini, flanqué d’une nouvelle étiquette, a rejoint son grand carton.

Silencieusement, bientôt oublié dans le carton du fond avec sa pomme sur le couvercle, un vaillant petit serveur mouline.

Comment le Parlement européen avait voté contre Hadopi

2009-06-08T10:20:00.003+02:00

Sur le bon blog « Coulisses de Bruxelles » un article qui narre le vote majoritaire (c'est important) du paquet télécom au Parlement européen, avec la fameuse obligation d'une décision judiciaire pour couper un accès internet : Surprise partis à Strasbourg.

Rappelons que le Parlement européen est élu au suffrage universel direct. C'est ce qui vient de se passer ce dimanche 7 juin 2009. Le suffrage universel direct est une disposition démocratique extrêmement importante, qui semble aller de soi, notamment en France, mais qui n'est pas naturelle. En pratique il faut d'abord la gagner (rappelez-vous 1789), la valider, vérifier son application, et l'alimenter au fil des ans et des générations (non, l'abstention n'est pas une façon d'entretenir le suffrage universel).

En revanche la Commission européenne n'est pas élue directement : elle représente peu ou prou les États (disons les gouvernements) en tant que nations, pas en tant que peuples. Or c'est elle qui propose 80 % des textes qui seront ensuite votés, pas le Parlement européen. S'il y a dissensions entre le désir citoyen et les « décisions de Bruxelles » c'est justement en grande partie parce que les textes proposés ne réflètent pas les simples problématiques des peuples.

Vouloir que l'entité européenne (aujourd'hui la Commission) qui propose les textes aux votes soit plus proche de l'expression populaire, c'est une certaine façon de vouloir l'Europe, absolument pas partagée par tous les membres de l'Union. En pratique cela consisterait à modifier les institutions, ce qui ne se fait pas pendant les élections européennes (dont les effets se limitent au Parlement), mais par des traités, généralement soumis à référendums populaires. Cela peut également se faire par une révolution populaire européenne ou un putsch de niveau Empire.

On fait mine de croire que tout est géré « en haut lieu », mais il faut au contraire être bien conscient qu'il y a actuellement un combat très tendu entre ce que pourrait être une Europe des citoyens et une éventuelle Europe des gouvernements.

Pour ce sujet, dans quel sens le défunt TCE et le Traité de Lisbonne vont-ils ? Eh bien vers un accroissement de pouvoir du Parlement européen. Ce nécessaire accroissement est-il suffisant ? Sans doute pas.

La face cachée d'Hadopi

2009-05-02T08:29:00.002+02:00

Sur Agora Vox, un article intitulé La face cachée du projet de loi Internet & Création, dite « HADOPI », avec lequel je suis assez d'accord.

L'article parle bien du problème de la preuve : en gros ce qui fera techniquement preuve dans un premier temps sera l'adresse IP interceptée et qui aura permis de remonter jusqu'à la connexion à internet de l'abonné. Je détaillerais :

Ces adresses peuvent être « forgées » : selon le niveau de protocole qui sera utilisé pour le filtrage, il est possible d'usurper l'adresse IP de quelqu'un d'autre.
Ces adresses publiques ne concernent pas les sous-réseaux : dans le cas d'un accès partagé à internet (réseau domestique, Wi-Fi...), impossible de décider quel ordinateur est impliqué. C'est pour cela qu'un logiciel client est indispensable pour avoir des preuves tangibles. Sans logiciel client, la preuve est potentiellement fausse, d'où l'absurdité de la loi, or une loi absurde est dangereuse. Avec un logiciel client (et certainement pas open source, ce n'est pas l'esprit), adieu votre vie privée.
Ces adresses concernent un accès à internet, mais pas une personne : en cas d'ordinateur partagé par une famille ou un groupe, impossible de savoir qui a fait quoi. Donc d'une part on peut vous pirater, d'autre part ça peut venir de chez vous. La loi va dans le sens de vous accuser a priori.

Problématique de la preuve, donc, et volonté de pouvoir accuser n'importe qui. C'est extrêmement grave.

Le deuxième énorme problème à mon sens est celui de la surveillance, dont parle également l'article d'Agora Vox.

Je pense que la question de la preuve, donc ici de l'arbitraire, voire du délirant (quand l'arbitraire est, en plus, « de bonne foi » !), est un cas d'école des coups de boutoirs que subit régulièrement la République. Dans le but de conforter une structure économique qui na pas su s'adapter (ici le modèle de distribution des œuvres numériques), on souhaite remodeler le consommateur lui-même (un peu comme Monsanto qui remodèle les graines pour imposer son modèle d'agriculture), quitte à ce qu'il y ait des effets nocifs sur l'individu en tant que citoyen, et quitte à se torcher avec les fondamentaux du droit.

Pour moi ce n'est pas une tension entre le fric et la République, tension qu'il s'agirait de régler par une voie médiane, mais très fondamentalement un combat entre des comportements débridés, qui se conçoivent eux-mêmes comme sans limites ou alors éventuellement extérieures — ainsi le droit est considéré comme une circonstance —, et une volonté positive, dont le droit est logiquement une conséquence.

Notes scolaires et Facebook

2009-04-12T15:39:00.002+02:00

Je cite un article du Post :

Accro à Facebook ? Attention à vos notes !

Selon une enquête très sérieuse, faite par des chercheurs, les étudiants qui passent beaucoup de temps sur Facebook, à accumuler des amis, papoter ou poker les gens « consacrent moins d'une heure à leurs devoirs ».

Pour le Times, qui révèle cette enquête, elle confirme les craintes des parents et des profs, et va dans le même sens que ces entreprises qui empêchent l'accès à Facebook dans leurs locaux, pour éviter le gaspillage de temps par les employés...

« Chaque génération a ses distractions, mais je pense que Facebook est un phénomène unique » explique Aryn Karpinski, de la Ohio State University.

Je pense surtout qu'il manque un espace web ludique pour faire ses devoirs. Et qu'avec un tel type d'espace, les « notes » remonteraient. D'autant qu'il n'y a pas que les notes dans la vie, certes qu'elles soient bonnes est un préalable. Il s'agit au moins d'en donner les conditions aux enfants.

Quand je dis un espace web pour faire ses devoirs, ce n'est même pas que le prof ait à mettre sur le web ses énoncés, mais seulement que l'élève puisse y rédiger ses réponses et y travailler en groupe avec d'autres.

Petits robots mignons

2009-04-11T21:56:00.003+02:00

Beaucoup de buzz sur cette expérience, qui à la lecture est sympa comme tout : Tweenbots: Cute Beats Smart

Le but, fabriquer un robot qui arrive à aller d'un bout à l'autre de Central Park.

Un gars a eu l'idée de construire un petit robot, qui ne sache aller que tout droit, mais arborant un petit papier « je veux aller [à tel endroit] » plus un grand sourire dessiné sur le carton.

Et donc les passants dans Central Park ont aidé le petit robot à trouver son chemin.

:-)

Hadopi la sorcière, votée

2009-04-03T10:43:00.003+02:00

Ben voilà, l'infâme loi Hadopi vient d'être votée. J'ai réagi en premier lieu sur Twitter :

Hadopi : loi, par importance 1. suicidaire pour notre droit, 2. rongeuse de libertés, 3. économiquement idiote, et 4. techniquement absurde.

Hadopi loi tueuse de droit. Or seulement 60 députés au vote. Et personne dans les rues. Lendemains qui déchantent à prévoir pour le citoyen.

Je pense qu'on est dans un cas flagrant de délitement de ce qui constitue un État de droit. Ce n'est certes pas le seul de l'actuelle période.

Je suis assez d'accord avec l'article sur Numerama : La loi Hadopi votée à la sauvette par 16 députés ! et surtout solidaire de la phrase suivante que j'en extrais :

(...) en tant que citoyens, cette violation des principes qui fondent la République nous révulse.

Il est anormal que les artistes français soient à ce point à la ramasse quant à leur propre avenir face aux échanges économiques que permettent les réseaux informatiques. Certes. Mais le coup d'instrumentaliser lesdits artistes, et de s'appuyer sur une si grande ignorance du peuple, pour faire passer en douce des lois contraires aux principes d'égalité des citoyens entre eux et à la liberté individuelle, c'est odieux.

Hadopi la sorcière

2009-04-01T09:48:00.004+02:00

Des cerveaux suprêmes ont imaginé que le déboussolement des industriels de la culture par artefacts (notamment livres, musique et films) vis-à-vis d'internet (notamment web et P2P), pourraient servir à faire passer une loi de surveillance généralisée de l'usage d'internet en France, et sans contrepartie en droit, par le truchement de la mise en place du processus suivant :

soit un internaute qui télécharge illégalement une œuvre numérisée,
téléchargement dont l'illégalité est détectée par un système automatisé,
cet internaute reçoit un e-mail lui signifiant que telle Haute Autorité sait qu'il télécharge illégalement quelque chose, sans lui dire exactement quoi,
puis en tant qu'usager il reçoit un courrier recommandé avec accusé de réception, toujours sans qu'on lui précise exactement ce qu'on lui reproche,
puis toujours en tant qu'usager sa connexion se voit interrompue.

Je passe sur les suites judiciaires telles qu'amendes et procès.

Je passe sur l'aspect délibérément kafkaïen du scénario.

Le Parlement Européen de se déclarer pour une reconnaissance d'un droit inaliénable à la connexion à internet, les associations faisant remarquer que couper une connexion à internet dans le cas d'un accès partagé, tel qu'au sein d'une famille, pénalise tous les usagers sans distinction, les entreprises n'étant pas concernées, bref.

Les acteurs du web de signaler que l'interconnexion des réseaux et les comportements sociaux qui existent d'ores et déjà au-dessus d'internet impliquent nécessairement une évolution du modèle économique que suivent les industriels de la culture de masse, et qu'un repli irrationnel du genre loi Hadopi ne fera en tout état de cause que s'opposer vainement au sens de l'Histoire plutôt que l'accompagner, c'est-à-dire obligera tout le monde à subir les changements plutôt qu'en être les acteurs, bref.

Les techniciens qui connaissent leur sujet d'estimer que pour mettre en place un filtrage un tant soit peu consistant les moyens à mettre en œuvre, en plus de la coordination entre les services publics et les opérateurs privés, dépassent de beaucoup tout ce qui serait suffisant à radicalement moderniser les usages des NTIC par l'État, dossier dont on sait par ailleurs, et peut-être par une symétrie d'ignorance ? que les parlementaires refusent de le prendre en main par peur de l'effort à produire, bref.

Ce qui intimement me choque depuis le début se condense en deux points, qui ne sont pas relevés dans ce qui précède :

un projet législatif qui consiste à surveiller et à demander des comptes aux citoyens de leur surveillance sans leur donner les éléments auxquels ils pourraient s'opposer. Au lieu de dire : « nous avons relevé que le 12 juin 2009 à 21 h 53 la connexion internet n°XYZ chez le fournisseur XYZ, dont vous êtes l'abonné, a été utilisée pour le téléchargement du film "Taxi 4" par le logiciel Peer-to-peer eMule en passant par les cartes réseau d'adresses MAC n°XYZ, ce qui sauf au cas où vous détiendrez par ailleurs le droit de ce téléchargement (copie privée) vous expose, etc. etc. », le projet de loi prévoit de pouvoir dire : « une activité illégale a été détectée sur votre ordinateur, veuillez désormais obtempérer aux ordres de telle Haute Autorité ».

une surveillance et une analyse exhaustives des communications qui passent par le réseau internet, toujours sans à rendre de comptes aux usagers.

Le premier point contrevient frontalement à l'idée que je me fais du droit. Je sais que l'Habeas corpus a été un progrès dans l'Histoire, eh bien visiblement il faut continuellement expliquer les progrès passés et réaffirmer les acquis dont nous jouissons au quotidien.

De plus les NTIC permettraient à moindre coût une transparence d'information des citoyens, qu'il s'agisse de l'action de l'administration ou à plus forte raison de ce que la société serait en droit de leur reprocher. Envoyer un courrier à un quidam coûte au moins un timbre, mais mettre en ligne tous ses logs de connexion qui ont fait l'objet de telle surveillance automatisée, coûte bien moins, et garantirait une symétrie entre l'accusé et l'accusateur, symétrie qui devrait au-delà de l'épiphénomène Hadopi être revendiquée comme sacro-sainte, mesurée par des moyens objectifs et dont la mesure devrait être publiée.

Je trouve que le fait que la magouille évoquée concerne un projet de loi du domaine des NTIC est parfaitement secondaire. J'ai ainsi toujours été choqué que sous prétexte de radars automatiques on fasse payer des amendes sans en pratique fournir systématiquement la preuve du délit.

Le deuxième point, de surveillance absolue, concerne une question de projet de société. Voulons-nous ou non que nos agissements soient l'objet de surveillance systématique ? C'est en quelque sorte un retournement de la question démocratique, mais dans les deux cas la symétrie est une nécessité pratique : on ne peut pas imaginer une démocratie dans laquelle les citoyens n'auraient pas un accès égalitaire à l'éducation et à l'information d'une part libre et d'autre part publique, et on ne peut pas construire une société de la surveillance si, en gros, ce qui est relevé et désormais décortiqué n'est pas librement accessible en tant que données brutes à ceux qui sont surveillés.

Certes, la surveillance totale et la symétrie qui lui est un nécessaire corollaire dans un bête cadre de stabilité sociale, impliquent de refonder l'idée qu'on se fait de l'intimité et de la vie privée. Il faut simplement savoir ce qu'on veut.

Pour conclure et résumer je dirais que le projet de loi Hadopi ressort d'un monstrueux et pervers processus de démantèlement du droit et par conséquent d'aliénation de nos libertés. Que je suis effaré que le débat populaire sur Hadopi se concentre sur les aspects dits de progrès, qu'ils soient technologiques ou relevant de nouveaux modèles économiques, alors que les principes mêmes qui permettent qu'on s'accorde librement à se soumettre au droit y sont violemment souffletés.

C'est comme s'il y avait la volonté d'un divorce entre le droit subi et celui auquel on adhère. Petit à petit cela représente une catastrophe sociale.

Kissing the mirror

2009-03-29T14:07:00.002+02:00

Je traduis :

Telle école privée aux USA a dû interdire à ses gamines d'élèves de laisser des bisous sur les miroirs de leur salle de bains.

Chaque matin, plusieurs jeunes élèves autour de douze ans, se peinturluraient les lèvres de rouge dans la salle de bains. Rien à dire à cela, sauf qu'ensuite elles imprimaient un bécot au miroir, y laissant ainsi des dizaines de petites traces écarlates, que chaque fin de journée l'employé chargé du nettoyage devait nettoyer, et chaque matin le coupable manège recommençait.

Finalement le principal décida qu'il fallait faire quelque chose. Il convoqua les filles dans la salle de bains, ainsi que l'employé qui effaçait chaque jour les rouges forfaits. Le principal expliqua que ces petites traces représentaient un problème majeur pour l'employé qui devait les nettoyer.

Afin d'expliquer la difficulté, il demanda à l'employé de montrer aux filles la somme de travail que cela représentait. L'homme sortit alors une longue raclette, la plongea dans la cuvette des toilettes, et nettoya un miroir avec. Depuis, il n'y a plus de ces petites traces rouges dans la salle de bains.

Kissing the mirror

J'aime beaucoup la structure narrative :-)

Développement : Dependency Analyzer

2009-01-30T11:03:00.003+01:00

Oui, pardon, il y a un outil bien connu qui permet de voir des dépendances d'un projet Maven : Dependency Analyzer, de jfrog, ceux qui font Artifactory.

C'est bien et utile, mais ce n'était pas mon besoin. Mon besoin était un besoin de m'y retrouver dans mon développement, pas de nettoyer ma configuration.

Dependency Analyzer :

me montre les dépendances extraites récursivement à partir d'un projet source donné,
donne toutes les bibliothèques, donc en particulier pléthore de bibliothèques tierces,
traite correctement les versions,
s'appuie sur les POMs installés du local repository.

Mon outil :

me montre les dépendances dans un espace de travail vu comme un ensemble,
est centré sur les projets dont j'ai les sources de l'espace de travail plutôt que les bibliothèques tierces ou les projets déjà construits,
fait n'importe quoi avec les versions (bug secondaire vu mon besoin),
s'appuie sur les POMs en cours de développement de l'espace de travail.

Les deux types d'outils se complètent.

Développement : visualisation de dépendances Maven

2009-01-30T07:23:00.012+01:00

Voici une micro-documentation sur l'outil dont je parlais dans mes précédents billets, qui produit un diagramme UML à partir d'une analyse des dépendances entre des projets Maven.

Pour télécharger l'outil

En utilisant Maven, avec l'adresse de mon repository :

http://ref.avcompris.com/nexus/content/repositories/public-releases/

Ou en prenant directement le JAR : JAR with dependencies.

Pour utiliser l'outil depuis Ant

Pour ne pas trop se prendre la tête, mettre le JAR téléchargé avec les autres bibliothèques de Ant : répertoire $ANT_HOME/lib/. Sinon, il faut renseigner <classpath> dans les <taskdef> ci-dessous.

Le principe ensuite consiste à enchaîner deux tâches :

concaténation de tous les POMs dans un seul fichier XML (xmlconcatscan)
analyse de ce fichier et génération d'un diagramme UML (poms2uml)

Voici un exemple :

<project name="umlgen" default="umlgen">

<taskdef name="xmlconcatscan"
classname="com.avcompris.tools.ant.XMLConcatScanTask">

</taskdef>

<taskdef name="poms2uml"
classname="com.avcompris.all.uml.ant.Poms2UmlTask">

</taskdef>

<target name="umgen">

<mkdir dir="target" />

<xmlconcatscan destFile="temp.xml">
<fileset dir="/home/blabla/workspace"> 
<include name="*/pom.xml" />
</fileset>
</xmlconcatscan>

<poms2uml srcFile="temp.xml"
destFile="all-poms.uml" />

</target>

</project>

Ce projet Ant scanne le répertoire « /home/blabla/workspace », puis produit un diagramme UML dans le fichier « all-poms.uml ». Ce fichier peut ensuite être ouvert et manipulé avec l'outil StarUML.

Diagramme après nettoyage dans StarUML

Cet exemple est fourni, plus complet, dans le projet Maven avc-commons-all-umldep.

Pour poser une question au support ;-)

Écrire un commentaire dans cet article de blog http://snurl.com/azp1d

Ou par e-mail : david.andriana@free.fr

Pour récupérer les sources en local

Note : les sources sont en UTF-8.

Elles se récupèrent en lecture sur http://svn.avcompris.com/

Faire un checkout, projet par projet :

svn co http://svn.avcompris.com/avc-commons-all-noci/trunk avc-commons-all-noci
svn co http://svn.avcompris.com/avc-commons-all-umldep/trunk avc-commons-all-umldep
svn co http://svn.avcompris.com/avc-commons-databeans/trunk avc-commons-databeans
svn co http://svn.avcompris.com/avc-commons-lang/trunk avc-commons-lang
svn co http://svn.avcompris.com/avc-commons-parent/trunk avc-commons-parent
svn co http://svn.avcompris.com/avc-commons-testutil/trunk avc-commons-testutil
svn co http://svn.avcompris.com/avc-plugin-common/trunk avc-plugin-common
svn co http://svn.avcompris.com/avc-plugin-parent/trunk avc-plugin-parent
svn co http://svn.avcompris.com/avc-tools-ant/trunk avc-tools-ant
svn co http://svn.avcompris.com/avc-tools-common/trunk avc-tools-common
svn co http://svn.avcompris.com/avc-tools-databeans-plugin/trunk avc-tools-databeans-plugin
svn co http://svn.avcompris.com/avc-tools-databeans-plugin-ut/trunk avc-tools-databeans-plugin-ut

(12 projets au total)

Ou alors une astuce sous Unix :

créer des répertoires vides « avc-commons-all-noci », « avc-commons-all-umldep », etc. puis taper la commande suivante :
for i in `ls`; do svn co http://svn.avcompris.com/$i/trunk $i; done

Pour construire tous les projets avec Maven en ligne de commande, se placer dans le répertoire « avc-commons-all-noci », et taper la commande : mvn install

Pour installer les sources dans son IDE

Pour Eclipse, une fois que tous les projets Maven ont été récupérés en local, se placer dans « avc-commons-all-noci », et taper la commande : mvn eclipse:eclipse

Cela crée les fichiers .project et .classpath attendus par Eclipse.

On peut ensuite importer les projets dans Eclipse.

Pour IDEA : File, Open Project..., et ouvrir avc-commons-all-noci/pom.xml.

Pour lancer l'outil depuis Eclipse

La classe de tests JUnit WorkspaceInsiemeUmlTest dans le projet avc-commons-all-umldep fait justement un test de scan, concaténation et génération d'UML. Il suffit donc de lancer le test JUnit, que ce soit depuis son IDE ou en ligne de commande. Exemple : mvn test

Une fois le test lancé on peut récupérer le fichier « all-poms.uml » dans le répertoire « target », et c'est le même que ci-dessus.

Développement : packaging de l'outil de visualisation de dépendances Maven

2009-01-30T00:27:00.004+01:00

Voici que quelqu'un qui lit mon blog me demande l'outil qui produit un diagramme UML correspondant aux dépendances entre mes projets Maven... Voir mon post ici : Visualiser les dépendances entre projets Maven.

OK, certes c'est à sa propre demande et à ses risques et périls, et il est par ailleurs simple d'envoyer le JAR par e-mail à cette personne.

Mais alors quid de :

la capitalisation ? C'est-à-dire, cette démarche d'envoyer le JAR, comment la répéter à moindre coût si on me refait plus tard la demande ?
la documentation ? Je n'ai pas tellement envie de passer du temps là-dessus.
le support ?
... la capitalisation du support : il y aura des bugs, des questions, auxquelles je répondrai volontiers, mais comment capitaliser là-dessus ?
... l'accès aux entrailles de l'outil : le mieux serait de donner accès aux sources.
la licence sur l'outil et son utilisation ? - voire sur ses sources.

Donc, cher fred que je ne connais pas ;-) je propose que nous fassions simple :

pour le JAR, je le rends publiquement disponible sur mon serveur Nexus. Le téléchargement se fait donc par en utilisant comme repository Maven : http://ref.avcompris.com/nexus/content/repositories/public-releases/ Ou directement pour le JAR en question : JAR with dependencies.
pour les sources sous Subversion, je les mets ici, accessibles en lecture seule par HTTP sans authentification : http://svn.avcompris.com/
pour la documentation, eh bien je vais faire un article dans ce blog pour expliquer succinctement comment faire fonctionner l'outil. Prochainement. Le reste proviendra des réponses aux questions.
pour le support, donc, envoyer questions/réponses dans le blog ou par e-mail.
pour la licence :
... utilisation et modification qui imposent de respecter et de mentionner le nom de l'auteur David Andrianavalontsalama, ou encore David Andriana an nom d'usage
... application de la licence open source BSD, dont une version en anglais est ici : The BSD License
... utilisation et modification libres sans restriction à part celles qui précèdent.
logiciel et sources mis à disposition sans aucune garantie de quoi que ce soit et attention ce logiciel peut partir en vrille et vous êtes responsable de ce qui arrive, à vous ou à d'autres, à partir du moment où vous l'utilisez.

Je ne vais pas recopier tout de suite la licence dans les fichiers sources. Manque de temps, tout ça.

Déjà qu'il me faut faire les deux trois choses qui suivent...

...

Plus de quatre heures après (eh oui !), voici ce que ça m'a coûté :

créer sur mon serveur Nexus un repository ouvert au public pour les 12 projets Maven concernés,
changer la configuration <distributionManagement> des projets Maven pour qu'ils se déploient désormais dans ce repository,
passer deux projets de mon repository Subversion privé vers mon repository public,
rajouter une ligne de Copyright dans les fichiers,
faire une petite revue de javadoc rapide « histoire de »,
passer quelques tests maison orientés qualité,
reconstruire les projets,
lancer les releases Maven,
rédiger et publier des articles de blog.

Je suis à quelques jours d'une mise en production d'un projet qui dépend de ceux-là : il était donc de toute façon nécessaire que je fasse tout ce qui concerne les releases Maven. On va dire que le fait de rédiger de la doc est un effet collatéral positif ;-)

Voilà fred, tu pourras me faire ton retour...

Développement : à propos d'injection de dépendances (DI)

2009-01-27T08:50:00.012+01:00

Petit topo sur la DI telle que je la pratique en Java en ce moment.

Généralités

L'injection de dépendances (en anglais Dependency Injection, DI) est aujourd'hui un principe fondamental de la programmation. Elle évite par exemple de devoir instancier directement des implémentations. Du code comme celui-ci :

public class PeopleManagerImpl implements PeopleManager {

   private final EmailSender sender = new EmailSenderImpl();
   private final Collection<Person> people =
   new ArrayList<Person>();

   public void welcomeNewPerson(String name, String email) {
   people.add(new Person(name, email));
   sender.sendMail(mail, "Welcome " + name);
   }
}

Devient par exemple avec l'injection de dépendances :

import static com.google.common.base.Preconditions.checkNotNull;
import com.google.inject.Inject;

public class PeopleManagerImpl implements PeopleManager {

   private final EmailSender sender;
   private final Collection<Person> people =
   new ArrayList<Person>();

   @Inject
   public PeopleManagerImpl(EmailSender sender) {
   this.sender = checkNotNull(sender);
   }

   public void welcomeNewPerson(String name, String email) {
   people.add(new Person(name, email));
   sender.sendMail(mail, "Welcome " + name);
   }
}

L'injection de dépendances est particulièrement utile pour les tests, ainsi que pour la programmation orientée aspects (AOP).

Comparée à d'autres types d'injection de champs, par exemple via des accesseurs ou en manipulant directement les champs, je trouve que l'injection par le constructeur est la plus fiable. Vu qu'on peut tout manipuler au runtime en Java cela relève au final d'une sorte de convention, mais cette convention est bien relayée par les compilateurs et les IDEs.

Comme on l'aura compris au vu du code précédent, c'est l'approche suivie par Google Guice, bibliothèque que j'apprécie particulièrement. Parmi ses avantages :

son API est typée (Java 5),
la responsabilité de la bibliothèque est bel et bien limitée à l'injection de dépendances,
la configuration se fait en Java, donc avec les avantages du typage, et non en XML ou autre.

Pour le code ci-dessus, voici un exemple de code client qui récupère une instance et l'utilise :

PeopleManager peopleManager =
   injector.getInstance(PeopleManager.class);
peopleManager.welcomeNewPerson(
   "Jean Dupont", "jean.dupont@xxx.com");

Injecter une ressource avec cycle de vie

Parlons par exemple de l'injection d'une connexion SQL, qu'il s'agit de fermer à la fin de son utilisation. Je sais je sais, je suis vieux jeu en gérant mon mapping O/R moi-même.

Le code suivant accède à la base de données :

public class PeopleManagerImpl implements PeopleManager {

   private final Collection<Person> people =
   new ArrayList<Person>();

   public void persistPeople() {
   try {
   Connection cxn = ...; // ?
   try {
   PreparedStatement pstmt =
   cxn.prepareStatement("INSERT INTO people"
   + " (name, email) VALUES (?, ?)");
   try {
   for (Person p : people) {
   pstmt.setString(1, p.getName());
   pstmt.setString(2, p.getName());
   pstmt.executeUpdate();
   }
   } finally {
   pstmt.close();
   }
   } finally {
   cxn.close();
   }
   } catch (SQLException e) {
   throw new UncheckedBusinessException(e);
   }
   }
}

Noter la transformation des SQLException en exceptions métier (qui soient Runtime, histoire d'alléger le code).

La question est : comment récupérer l'objet Connection ? On ne peut pas l'injecter par le constructeur de PeopleManagerImpl, car chaque appel de méthode qui accède à la base de données se termine par un cxn.close() donc au bout du deuxième appel sur le même objet cxn ça plantera.

La solution est évidemment d'injecter une factory, en l'occurrence un provider qui crée une nouvelle connexion à chaque fois :

public class PeopleManagerImpl implements PeopleManager {

   private final ConnectionProvider cxnProvider;
   ...

   @Inject
   public PeopleManagerImpl(ConnectionProvider cxnProvider) {
   this.cxnProvider = checkNotNull(cxnProvider);
   }

   public void persistPeople() {
   try {
   Connection cxn = cxnProvider.createConnection();
   try {
   PreparedStatement pstmt =
   cxn.prepareStatement(...);
   ...
   } finally {
   cxn.close();
   }
   } catch (SQLException e) {
   throw new UncheckedBusinessException(e);
   }
   }
}

Personnellement je trouve super pénible cette obligation d'appeler soi-même la méthode create() sur la factory et de faire le close() final (eh oui, il n'y a pas de destructeurs en Java), sans compter la transformation de l'exception. 9 lignes de code pour rien au total.

Injection de paramètres dans les méthodes

J'ai donc trouvé une autre solution : changer la signature des méthodes dans l'implémentation, pour y injecter des objets dont le cycle de vie est géré par le container.

Cela implique de casser le lien entre interface et implémentation. Même si je déclare ce lien à la compilation par une interface paramétrée - que j'ai appelée BeanImpl -, la cohérence entre les méthodes de l'implémentation et celles de l'interface ne sont vérifiées qu'au runtime.

Les méthodes à appeler dans le cycle de vie sont également annotées. Quant à la classe d'implémentation elle-même, elle continue d'être gérée par Guice, ce qui permet d'utiliser @Inject.

public class PeopleManagerImpl
implements BeanImpl<PeopleManager> {

   final ConnectionProvider cxnProvider;

   @Inject
   public PeopleManagerImpl(ConnectionProvider cxnProvider) {
   this.cxnProvider = checkNotNull(cxnProvider);
   }

   public void persistPeople(@BeanInject Connection cxn)
   throws SQLException {
   PreparedStatement pstmt = cxn.prepareStatement(...);
   try {
   ...
   } finally {
   pstmt.close();
   }
   }

   @InitBeanInject
   private Connection createConnection()
   throws SQLException {
   return cxnProvider.createConnection();
   }

   @ReleaseBeanInject
   private void releaseConnection(Connection cxn)
   throws SQLException {
   cxn.close();
   }
}

Je gagne ainsi en lisibilité dans mes méthodes (sauf quand le code est affiché dans Blogger, apparemment...), donc en productivité de développement.

Noter que le code du client est toujours le suivant :

PeopleManager peopleManager =
injector.getInstance(PeopleManager.class);
...

À la compilation, il n'y a plus qu'un lien lâche entre l'interface et l'implémentation-cœur. Une autre contrainte de cette méthode est que l'interface du Bean PeopleManager ne peut pas avoir deux méthodes de même nom avec des signatures différentes. En fait cela était déjà une convention dans mes programmes, pour des raisons de portabilité vers d'autres langages comme PHP.

En tout cas j'aime bien.

Développement : visualiser les dépendances entre projets Maven

2009-01-26T15:33:00.005+01:00

Mon projet global est constitué d'une bonne centaine de projets Maven. Cette structure est assez pratique pour l'intégration continue (voir le tableau de bord Continuum 1.0.3) et pour vérifier que tout fonctionne sur différentes plates-formes, pratique pour les releases, pratique pour construire morceau par morceau et intégrer de même. Par exemple on peut segmenter la difficulté d'intégrer des Web Services en isolant les responsabilités suivantes dans des projets différents :

logique applicative,
liens avec la base de données,
interopérabilité,
distribution,
sécurité.

Cependant au fil des développements les projets évoluent, et les liens entre eux. On se retrouve avec une sorte de plat de spaghettis dont il nous manque une vue d'ensemble. Pour cela je n'ai pas trouvé mon bonheur dans des outils comme le Maven Dependency Plugin, plugin certes très utile, mais cantonné à des analyses projet par projet.

À défaut d'avoir trouvé un outil qui réponde exactement à mon besoin, j'en ai développé un moi-même. Ce n'est certes pas mon métier de faire ça, je ne vais donc pas aller plus loin pour cet outil que la bête réponse, non intrusive, au besoin initial.

C'est un programme qui scanne les fichiers pom.xml de mon espace de travail, et produit un diagramme UML.

Dépendances entre mes projets Maven.

Pour les détails :

le programme est en Java (le scan et la concaténation étaient au départ une tâche Ant),
le diagramme UML final est un fichier XML au format du logiciel StarUML,
le temps d'exécution (scan, analyse, génération) est de 10 secondes pour 113 projets.

Quelques différences de principe avec le Maven Dependency Plugin :

je m'appuie sur les sources des fichiers POM, et non sur les artifacts déjà installés dans le repository local - je peux donc aussi analyser les POMs de projets qui sont en erreur,
l'analyse porte sur l'espace de travail complet,
le rendu est graphique.

Je traduis ainsi en UML les liens entre projets Maven :

<parent> : héritage UML
<dependency> : association UML
<module> : agrégation UML
<plugin> : dépendance UML

Certes, le diagramme UML produit par défaut est illisible parce que surchargé. L'intérêt d'avoir un résultat lisible par un logiciel tiers, StarUML en l'occurrence, est qu'on peut ensuite y déplacer à la main des éléments et en supprimer, afin d'en extraire des sous-diagrammes orientés par domaine.

Voici par exemple un extrait du diagramme ci-dessus, limité à une vingtaine de projets, pour une couche applicative sur laquelle je bosse en ce moment.

Ce genre de petite documentation extraite des fichiers sources est bien utile. La cohérence est importante entre la documentation et le développement.

Pour en revenir à Maven, cette vue permet entre autres de visualiser les dépendances inutiles (quand A dépend de B qui depend de C, A ne devrait pas avoir à déclarer qu'il dépend de C), ou les incohérences entre les versions des bibliothèques.

Si quelqu'un connaît des outils plus évolués pour faire la même chose je suis preneur...

Développement : Custom Maven Repository

2009-01-24T07:07:00.010+01:00

Depuis 2007 j'utilise Artifactory comme repository Maven pour :

déployer les bibliothèques tierces que je ne trouve pas dans des public Maven repositories tels que ceux d'Apache ou de Codehaus. De telles bibliothèques sont par exemple jvyaml, ou encore les outils Sun pour JMX, pourtant importants dès qu'on tape un peu dans du Lo4J 1.2.15 par exemple,
pouvoir déployer mes propres artifacts, notamment ceux en version release.

Artifactory a de nombreux avantages. Il est facile à installer, et son interface HTML est pratique d'utilisation. Il est depuis peu en 2.0.0, version stable et dont l'IHM s'appuie sur Ajax à relativement bon escient. Je compare cela avec des versions d'Archiva livrée avec Maestro, par exemple.

Artifactory fonctionne très bien, et les déploiements Maven s'y font sans souci.

En revanche, il souffre d'un gros défaut : il fait systématiquement planter la Dedibox sur laquelle je l'ai installée.

C'est une Dedibox V1, avec un processeur C7 à 2 GHz et 1 Go de RAM, sous Debian. Les services que j'y ai installés sont :

BIND9
Apache 2.2 + PHP + MySQL
Subversion
Java 5 + Tomcat 5.5.20 pour : Confluence, Jira, Artifactory
scripts de backups

Tomcat5.5 démarre avec les options de mémoire suivantes : -Xmx512m -XX:MaxPermSize=256m

Concernant les fuites mémoires connues dans Jira je suis bien en Tomcat 5.5.15+ et j'ai bien -Dorg.apache.jasper.runtime.BodyContentImpl.LIMIT_BUFFER=true

Rien n'y fait, même en désactivant le service de backup (une tâche répétitive pilotée par un serveur J2EE, bonjour l'architecture) et en limitant les repositories à indexer, Artifactory me fait tomber la machine. Certes pas tout à fait à heure fixe, mais en moyenne cinq fois par semaine.

Plantage de machine, ce qui signifie notamment que le wiki et Subversion sont inaccessibles. De plus un redémarrage matériel est nécessaire, ce qui n'est jamais très bon.

Sachant d'autre part que -Xmx256m suffit à faire tourner Confluence et Jira sans Artifactory.

Alors pour le remplacer je vais regarder Nexus. Une comparaison trouvée par ici : Comparing Nexus and Artifactory évoque bien les différences de philosophie, notamment dans le stockage des artifacts. Faire une sauvegarde d'un repository Nexus (un répertoire, tâche pilotable par un bête script) semble bien plus simple que dans le cas d'Artifactory (une base de données JackRabbit, et surtout tâche à piloter par le serveur J2EE... N'importe quoi).

Si cela pouvait m'éviter d'avoir à dédier une machine puissante à ma solution de Custom Maven Repository...

Rachat du nom de domaine Les Fûts

2009-01-12T18:01:00.002+01:00

Eh oui, c'est bien parti.

Je ne mets pour l'instant qu'une page web d'attente : Les Fûts, histoire de commencer le référencement.

Site de l'association graine d'école : pas Les Fûts

2009-01-07T21:12:00.006+01:00

En 2006 l'idée des Fûts a germé. Des associations locales étaient vivement intéressées par le projet, comme Graine d'école, ou Le jardin sauvage.

Et puis par manque de moyens au vu des ambitions, et aussi par un enchaînement de priorités autres, le projet les Fûts a capoté.

Pour Graine d'école j'avais fait une page HTML, qui se voulait provisoire, hébergée chez Free.

Mais, depuis, l'association a fait son propre site avec Joomla! et a un nom de domaine en .com : http://graine-ecole.com/. Il est alimenté avec des nouvelles, des photos, il a un calendrier, des documents partagés... Bref il est vivant est c'est chouette. Du coup je viens de mettre une redirection « 301 », c'est-à-dire permanente, de l'adresse http://grainedecole.free.fr/ vers le site.

Mon ancienne page se voit sur http://grainedecole.free.fr/old/

Association + groupe de rock

2009-01-07T20:43:00.002+01:00

Jean-Charles, mon voisin, vient de passer pour qu'on discute d'un projet de site web d'association.

Ben oui, je déterre occasionnellement le projet Les Fûts, sans velléité cette fois d'en faire lui-même un projet associatif.

Il me donne donc les prolégomènes de son attente, et là j'apprends qu'il y a deux sites à prévoir car deux entités conjointes : d'une part un groupe de rock, qui donne des concerts, vend des CDs, etc. dont les membres ont d'ores et déjà des espaces MySpace mais qui aimeraient éventuellement les restructurer, et d'autre part une association engagée dans des enjeux environnementaux, sorte de spin-off du groupe, association dont Jean-Charles est le président.

Ma première réaction par rapport à cette dissociation était de voir le site du groupe (site à petit budget) comme un site standard, avec tous les écueils de ce genre de projets : site vitrine, pas vraiment business driven, structure archi-classique, évolutions coûteuses, et solution parfois moins conviviale et dynamique qu'une solution gratuite.

Mais une autre direction pourrait être de définir les attentes en termes d'utilisations-types (on a commencé à parler de scénarios) et surtout de retours sur investissement, que ce ROI soit pécunier ou non (il y a la notoriété, les tremplins...). Il faudrait confronter les idées et surtout peut-être les retours d'expériences d'avoir jusqu'ici utilisé des espaces MySpace. De plus je me demande dans quelle mesure le groupe de rock évoqué ne pourrait pas être vu comme un partenaire artistique de l'association, ce qui à la limite inverserait la donne. Bref, voir quelles sont les attentes qui passent en avant.

J'en saurai davantage quand je rencontrerai les membres du groupe, à la fin de cette semaine.

Restriction des accès SSH extérieurs par IP

2009-01-06T09:47:00.005+01:00

Ce qui suit est générique, mais, pour savoir, la plate-forme considérée est une Debian.

Quand on met en place un serveur SSH sur un serveur pour en permettre l'administration à distance, on renseigne avec la ligne suivante le fichier /etc/ssh/sshd_config afin d'interdire à root de se connecter, car ce serait un beau trou de sécurité :

PermitRootLogin no

Il est également possible et facile de restreindre les accès par adresses IP pour le service SSH. Pour cela, renseigner dans le fichier /etc/hosts.allow :

sshd: adresses IP séparées par des espaces

Exemple :

sshd: 10.11.22.33 10.44.55.66 10.77.88.99

Et dans le fichier /etc/hosts.deny, renseigner :

sshd: ALL

On peut sécuriser l'accès à d'autres services que SSH, donner des classes d'adresses IP, etc.

En revanche, ne pas chercher la complication en mettant des noms d'hôtes, mais se cantonner aux adresses IP.

C'est une sécurisation fiable et simple. L'étape suivante est la configuration iptables, dont je ne traiterai pas ici.

Le schéma ci-dessous donne un exemple d'une personne derrière une « box » ADSL avec une adresse IP fixe (sinon, au premier changement d'IP, il ne sera plus possible d'administrer les serveurs !) et en mode routeur, qui administre deux serveurs, et souhaite interdire les accès SSH depuis d'autres machines.

Sur les deux serveurs il configurera un fichier hosts.deny avec sshd: ALL, et des fichiers hosts.allow :

sur la machine Serveur 1 : sshd: 10.11.22.33
sur la machine Serveur 2 : sshd: 10.11.22.33 10.44.55.66

Pour la petite histoire, tous les services n'ont pas un accès qui puisse être sécurisé par hosts.deny. En effet, il faut que le service concerné soit compatible avec les tcpwrappers, ce dont on peut s'assurer par la commande suivante par exemple pour sshd :

$ ldd `which sshd` | grep libwrap
$ ldd /usr/sbin/sshd | grep libwrap (plus précis, si which ne va pas)

Cette astuce fonctionne à peu près pour tous les services. Ainsi, ldd /usr/sbin/apache2 | grep libwrap montre que Apache 2 n'est pas compatible avec les tcpwrappers, et ne pourra donc pas voir son accès sécurisé par hosts.deny / hosts.allow.

Pour avoir un aperçu de qui cherche à se connecter en brute force par SSH sur vos machines, faites un tour dans /var/log/auth.log. Sans la sécurisation par IP on trouve en général des tentatives de connexions root, et toute une liste de tentatives avec des identifiants bidon (admin, test, virus...).

Pour compter ces tentatives :

# grep Failed /var/log/auth.log | wc -l

Sur mes serveurs le nombre de tentatives varie selon les hébergeurs entre une par heure et 150 par heure.

Millennium Falcon ™ en LEGO ®

2009-01-04T16:33:00.006+01:00

Mon fils Emmanuel vient de finir la construction de son Millennium Falcon ™ en LEGO ®. Pour le bonhomme de sept ans qu'il est cela représente plusieurs jours de concentration. Je l'ai aidé à organiser son temps pour ne pas tourner chèvre, et à gérer les erreurs de montage, inévitables sur un tel chantier.

Le principal écueil de ces énormes jeux est bel et bien la tension nerveuse, qui va souvent crescendo et s'étale sur une longue durée. Ils sont en général conseillés aux plus grands.

Et voilà, « les copains pourront être épatés » comme il dit. On verra bien ce qu'ils en pensent ; nul doute que les plus simples Kapla continueront aussi de les intéresser. Car pour le Faucon Millénium, il semble approprié de le conserver tel quel...

Pont HTTP pour FTP vers Dedibackup

2008-12-27T21:30:00.001+01:00

Souci de backup : je ne peux plus récupérer mes archives stockées sur un Dedibackup directement par FTP pour en avoir une copie locale, et accessoirement les valider. Sur ce dernier sujet voir l'article Validation de backups daté d'avril 2008.

Les serveurs Dedibackup sont des espaces FTP accessibles depuis les serveurs dédiés Dedibox, et jusqu'à il y a quelques mois ils étaient également accessibles en download par l'extérieur. Il suffisait de sécuriser ça en n'acceptant que certaines IP appelantes.

J'utilisais donc ce système pour avoir une machine locale « bkp » qui allait chercher régulièrement ce que déposaient tout aussi régulièrement sur mon espace Dedibackup deux Dedibox « ref1 » et « ref2 ».

Pas de bol, donc, Dedibox a coupé l'accès extérieur :

Comment résoudre ça au plus vite ? J'ai fait un service web ad hoc qui délègue ensuite au FTP, pour « contourner » le problème comme on le voit :

Le gros du boulot a consisté à bétonner le fonctionnement du client FTP embarqué dans la webapp J2EE, elle-même bien bridée (une seule exécution à la fois, etc.). Les choix d'architecture n'étant pas vraiment conformes à la norme et donc n'apportant aucune garantie, « bétonner » signifie ici développer des tests d'intégration sur des chaînes un peu trapues. Au total avant d'être déployé, le système a été validé sur 3 environnements différents, dont un d'intégration continue.

Le tout a été conçu en une journée (elapse) et développé en une journée (load). Le développement a été concentré (focus), donc en tout on a un elapse de deux jours, et c'est tant mieux puisqu'après c'étaient les fêtes. Comme les backups sont un point crucial de la chaîne du SI, et sont en même temps totalement éloignés du métier, il était important de se sortir de cette charge le plus vite possible. Il ne reste qu'à mener des tests de performances et avoir des chiffres pour le futur suivi des évolutions.

Je dégage de cette histoire deux enseignements :

c'est justement parce que certaines choses importantes ne font pas partie à proprement parler du métier qu'il faut absolument s'en occuper sérieusement, éliminer toutes les frictions et perdre le moins de temps et d'argent possible sur elles.
une architecture technique pourrave est parfaitement acceptable (en fait je m'attends même à ce qu'elle tienne la durée) si par ailleurs les cas d'utilisation sont encadrés : en l'occurrence ceinture et bretelle par des tests en continu.

Le premier point incite au discernement quant à notre cœur de métier et pousse logiquement aux actions-force quand il y a besoin plutôt que d'accepter des demi-mesures qui laissent ouverts les problèmes périphériques. Pour atteindre le centre est nécessaire que la périphérie ne soit plus un problème |-)

Le deuxième point incite à un dilettantisme de bon aloi ; et en même temps qui sait rendre des comptes.

Let it go.

Déclaration d'une DataSource dans Tomcat 5.5

2008-12-27T20:59:00.006+01:00

Testé sous Windows XP et Debian, avec MySQL et PostgreSQL.

La webapp a les lignes suivantes dans WEB-INF/web.xml :

 <resource-ref>
  <res-ref-name>jdbc/janitorDB</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>
 </resource-ref>

Et dans META-INF/context.xml (important) :

 <Context
  path="/avpoc-webapp-datasource"
  reloadable="true"
  antiJARLocking="true"
  antiResourceLocking="true">
 </Context>

La déclaration de la DataSource jdbc/myJndiName dans Tomcat 5.5 peut se faire de la façon suivante.

D'abord dans conf/server.xml, pour par exemple MySQL :

 <Resource  
  name="jdbc/myJndiName"
  type="javax.sql.DataSource"
  password="myPassword"
  driverClassName="com.mysql.jdbc.Driver"
  maxIdle="2"
  maxWait="5000"
  username="myUsername"
  url="jdbc:mysql://localhost:3306/myDbName?autoReconnect=true"
  maxActive="4"/>

Pour PostgreSQL ça donne quelque chose comme ça :

 <Resource  
  name="jdbc/myJndiName"
  auth="Container"
  type="javax.sql.DataSource"
  driverClassName="org.postgresql.Driver"
  url="jdbc:postgresql://127.0.0.1:5432/myDatabaseName"
  username="myUsername" 
  password="myPassword"
  maxActive="20" 
  maxIdle="10" 
  maxWait="-1"/>

Ensuite dans conf/context.xml :

        <ResourceLink
  global="jdbc/myJndiName"
  name="jdbc/myJndiName"
  type="javax.sql.DataSource"/>

On peut également mettre directement dans conf/context.xml la configuration de la <Resource> mais c'est moins propre.

En tout cas si on ne met rien du tout dans conf/context.xml on obtient :

org.apache.commons.dbcp.SQLNestedException: Cannot create JDBC driver of class '' for connect URL 'null'
        at org.apache.commons.dbcp.BasicDataSource.createDataSource(BasicDataSource.java:780)
        at org.apache.commons.dbcp.BasicDataSource.getConnection(BasicDataSource.java:540)
        at com.avcompris.avpoc.webapp.PocDataSourceServlet.executePoc(PocDataSourceServlet.java:86)
        at com.avcompris.avpoc.webapp.PocDataSourceServlet.service(PocDataSourceServlet.java:42)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:802)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:252)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:173)
        at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:213)
        atA org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:178)
        at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:126)
        at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:105)
        at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:107)
        at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:148)
        at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:869)
        at org.apache.coyote.http11.Http11BaseProtocol$Http11ConnectionHandler.processConnection(Http11BaseProtocol.java:664)
        at org.apache.tomcat.util.net.PoolTcpEndpoint.processSocket(PoolTcpEndpoint.java:527)
        at org.apache.tomcat.util.net.LeaderFollowerWorkerThread.runIt(LeaderFollowerWorkerThread.java:80)
        at org.apache.tomcat.util.threads.ThreadPool$ControlRunnable.run(ThreadPool.java:684)
        at java.lang.Thread.run(Thread.java:595)
Caused by: java.sql.SQLException: No suitable driver
        at java.sql.DriverManager.getDriver(DriverManager.java:243)
        at org.apache.commons.dbcp.BasicDataSource.createDataSource(BasicDataSource.java:773)
        ... 18 more

Joyeux Noël

2008-12-25T20:26:00.001+01:00

J'adore cette fête :-)

Wanted: Code reviewers

2008-12-22T08:23:00.003+01:00

Je suis à la recherche de personnes qui pourraient regarder avec un œil critique du code Java que j'écris, et me faire des remarques.

Code libre d'accès (http://svn.avcompris.com/), liberté de bloguer le résultat des revues, échanges par messagerie instantanée ou e-mail.

La critique est attendue à tous les niveaux : licensing, architecture, choix techniques, cohérence fonctionnelle, cohérence technique, conception, algorithmique, bonnes pratiques, outillage, conventions et le reste.

C'est une activité non rémunérée : je ne sais pas qui des deux parties a le plus à y gagner... :-)

Et en échange... ben faites vos propositions.

Pour se remettre au LOGO

2008-12-17T00:53:00.008+01:00

Histoire de permettre à de très jeunots de s'initier à la programmation, j'ai implémenté un interpréteur des commandes basiques du LOGO par ici : http://www.half-serious.com/logo/

Le langage LOGO permet en gros de faire des dessins à l'aide d'une tortue qui sait tracer des traits et pivoter sur elle-même.

Les commandes reconnues dans mon implémentation sont :

FORWARD xxx, ou FD xxx : avancer la tortue de xxx points
BACK xxx, ou BK xxx : reculer la tortue de xxx points
RIGHT xxx, ou RT xxx : pivoter la tortue d'un angle xxx à droite
LEFT xxx, ou LT xxx : pivoter la tortue d'un angle xxx à gauche
PENUP, ou PU : lever le crayon
PENDOWN, ou PD : rebaisser le crayon
HIDETURTLE, ou HT : cacher la tortue
SHOWTURTLE, ou ST : montrer la tortue
REPEAT xxx [ ... ] : répète xxx fois les commandes entre crochets

Voilà. Pas de procédures, pas de variables, pas de calculs. Du bon basique pour débuter.

L'exemple ci-dessous dessine un carré :

FORWARD 100

RIGHT 90

FORWARD 100

RIGHT 90

FORWARD 100

RIGHT 90

FORWARD 100

Cet exemple peut aussi s'écrire FD 100 RT 90 FD 100 RT 90 FD 100 RT 90 FD 100, et un dessin équivalent est REPEAT 4 [FD 100 RT 90].

Quant à l'exemple ci-dessous, il dessine une espèce de rosace :

HIDETURTLE

REPEAT 100

[

FD 300 RT 45

FD 50 RT 125

]

Surveillance de la santé des machines

2008-12-13T20:00:00.006+01:00

Soit un parc de machines et services hétérogène : machines locales, distantes, serveurs web, Subversion, divers sites, divers hébergeurs, divers noms de domaines et registrars, bref, tout et n'importe quoi.

Comment assurer une surveillance de tout ceci ?

J'avais bien quelques outils de surveillance web, mais ils n'analysent pas forcément tous les critères, ni ne versionnent les règles de surveillance.

J'ai bien quelques tests JUnit, mais ils dépendent d'un environnement d'exécution (Continuum) assez lourd, qui lui-même peut être soumis à plantage, en particulier parce qu'un serveur J2EE demande beaucoup de ressources.

Je me décide donc à rationaliser tout cela :

une seule technologie d'écriture des tests : Java, sous la forme de tests JUnit.
une version minimale du service de surveillance, qui assure le découplage des traitements et de l'affichage :
- un daemon Java le plus léger possible pour l'exécution des tests,
- une application PHP pour afficher les résultats de façon simplifiée,
- une communication entre Java et PHP qui passe par une base de données.
et une réplication de ce système sur deux machines différentes, au cas où l'une d'entre elles tomberait en panne.

Le système avec Continuum est conservé sur une (grosse) machine, en lui faisant en prime exécuter les mêmes tests JUnit que la version daemon Java + PHP.

Reste à faire en sorte qu'un e-mail soit envoyé automatiquement quand un service est détecté comme tombé. Possibilité de configuration en Java : déclarer la gravité du test dans une annotation de même niveau que @Test.

Et évidemment tester par le système lui-même les fonctionnalités d'envoi et de réception d'e-mail.

Quelques états de santé à agréger :

bonne santé de toutes les applications web déployées,
Twitter,
envoi et réception d'e-mails,
âge du ou des derniers backups inférieur à 24 h,
espaces disques libres supérieurs à 50 %...

Des idées ?

Merci d'avance.

Projet Les Fûts

2008-12-13T17:24:00.003+01:00

Mmh, alors que les associations peuvent relativement facilement et à moindre coût se doter elles-mêmes d'un site web (voir par exemple le site officiel de Graine d'école : http://graine-ecole.com/ réalisé avec Joomla!), voilà-t-y pas qu'on me relance pour la réalisation de sites associatifs.

Si l'aventure doit être retentée j'abandonnerai la structure associative, sans beaucoup de valeur ajoutée. Et j'augmenterai un peu les tarifs, pour être plus proche du marché.

En l'occurrence il s'agirait d'une association qui a également un produit à présenter sur le web, à dissocier éventuellement du site associatif lui-même.

Chez Maître Eolas : Journal des magistrats en colère

2008-10-23T20:47:00.004+02:00

Maître Eolas ouvre son espace à la parole de magistrats. http://maitre-eolas.fr/

Plus de 50 articles, en majorité des témoignages.

À tous, bienvenue chez les blogs, levier bénéfique pour la parole vraie.

Intégration continue au boulot

2008-09-09T19:29:00.004+02:00

Après un mois et demi dans mes nouvelles fonctions, je viens de faire une présentation de l'intégration continue à mon équipe. Cela vient au moment où nous avons déjà des premiers résultats : intégration via Continuum dans WebSphere d'une douzaine de modules Maven sur une centaine, réalisée par un petit groupe, même pas dédié à cent pour cent.

En plus des questions sur le sujet stricto sensu, la présentation a été suivie d'un débat ouvert où toute l'équipe a eu l'occasion de participer et de s'exprimer, sur le thème « existant, problèmes, améliorations ». Le côté expression libre est primordial quand on a de gros enjeux de développement informatique. Je pense réitérer l'expérience, que j'ai jugée extrêmement positive, quand le moment viendra.

Bref, une bonne fin de journée. J'ai cadré la réunion sur deux heures, ni trop ni trop peu. On verra par la suite si les-filles-zet-les-gars alimentent de leurs réflexions le wiki commun.

Mais je suis bien confiant :-)

Un peu de code pour la détente

2008-09-06T07:08:00.002+02:00

Ben oui, histoire de se faire un peu plaisir, quelques heures de programmation bien installé dans son fauteuil. Dans le temps on lisait des polars.

C'est drôle, ça se ressemble aujourd'hui, dans l'aspect quête de la vérité.

Dans un polar on vous donne assez souvent le contexte et les événements à élucider, le plus généralement un meurtre ou plusieurs. S'ensuit une histoire, qui ne raconte pas l'histoire elle-même (sinon autant lire de la mythologie), mais qui est un déroulé de la recherche de la « solution ». Solution au sens de résolution plus que de preuve. Le plaisir réside dans ce déroulé, et évidemment dans le succès final qui est moins la compréhension (penser au Big Sleep, incompréhensible, de son propre aveu pour son auteur même) que l'élucidation, la mise à la lumière de ce qui était caché ou obscur.

Dans le développement informatique aujourd'hui, avec des méthodologies comme TDD (Test Driven Development), on a un peu le même aspect, et évidemment le même plaisir. Je m'explique. En TDD, on commence par écrire les tests, c'est-à-dire que le programme n'existe pas encore, mais on commence déjà à le faire planter. Ensuite, le travail consiste à réaliser le programme pour faire passer les tests. Et quand on a fini, il arrive selon la complexité ou le déroulé qu'on ne comprenne plus rien (c'est rare) à ce qu'on a programmé, mais dans tous les cas au moins les tests passent. On peut alors livrer le programme, et c'est bien cette élucidation qu'on recherchait.

Je parlais au début de quête de la vérité, dans le sens de sa nature, évidemment, pas de son contenu.

Bien qu'en poursuivant l'analogie avec le polar, écrire du code aujourd'hui apprenne aussi des choses sur le monde : quelques clics sur Wikipédia pour cerner un cas fonctionnel, et on découvre de nouveaux espaces à connaître, de façon comparable à ce qui se passe lors d'une digression dans un roman policier, Série Noire ou pas. La seule chose qu'on n'ait pas est l'aspect historique : les informations du web sont d'une part récentes (moins de 20 ans), et sans cesse actualisées. Un exemplaire de la Série Blême a, lui, une présence qui vient tout droit d'une autre époque.

Toujours dans l'analogie entre code développé en TDD et polar, on pourrait dire que dans le code les tests s'accumulent de la même façon qu'on peut toujours dans un livre revenir aux pages précédentes sans qu'elles aient changé (non, le « Livre de sable » que décrit Borgès n'est pas un polar ;-)). Ce n'était pas du tout le cas avec d'autres façons de programmer, où au contraire les tests se faisaient de façon globale à la fin, sur l'objet complet. C'était de l'ingénierie classique, pas du développement.

Alors, un peu de code pour la détente.

Nouvelles de Limoges

2008-07-27T07:22:00.011+02:00

Pour mon fils Emmanuel je suis venu m'installer à Limoges.

C'est à la mi-mai 2008, c'est-à-dire il y a deux mois et demi, que j'ai quitté Montech dans le Tarn-et-Garonne pour la Haute-Vienne. C'était une période idéale pour s'installer.

J'habite maintenant pas très loin du centre de Limoges, près de la gare.

J'ai trouvé une petite maison avec vue et jardin, et des voisins fort sympathiques. La voisine au Nord élève des poules (c'est génial, non ? En pleine ville en plus), le voisin de l'Ouest a un magnifique potager (même remarque), au Sud ce sont des étudiants, et du côté Est on me tient parfois en rentrant du boulot des discussions très intéressantes.

La dernière fête organisée pour Emmanuel et ses copains a été très réussie aussi.

(des pingouins qui se mettent à l'eau et s'éclaboussent, quel rapport ? me direz-vous)

Côté boulot sur Limoges dans ma spécialité, j'ai commencé une mission au CNASEA ce mercredi. J'y ai déjà rencontré des personnes attachantes.

Petite fête du côté des étudiants vendredi soir, et hier samedi j'ai eu l'occasion à Blond au festival Estivol, de faire de la montgolfière au-dessus du pays.

(photo non contractuelle)

Tout ça commence bien.

"The F5 Factor"

2008-07-07T17:02:00.010+02:00

Une tendance généralisée dans le développement informatique est l'utilisation d'environnements de développements (IDE, Integrated Development Environment), comme Eclipse, dont je vous conseille par ailleurs la 3.4 « Ganymede ». Ces outils apportent par exemple la syntaxe colorée, la navigation entre fichiers, mais aussi l'aide à la saisie et la compilation à la volée, parmi des milliers d'autres fonctionnalités (je n'exagère pas).

Je pense qu'il faut distinguer entre ces fonctionnalités par leur type d'interaction avec l'utilisateur :

sans interaction : la coloration syntaxique, par exemple. La frappe suit son cours, et le résultat est formaté à l'écran.

interaction au cours de la frappe : vérification de la syntaxe, aide à la saisie, compilation en tâche de fond... Ces assistants se déclenchent certes de façon asynchrone (ouf !), mais pompent quand même des ressources, aussi bien sur la machine que dans le cerveau de l'utilisateur (les fenêtres pop up ne sont jamais neutres pour un cerveau humain ;-)), ce qui au final freine le rythme naturel de la frappe... tout en accélérant par ailleurs la saisie des noms de classes, de méthodes, de variables. Avec une utilité à mesurer pour chacun, donc.

interaction par décision de l'utilisateur : lancer l'exécution de tests ou d'une application par exemple. Cela se fait en général par un raccourci-clavier, plus rapide qu'un clic souris. Cette interaction ne perturbe pas le flot de développement : l'utilisateur déclenche de lui-même les événements.

Je ne parle pas des interactions de type Wizard, où l'utilisateur suit une série de formulaires.

Ajoutons un quatrième type, l'interaction par déclenchement en ligne de commande d'un script par l'utilisateur. En gros, je vais dans ma console, je tape ma commande (disons : mvn clean install), elle s'exécute, et je me rends le plus souvent dans une autre application pour voir le résultat (disons : un éditeur de texte, pour voir les logs).

Cette dernière interaction est la plus primitive et naît de la nécessité (pas d'intégration continue sans scripts autonomes, par exemple), et pourtant c'est celle qui est la plus perturbatrice, car on navigue entre des contextes différents, avec leurs IHMs et leurs temps propres. Là où les IDEs font énormément gagner de temps, c'est bien sur la suppression des interactions en ligne de commande.

Prenons par exemple un script qui fabrique et déploie une application web (je me place dans le cas où le serveur web n'est pas embarqué dans l'IDE, cas le plus courant pour moi). Le scénario classique est le suivant :

IDE : finir de modifier le code
console : lancer le script en ligne de commande de fabrication et de déploiement
navigateur web : voir le résultat

Pour gagner en puissance, nous pouvons faire la chose suivante qui nous évite le passage par la console :

IDE : finir de modifier le code
IDE : lancer le script externe par un raccourci clavier (voire obliger son lancement automatique après toute modification)
navigateur web : voir le résultat

Mais je pense que c'est quand même une perte cognitive : on demande à un contexte (l'IDE) de réaliser quelque chose, qui peut d'ailleurs mettre du temps, dont on verra le résultat dans un autre contexte (le navigateur). Cognitivement on est déjà dans le résultat (on sait ce qu'on demande au final : un résultat dans le navigateur), mais du point de vue de l'outillage on est encore dans la préparation (l'IDE).

Pour moi la bonne séquence est la suivante :

IDE : finir de modifier le code
navigateur web : rafraîchir la page en cours (touche F5), ce qui lance le script externe, puis affiche le résultat, sans changer de contexte

J'appelle ça le « facteur F5 » ("The F5 Factor" en anglais). Ce principe est orienté contexte de résultat, et non environnement de développement.

Si possible, disposer de deux machines, une pour le code, une pour le navigateur : ainsi il ne s'agit que d'appuyer sur F5 sur le clavier d'à côté. Pas d'autre manipulation du genre Alt-TAB. Aucun changement d'application, de perspective, de vue, de fenêtre, de space... ni aucun switch mécanique : on tourne simplement la tête.

Dans ce modèle, le serveur web doit évidemment être sur la première machine, ou en tout cas avoir accès aux fichiers qui ont été modifiés.

J'essaie de faire en sorte que mes outils de développement web, notamment mes outils de maquettage, mais aussi mes outils de validation, appliquent le « facteur F5 ». Cela pose de nombreuses questions d'intégration et de réactivité : sur la parallélisation des traitements, sur l'optimisation, sur la gestion des fichiers, etc. mais aussi sur le découpage des composants : s'il faut dérouler ne serait-ce qu'une partie de scénario fonctionnel pour arriver sur la page dont on veut valider le HTML, on n'est plus dans le « facteur F5 ». C'est dire s'il faut parfois pour se donner les moyens réarchitecturer entièrement un projet, et notamment repenser les phases de maquettage.

Ces outils sont évidemment couplés à des scripts autonomes (toujours pour l'intégration continue), mais les scripts encapsulent les outils, et non le contraire.

Au final, un très grand confort de développement : modifier deux lignes de Java, et voir le résultat quasiment immédiatement dans le navigateur. On se croirait en PHP ?... En fait c'est encore mieux, car si toutes les pages du site sont testables en appliquant le « facteur F5 », le temps gagné est inestimable. Par ailleurs il s'agit là d'une méthodologie, et c'est donc transverse aux technologies.

Pour mémoire, mon dernier outil en date qui applique le « facteur F5 » est un lanceur d'applications (Java) depuis une page web, qui en affiche ensuite les résultats à l'écran : résultats images, SVG, HTML ou texte. À utiliser en phase de maquettage, en appuyant sur... F5.

Kazeii.com - Gérer, suivre, partager sa construction de maison

2008-06-30T18:11:00.002+02:00

Fin 2007 et début 2008, je m’étais lancé avec un copain établi près de Toulouse, Jérémy Girard, dans l’aventure d’une start-up web. Le thème : suivi de projets de construction de logements individuels et collectifs.

Il s’agissait d’une plate-forme web classique, de blogging, d’albums photos, etc. au service des particuliers qui font construire leur maison, cela afin de leur permettre de montrer aux copains et à la famille l’avancement des travaux (les internautes qui font construire ouvrent souvent un blog pour cela), d’avoir une vision synthétique des différentes étapes, voire d’utiliser la plate-forme pour gérer ses postes comptables et faciliter ses échanges avec l’architecte ou le maître d’œuvre. Le fait d'avoir une plate-forme centralisée pour plusieurs blogs de constructions, permettait également de créer une communauté autour du sujet.

L’idée est simple, et très bonne à mon avis. On avait pas mal dégrossi le concept, pondu un Business Model, demandé leurs avis à plusieurs professionnels, sans compter évidemment les particuliers rencontrés, puis commencé le développement. Étant tous les deux développeurs Java, ça travaillait fort.

Malheureusement, après un bout de chemin ensemble, il m’est apparu que l’équipe de Batilog.com (nom initial du projet) ne fonctionnait pas avec une vision commune. Proche, mais pas commune. Or dans un projet comme celui-là, l’énergie étant forcément présente, ce qui compte c’est la cohérence. Malgré les indéniables qualités humaines de part et d’autre, et le bon feeling, j’ai donc pris la sage décision de sortir du projet en l’état. Sage décision à mon avis en terme d’entrepreneuriat. Jérémy a continué d’arrache-pied seul pour sortir une version publique (ne me demandez pas quelle aurait été ma position : vous m’avez vu sortir une version publique dans les mêmes délais ? ;-) que voici : Kazeii.com - Gérer, suivre, partager sa construction de maison.

La version a été rendue publique hier dimanche 29 juin 2008, et il y a déjà presque 100 inscrits !

Je voudrais chaleureusement féliciter Jérémy pour avoir lancé son site. Grand bravo, et le succès pour cette implémentation d’une très bonne idée ! Il n’y a qu’à lire certains commentaires pour voir que l’accueil est positif ; Jérémy a fait connaître son site dans divers forums francophones, notamment par ici : Forum BricoZone - Sujet : Comment assurer un bon suivi de sa construction.

Bonne route Jérémy :-)

La vérification à la compilation, c'est bien

2008-06-27T16:46:00.006+02:00

Soit un modèle où l'on diffère, sous forme de commandes, des appels à passer à une certaine classe. Par exemple, dans le cas où l'implémentation finale de la classe est distante, on souhaite passer tous les appels dans une seule connexion réseau : on va donc trouver un moyen de « sérialiser » les intentions d'appels, en général sous forme de texte, on les enverra en lot, puis côté serveur la liste sera détricotée, les appels passés, et on retournera la liste des résultats (dans le cas où tout se passe bien).

Pour illustrer le problème, disons que l'interface de la classe distante s'appelle « Toto », avec les méthodes « doSomething(int, int) » et « doSomethingElse(String) ».

On faisait jusqu'ici un appel réseau pour chaque invocation :

Avec le code Java ci-dessous :

final Toto toto = <proxy>; // proxy pour appel distant

toto.doSomething(2, 5); // 1er appel
toto.doSomething(14, 8); // 2e appel
toto.doSomethingElse("Fantastic!"); // 3e appel
toto.doSomething(0, 1); // 4e appel

Après s'être aperçu qu'on pouvait gagner en performances, nous décidons que du point de vue du réseau il n'y aura qu'un appel, qui agrègera les invocations :

Eh bien je ne sais pas pourquoi, mais pour faire ça certains pensent à écrire la chose suivante :

final Commands commands = new Commands(Toto.class);

commands.storeCommand("doSomething", 2, 5); // 1er
commands.storeCommand("doSomething", 14, 8); // 2e
commands.storeCommand("doSomethingElse", "Fantastic!"); // 3e
commands.storeCommand("doSomething", 0, 1); // 4e

CommandUtils.executeCommands(<proxy>, commands);

C'est tout à fait dommage, car on perd l'avantage de la vérification à la compilation : si on se trompe dans une chaîne de caractères qui contient un nom de méthode, ou dans le type des paramètres d'une méthode, on ne s'en apercevra qu'à l'exécution.

En fait il faut s'arranger pour pouvoir coder ainsi :

final Toto toto = FutureUtils.newFuture(Toto.class);

toto.doSomething(2, 5); // 1er appel
toto.doSomething(14, 8); // 2e appel
toto.doSomethingElse("Fantastic!"); // 3e appel
toto.doSomething(0, 1); // 4e appel

FutureUtils.execute(<proxy>);

C'est-à-dire qu'il faut s'appuyer le plus possible sur ce qui compile... déjà.

Un très bon modèle pour penser de cette façon, est EasyMock : ce framework d'aide aux tests permet d'enregistrer les appels à contrôler par du code d'appel ! On a donc la vérification de la syntaxe à la compilation, puis évidemment la vérification de la séquence à l'exécution.

Message de maintenance

2008-06-23T19:36:00.002+02:00

L'hébergeur Online a procédé ce week-end à un changement de plate-forme technique du site de ma société Avantage Compris. Du coup plus rien ne fonctionnait. Pour seulement 5 simples pages, c'était un peu dommage.

Ça y est, c'est rétabli.

Pour les techniciens, attention à passer vos XSLT en UTF-8 : certaines configurations de Sablotron n'acceptent pas l'ISO-8859-1 dans les feuilles de styles (mais pour le XML en entrée, bien).

L'Irlande a dit non au traité de Lisbonne

2008-06-13T19:48:00.004+02:00

Apparemment les Irlandais qui ont profité de la chance que leur démocratie à eux leur permet de s'exprimer sur un sujet qui les engage au sein de l'Union Européenne, ont répondu majoritairement « non » à la question qui leur était posée quant à la ratification par leur pays du traité de Lisbonne, lui-même vendu comme un mini-traité remplaçant le TCE, qui en 2005 avait déjà montré le gouffre abyssal entre certaines couches de la population européenne, notamment de la population française, et les élites-zet-dirigeants.

La démocratie est un sujet qui me tient à cœur. Peut-être plus encore que l'Europe, c'est dire. Ainsi le projet « Les Fûts » est, ou fut, un projet d'empowerment de citoyens, en l'occurrence de citoyens déjà engagés dans l'action collective et associative.

Pour en revenir à ce 13 juin 2008, je trouve admirable que les Irlandais aient dans leur Constitution une clause qui à oblige à organiser un référendum pour un sujet de cette nature. Je trouve évidemment lamentable qu'on ne prenne pas en compte le « non » français de 2005.

Car quelle que soit ma virulence à défendre le « oui », je suis avant tout pour un régime démocratique, c'est-à-dire qui donne le pouvoir à un peuple qui a les moyens d'en être responsable. Quand la question se résume à « vous sentez-vous prêt(s) à ratifier ce traité que vous avez dit à maintes reprises incompréhensible et loin de vos préoccupation ? », je trouve sain, je trouve hygiénique, que la réponse soit « non » quand les citoyens consultés ne se sentent effectivement pas prêts.

Je lis çà et là qu'il y aurait eu 885 000 Irlandais à voter non, contre 764 000 ouis, sur un traité qui doit être ratifié à l'unanimité au sein de 27 pays qui comptent au total 500 millions d'habitants. Ce sont les règles que nous nous sommes fixées, simple constat.

Une première remarque, qui me trouble énormément, c'est que si sur lesdits 27 pays, disons, 20 étaient à ce point pour le « oui », que n'ont-ils uni leurs forces de propagande (médias, conférences, meetings... ils avaient même les moyens de faire des films et de les diffuser dans les cinémas !) pour agir et faire œuvre éducative, sinon marketing ? La construction européenne les concerne-t-elle aussi peu qu'ils s'en tiennent à pleurer quand le mal est fait ?

L'autre remarque, je la tire d'un adage qui veut que l'éducation et la paix soient sœurs siamoises. En effet, dit vite, l'éducation permet la paix (elle en montre les bienfaits, les limites, la fragilité, les conditions), et la paix permet l'éducation (elle en est une condition). Or nous construisons l'Europe certes pour le bien-être économique et pour que tout le monde parle anglais, mais surtout et avant tout pour la paix. Aujourd'hui d'ailleurs cette paix a de plus en plus une composante écologique. Un corollaire de cette paix, c'est l'éducation, et notamment l'éducation politique, avec ses ramifications dans la plupart des sciences humaines. Ne pas construire l'Europe sur cette base-là, c'est ne pas construire l'Europe dans l'objectif de la paix.

Alors on peut pleurer d'un « non » dû à une inexistante propagande (j'emploie ce mot de façon pragmatique, sans connotation morale) d'État, mais il montre surtout un désintérêt des penseurs de l'Europe pour la question éducative. Et soyons clairs, je ne dis pas que le traité serait passé avec davantage d'éducation, car je ne confonds pas propagande et éducation : je dis qu'avec davantage d'éducation en amont le hiatus, pour le moins, entre ceux qui ont rédigé et manigancé ce traité, et ceux qui étaient consultés, voire ceux qui auraient dû l'être dans une visée démocratique, se serait grandement réduit. En particulier le traité lui-même n'aurait pas été rédigé dans cette forme si complexe. Accorder de l'importance à l'éducation, c'est aussi permettre un certain feedback entre les diverses couches sociales.

Inscription au Déjeuner sur web n°2 et Je-ne-sais-quoi

2008-04-21T16:48:00.004+02:00

Voilà voilà, je me suis inscrit à la deuxième édition de Déjeuner sur web, à Toulouse, sur le site de la Mêlée Numérique.

C'est l'occasion d'une « magnifique » annonce Twitter :

Oui, j'utilise Twitter entre autres comme révélateur de TODO List : les choses que j'ai à faire n'apparaissent que quand elles sont faites. Comme ça, pas de stress. Et cela comble le Knowing-Doing Gap.

... J'ai comme l'impression que bloguer sur le Knowing-Doing Gap à partir d'un événement aussi anodin qu'une inscription à quelque chose qui n'a pas eu lieu, peut donner la même impression d'inutile mise en abyme que Twitter soi-même. Pourtant pourtant quelque chose se joue...

Déjeuner d'ex-Fûteurs et retour sur les Fûts

2008-04-08T19:17:00.003+02:00

J'ai déjeuné ce midi avec les deux autres instigateurs du projet original « Les Fûts », c'est-à-dire Christophe et Pierre (ils sont dans la colonne à droite).

Repas très sympa à Gradignan ; on mange toujours aussi bien au Thé à la menthe.

On est revenus un peu sur le projet des Fûts (entre moults autres sujets). Pour ma part ce que j'en retiendrai :

l'idée d'une plate-forme web avec fédération d'identité pour les associations reste « une idée qu'elle est bonne »
pour des sites mon-associatifs, des solutions existaient à l'époque, et de nouvelles existent aujourd'hui, ou ont évolué. On a parlé par exemple de Joomla!, de Guppy...
la disponibilité de l'équipe n'était pas là, ou mauvaise : on ne se voyait que quelques fois par semaine, par exemple. Or pour un tel projet, qui demandait un fort investissement technique, il faut s'y mettre à fond, et surtout sur de grosses plages de temps.
à mon avis, le modèle économique basé sur un modèle associatif n'était pas bon. C'est une autre façon de voir le point précédent.
on s'est dispersés à tort sur deux objectifs : des réunions d'architectes NTIC bordelais, et une plate-forme web pour les associations, les architectes développant (imaginait-on) la plate-forme.
et évidemment, on a été trop ambitieux sur les délais affichés...

Gros problème de focus, je dirais.

Mais l'idée reste bonne ;-)

Validation de backups

2008-04-02T21:19:00.009+02:00

OK, on fait tous des sauvegardes, ou backups, automatisés.

Un des risques est qu'un grain de sable s'immisce dans le processus de backup, et que le fichier de sauvegarde soit au final invalide, c'est-à-dire qu'il ne puisse plus servir à la restauration des données. Pas très pertinent, du coup.

Pour gérer ce risque, on peut disposer d'une machine jumelle, sur laquelle on va régulièrement procéder à une restauration de l'environnement qui a été sauvegardé. Mais il s'agit là de tâches « bas niveau », comme dirait un administrateur système de mes connaissances, et elles ne valident que le processus de restauration, non pas que les données ont été réinstallées avec succès.

Pour illustrer ce risque, imaginons que telle procédure de backup consiste à créer l'archive d'un répertoire. Et que pour un bête problème de configuration qui change, se retrouve archivé un mauvais répertoire ou un répertoire vide. Toutes les opérations techniques de sauvegarde, copie, transfert, et restauration, se passeront bien, mais les données issues de la restauration n'auront aucun intérêt. Et on ne s'en apercevra qu'en cas de besoin... (Ne rigolez pas, ça m'est arrivé).

J'ai donc pensé à automatiser une validation « applicative » de la restauration quotidiennne de mes données sauvegardées.

Prenons l'exemple d'un repository Subversion, qui est le cas le plus critique pour le développement. À intervalles réguliers, j'ai un processus qui :

récupère sur une machine dédiée la dernière version du backup du repository
extrait les fichiers
les installe en tant que repository temporaire, et démarre une instance svnserve (serveur Subversion)
simule un client (un poste de travail de développeur), et se connecte au serveur démarré pour rapatrier tous les fichiers
fait quelques mesures et validations sur les fichiers ainsi rapatriés : le nombre de projets est supérieur à 10, etc.

Au fil du temps, je vérifie que les restaurations de backups vérifient certains critères, comme :

le numéro de révision Subversion ne cesse de croître avec le temps (non-réversibilité)
le nombre de projets ne cesse de croître avec le temps (loi d'entropie du développement Java)
la taille de l'archive croît grosso modo avec le temps (avec une tolérance de -2 %, car cela dépend de la compression)

Je pourrais aussi vérifier que :

le numéro de révision Subversion rapatriée correspond à peu près (à 100 près, par exemple) à la révision Subversion qui est active sur la machine de production

J'ai une console qui me permet de suivre ces évolutions.

L'architecture technique que j'utilise est la suivante :

Le serveur « ref » contient les données de référence, en l'occurrence le repository Subversion utilisé en développement
[1]. À minuit (0:00), une hot copy est créée localement, compressée, et envoyée par FTP vers le serveur « ftp », qui est une sorte de sas.
[2]. À 1:00, l'archive est récupérée et copiée localement sur « bkp », qui collecte une copie de tous les fichiers de sauvegarde de l'architecture.
[3]. À 2:00, l'archive est récupérée et copiée localement sur « ci », qui est vu comme un serveur d'intégration continue (Continuous Integration).
Les fichiers de l'archive sont extraits, installés en tant que repository local, svnserve est démarré, des tests sont passés, etc.
Un rapport est émis, qui pourra être agrégé aux autres et servi par un Web Service.

Une console agrège ensuite les différentes informations. Voici un exemple de tableau de bord :

La console présente les noms des derniers fichiers de sauvegarde, leur date, leur « âge » en jours, leur taille, et indique s'ils ont fait l'objet d'une restauration ou non.
La mention « restored » indique que la restauration du fichier a réussi.
La mention « NO » indique que la restauration n'a pas eu lieu (il y a quelques progrès à faire, visiblement)
Les mentions « -1 », « -2 », etc. indiquent que le dernier fichier de sauvegarde n'a pas encore fait l'objet de restauration, et que la dernière restauration pour ces données a eu lieu sur l'avant-dernière sauvegarde, l'antépénultième, etc.

L'intérêt de la machine sas « ftp » est de pouvoir interdire les accès directs de « ref » vers « bkp », dans le cas de réseaux différents par exemple. Dans le cas où tout ce beau monde est sur le même réseau, on peut s'en passer.

La machine « bkp » a bien comme responsabilité de centraliser tous les backups de l'architecture. On pourrait avoir par exemple :

Une remarque :

il est intéressant d'imposer que les données de référence soient systématiquement versionnées en amont (exemples : Subversion, un wiki, etc.). Une réflexion à mener pour les données métier si vous voulez mon avis...

Bon, je suis bien content. Ça fait longtemps que je souhaitais implémenter ce système.

Et vous ? Quelle garantie vous offrez-vous sur la pertinence de vos backups ? Vous contentez-vous de faire confiance à vos logiciels utilitaires ?

Cela vous paraît un peu compliqué ?... ;-)

Assertions JUnit 4.4 : assertThat()

2008-04-02T18:01:00.002+02:00

Merci aux blogueurs de Xebia France de me faire découvrir la méthode assertThat() de JUnit 4.4, sur laquelle je ne m'étais pas encore penché : Simplifier les assertions JUnit et améliorer vos tests.

Avoir des tests les plus clairs possible est une Bonne Chose™.

À lire : Scrum and XP from the Trenches

2008-03-31T15:34:00.002+02:00

Dans mon post précédent sur Scrum, j'ai oublié de reparler du bouquin de Henrik Kniberg, « Scrum and XP from the Trenches ». Les opérationnels et les techniciens liront ce PDF gratuit comme un roman. Il s'agit d'une plongée passionnante dans le quotidien d'un Scrum Master.

Faites-vous de l'agile ?

2008-03-30T17:37:00.001+02:00

Anecdote rapportée :

- Faites-vous de l'agile dans votre organisation ?
- Oui !
- Ah, et quelles pratiques avez-vous adoptées ? XP (eXtreme Programming) ?
- Non.
- Le pair programming ?
- Non.
- Euh... Vous faites du refactoring, alors ?
- Non plus.
- ... De l'intégration continue ?
- Non.
- ... Alors quoi ???
- On ne fait pas de documentation.

Formation Scrum Master à La Défense

2008-03-30T16:55:00.004+02:00

J'ai eu l'occasion la semaine dernière, précisément les mardi 25 et mercredi 26 mars, de suivre une formation « Scrum Master » donnée par Jeff Sutherland en partenariat avec Xebia France, à Paris-La Défense.

Pour ceux qui ne connaissent pas Scrum, je dirais qu'il s'agit d'une boîte à outils méthodologiques pour mener des projets à bien.

Basiquement, ces projets sont :

avec des objectifs « démontrables » : par exemple, un site web, un rapport rédigé, un gâteau...
suivis de près par un « directeur de produit » (Product Owner)
à équipe réduite : entre 5 et 9 personnes, avec une préférence pour des équipes de 5
menés de façon itérative : à la fin de chaque itération, une version du produit est garantie testée, et est démontrable entre autres au directeur de produit ; cela assure que le feedback est reçu à intervalles rapprochés et réguliers, et qu'on vérifie que la trajectoire prise par l'équipe n'est pas déconnante
menés sur des itérations courtes : de 2 à 5 semaines, avec souvent une préférence pour des itérations de 2 semaines (je n'en reviens toujours pas, car cela me semble bien court, mais plusieurs participants m'ont assuré travailler ainsi)

Une des grandes devises de Scrum est « inspect & adapt », c'est-à-dire qu'un projet mené avec Scrum améliore lui-même sa méthode de travail tout du long.

Scrum est une méthodologie « agile », au même titre que XP pour le processus de développement logiciel.

Pour de plus amples renseignements, je vous conseille le blog de Claude Aubry, et le livre Agile Project Management with Scrum, de Ken Schwaber (Ken Schwaber est le co-inventeur, avec Jeff Sutherland, de Scrum).

J'avais eu l'occasion de m'intéresser à Scrum par l'intermédiaire de lectures sur le web, et d'expérimenter avec enthousiasme deux ou trois principes portés par ce framework. Suivre la formation à Paris m'a permis d'équilibrer mes connaissances théoriques, et évidemment de rencontrer d'autres personnes impliquées dans Scrum.

Ce furent deux jours passionnants.

D'abord, Jeff Sutherland, l'homme. Il est à la fois brillant et précis dans son discours, très intelligent dans sa façon d'appréhender les choses, humble et... marrant. Je dirais qu'il apparaît que Scrum s'inscrit pour lui dans une démarche plus globale. Il a évoqué le bouddhisme zen par exemple.

Ensuite, Scrum. En anglais, « scrum » signifie « mêlée » : celle du rugby. À entendre Jeff Sutherland, il s'agit bien et prioritairement de permettre à une équipe d'être la plus efficace possible pour atteindre un objectif commun. Pour cela, il faut (et il suffit ?) de clarifier par tous les moyens (discussions, démonstrations suivies de feedbacks, échanges avec le client) l'objectif à atteindre, et de libérer l'équipe de tout ce qui pourrait gêner sa tâche.

À ce titre, la méthode invoque un rôle particulier dans l'équipe, celui du « Scrum Master » (c'était l'objet de la formation, vous suivez). Je dirais que celui-ci est principalement là pour régler les impediments, c'est-à-dire les obstacles que rencontre l'équipe, et pour favoriser les échanges et le feedback continuels, en organisant notamment, et en cadrant, des réunions quotidiennes d'environ un quart d'heure (daily scrums).

Les impediments peuvent être de divers ordres : matériels, logiciels, environnementaux, voire budgétaires, mais aussi humains, politiques, ou managériaux. Le Scrum Master est concentré sur le travail que doit fournir l'équipe, pas sur la hiérarchie dans l'organisation.

Quand on se pose la question de cette façon simple, il n'y a pas grand-chose à penser :

Le Scrum Master met de l'huile dans les rouages (daily scrums et tenue à jour des backlogs),
et balaie les grains de sable de l'engrenage.
L'équipe prend à sa charge la réalisation du produit,
produit dont le Product Owner maintient une vision claire et compréhensible (accessible).

L'image qui me venait est celle d'une piste de bobsleigh : si la piste est constamment dégagée, l'équipe la descendra d'abord à pied (on n'est jamais trop prudent), puis en se laissant glisser individuellement (confiance), puis... en bobsleigh (confiance + équipe).

Les études menées sur l'utilisation de Scrum montrent paraît-il qu'une équipe de développeurs moyens est toujours meilleure à terme que des bons ou des très bons développeurs qui travaillent séparément. Cette émergence qui naît au sein d'une équipe est captée dans le « ba », terme japonais.

Le fait d'avoir son esprit vacant (no impediment) et concentré sur l'activité s'appelle le « kaizen ».

L'objectif de Scrum est de permettre au « ba » de s'exprimer dans une équipe composée de personnes en état de « kaizen » ;-)

Pour en revenir à la formation, nous étions 30 stagiaires. La formation et le support étaient en anglais, avec l'aide de Guillaume Bodet, directeur technique de Xebia France, présent pendant ces deux jours, dans le cas où des termes auraient nécessité une traduction (cela n'a finalement pas été le cas).

Deux exercices m'ont particulièrement intéressé :

la réflexion en équipe et la rédaction collaborative d'une réponse à un problème donné, en trois itérations de 8 minutes, chacune précédée de 4 minutes de daily scrum. Je jouais le Scrum Master, et me bornais donc à organiser les daily scrums et à régler les problèmes de l'équipe. J'ai trouvé que le résultat, c'est-à-dire le document rédigé, malgré le caractère parfois désordonné du travail, et la vitesse demandée, était de bien meilleure facture que ce qu'on aurait pu composer chacun de son côté, ou de ce qu'on aurait pu organiser linéairement sans itérations. Pour la démo, l'équipe m'a demandé de présenter le document ! alors que je n'avais pas participé à sa matière. C'est le rôle du Scrum Master, si j'ai bien compris : être au service de l'équipe...
un exercice de planification en fonction de la « valeur métier » des composants d'un produit à réaliser. Notre équipe n'a pas terminé l'exercice (!!!) car nous passions trop de temps en planification. La qualité de réalisation était évidemment très bonne (vu la planification), mais le projet a été planté, vu que nous n'avancions pas à un rythme suffisant. Cet exercice m'a montré l'importance primordiale du Product Owner, qui doit être clair dans ses demandes et exigeant quant au résultat, et celle, finalement secondaire, du cadrage apporté par le Scrum Master.

Quelques questions font débat :

Scrum Master, n'est-ce pas simplement un rôle chef de projet ? Voire un sous-rôle de chef de projet ? Pour ma part je pense que le Scrum Master a notamment comme fonction de balayer les obstacles et de cadrer l'énergie collective, pas de se mettre en avant par rapport à l'équipe (d'ailleurs par moments ça gêne, si on se met en avant). Par ailleurs ce n'est en aucun cas un positionnement hiérarchique : les tâches ne sont pas affectées par le Scrum Master. Donc à chacun de se faire son idée.
Le client final a-t-il plutôt besoin de bons Scrum Masters, ou de bons Product Owners ? La réponse de Jeff Sutherland est fortement et sans hésiter : de bons Product Owners. La vision du produit doit être portée, avec en permanence la visée de la maximisation de la valeur métier. C'est le Product Owner qui fixe les priorités de chaque itération et qui, en fonction des réalisations de l'équipe (et de la vélocité, dont je n'ai pas parlé dans ce post), gère les dates de livraison.

Au final, je vais appliquer Scrum sur tous mes projets. Outre le contact avec le Scrum Trainer, la formation Scrum Master permet de faire le tri dans les bases théoriques sur Scrum, largement disponibles sur le web ou dans la littérature, et de les confronter à la réalité à l'aide de quelques exercices pratiques.

Je ne peux que conseiller cette formation.

Google for Non Profits : plate-forme Les Fûts ?

2008-03-19T17:06:00.002+01:00

C|net: Google launches tool portal for nonprofits.

Google communique sur sa palanquée d'outils auprès des organisations à buts non lucratifs :

Gmail
Checkout
Docs
Calendar
Analytics
Google Grants
YouTube
Blogger
Maps&Earth
Gadgets
Groups

Il manque le wiki, je suis surpris.

Reste qu'avec les outils Google, et si on n'en sort pas, le concept d'identification numérique partagée d'association à association, concept qui est au cœur des Fûts (une personne qui fait partie d'une association appartient souvent à d'autres groupes), est fourni de base.

MindManager gratuit pour les blogueurs

2008-03-17T12:43:00.002+01:00

Vu chez Cmicblog : MindManager gratuit pour les blogueurs

J'ai demandé ma clef, qu'on m'a fort gentiment envoyée. Puis j'ai installé cette application paraît-il surpuissante de mind mapping. On verra bien. En tout cas pour s'y mettre, d'après les habitués de la pratique, il faut prendre « au moins » MindManager.

YAML est au-dessus de XML

2008-03-15T19:48:00.011+01:00

Développeur Java.

Des montagnes de fichiers XML pour la configuration, pour les tests, pour la sérialisation de données, parfois même pour les logs.

Une envie de penser plus vite.

Solution : adoption radicale de YAML.

Un exemple

Pour mes tests je joue beaucoup avec des descriptions de données au format XML. Ainsi, je peux manipuler des valeurs de référence (pour les tests) sous la forme suivante :

currentUser.xml :

<DataBean name="currentUser"
 class="com.avcompris.model.User" scope="request">
<properties>
 <property name="firstName"
    class="java.lang.String">Dominique</property>
 <property name="lastName"
    class="java.lang.String">Vandrault</property>
 <property name="birthDate"
    class="org.joda.time.DateTime">1978-01-06</property>
</properties>
</DataBean>

Première discussion. On m'objectera qu'il vaudrait mieux avoir deux fichiers XML, un pour la description de la structure et un pour les valeurs. Cela donnerait éventuellement :

User.xml :

<DataBeanClass
 class="com.avcompris.model.User" alias="User">
<properties>
 <property name="firstName"
    class="java.lang.String"/>
 <property name="lastName"
    class="java.lang.String"/>
 <property name="birthDate"
    class="org.joda.time.DateTime"/>
</properties>
</DataBeanClass>

currentUser.xml :

<User name="currentUser" scope="request">
<firstName>Dominique</firstName>
<lastName>Vandrault</lastName>
<birthDate>1978-01-06</birthDate>
</User>

C'est un premier choix à faire. L'idée n'étant pas de faire de l'architecture mais bien de pisser du test, je n'ai aucune envie de me retrouver avec des fichiers de description dans tous les sens, qui deviendront impossibles à maintenir au bout de 30 refactorings. Pourquoi pas écrire des XML Schemas dès maintenant, aussi ?

Pour mes procédures de tests je conserve donc le principe du fichier unique, avec méta-données côte-à-côte avec les données.

Mon fichier de départ est bien le suivant :

currentUser1.xml :

<DataBean name="currentUser"
 class="com.avcompris.model.User" scope="request">
<properties>
 <property name="firstName"
    class="java.lang.String">Dominique</property>
 <property name="lastName"
    class="java.lang.String">Vandrault</property>
 <property name="birthDate"
    class="org.joda.time.DateTime">1978-01-06</property>
</properties>
</DataBean>

Première idée, accepter les valeurs par défaut. Convention over configuration. Ainsi, je pourrais décider par convention que quand l'attribut @class est absent, la propriété est forcément de type java.lang.String. Et puis supprimons le tag <properties> qui ne sert à rien (il serait très utile si je souhaitais écrire un XML Schema validant mon XML, mais... ce n'est pas le cas pour le moment). Voyons ce que ça donne :

currentUser2.xml :

<DataBean name="currentUser"
 class="com.avcompris.model.User" scope="request">
 <property name="firstName">Dominique</property>
 <property name="lastName">Vandrault</property>
 <property name="birthDate"
    class="org.joda.time.DateTime">1978-01-06</property>
</DataBean>

Ah, mieux. Beaucoup mieux !

Deuxième idée, passer à des éléments qui ont le nom de la propriété. On élimine donc, par convention, l'attribut @name (et parallèlement, on s'éloigne de plus en plus de la possibilité d'écrire un XML Schema validant non trivial).

currentUser3.xml :

<currentUser
 class="com.avcompris.model.User" scope="request">
 <firstName>Dominique</firstName>
 <lastName>Vandrault</lastName>
 <birthDate
    class="org.joda.time.DateTime">1978-01-06</birthDate>
</currentUser>

Ça avance. Je ne me pose pas la question des sous-DataBeans, car je sens que ça me ferait reculer dans ma joie simplificatrice.

Continuons. Passons maintenant en tant qu'attributs de leur parent les éléments uniques qui n'ont pas d'attributs.

currentUser4.xml :

<currentUser
 class="com.avcompris.model.User"
 scope="request"
 firstName="Dominique"
 lastName="Vandrault">
 <birthDate
      class="org.joda.time.DateTime">1978-01-06</birthDate>
</currentUser>

OK. C'est un peu mélangé, ce n'est pas uniforme, mais j'y gagne.

Chouette.

...

Allez, j'arrête le cinéma. Ce XML est immonde, il n'est pas évolutif, il n'est pas validable, et il est moche. Moche comme du... XML.

Dites-moi que vous n'y avez pas cru...

L'approche YAML

YAML est un format de données qui est abondamment utilisé dans le monde de Ruby on Rails.

Quand je choisis YAML pour décrire mes données, je ne me dis pas « comment être sûr que je pourrai écrire un XML Schema validant plus tard », mais « comment ai-je envie d'écrire mes données ».

Le parsing, les transformations et la validation viendront bien plus tard. En fait, le plus souvent en passant par une étape XML intermédiaire.

En premier lieu je me contente d'une utilisation ad hoc du format.

Ainsi, mon fichier currentUser4.xml deviendrait :

currentUser4.yaml :

currentUser:
 class: com.avcompris.model.User
 scope: request
 value:
   firstName: Dominique
   lastName: Vandrault
   birthDate:
     class: org.joda.time.DateTime
     value: 1978-01-06

Beaucoup mieux que l'équivalent XML.

Mais on peut aller plus loin :

currentUser5.yaml :

currentUser:
 com.avcompris.model.User:
   firstName: Dominique
   lastName: Vandrault
   birthDate:
       org.joda.time.DateTime: 1978-01-06

(En passant, je supprime l'attribut @scope, en décidant qu'il vaut "request" par défaut. J'aurais aussi pu le faire dans le cas du XML).

Voici les « équivalents » YAML des autres fichiers XML :

currentUser3.yaml :

currentUser:
 class: com.avcompris.model.User
 scope: request
 value:
  firstName: Dominique
  lastName: Vandrault
  birthDate:
     class: org.joda.time.DateTime
     value: 1978-01-06

currentUser2.yaml :

- DataBean:
   name: currentUser
   class: com.avcompris.model.User
   scope: request
   properties:
    - name: firstName
      value: Dominique
    - name: lastName
      value: Vandrault
    - name: birthDate
      class: org.joda.time.DateTime
      value: 1978-01-06

currentUser1.yaml :

- DataBean:
    name: currentUser
    class: com.avcompris.model.User
    scope: request
    properties:
     - name: firstName
       class: java.lang.String
       value: Dominique
     - name: lastName
       class: java.lang.String
       value: Vandrault
     - name: birthDate
       class: org.joda.time.DateTime
       value: 1978-01-06

Ou le « degré zéro » de YAML :

currentUser0.yaml :

- DataBean:
    name: currentUser
    class: com.avcompris.model.User
    scope: request
    properties:
     - property:
           name: firstName
           class: java.lang.String
           value: Dominique
     - property:
           name: lastName
           class: java.lang.String
           value: Vandrault
     - property:
           name: birthDate
           class: org.joda.time.DateTime
           value: 1978-01-06

« currentUser5.yaml », propre, intelligent, lisible, fait 6 lignes.

Le dernier fichier, « currentUser0.yaml », d'une structure digne d'un fichier XML validable, pour ne pas dire d'une base de données relationnelles, en fait 17. Quasiment 3 fois plus.

YAML :

ne demande pas d'indiquer les fins d'éléments (ouf !), car il se base sur l'indentation
n'a pas de notion de sous-élément ou d'attribut : on se débrouille avec l'arborescence. Disons qu'il y a bien la notion de maps et de lists, qui correspondraient à peu près aux attributs (noms uniques) et aux sous-éléments (noms éventuellement répétés), mais les maps peuvent avoir des sous-arborescences, contrairement aux attributs du XML.
est... lisible.

il n'y a pas de guillemets dans tous les sens
l'indentation fait partie de la syntaxe

YAML n'a rien à voir avec JSON. Je dirais grosso modo que YAML est orienté lisibilité des fichiers par des humains, tandis que JSON est orienté transfert de données entre machines. Mais surtout, JSON est fortement similaire à XML, tandis que YAML a une autre logique.

La place de YAML dans le processus de développement

J'utilise YAML pour les données de tests, la configuration, et les fichiers sources de génération.

Comme les composants côté serveur ou côté plugins savent surtout ingérer du XML, j'opère toujours une première phase de sérialisation de YAML vers un XML « neutre » équivalent.

La bibliothèque Java que j'utilise pour le parsing de YAML est JvYAML.

Voir aussi la bibliothèque JYaml.

La page de Wikipedia sur YAML : YAML.

Pour une check-list de productivité

2008-03-12T10:47:00.003+01:00

À mon sens, la productivité et l’efficacité sont avant tout une affaire de détermination.

De déterminations extérieures :
1.1. L’environnement doit faciliter l’activité
1.2. L’environnement ne doit pas gêner l’activité
De déterminations propres :
2.1. Il faut avoir envie de bosser
2.2. Il faut que ce soit le bon moment
2.3. Il faut savoir ce qu’il y a à faire
2.4. Il faut être « motivé » par le feedback qu’on reçoit

Je vais décliner chacun des points pour mon cas personnel, en ne parlant que de ce qui concerne le développement J2EE / web.

1.1. Un environnement qui facilite l’activité

Par environnement, entendons au sens large tout ce qui m’entoure, avec qui je bosse, avec quels outils, et où je suis installé.

Le meilleur type d’endroit dans lequel j’ai pu faire du développement a été :

un bureau dédié qui ne soit pas partagé avec des collègues,
disposant d’une grande fenêtre — en fait une baie vitrée sur deux niveaux donnant sur l’Océan Atlantique,
travaillant avec une équipe de « smart guys », jeunes ou moins jeunes,
dans des locaux donnant accès à une bibliothèque interne, à une salle de repos, à des lieux informels de relaxation et de discussion (poufs bienvenus),
donnant accès à un tableau partagé où chacun peut noter ses idées,
avec une connexion internet haut débit (si, si, il faut le préciser),
et un réseau local performant (ou une solution « on the cloud ») pour le partage occasionnel de fichiers — la grande majorité des échanges se faisant par le SCM.

Toujours à titre personnel, le meilleur poste de travail comprenait :

un fauteuil de qualité (Markus, anyone?),
une immense table (enfin, à l’époque elle me paraissait immense…),
deux machines puissantes avec écran et clavier, dont une avec un ecran plat 20’’,
pour le choix des systèmes d’exploitation, dans l’ordre : MacOS X, Windows 2000, Windows XP, Ubuntu,
et un téléphone fixe avec haut-parleur, avec accès au national et à l’international.

On peut aussi faire son marché dans la liste de Calacanis : How to save money running a startup (17 really good tips)

Divers outils en coulisses qu’on ne présente plus :

un SCM propre, comme Subversion,
un wiki propre, comme Confluence,
une plate-forme de blogging interne (en général, la même plate-forme offre le wiki et le blogging ; c’est le cas de Confluence),
un bug tracker propre, comme Jira,
une solution interne de messagerie instantanée, comme Jabber,
et une plate-forme d’intégration continue propre, comme Continuum.

Parmis les outils logiciels, toujours pour ma partie, citons les plus importants :

Java 5 ou ultérieur,
Maven 2
un IDE, comme Eclipse 3.3.2
une panoplie de navigateurs web, dont Firefox 2.0.0, Mozilla et Opera
un éditeur de textes, comme TextWrangler, Crimson Editor ou UltraEdit
YAML, XML, XSLT

De plus, il est important de savoir investir dans des outils maison. Un bon outil maison est un outil qui n’est pas indispensable techniquement (surtout pas d’adhérence à la technologie !) et qui fait gagner des jours de charge.
Les contre-exemples bien connus sont :

les framework maisons monolithiques auxquels le legacy est fortement couplé
les outils maisons difficiles d’utilisation : mal documentés, qui gèrent mal les erreurs, pas ergonomiques, etc.

Le summum étant je pense les outils développeés en interne qui se révèlent moins bons que les solutions gratuites strictement équivalentes.
Attention, ce genre d’initiative freine la productivité non seulement en terme d’outillage pur, mais également en minant la motivation des équipes, car l’image de la boîte renvoyée en interne n’est pas bonne.

Je cite mes outils maison préférés jusqu’ici :

plugins Maven de génération de code
outil de rendu dynamique de JSP/JSF sans déploiement (et ne me parlez pas de Tomcat dans Eclipse, ou de JBoss qui redéploie en autonome)
plugins Maven de tests de design web

Et la décoration du bureau ? Et la musique ? Et le Feng Shui ? À creuser…

1.2. Un environnement qui ne gêne pas l’activité

Il faut laisser la place aux bons points qu’on a vus précédemment d’être utiles.

Ainsi, on évitera, et je parle là de seuils d’acceptabilité :

le bureau où on est 5 dans lequel parle à voix haute (je rappelle que je parle de développement. De tels bureaux peuvent être utiles pour d’autres choses),
les open spaces,
le bureau sans lumière extérieure,
l’équipe de neuneus (oui, je sais, on est toujours le neuneu de quelqu’un),
la société qui n’affiche pas un intérêt évident à investir dans des livres, dans des serveurs ou dans des formations,
l’absence ou la restriction d’accès à internet,
le poste de travail sous-dimensionné,
la société où l’on ne peut pas capitaliser la connaissance dans une base ouverte, partagée, pratique d’utilisation et indexée,
la société où l’on ne communique pas librement (oui, je sais, c’est le Moyen Âge, mais ça existe encore),
les projets techniques sans phase d’investissement dans l’outillage technique : il faut savoir gérer les effets de seuil.
les projets Java en-deçà de Java 5

En termes d’outils, je ne peux que souscrire à la liste de Pierre-Olivier Carles : 10 conseils pour conjuguer Innovations, Internet & Efficacité, en retenant pour ma part :

Bloquer les e-mails entre 8 h 00 et 14 h 00
Trier ses flux RSS
Bloquer Skype et Twitter (très difficile) sur certaines plages temporelles

Souffrant d’électro-hyper-sensibilité (EHS), l’absence de téléphone portable et de Wi-Fi est cruciale pour moi si je veux pouvoir réfléchir normalement. Cela me restreint d’emblée l’accès à un bon nombre de locaux, mais ce type de discernement est tout le sujet de ce post.

Et la décoration du bureau ? Et la musique ? Et le Feng Shui ? À creuser également…

2.1. Avoir envie de bosser

Bah, ce n’est pas compliqué : il faut et il suffit d’être convaincu du résultat.

2.2. Le bon moment

Entre quatre heures et huit heures du matin, je suis en général trois fois plus rapide et efficace qu’après neuf heures du soir…

À huit heures, c’est le journal…

À midi, la faim se fait sentir, donc je réfléchis mieux…

Après le repas, sans sieste je passe trois heures à ne pas démarrer…

À 18 h 00, ça stagne… Pour baisser en général vers 19 h 00…

À environnement idéal (en dormant au boulot, donc !), je pourrais donner la courbe de productivité suivante :

Noter que je passe sur les problématiques de fatigue installée, de stress, etc. Tout ce qui constitue la moitié basse de la Pyramide de Maslow doit évidemment être réglé.

Cela étant dit, dans une journée la productivité n’est pas constante. Il faut connaître et utiliser les bons moments.

Il est inefficace de travailler quand le moment « n’y est pas »
Il est inefficace de ne pas travailler quand c’est le moment

Pour un article radical sur le bon emploi de son temps, et qui va bien plus loin que le bête sujet de la productivité, lire chez Paul Graham : Good and Bad Procrastination.

2.3. Savoir ce qu’il y a à faire

La concentration (notions de focus et de flow) est indissociable de la productivité.

À ce titre, il est crucial que la TODO-List, la liste des tâches à faire (par extension, l’ensemble des backlogs de Scrum par exemple) soit claire et affichée. Utiliser un outil informatique ou un cahier ne suffit pas. Pour les tâches du quotidien, un affichage mural est bien plus efficace.

2.4. Être « motivé » par le feedback qu’on reçoit

C’est un point important dans l’efficacité.

D’abord, comment savoir qu’on maintient le cap ? Qu’on a le sens des priorités ? On peut en effet être très concentré, très « productif » sur des menus détails, et laisser tomber des pans de l’activité. Pour cela, la TODO-List, ou les fameux backlogs de la méthode Scrum sont utiles.

En parlant de Scrum, les dailys scrums, lors desquelles toute l’équipe se réunit debout une demi-heure pour présenter les choses faites, le reste à faire et les problèmes rencontrés, représentent un gain redoutable tant pour la productivité individuelle que collective (notion de gel). La productivité en équipe n’est cependant pas le sujet de cet article.

Ensuite, il faut savoir juger ce qu’on produit. C’est aussi une façon de maintenir le cap. Et c’est encore une question de priorités : savoir identifier ce qui est important dans le produit réalisé, afin de se concentrer dessus.
Il s’agit d’un ensemble d’indicateurs, dont aucun n’est à négliger. Ils devraient même à mon sens avoir le même coefficient, avec seuils planchers éliminatoires :

Les feedbacks des utilisateurs (organiser des démonstrations)
Les feedbacks des « pairs » (peer reviews) (idem, et rédiger des bilans)
La qualité interne du produit (audits automatisés réguliers)

Ces différents feedbacks, backlogs et indicateurs, sont bien des moteurs de « motivation », au sens où sans eux il est très facile de rester enkysté dans un axe de développement donné. Même s’il produit du code, et semble rassurant par certains aspects, cet immobilisme est forcément nocif, et au niveau de la productivité sera à terme destructeur. La remise en question, donc l’écoute des avis extérieurs, est un élément indirect mais fondamental de la motivation.

Enfin, il y a un feedback capital dans la productivité, c’est celui qu’on apporte soi-même. Passer du temps à bloguer en interne ce qu’on a fait dans la journée, à formaliser telle procédure, tel outil, telles spécifications même incomplètes… Bloguer ses pratiques, bloguer ses configurations, alimenter les bug trackers et les backlogs… On en retire :

une capitalisation du savoir (non ? Sans blague ?),
une pratique de la formalisation
une réflexion en tâche de fond, et une habitude de communiquer,
un recueil incrémental des problèmes et des solutions

Passons rapidement sur l’aspect évidemment pratique de faire vivre une telle base de connaissance.

En terme de productivité de développement, c’est utile car on y gagne en recul, donc d’acuité, donc de pertinence… donc de productivité.

On a vu l’importance de la concentration (focus) : il faut donc éviter le trop-plein de feedbacks qui mènent à la distraction voire à la dispersion. C’est tout l’objet de ce point : à mon avis le feedback doit être motivant, bien qu’il soit parfois laudateur ou critique. Motivant, c’est-à-dire qu’on ne doit pas le chercher pour lui-même mais pour l’effet qu’il aura sur l’activité.

C’est aussi pour cela que je parle de « détermination propre » au lieu de « détermination extérieure » pour le feedback : ce qui compte pour la productivité c’est ce que j’en fais moi.

Bonus : 3. Ce qui n’apporte rien

Grande question : que fait-on des outils suivants ? Sont-ils des facilitations de productivité pour le développement ?

Twitter
Blogs publics (via des flux RSS)
Comptes publics de messagerie instantanée (Skype…)
Facebook (que je ne connais pas assez)
E-mail

À mon sens, ces outils, dont j’aurais bien du mal à me passer, notamment Twitter avec twhirl, maintiennent un certain éveil, une certaine acuité. Ils nous permettent d’apporter, de recevoir, de nous ouvrir, ils participent de la confiance et de l’estime.

Seulement, en terme de pure productivité, l’élément important est l’acuité. Ainsi, se concentrer quatre heures sur un bouquin ou une doc en ayant éteint tous ces outils, sera plus profitable à un moment donné que fureter sur le même sujet sur internet. Il ne faut pas gérer sa productivité uniformément, mais selon les caps à franchir.

Conclusion

La productivité s’appuie sur un environnement, des outils et des pratiques, et est liée par feedback à la motivation (feedback dans les deux sens). Elle peut être favorisée ou handicapée par la nature de ces différents éléments. Les éléments en gras ci-dessus constituent une check-list empirique d’éléments à prendre en considération.

La productivité se jauge continuellement. Outre la quantité de travail abattue, un signe de bonne productivité et d’efficacité est l’agilité.

Encore une fois, tout cela vaut comme mon avis personnel. Si vous avez des réflexions ou des pointeurs sur le même sujet, je serai heureux d’en discuter.

Simplicité, deuxième

2008-03-10T21:57:00.002+01:00

Que voit-on à l'entrée de votre entreprise ?

À ma gauche, 1, Infinite Loop (Apple). À ma droite...

Je trouve ça excellent.

Via Sanji.

Blog sur Garonne, 4 mars 2008

2008-03-10T09:19:00.003+01:00

Bon ben oui, j'y étais, à l'édition de mardi dernier de Blog sur Garonne.

C'était évidemment à Toulouse, au « Sur Mesure », anciennement appelé le « Chez Nous ».

On était quoi ? 20 ? 25 ? Dans le petit espace, c'était assez chaleureux. L'ambiance était cool et... jeune.

Allez, un peu de name dropping...

J'y ai discuté avec plusieurs personnes, mais pas tous les présents ! On a pas mal parlé avec Xavier, qui semble très actif sur tel blog politique (UMP). Adresse = ?. J'ai pu revoir avec plaisir Maxime Garrigues (rencontré au Déjeuner sur web 2.0) qui comme d'hab' déchire. Cédric Giorgi. Benoît Ramus, de NetOcéan, m'a parlé des deux versions de sa boutique Boatiful, version e-commerce et version vraie boutique toulousaine. J'ai trouvé la démarche logique et excellente. Bien, de voir des projets qui grandissent. Guillaume Beuvelot (PME Performance), était là aussi... Ah, et je n'ai fait que croiser Pierre-Olivier Carles, de FoolInvest.

Cette soirée était vraiment sympa. Les gars ont un très bon état d'esprit. Conquérant, positif, beaucoup d'écoute. On sent très bien le côté « ce que tu m'apprends m'enrichis ». Et le respect. La pratique des blogs est civilisatrice, par définition.

Côté réseautage, je pense que sans téléphone portable / iPhone / Wi-Fi / MacBook Air en poche, je vais encore avoir à échanger quelques cartes de visite papier. C'est d'ailleurs parfois ce qui convient le mieux, car dans l'histoire de la relation ça fait un point d'entrée fixe pour se retrouver, contrairement au nuage de blogs / recherches Google / profils Ziki / MyBlogLog / CopainsDavant / groupes Facebook, etc.

C'est marrant, après ce genre de rencontres on va davantage faire du Follow sur Twitter, éventuellement du lien sur FaceBook (pas mon truc cependant), que faire des mises en relation Viadeo ou LinkedIn. Et suivre directement les liens RSS avec un agrégateur ? It's so 2004... Pour le suivi live de la présence numérique au sein de cette génération, Twitter gagne haut la main. Enfin, disons que c'est vrai pour 2008 Q1 ;-)

SigmaT 5 : Scrum et méthodes agiles à Toulouse

2008-02-29T08:10:00.002+01:00

Vendredi 28 mars 2008 prochain aura lieu le 5e séminaire « SigmaT ». Il s'agit d'une rencontre sur Toulouse d'acteurs des méthodologies agiles, comme Scrum ou XP. Cette session se focalisera sur les retours d'expérience.

Cela se déroule à l'Université Paul Sabatier, et ça commence à 16 h 00.

Voir des détails ici :

J'avais assisté au SigmaT 4 le 14 décembre dernier, dont le thème était « le feedback ». C'était décontracté et assez intéressant, notamment le retour d'expérience d'une équipe des laboratoire Pierre Fabre sur la mise en place d'une méthodologie « agile », c'est-à-dire itérative, avec des contacts appuyés avec la MOA, et une acceptation d'entrée de jeu que le scope fonctionnel sera susceptible d'évoluer en cours de projet.

N'oublions pas les backups

2008-02-27T19:09:00.004+01:00

Tâche basique pour un informaticien, les sauvegardes, ou backups.

Voici par exemple une photo de ce qui reste d'un disque dur après une grosse grosse panne :

Le reste des photos est ici : Worst hard crash I've seen.

Et quand on obtient sa sauvegarde, il est urgent de vérifier qu'elle fonctionne, c'est-à-dire qu'on saura bien réinstaller les données à partir d'icelle.

Que celui qui n'a jamais été confronté à un backup vide ou inutilisable fasse comme si ;-)

En bon intégriste de l'intégration continue, cela signifie pour moi dédier une machine à la restauration automatique et quotidienne de backups.

Et vous ?...

Terre végétale

2008-02-26T07:11:00.003+01:00

J'ai appris hier que lorsqu'il a fait construire il y a quelques années en tant qu'investissements locatifs les 6 maisons qui composent la résidence que j'habite, mon propriétaire a fait emporter la terre végétale qui se trouvait sur cet ancien champ, l'a vendue, et a fait déverser à la place du remblai... Moins cher, donc.

Ansi, en cherchant à y faire pousser des carottes, vous tomberez non sur des taupes, mais sur des morceaux de tuiles, de la mauvaise terre et de la caillasse.

Ainsi, en cherchant à y faire pousser du gazon, vous n'obtiendrez qu'une sorte de pelade verdâtre.

En revanche, les équipements internes à la maison, notamment le chauffage et la salle de bains, paraissent tout ce qu'il y a de plus modernes.

Je suis atterré, c'est le cas de le dire.

D'autant plus que ce que j'y fais pousser moi y grandit effectivement.

Déjeuner sur web 2.0 à Toulouse le 15 février 2008

2008-01-25T07:34:00.001+01:00

Le premier des rendez-vous toulousains-zet-bimestriels de « Déjeuner sur web », organisés par la Mêlée Numérique, PetitDeviendraGrand (voir aussi le blog de Maximes Garrigues) et le Samsara.

Vendredi 15 février 2008. Les détails par ici : Déjeuner sur web

Le nombre de places est limité à 40 !??? Suivons ce point avec attention...

Mac vs. PC

2008-01-23T07:20:00.000+01:00

Une image très frappante chez Fred Cavazza : Les acheteurs de Mac répondraient-ils à des stimuli différents ?

À gauche, le packaging pour les possesseurs de PC, pimpant et chargé. Buy me, I'm from Microsoft. À droite, le packaging de la même souris, mais pour les Macounets. Sobre. You know you want me.

Je rencontre quotidiennement des débats de type Mac vs. PC, et pas uniquement dans l'informatique :

productivité et prix élevé vs. omniprésence et connaissance par tous ?
investissement à long terme vs. consommable ?
exigence vs. tout-venant ? (là, j'ai fait mon choix)
complexité et richesse vs. limitation conceptuelle ?
souci du détail vs. finition grossière ? (pour en revenir à l'informatique, on ne peut pas dire que MacOS X tranche autant que MacOS classique sur le sujet)
ergonomie vs. marketing ? (là, j'ai fait mon choix)
achat d'un produit dans lequel on s'investit vs. consommation ?

Mine de rien, pour une entreprise, ce sont là des questions de valeurs. Ce sont ces choix préalables qui déterminent les coups de volant qu'on donne dans certaines circonstances.

Cela me rappelle un autre rapprochement saisissant de deux images qui proviennent de deux cultures : "The" way vs "a" way (Japan v China dept).

Des techniciens japonais qui font le plein d'un avion, en costumes et avec le petit coussin pour ne pas tacher :

... Et des Chinois, qui y vont au siphonnage et à l'entonnoir :

Il y aurait des choses à noter sur ces débats, qui je le répète, peuvent être quotidiens.

Ainsi, j'ai remarqué que souvent le choix pour ou contre l'exigence, se ramène à un arbitrage entre sujet et objet : qui décide ? Moi ? ou l'environnement ? Achetè-je un ordinateur pour être productif moi, ou pour bosser comme tout le monde ? Vais-je en vacances là où je vais prendre du plaisir moi, où là où vont tous les autres ? Au résultat, ça ne change pas forcément la destination ou l'objet acheté. Mais la motivation est tout autre. Et donc la vie.

D'ailleurs c'est drôle car en matière d'écologie on parle souvent d'« environnement », mais c'est justement le contraire : les choix pro-écologie dépendent de Moi, et non de l'environnement : je ne peux pas attendre de l'environnement qu'il me pousse malgré moi à agir de façon écologique.

Il ne faut d'ailleurs pas confondre avec le lâcher-prise, où on laisse les choses se faire... tout en les faisant ! C'est bien nous qui nous mettons dans le sens des choses.

Autre point que j'ai remarqué : choisir l'exigence, la qualité, coûte plus cher sur le court terme. Le calcul à long terme ne souffre pas la discussion, mais à court terme... Mazette ! Un Mac coûte parfois 6 foix le prix du PC chez Leclerc. Cela s'explique entre autres par le fait qu'on ne s'investit pas du tout de la même façon dans l'un et dans l'autre : les configurations comparées ne sont absolument pas équivalentes. Personnellement j'achète dans un PC, d'abord la disponibilité immédiate, ensuite le fait de ne pas m'attacher.

Avec le tout-venant on gagne du temps, ce qui permet de se recentrer sur ses exigences :-)

Google.org : Inform and Empower to Improve Public Services

2008-01-19T02:12:00.000+01:00

Google.org, émanation de l'entreprise Google (vous savez, celle qui fait Google.com) dans le monde des organisations à but non lucratif, vient de faire une communication sur 5 buts :

Prévoir et prévenir des évènements écologiques aussi bien que sociaux qui pourraient se transformer en désastre notamment en Asie du Sud-est et en Afrique Tropicale. Grippe aviaire et changements climatiques, entre autres
Informer et responsabiliser pour améliorer les services publics. L’idée bien sûr est que si les citoyens en savent plus ils peuvent demander et obtenir un meilleur fonctionnement des institutions. C’est fondamental, notamment dans les pays où les services publics d’éducation et de santé, par exemple, sont pratiquement inexistants.
Stimuler les petites et moyennes entreprises. Elles sont essentielles à la croissance économique et à la création d’emplois, en particulier dans les pays en voie de développement.
Développement des énergies renouvelables pour qu’elles deviennent moins chères que le charbon: énergies solaire et éolienne entre autres.
Accélérer la commercialisation des véhicules rechargeables.

(Traduction trouvée chez Transnets)

Pour ma part j'ai toujours pensé que l'accès à l'information publique, la propagation de ladite information (que ce soit en push ou en pull), et surtout la discussion libre, facilitée, publique ou privée, bref, la réappropriation du mythos par l'Agora, par opposition au soi-disant (soi-disant) logos déversé par les mass media, était une nécessité primordiale à, on pourrait dire une condition nécessaire pour, en quelque sorte une bête conséquence de, une saine existence de la démocratie, c'est-à-dire cet espace civil où le peuple se gouverne lui-même.

J'ai toujours vu dans le pragmatisme et l'excellence technologiques de Google un potentiel nécessaire à l'émergence dans le champ public de ce levier informationnel que j'appelle de mes vœux.

Pour préciser ma pensée, voici deux aspects de ce que cela sous-tend :

le modèle économique actuel de Google fondé sur la publicité ne me paraît ni vertueux, ni reproductible à l'infini, ni pérenne. Certes c'est pratique en ce moment et apparemment pour longtemps encore. Mais... Ils valent mieux que ça. (Pensons à 20 ans, 40 ans, un peu !).
le fait qu'aujourd'hui des documents officiellement publics (certaines statistiques départementales, par exemple) fassent l'objet de la part des administrations françaises de rétention, de masquage, de refus de partage (vous allez rire : entre les différentes administrations elles-mêmes parfois), est contre-productif. Essayez d'obtenir la liste et la source des subventions reçues par les associations d'un département.
Et il faudra une ampleur de vision et de moyens analogue à celle de Google pour rétablir le courant dans le bon sens.

Grâce à la technologie, mais surtout grâce à une compréhension des gens (eh oui), Google a apporté plusieurs révolutions. J'en citerai deux, qui sont pour moi emblêmatiques :

la révolution dans la recherche dans les contenus. Google a permis de penser une recherche « full text » qui soit rapide et pertinente. Ils ont matérialisé le concept (avec plus ou moins de bonheur).
C'était une « bête » application technologique, mais comme de nombreux techniciens considéraient que ce n'était pas essentiel [aux utilisateurs], ils ne se sont tout simplement pas penchés sur le sujet.
Google Earth et/ou Google Maps, c'est-à-dire la géographie courante dans les foyers, comme à une époque on y voyait arriver l'eau courante. L'impact de Google Earth, cette banalisation d'une carte du monde partagée, possiblement sans frontières (essayez un peu d'effacer les frontières sur une carte papier...), est immense.
C'était une vraie attente de beaucoup de gens. Et s'il était légitime et logique que la technologie y répondît, il fallait de lourds moyens industriels, et par suite une vision précise pour les dédier à la solution.

Je ne pense pas que Google soit la panacée. Ainsi je pense qu'en démocratisant à ce point l'usage de la publicité (à des fins commerciales, ha ha, quelle surprise), ils vont exactement à l'opposé de ce qu'ils apportent sur un plan culturel par ailleurs ; je pense de nouveau à la géographie.

Je ne pense pas que Google soit la seule réponse possible.

Ce que je pense, c'est que Google met en musique des principes à la fois de focus et d'ampleur de pensée. Et que certains problèmes vont se résoudre à l'aide de tels principes.

Pour soulever le monde, il faut un bon levier et... un bon point d'appui.

Hellotipi co-lauréat du concours kelblog

2007-12-19T20:58:00.000+01:00

Je suis hyper content : Hellotipi va être accompagné par Pierre Chappaz (start-up : Kelkoo). C'est génial. J'ai toujours trouvé l'idée bonne. J'ai toujours trouvé que MrBoo était très fort de tout faire tout seul, et d'avoir cet avancement équilibré. En termes de dynamisme et de rythme vu les moyens, c'est un projet de start-up exemplaire.

L'article de Pierre : eBuzzing et Hellotipi vainqueurs du concours de Startups sur Kelblog!

L'article de MrBoo : Like a... Monday un peu particulier

Here Comes Another Bubble

2007-12-04T17:50:00.000+01:00

Yeah, baby!

GroupSpaces : Les Fûts ?

2007-11-25T18:41:00.000+01:00

Je cite : GroupSpace provides free web-based tools for clubs, societies, organisations or groups of friends or coworkers.

Pour certaines associations, ça a l'air suffisant.

Certes, il n'y a pas l'aspect vitrine web (encore que quand je lis « Improve your Google ranking »...), mais seulement l'aspect outillage de travail collaboratif.

Java et la productivité

2007-11-18T20:14:00.000+01:00

La communication, pour quoi faire ?

2007-10-14T20:38:00.000+02:00

Parfois dans une entreprise on n'estime pas bien la communication. On dit avoir d'autres préoccupations, on lâche quelques pourcents du budget à la communication puis on laisse courir. Après tout pourquoi la communication ne serait-elle pas un projet comme les autres ?

Eeeh bien. Pour moi qui pense e-mail depuis 1992 et forums depuis 1999, qui décortique l'intérêt des protocoles et des outils dans cette pratique bêtement humaine, qui ne conçois de m'attacher un collaborateur que dans la mesure où il a la « communication chevillée au corps », la question n'a quasiment pas de sens. Certes les wikis, forums, blogs, et autres messageries instantanées constituent mon quotidien (au fait, qui utilise encore les e-mails ?) — même si je fais aussi figure d'exception en n'ayant pas de téléphone portable —, mais ce qui est avant tout fondamental pour moi est de raconter une histoire, des histoires, ou que je les raconte, ou que je sois dans un espace où elles se racontent. Ainsi pour moi un projet est primitivement et avant tout, une histoire qui se raconte. Une équipe est d'abord soudée par « quelque chose ». Cela qui existe par le discours et par la parole. Ce n'est pas tout-à-fait le projet, ce n'est pas tout-à-fait le discours, c'est « quelque chose » qui procède des deux, et qui, c'est bien sûr important, donne une place active, dynamique, aux membres de l'équipe.

Dans l'image des Fûts, il y avait aussi cela : les colonnes de l'architecture laissent exister un « espace » pour que les personnes réalisent leur projet. Elles se réunissent dans cet endroit car il est favorable aux projets, et produisent le leur.

Revenons à la communication. Pourquoi certaines entreprises passent-elles encore aujourd'hui, c'est-à-dire en 2007, complètement à côté, de l'aspect communication ? Faut-il à toute force les pousser dans cette voie-là ? Nous savons qu'elles y gagneraient. Mais elles semblent avoir peur d'y perdre quelque chose d'aussi fondamental.

Nous pouvons voir la communication comme un symptôme de la bonne santé d'une organisation. Je ne pense pas qu'il y ait une « bonne » et une « mauvaise » communications. Soit le fluide s'écoule dynamiquement, et les crises sont gérées avec le reste, soit il ne passe pas. C'est la rétention, le blocage, c'est-à-dire l'absence de communication, qui sont critiques, pas la qualité de la communication, ni même du contenu charrié par elle. Si aujourd'hui n'apporte pas du bon, on l'aura demain. Les vannes doivent simplement être ouvertes. En amont comme en aval : je dois savoir m'exprimer, et il vaut mieux que je m'intéresse à ce qu'on me dit.

En voyant la communication comme un symptôme ou comme un signe, et non comme un facteur de réussite, la situation est très simple :

une organisation qui ne communique pas a d'autres problèmes à régler avant
si on se met en capacité de communiquer, alors on aura réglé ces problèmes

C'est-à-dire par exemple qu'installer un wiki à brûle-pourpoint n'a aucun intérêt en soi.

En revanche, s'assurer que tel collaborateur a la capacité de s'exprimer et d'être écouté au sein de l'organisation (parfois cette capacité ne repose pas sur un défaut d'outillage technique ; cela peut venir du collaborateur lui-même, eh oui), voilà une démarche d'audit plus que pertinente.

Alors, la communication, pour quoi faire ?

Eh bien, encore une fois, pour ceux qui baignent dedans, la question ne se pose pas.

Et pour les autres, la communication peut être un « indicateur cible » qui aide à savoir si l'organisation va bien. Il suffit de changer les deux ou trois choses qui feront que la communication sera mise en marche, et l'organisation ira bien.

Quelqu'un a dit Test First? Oui, oui, la communication est bien une sorte de test JUnit de la bonne santé de l'organisation.

Lesfuts.com, .fr, .org bientôt disponibles

2007-09-30T22:26:00.001+02:00

Vu où en est le projet Les Fûts, je ne vois pas l'intérêt de reconduire les noms de domaines.

lesfuts.com, lesfuts.fr et lesfuts.org seront bientôt libres de tout propriétaire.

NoseRub

2007-09-19T08:55:00.000+02:00

http://noserub.com/

NoseRub wants to be an inspiration, protocol and implementation of a decentralized social network.

Yi-pee.

Réseautage sur Toulouse (3 ou 4)

2007-09-15T10:21:00.000+02:00

Olivier, de Cadres d'Oc, m'avait parlé de la Mêlée numérique, dont un Apéri'TIC nous avait fait rencontrer le président, qui nous a invités à une soirée, où Bruno nous a parlé d'une soirée Capitole Angels, où nous avons rencontré Jean-Paul, Business Angel, et discuté un peu avec Arnaud de Latude, créateur de Capitole Angels (voir le podcast de Maxime Garrigues).

De fil en aiguille...

Eclipse : raccourcis clavier

2007-09-11T07:59:00.000+02:00

Eclipse 3.2.2, Windows XP...

Pour afficher la liste des raccourcis clavier disponibles dans le contexte courant, tapez Ctrl+Shift+L.

Voici une liste aide-mémoire que j'ai constituée, téléchargeable au format CSV, et ci-dessous au format blog ;-)

Activate Editor	F12
Add Block Comment	Ctrl+Shift+/
Add Import	Ctrl+Shift+M
Add Javadoc Comment	Alt+Shift+J
Backward History	Alt+Left
Breakpoints	Alt+Shift+Q, B
Build All	Ctrl+B
Change Method Signature	Alt+Shift+C
Cheat Sheets	Alt+Shift+Q, H
Close	Ctrl+F4 (or Ctrl+W)
Close All	Ctrl+Shift+F4
Collapse	Ctrl+Numpad_Subtract
Collapse All	Ctrl+Shift+Numpad_Divide
Console	Alt+Shift+Q, C
Content Assist	Ctrl+Space
Context Information	Ctrl+Shift+Space
Copy	Ctrl+C
Copy Lines	Ctrl+Alt+Down
Cut	Shift+Delete
Debug Ant Build	Alt+Shift+D, Q
Debug Eclipse Application	Alt+Shift+D, E
Debug Equinox Framework	Alt+Shift+D, X
Debug JUnit Plug-in Test	Alt+Shift+D, P
Debug JUnit Test	Alt+Shift+D, T
Debug Java Applet	Alt+Shift+D, A
Debug Java Application	Alt+Shift+D, J
Debug Last Launched	F11
Debug SWT Application	Alt+Shift+D, S
Declaration in Workspace	Ctrl+G
Delete	Delete
Delete Line	Ctrl+D
Delete Next Word	Ctrl+Delete
Delete Previous Word	Ctrl+Backspace
Delete to End of Line	Ctrl+Shift+Delete
Display	Ctrl+Shift+D (For Which View?)
Duplicate Lines	Ctrl+Alt+Up
Execute	Ctrl+U
Expand	Ctrl+Numpad_Add
Expand All	Ctrl+Numpad_Multiply
Extract Local Variable	Alt+Shift+L
Extract Method	Alt+Shift+M
Find Next	Ctrl+K
Find Previous	Ctrl+Shift+K
Find Text in Workspace	Ctrl+Alt+G
Find and Replace	Ctrl+F
Format	Ctrl+Shift+F
Forward History	Alt+Right
Go to Line	Ctrl+L
Go to Matching Bracket	Ctrl+Shift+P
Go to Next Member	Ctrl+Shift+Down
Go to Previous Member	Ctrl+Shift+Up
Incremental Find	Ctrl+J
Incremental Find Reverse	Ctrl+Shift+J
Indent Line	Ctrl+I
Inline	Alt+Shift+I
Insert Line Above Current Line	Ctrl+Shift+Enter
Insert Line Below Current Line	Shift+Enter
Inspect	Ctrl+Shift+I
Java Declaration	Alt+Shift+Q, D
Java Package Explorer	Alt+Shift+Q, P
Java Type Hierarchy	Alt+Shift+Q, T
Javadoc	Alt+Shift+Q, J
Last Edit Location	Ctrl+Q
Line End	End
Line Start	Home
Maximize Active View or Editor	CTRL+M
Move - Refactoring	Alt+Shift+V
Move Lines Down	Alt+Down
Move Lines Up	Alt+Up
New	Ctrl+N
New menu	Alt+Shift+N
Next	Ctrl+.
Next Editor	Ctrl+F6
Next Perspective	Ctrl+F8
Next View	Ctrl+F7
Next Word	Ctrl+Right
Open Call Hierarchy	Ctrl+Alt+H
Open Declaration	F3
Open External Javadoc	Shift+F2
Open Resource	Ctrl+Shift+R
Open Search Dialog	Ctrl+H
Open Structure	Ctrl+F3
Open Type	Ctrl+Shift+T
Open Type Hierarchy	F4
Open Type in Hierarchy	Ctrl+Shift+H
Open UML Diagram	Ctrl+Shift+D (Omondo)
Organize Imports	Ctrl+Shift+O
Paste	Shift+Insert
Previous	Ctrl+,
Previous Editor	Ctrl+Shift+F6
Previous Perspective	Ctrl+Shift+F8
Previous View	Ctrl+Shift+F7
Previous Word	Ctrl+Left
Print	Ctrl+P
Properties	Alt+Enter
Quick Assist - Assign to field	Ctrl+2, F
Quick Assist - Assign to local variable	Ctrl+2, L
Quick Assist - Rename in file	Ctrl+2, R
Quick Diff Toggle	Ctrl+Shift+Q
Quick Fix	Ctrl+1
Quick Hierarchy	Ctrl+T
Quick Outline	Ctrl+O
Quick Switch Editor	Ctrl+E
Redo	Ctrl+Y
References in Workspace	Ctrl+Shift+G
Refresh	F5
Remove Block Comment	Ctrl+Shift+\
Remove Occurrence Annotations	Alt+Shift+U
Rename	F2
Rename - Refactoring	Alt+Shift+R
Reset Structure	Ctrl+Shift+Numpad_Multiply
Restore Last Selection	Alt+Shift+Down
Run Ant Build	Alt+Shift+X, Q
Run Eclipse Application	Alt+Shift+X, E
Run Equinox Framework	Alt+Shift+X, X
Run JUnit Plug-in Test	Alt+Shift+X, P
Run JUnit Test	Alt+Shift+X, T
Run Java Applet	Alt+Shift+X, A
Run Java Application	Alt+Shift+X, J
Run Last Launched	Ctrl+F11
Run Maven2 Build	Alt+Shift+X, M
Run SWT Application	Alt+Shift+X, S
Save	Ctrl+S
Save All	Ctrl+Shift+S
Scroll Line Down	Ctrl+Down
Scroll Line Up	Ctrl+Up
Search	Alt+Shift+Q, S
Select All	Ctrl+A
Select Enclosing Element	Alt+Shift+Up
Select Line End	Shift+End
Select Line Start	Shift+Home
Select Next Element	Alt+Shift+Right
Select Next Word	Ctrl+Shift+Right
Select Previous Element	Alt+Shift+Left
Select Previous Word	Ctrl+Shift+Left
Show In menu	Alt+Shift+W
Show Key Assist	Ctrl+Shift+L
Show Occurrences in File Quick Menu	Ctrl+Shift+U
Show Refactor Quick Menu	Alt+Shift+T
Show Ruler Context Menu	Ctrl+F10
Show Source Quick Menu	Alt+Shift+S
Show System Menu	Alt+-
Show Tooltip Description	F2
Show View	Alt+Shift+Q, Q
Show View (View: Outline)	Alt+Shift+Q, O
Show View (View: Problems)	Alt+Shift+Q, X
Surround With Quick Menu	Alt+Shift+Z
Switch to Editor	Ctrl+Shift+E
Synchronize	Alt+Shift+Q, Y
Text End	Ctrl+End
Text Start	Ctrl+Home
To Lower Case	Ctrl+Shift+Y
To Upper Case	Ctrl+Shift+X
Toggle Comment	Ctrl+Shift+C (or Ctrl+/)
Toggle Folding	Ctrl+Numpad_Divide
Toggle Insert Mode	Ctrl+Shift+Insert
Toggle Line Breakpoint	Ctrl+Shift+B
Toggle Mark Occurrences	Alt+Shift+O
Toggle Overwrite	Insert
Toggle Step Filters	Shift+F5
Undo	Ctrl+Z
Variables	Alt+Shift+Q, V
Word Completion	Alt+/
Zoom In	Ctrl+=
Zoom Out	Ctrl+-

Espace de programmation

2007-08-27T06:24:00.001+02:00

Ma façon de travailler sous Windows XP avec Eclipse sur un 20" (1600x1200) :

code formaté à 80 caractères ; pour les scripts, 72 est un meilleur compromis encore.
police ProFont Windows 8pt.
le maximum d'espace vertical pour le code. L'idée étant évidemment de pouvoir visualiser les algorithmes d'un seul coup d'œil. Si chaque méthode entre dans l'écran, c'est bon. Avec cette config je dispose de 96 lignes pour bosser.
oui, sur l'image du dessus, tout le code est bien contenu en largeur dans la colonne centrale.
je gagne encore en verticalité en mettant la Barre des tâches sur un côté plutôt qu'en bas de l'écran.

Certes, comparé au regretté CodeWarrior sous Mac, c'est loin d'être la panacée. En particulier pour du multi-fenêtrage je dois utiliser des outils tiers. Mais ça permet d'avancer.

Maintenant, comment certains programmeurs utilisent le même IDE et le même écran :

code sans limite horizontale. C'est plus lisible, paraît-il. Même quand ça déborde à droite de la zone visible ? Il se trouve que c'est le cas sur l'image : il va falloir faire défiler la ligne pour lire trois pauvres bouts de code.
police Courier New 10pt
la console qui mange le bas de l'écran. Bien large la console, pour lire les StackTraces. Important, les StackTraces.
l'espace vertical restant est pour le code. C'est-à-dire 32 lignes sur un 20". Wow! Ne demandez pas pourquoi on rogne votre budget, vu comment vous utilisez les outils de base.

Pour conclure, deux questions pour savoir si votre setup est convenable :

avez-vous du plaisir à travailler ?
avez-vous pris le temps de réfléchir à d'autres possibles configurations ?

Et sur la question du plaisir pris à travailler. Certes non, une bonne configuration d'un IDE ne procure pas automatiquement une ineffable joie de vivre. En revanche, si de toute façon vous n'êtes pas content de bosser, aucune configuration d'Eclipse ne conviendra :-)

Génération internet 2.0

2007-08-25T19:52:00.000+02:00

Employers Are Viewing Your Profile on Social Networking Sites

C'est un fait. Dans la communication, l'informatique, mais aussi le management, les petits jeunes qui chercheront du travail dans les 10 prochaines années auront déjà tenu un blog ainsi qu'un espace public Facebook / MySpace. Ils auront l'habitude d'utiliser Google et Wikipedia pour aller chercher des informations qui leur manquent, et d'utiliser la messagerie instantanée (IM ou IRC) et les discussions différées (blogs ou forums), bref, l'intelligence de groupe, pour s'aider à faire des choix et prendre des décisions. Ils auront peut-être même pris l'habitude de contribuer eux-mêmes à des silos de connaissances, sur divers sujets, avec des wikis par exemple.

Et leurs employeurs pressentis pourront eux aussi faire une recherche Google sur leur nom. Et ainsi apprendre éventuellement que tel candidat fumait tant de joints dix ans auparavant, écoutait telle musique (c'était à l'époque où le téléchargement était interdit, rappelez-vous : les années 2000), affirmait telles choses. D'ici-là il est possible que les étudiants aient appris, au fur et à mesure que s'approche le moment de chercher un emploi ou des clients, de ne plus laisser traîner sur internet n'importe quelle histoire sur leur compte, et que les seules données «confidentielles» qui aient fui soient déjà vieilles d'un ou deux ans.

Mais quel est le risque ? Est-ce que le patron risque de ne pas embaucher un étudiant à cause de ce qu'il aura découvert sur son profil Facebook ? C'est le sens de l'article que j'ai mis en lien plus haut. Dans ce cas... qui y perd réellement ? L'ex-étudiant, bien sûr, pour qui le chemin de l'embauche peut être plus difficile qu'avant. Mais on ne voit pas pourquoi il ne trouverait pas un travail au final, puisqu'ils seront majoritaires dans son secteur à avoir fait la même chose, à savoir laisser des traces de leur vie sur internet.

Non. À mon sens, celui qui y perd fondamentalement, c'est le patron, ou plutôt son entreprise. Parce que les temps changent. Et qu'un futur travailleur qui sait déjà communiquer de façon fluide avec son entourage notamment grâce aux outils à sa disposition, qui a déjà montré qu'il pouvait donner plus d'information qu'attendu (certes, il faudra peut-être recadrer. So, what?), représente une valeur interne pour l'entreprise.

Donc la question qu'on peut poser à l'étudiant blackboulé est celle-ci : souhaitez-vous vraiment travailler pour une entreprise qui de facto n'est pas adaptée aux méthodes classiques de communication ? (modernes en 2000, classiques en 2010. Selon les secteurs, of course)

De là à se retrouver en slip sur son profil Facebook, évidemment...

Référencement web de nos sites

2007-08-16T07:07:00.000+02:00

Tel le Petit Poucet moyen, laisse-t-on suffisamment de traces sur le web pour que les zamis-zet-les-contacts puissent nous retrouver ?

Si sur le web on fait...	on obtient...
Google.com, «David Andriana», «I'm Feeling Lucky»	mon profil sur WikiPatterns, site d'Atlassian sur lequel je m'étais inscrit, à propos de patterns d'utilisation et surtout de mise en œuvre des wikis
Google.fr, «David Andriana», «J'ai de la chance»	un vague message d'avril dernier, par votre serviteur sur le forum de Mobiles Sans Gêne
Google.com, «Andrianavalontsalama», «I'm Feeling Lucky»	la page d'accueil de mes anciens sites personnels, pas mis à jour depuis 2003
Google.fr, «Andrianavalontsalama», «J'ai de la chance»
Google.com, «Je Fûte», «I'm Feeling Lucky»	l'article de ce blog sur les plateformes applicatives
Google.fr, «Je Fûte», «J'ai de la chance»	l'article de ce blog sur les plateformes applicatives
Google.com, «Avantage Compris», «I'm Feeling Lucky»	la page «À propos» du site Avantage Compris
Google.fr, «Avantage Compris», «J'ai de la chance»	la page «À propos» du site Avantage Compris

Je retiens donc les éléments suivants...

pour avoir son nom référencé chez Google, il suffit de ne pas avoir un nom trop courant (Andrianavalontsalama, anyone?), et d'apparaître dans un site à forte fréquentation. WikiPatterns compte 574 utilisateurs enregistrés, et est abondamment visité.
pour avoir son site référencé chez Google, il suffit d'apparaître dans un blog visible (oui, oui, le blog de quelqu'un d'autre. Dingue) et d'y laisser des liens
pour avoir son blog référencé chez Google, il suffit de l'héberger chez Google :-) (Blogger/blospot.com)
pas besoin d'activité régulière sur ces divers points
pas besoin d'avoir des tétrachiées de commentaires, ni d'avoir des liens sortants (le site d'Avantage Compris a une page de contact très simple, et rigoureusement aucun lien sortant)
la présence dans les bases de données de réseautage social (Viadeo par exemple) n'apporte pas grand-chose non plus

Bien sûr, l'objectif recherché est de pouvoir être retrouvé : la visibilité de l'adresse e-mail suffit. S'il s'était agi de garantir l'accès à un blog, par exemple, l'état du référencement décrit ci-dessus n'aurait pas été suffisant.

Il aurait alors fallu, à partir de la liste décrite ci-dessus, mettre à jour les liens des pages les unes vers les autres, et... «consolider la nébuleuse» :-)

IoC par annotations : Guice

2007-08-15T10:42:00.000+02:00

Je me mets sérieusement aux annotations Java 5. Les liens entre la génération de code et les annotations me semblant clairs désormais, il est temps de passer à l'utilisation frénétique des annotations et de profiter enfin des facilités de refactoring offertes par les IDEs. C'est un argument pour positionner Java, et non plus XML, comme format source du processus de développement (oui, oui, même si on doit ensuite produire du PHP).

Les candidats pour de l'IoC via les annotations sont à ma connaissance : Guice 1.0 et Spring 2.1 (pas encore sorti).

Le binding nommé est une des fonctionnalités de base que j'attends de tels frameworks. Le moins qu'on puisse dire c'est qu'avec Guice ce n'est pas immédiat.

On s'en sort avec... une indirection ;-)

Wikis publics chez Sun

2007-08-10T22:14:00.000+02:00

Lu chez Padawan, Sun déploie des wikis publics.

Ils utilisent Confluence.

Plom, plom, plom...

Télétravail

2007-08-10T00:41:00.000+02:00

Je finis à l'instant une séance de travail à deux, assez intensive, sur du développement Java. C'est banal aujourd'hui, bien sûr. On a dans cette séance utilisé les sempiternels wikis et messageries instantanées. On a bien sûr utilisé un gestionnaire de configuration pour le code, et un serveur d'intégration continue. Et à part ça, pas de téléphone, pas de caméra, pas d'e-mail. On peut dire qu'on est davantage dans la gestion asynchrone du temps (car on utilise par exemple le texte plutôt que la vidéo), et la capitalisation des échanges, que dans l'échange lui-même.

Là où j'ai été le plus attentif, c'est sur la qualité des idées amenées : dans quel sens joue la distance, c'est-à-dire plus exactement le fait de ne pas se trouver physiquement dans la même pièce ?
Quand je lis un article comme It Turns Out Brainstorming Has NEVER Worked — qui pointe par ailleurs l'excellent blog de Marc Andreessen, ainsi que l'étude initiale, étude qui a découvert que des personnes amenées à réfléchir en présence ensemble pouvaient être moins créatives que quand elles réfléchissaient d'abord voire exclusivement chacune de leur côté sur leur sujet commun —, j'essaie de mesurer l'avantage de cette situation.
Et j'ai l'impression qu'il est immense.

D'abord, c'est à chacun de décider s'il souhaite être interrompu. Le flow peut ainsi exister librement. C'est une pratique d'autant plus complète quand chacun essaie d'appliquer l'adage «Achieve greatness fifteen minutes at a time» (voir par ici : How to Work Like the Masters). Toutes les 20 minutes environ, on est lancés sur une tâche individuelle, et en général on arrive à quelque chose. Grand ou petit, on a quelque chose. On valide dans la foulée.

Ensuite, c'est la capitalisation. Parce que les échanges sont écrits, la pensée est formalisée. Et parce qu'ils se font par le biais de systèmes informatiques, ils sont stockés, indexés, archivés, pour être ensuite accessibles, copié/collables, modifiables.

Pourtant, il reste évident que le brainstorming, et le travail en équipe, ont une valeur intrinsèque, un je-ne-sais-quoi qui ne peut pas se retrouver dans une routine de collaboration à distance. L'écoute, et donc le partage du même temps, c'est important.

Et donc par balancier... c'est la parole qui est retrouvée quand on est ensemble :-)

AssoPass

2007-07-21T15:34:00.000+02:00

«AssoPass : Créez le site de votre association en toute simplicité.»

Quelques services d'ores et déjà disponibles :

site internet
forum
annuaire
album photos
calendrier
petites annonces
cotisations par internet
vente de produits

Formule de base : 9 EUR/mois.

Le site revendique 622 associations clientes.

On est dans le très-basique, on est dans le très-classique, j'ai même l'impression qu'on est dans du fonctionnel arborescent très « 1.0 » : pas de fonction de recherche systématique, pas de blogging... mais si la critique est facile, le gros intérêt est qu'on est avec AssoPass dans quelque chose qui existe :-)

Lire le commentaire qu'en faisait fin juin Laurent Samuel sur son blog « créer et animer une association loi 1901 ».

Je suis entièrement d'accord sur le caractère insupportable de la speakerine ;-)

Parakey sera open source

2007-07-20T13:18:00.001+02:00

Facebook, qui fait émerger les plates-formes applicatives sur internet, à grands coups de web collaboratif et de propagation virale, acquiert Parakey, une start-up qui développe un système d'exploitation réparti/partagé accessible via le web.

Voir l'info sur Techcrunch/fr.

Techcrunch donne en outre l'info suivante : Parakey sera en mode open source.

Voilà, voilà...

Soyons clairs : il reste la fédération d'identité, avec par exemple un Open ID musclé, plus la répartition du système métier par peer-to-peer, à la NNTP par exemple, puis le système sera génial.

Il ne s'appellera sans doute plus Facebook Platform, ni Parakey, et il n'aura certainement pas le même business model que ces deux entreprises.

Quand ce système arrivera, il aura fallu beaucoup d'apports open source, beaucoup de fonds privés, beaucoup de communautés actives, beaucoup de créations (et donc de morts) d'entreprises. Et les États ? Ben...

Certes l'histoire n'est pas terminée, mais on ne les voit pas beaucoup dans le générique pour l'instant. Alors qu'un tel système sera pour le moins d'utilité publique.