new Blog( perso );

La contribution de Sonatype au développement de Maven 3 est proche de 100%, aussi il ne faut pas s'étonner qu'il soit difficile de suivre ce qu'ils font depuis l'extérieur ... mais quelque fois ça devient plus que difficile.

Je vous ai déjà parlé de l'intégration de Guice comme conteneur de Maven 3. L'idée a été poussée par Olivier Lamy qui tente d'intégrer correctement Maven 3 dans Hudson, ce qui est nettement plus simple avec la branche Guice qu'avec le code historique Plexus. Fin de non recevoir, avec renvoi dans les cordes comme quoi ce code n'est pas suffisamment testé et que nous (pauvres développeurs indépendants) sommes mal placé pour juger de sa stabilité.

Et voilà un petit message amusant sur la Mailing List Maven :

Les réactions n'ont pas tardé. En effet, ces développements se sont fait purement en interne chez Sonatype, en particulier pour Aether. Le meilleur moyen pour se tenir au courant était alors de suivre le twitter de Jason, et le PMC (Project Management Committee) Maven est donc quasiment le dernier consulté.

Perso je ne comprend pas pourquoi Sonatype ne prend pas tout simplement les commandes de Maven 3 "hors Apache", comme SpringSource le fait de son framework ou JBoss de son serveur d'applications, ce qui ne nous empêche pas de les utiliser sans plus de questions.

Maven est déjà largement utilisé et n'a plus besoin de l'aura "Apache" pour se faire connaître. Dans le pire des cas ça pourrait être un fork dans la douleur, mais vu l'avance de Sonatype sur le sujet ça ne changerait pas grand chose. iBatis a quitté la fondation Apache dans des conditions moins politiquement correctes sans que ça fasse plus de vagues, et de toute façon la base des utilisateurs s'en moque.

Update :

"
Jason van Zyl
During the course of development of Maven 3.x development only Kristian and Olivier have dug in. I honestly don't believe droves of people here are going to all of a sudden start making huge contributions to the effort. 
( ... ) Having several people who haven't been even remotely involved in the project over the last year tell me what we should do with the code we wrote doesn't sit very well with me philosophically to be perfectly frank. You do the work, you earn the merit, and therefore the right to decide the fate of the code.
"


Si la philosophie de la fondation Apache, pour laquelle un PMC conserve son poste ad vitam même s'il ne contribue plus au code (il y a bien d'autres façons de contribuer), ne convient pas ... alors pourquoi s'encombrer avec cette fondation ?


à suivre.

Je passe l'été en compagnie de jMeter, parce que la plage c'est ringard et qu'on y prend des coups de soleil.

jMeter est un outil bien rodé, mais qui cache tout de même mal son âge. Si on pardonne l'IHM Swing assez moche, la logique de manipulation des éléments de contrôle est assez étrange. En particulier, les temps d'attente qu'il faut attacher en fils pour qu'ils s'exécutent avant une requête, plutôt que de les mettre ... avant elle, c'est assez tordu. Ceci dit, une fois qu'on a pigé le truc on arrive à s'y faire (« c'est pas pire que de passer à Maven » diraient certains).

Si on regarde sous le capot, là aussi ça sent fort le old school, jMeter date tout de même de 1998 (regardez le code de vos projets de 1998 pour rigoler). Il y a clairement une dette technique sur ce projet, même si ça ne l'empêche pas de rester pertinent. Pour ma part j'ai du développer un Sampler qui récupère les métriques JMX (java.lang:type=Memory) de la JVM sous charge, ainsi qu'un Listener qui stocke les mesures brutes dans une base Derby plutôt qu'un fichier CSV (données plus faciles à exploiter par la suite avec BIRT par exemple, voir ici). Ca se fait sans grande difficulté, mais c'est pas du code magnifiquement découpé comme on en fait tous aujourd'hui (ah bon, pas vous ? :P)

Une astuce à connaître : Quand on capture un scénario avec le proxy HTTP, on peut regrouper toutes les requêtes liées à un clic sous un contrôleur, ce qui clarifie le scénario. En remplaçant ces contrôleurs "génériques" par des "Transaction Controller" (et là on est bien content que le script soit en XML) on obtient une métrique pour chaque page de l'appli web, ce qui reflète mieux la performance ressentie par l'utilisateur que les résultats HTTP bruts.

Gros gros bémol à l'utilisation de jMeter : le reporting en est quasiment absent, et on est donc obligé d'exporter les données brutes en CSV (ou en base dans mon cas) pour une consolidation externe. D'un autre côté, quand on voit les tarifs de LoadRunner ou même de NeoLoad, on se dit que c'est l'occasion de s'essayer au reporting BIRT...

Autre soucis : jMeter utilise un Thread par utilisateur virtuel. C'est nettement plus simple pour son implémentation interne, mais pour simuler des milliers d'utilisateurs, même si chacun ne fait qu'une requête par minute, ça pose de gros soucis : chaque Thread occupe de la mémoire (native+heap) et on est vite à cours de ressources, sans parler de la surcharge pour l'OS qui doit gérer en masse les changements de contexte de ces Threads, qui ne font pourtant pas grand chose. Je me lancerais bien dans un gros refactoring de jMeter mais ... euh ... bon, vous aurez compris.

Ceci dit, la question est de savoir ce qu'on désire faire avec jMeter. Dans un esprit "consulting", on lui demande de valider une SLA et de fournir de jolis graphes 3D pour mettre dans le joli rapport d'audit en couleur sous Office 2010. Dans un esprit "main dans le cambouis" on lui demande de charger l'appli qu'on aura mis préalablement sous monitoring / profiling pour en déceler les faiblesses et y remédier. Ce n'est donc pas un hasard si jMeter supporte une dizaine de protocoles, mais sort péniblement un graphe tout moche : il a choisit son camp.

En tout cas, et jusqu'à preuve du contraire, jMeter est le seul outil à se greffer facilement dans une intégration continue pour faire de l'analyse d'évolution de perf, ce qui est nettement mieux que d'attendre la pré-prod pour tester l'appli et se rendre compte d'un gros problème de conception ...

Depuis la sortie de mon bouquin, j'ai eu l'occasion de signer quelques dédicaces et c'est un plaisir de voir l'enthousiasme des lecteurs. C'est toujours délicat de mettre un petit mot qui soit un minimum personnalisé pour quelqu'un qu'on rencontre tout juste. C'est aussi délicat d'écrire à peu près proprement et de ne pas consteller la dédicace de fautes d'orthographe ;)

Dans mon palmarès des meilleures dédicaces, il y a eu celles que j'ai faites lors du ParisJug pour les duchesses, avec la bière l'inspiration s'emballe (mais nous sommes restés bons amis, rassurez vous).

Mais ce "record" est maintenant battu à plate couture : les collègues de Fabien ont en effet décidé de lui faire un cadeau geekesque pour son  mariage avec Julie,  en me demandant une dédicace "spéciale".


Tous mes voeux de bonheur à ce joli couple, en espérant qu'ils aient tant de choses à faire ensembles, que lorsqu'ils ouvriront enfin ce fameux bouquin pour le lire, il soit complètement obsolète !

Pour ce billet je ne vais pas me fouler, je vais juste reprendre la traduction proposée par Nicolas Martignole. En gros, Oracle continue d'absorber SUN et d'incorporer le contenu de son site web dans ses propres pages ... sauf que de toute évidence ils ont pris un webmaster stagiaire. En effet, je me fiche pas mal de savoir sur quel CD Oracle stocke les sauvegardes du site de SUN, et surtout j'aimerais ne pas avoir à mémoriser des URL aussi mal fichues.

"

Le départ de SUN/Oracle de Kohsuke Kawaguchi a laissé planner quelques interrogations sur l'avenir de Hudson.

SUN finançait les travaux de Kohsuke sur ce qui était initialement un outil interne du projet Glassfish, et n'a jamais remis en question son orientation opensource. Le passage chez Oracle a fait peur mais n'a eu aucun effet notable sur le projet. Par contre, le départ de Kohsuke pour monter sa propre société autour d'Hudson pose de nombreuses questions.

Que va devenir le projet Hudson sur java.net ? Sans que personne ne soit indispensable, il reste très lié à Kohsuke et donc à sa bonne volonté / son temps pour soutenir le projet en opensource. Quel modèle pour sa toute jeune société InfraDNA ? Le lancement d'un Hudson "certifié" donne des éléments de réponse :

ICHCI (c'est son petit nom) répond à une préoccupation légitime de tout gestionnaire de forge logicielle : quelle version de Hudson installer, sachant qu'on a une release chaque semaine. Le temps de qualifier une version, la suivante est dans les bacs ! Une fois la version choisie, quels plugins activer ? Il y en a pour à peu près tout et n'importe quoi dans des états variables, du early-draft au plugin parfaitement stabilisé. L'idée d'IHCI est donc de ralentir la vitesse extravagante de développement d'Hudson pour en fournir une version "stabilisée" - comprendre testée en profondeur - accompagnée d'une sélection soigneuses de plugins, et bénéficiant d'un support dédié.

Selon un modèle assez classique opensource/pro, ICHCI se base sur la forte pénétration de Hudson et de l'intégration continue en général pour monnayer ce service. Ceux qui veulent/peuvent construire leur forge avec leur petite main le feront en opensource, ceux qui préfèrent ne pas dépenser des jours sur ce qui devient un élément courant de l'infrastructure projet feront un chèque.

Des plugins spécifiques propriétaires accompagnent cette version professionnalisée d'Hudson. Ils sont la valeur ajoutée qui permet d'afficher une plus value autre que le seul support (et s'adresse donc au techos que je suis, le DSI ayant été convaincu par l'offre de support :P). La communauté Hudson étant très, très active, ces plugins pourraient à terme avoir des équivalents opensource, ou bien InfraDNA pourrait ouvrir ses plugins en fonction de l'avance qu'il arrive à maintenir - comme Sonatype l'a fait avec le plugin LDAP pour Nexus.

Bref, ça bouge, c'est bien. Hudson a de l'avenir, aussi bien en opensource qu'en outil pro. Vous pouvez ranger votre CruiseControl.

L'informaticien, pour son numéro d'été, publie sur 4 pages un chapitre entier de mon bouquin "Apache Maven". Je suis tenté par trois hypothèses :

• ils ont trouvé le livre exceptionnel et il semblait plus efficace d'en publier un long extrait que d'en dire quelques mots dans la rubrique "à lire" ;
• Pearson, (<lêche>) en plus d'être le plus gentil éditeur de tous les temps (</lêche>), a un service de presse d'une efficacité redoutable ;
• ils manquaient d'inspiration pour boucler l'édition d'été, 4 pages blanches ça faisait désordre, à moins de coller des pubs supplémentaires pour Windev...

Quoi qu'il en soit, et si vous n'avez pas encore eu le livre entre les mains, jetez un oeil sur le magazine chez votre marchand de journaux préféré pour vous faire une idée du ton que nous lui avons donné. Il ne vous en coutera que 3€ si vous voulez le lire tranquillement chez vous, 3€ qui ne vous seront absolument pas remboursés si au final vous achetez le livre, faut pas rêver non plus :P

Après 13 années, je change lundi de job. C'est parti pour de nouvelles aventures !
Bon courage à ceux qui restent, ainsi qu'à ceux qui vont devoir me supporter.

Pour donner un cours à l'Epitech de Rennes, je me suis enregistré comme auto-entrepreneur. Comme promis par ce statut, l'enregistrement se fait en quelques clics et est effectif sous quelques jours sans formalité supplémentaire, ce qui tranche avec le tour des agences telle qu'il fallait le pratiquer il y a encore quelques années pour créer une entreprise.

Je reçois alors un courrier d'Inforegistre, un formulaire à case bien administratif avec la seule entête "à retourner sous 15 jours avec son règlement de 87,04€" (avec ces couleurs). Une rapide recherche sur Google montre que cet enregistrement sur Inforegistre, société qui gère un base de données pour le registre du commerce et de l'industrie, n'est absolument pas obligatoire. C'est donc une nouvelle forme de télé-vente : après les mails de spam, les coups de fil à 20h pour nous vendre des radiateurs ou un abonnement ADSL, voici le combiné publicité + facture. Je me dis qu'il doit y en avoir plus d'un à se faire avoir...

Après des années à trainer sur la mailing list de Maven, j'ai été invité dans la communauté Mojo qui héberge une large panoplie de plugins Maven "non stratégiques" - comprendre non supportés par le projet Maven lui-même. J'y ai lancé les javascript-maven-tools (à l'état dormant depuis) et repris le flambeau sur le plugin GWT. Ce projet, relativement ouvert aux nouveaux contributeurs, fonctionne sur ce modèle : proposer, supporter, passer la main. Un plugin n'y vit que si des développeurs sont là pour le soutenir, développeurs qui sont souvent ses premiers utilisateurs.

Je suis ensuite passé dans le code d'Archiva pour des besoins internes. Ayant du temps plus ou moins officiellement dégagé sur cette tâche j'ai pu m'investir et faire des évolutions intéressantes, créer des liens forts avec les développeurs, qui m'on finalement invités à rejoindre le projet Maven - à l'époque non différenciée d'Archiva. Nous sommes fin 2007.

Depuis cette date, j'ai continué à oeuvrer sur le plugin Mojo GWT et j'ai quelquefois apporté ma pierre à l'édifice Maven, via quelques contributions mineures (release:stage, c'est moi). Mes tentatives pour rentrer dans le "core" se sont soldées par un échec : soit j'ai clairement fait des boulettes et j'ai été vite renvoyé dans les cordes [svn rollback], soit mes propositions sont restées sur le pavé. En 30 mois je n'ai donc rien committé de concret dans le svn Maven.

Par contre, j'ai activement participé à la com' sur Maven, à travers les JUGs et ce fameux bouquin dans lequel j'ai réussi à embarquer Arnaud. Tout ça c'est du temps libre, ça ne rapporte rien en dehors de l'estime de la communauté - ce qui est déjà beaucoup.

Mon activité pro ne consiste pas à développer Maven, déjà que contribuer à corriger des bugs ou à améliorer quelques plugins ne soit pas une tâche tout à fait officielle. Mon temps libre est déjà largement amputé par l'organisation du BreizhJug. Je n'ai plus le temps pour élaborer des idées, développer un POC et le faire challenger par ceux qui passent leurs journées sur le projet. Même si cela parait nécessaire le coût est trop important pour un simple contributeur comme moi.

J'ai donc fait le choix symbolique de me retirer de la liste des développeurs Maven. Cela ne me retire pas le droit de commit, rassurez-vous, je pourrais donc encore venir appliquer quelques patchs intéressants pour corriger un bug que je rencontre dans mon boulot de tous les jours. Par contre je ne compte plus m'impliquer dans le développement de Maven.

Hudson utilise un modèle assez étrange au premier abord : pour devenir committer, il suffit de montrer patte blanche. "Bonjour, j'ai écrit un patch pour l'ano ###" (et/ou) "J'ai écrit un plugin rigolo boite-à-meuh-hudson-plugin". La réponse ne tarde pas : "Quel est ton ID java.net, comme ça tu pourras le committer toi même". Hudson fonctionne sur la confiance : ceux qui participent sont déjà une toute petite sous-catégorie de gens motivés, il ne faut surtout pas les freiner. Un plugin hudson ne vit que parce qu'un ou deux développeurs le supportent, et le projet a besoin de sang neuf pour vivre et s'épanouir.
C'est vrai que lorsqu'on regarde sous SVN, Hudson paraît particulièrement bordélique. C'est un effet de bord totalement assumé ! Obliger les développeurs à suivre des conventions trop rigides c'est créer une barrière aux contributeurs. Si un plugin est proposé, même dans un état discutable, mais avec de la motivation et du temps pour s'en occuper, alors feu vert. S'il devient vraiment utile et attire d'autres développeurs il sera toujours temps pour le "nettoyer". Jusqu'ici, le projet n'a pas eu à souffrir de ce qui ressemble a priori à un manque de rigueur. Les versions se succèdent à un bon rythme, avec des corrections rapides et de nouvelles idées.

Deux approches opposées,

• le modèle Apache Maven : les règles et les consensus à la Apache, et un pilotage "business-driven", 
• le modèle Hudson : "open-bar" ouvert à toutes les bonnes volontés. 

Les deux outils ont fait leurs preuves et sont devenus l'un comme l'autre des incontournables, avec un excellent niveau de stabilité. Comme quoi tout n'est pas gravé dans le marbre

Nicolas Romanetti m'a fait l'autre jour une remarque sur un manque dans mon livre Apache Maven concernant le chapitre sur JavaEE : Dans le modèle JavaEE (pré-6), on met les classes et les ressources dans un WAR, lui même dans un EAR, et on balance tout ça sur le serveur. Où placer la configuration de l'application ?

Si on lit la spec JavaEE, elle prévoit un rôle d'assembleur d'application, qui va prendre l'EAR, éditer ses fichiers de déploiement XML pour faire le lien entre les ressources de son serveur (DataSource, files JMS, ...) et l'application. Personnellement je n'ai jamais rencontré ce cas de figure, et mes clients attendent plutôt une application prête à fonctionner avec au plus un fichier de configuration properties externe à l'EAR.

Option 1 : embarquer la conf en fonction de l'environnement cible

Si on veut suivre l'esprit JavaEE on peut utiliser des profils Maven pour packager dans le WAR les ressources associées à l'environnement cible :

<profile>
      <id>dev</id>
      <build>
        <resources>
          <resource>
            <directory>${basedir}/src/env/dev</directory>
          </resource>
        </resources>
      </build>
    </profile>
    <profile>
      <id>prod</id>
      <build>
        <resources>
          <resource>
            <directory>${basedir}/src/env/prod</directory>
          </resource>
        </resources>
      </build>
    </profile>

il suffit donc d'ajouter un petit "-Pprod" pour générer l'application dans sa configuration de production. Par contre, la configuration ne peut pas être éditée simplement une fois l'application installée.

Option 2 : passer par le JNDI

L'autre option respectant l'esprit JavaEE est de se baser sur les ressources JNDI, et donc d'accéder à une donnée d'environnement de type URL ou String qui pointe vers notre fichier de properties. Dans le web.xml j'ajoute donc un petit :

<env-entry>
      <description>Chemin de la configuration locale</description>
      <env-entry-name>appli.home</env-entry-name>
      <env-entry-type>java.lang.String</env-entry-type>
      <env-entry-value>/valeur/par/defaut</env-entry-value>
    </env-entry>

Je n'ai plus qu'à définir cette ressource dans le JNDI de mon serveur d'application, ce qui va par contre être spécifique à chaque serveur - Tomcat par exemple ne permet pas de définir une ressource URL, alors que Websphère le supporte (pas classique de dire du bien de celui-là, n'est ce pas ?).

Pour y accéder, il faut faire un lookup JNIDI ce qui n'est pas léger léger, et si on veut passer par Spring et ses PlaceHolder ${truc} on regardera du côté de SPR-3030.

Option 3 : passer par une propriété système

Dernière option, la version "light" : dans de nombreux cas, je constat que le serveur d'application n'héberge qu'une seule instance de l'application, aussi on peut positionner des variables systèmes au niveau de la JVM pour lui passer un paramètre, typiquement notre appli.home. Et là, rien de spécial à faire pour activer le configuration Spring en dehors d'activer le SYSTEM_PROPERTIES_MODE_OVERRIDE.
Dans le même esprit, on peut externaliser la configuration log4j en ajoutant un -Dlog4j.configuration=file:///monlog4j.xml.

Perso je préfère cette dernière variante, la plus légère à mettre en oeuvre et la plus simple à expliquer aux développeurs. JNDI reste un truc assez mystérieux, qui plus est avec des variations pour sa configuration en fonction des serveurs d'application. L'accès au DirContext se fait trop souvent via un mauvais copier-coller qui référence les classes du serveur d'application (alors que justement le but est de s'en découpler !) et/ou en ajoutant au petit bonheur la chance des java:comp/env ... peut être le sujet d'un autre billet :)

Option 4: compléter le classpath du serveur

Suite au commentaire de Sylvain François, une 4ème option, comparable au system properties : ajouter au Classpath de l'application le chemin d'un répertoire contenant les fichiers de conf. En jouant sur l'ordre de chargement du ClassPath on peut ainsi surchager les fichiers de conf "par défaut" présents dans le WAR/EAR.

Ces deux dernière options sont assez comparables et leur mise en ouvre va dépendre de la liberté qu'on a pour configurer le serveur d'application. Certaines équipes d'exploit' donnent la main sur la commande de lancement de la JVM, d'autres préfèrent la blinder mais laissent libre accès aux répertoires de libs ...

Qu'en pensez vous ? Donnez votre avis : http://doodle.com/d4qdxc87w76i524c

Lors du dernier ParisJug, toute l'équipe du JUG Rennais à fait le déplacement, prétextant l'organisation de son Assemblée Générale. Occasion bien choisie, vu que nous revenons après une conf d'exception de Mme "Docteur" Holly Cummins, première speakeuse invitée au ParisJug, avec en bonus clé USB et casquette offertes par IBM - on a pas gagné l'iPad, faut pas rêver non plus.

Seul bémol de la soirée, arrosée avec abondance de champagne par la générosité d'octo pour un buffet démesuré, qui a eu ses effets pervers : les bouteilles circulant dans la salle lors de la seconde conférence, l'ambiance s'est vite échauffée pour devenir un peu débordante - votre serviteur ne montrant pas le meilleur exemple.

Il en résulte un état à la sortie de la session qui ressemblait plus à une fin de 3ème mi-temps qu'à une fin de conférence, avec les effets très négatifs que cela pourrait  avoir sur les relations du ParisJug avec l'école qui les accueille gracieusement, avec les sponsors qui payent le déplacement d'un speaker depuis Londres, et bien sûr avec l'invitée d'honneur du jour qui n'avait sans doute pas prévue de présenter OGSi devant une bande de pochtrons.

Je présente mes excuses pour mon attitude excessive auprès de tout ceux que cela a pu choquer, blesser, ou simplement déranger. J'ai promis à Antonio de faire le prochain JUG au diabolo-menthe (en tout cas, avant la 3ème mi-temps). Je présente aussi mes excuses aux sponsors qui s'impliquent pour faire des JUGs des rendez-vous d'exception. Je réserve enfin mes plus plates excuses à Holly Cummins, qui avait sans doute déjà entendu parler du "French Touch" mais n'avait sans doute pas mesuré l'ampleur de la chose.


Bizarrement, je n'arrive plus à me connecter au site du ParisJug, j'ai systématiquement une

406 Not Acceptable

Lors de la conf "Maven3" au ParisJug avec Arnaud Héritier, nous avons indiqué que le remplacement du coeur de Maven (Plexus) par Google Guice était repoussé à une version 3.1 de Maven. Les choses semblent cependant s'accélerer.

Pour les besoins de Nexus, Sonatype a développé une couche d'abstraction "Spice" qui permet d'utiliser la syntaxe Plexus avec un conteneur autre, typiquement Google Guice qui est le nouveau moteur de Nexus. Cette expérience réussie donne une sérieuse crédibilité à cette option de migration en douceur.

La même approche a été testée par Sonatype pour Maven3, et Olivier Lamy a importé ces modifications dans une branche du SVN Apache. Ce code passe déjà les tests IT de Maven, même s'il reste quelques incompatibilités liées à de mauvaises pratiques dans certains plugins (modification des composants internes de Maven) que ce nouveau moteur n'autorise plus. Ces signaux plutôt positifs pourraient aider à faire passer Guice comme moteur de Maven dès la version 3.0, ce qui aurait de nombreux effets bénéfiques :

Pour les utilisateurs ou développeurs de plugin, ce changement n'apporte rien de visible, sinon des logs plus clairs quand la configuration est incorrecte - ce qui, avec Plexus, donne parfois le signal de départ pour de longues heures d'analyse. A plus long terme, l'utilisation de Guice permet d'envisager une migration plus profonde des "bons usages" de développement de plugins Maven vers les annotations @Inject (JSR330). Ceci supposera cependant que les plugins qui suivent cette voie soient dédiés Maven3, ce qui promet de longues discutions sur la liste de dev :)

Pour ceux qui veulent embarquer Maven3 dans un autre outil par contre, ce changement est significatif. La configuration de Guice dans ce mode est nettement plus simple. L'intégration de Maven 3 sur Hudson nécessite ce genre d'acrobatie, et Guice sera le bienvenu pour ne pas inutilement compliquer la tâche.

Maven 3 est donc bien en mouvement, mais avec sa très large base d'utilisateurs il ne peut pas se permettre de changements brutaux sans fournir de harnais de sécurité. C'est ce qui le différencie de quelques concurrents comme Gradle, qui apportent de nouvelles idées, mais ont surtout la liberté de tout casser s'ils ont pris une mauvaise orientation.

Lors du premier anniversaire du ParisJug, j'avais annoncé qu'un de mes objectifs pour cette année serait d'organiser Devoxx à Rennes.

En dehors de la boutade adressée à Stephan Jansen présent exceptionnellement ce soir là, j'ai l'impression que l'idée n'est pas tombé dans l'oreille d'un sourd : Le PoitouCharentesJug organise le vendredi 10 septembre le JugSummerCamp !


Lors de cette journée (éligible au DIF, si votre employeur ne voit pas son intérêt de vous y envoyer d'office) ce sont les top-speakers francophone qui vont enchaîner des sessions. La crème de la crème du super poid lourd :

• Emmanuel Bernard
• Julien Dubois
• Alexis Moussine-Pouchkine
• Christophe Jollivet
• Damien Gouyette "c'est pas dur"
• Jérôme Benois

sans oublier (le meilleur pour la fin, en toute modestie)

• Nicolas De loof

Tout ça gratuitement, dans un cadre particulièrement agréable : la rochelle ! Voilà qui promet une pause repas à la plage et une belle after beach-volley (speakers vs groopies ?)

Pour résumer : une journée au top, en français, pas loin, imputable en formation, gratuite, et avec un peu de bol on aura du soleil en plus. Alors qu'est ce que vous attendez pour vous inscrire ?

Vous en avez une belle console comme ça vous ? Si avec ça on est pas submergé de propositions par les speakers de la terre entière, je ne sais plus ce qu'il faut faire ;)

En rachetant SUN, Oracle a par la même occasion hérité de pas mal de choses dont il ne sait que faire. Entre autre, la très large communauté des Java User Groups.
SUN a toujours été très fair-play avec ses User-Group. Pas de contrainte significative pour être accepté comme JUG (on pouvait même éventuellement créer plusieurs JUG pour la même ville!), et le soutien complet de SUN - y compris matériel avec un joli kit de lancement de JUG - sans aucune exigence de leur part.

Oracle, de son côté, à déjà des Oracle User Group, mais en dehors des deux dernières lettre de l'acronyme la comparaison s'arrête là. Les OUG sont des "Product" User Group, où sont présentés les produits Oracle avec la bénédiction, le soutien matériel, mais aussi l'avis parfois un peu intrusif de l'éditeur. De l'aveu même du responsable d'Oracle qui se récupère le bébé, il n'ont pas l'expérience des "Technology" User Groups - c'est déjà bien de savoir faire la différence.

Après une période de flou, Oracle nous propose maintenant son modèle : trois catégories de groupes,

1. les gros gros, plus de 1000 membres et un statut juridique : un soutien en force d'Oracle
2. les moyens, moins de membres et pas forcément de statut : soutien d'Oracle
3. les petits : on vous aime bien

En dehors des quelques JUGs dont l'adhésion est payante, tous les autres n'ont pas une notion de "membre" qui permet de trouver sa place dans ce modèle. Par ailleurs, les JUG français sont souvent des associations loi 1901 alors que de gros JUG peuvent ne pas avoir de statut juridique explicite. Le ParisJug par exemple peut compter 3 membres légaux, 200 "visiteurs" par session, et 2000 adresses enregistrées. Alors, catégorie 1, 2 ou  3 ?

Ensuite, Oracle demande que les JUG ne s'affilient pas entre eux, et tendent à se regrouper par secteur géographique. Hors, depuis un an, on constate l'inverse : des umbrella-JUG se sont formés pour aider le développement de plus petits JUGs locaux (JUG-USA, JUG-AFRICA, JUG-ASIA, JUR.RU ...) en fournissant un cadre juridique et organisationnel.  L'idée pour Oracle semble d'avoir un minimum d'interlocuteurs (pour dispenser la bonne parole ?), et de faire entrer les JUG-Leaders sélectionnés dans un Nième niveau hiérarchique, le Oracle User Group Community. La liste des JUG-Leaders hébergée par java.net suffisait à SUN pour cela, quel intérêt pour nous ? pour eux ?

Enfin, et c'est ce qui passe le plus mal, Oracle veut nous faire rentrer dans un moule - peut être pour doser ses contributions en fonction de la taille du moule ? L'intérêt des JUG est pourtant leur liberté et leur diversité. Certains prennent en charge l'organisation d'événements majeurs (Devoxx), d'autres se contentent de faire vivre une communauté locale entre potes sans se prendre la tête. Est-ce qu'on s'apprête à tuer les "petits" ?

Quoi qu'il en soit, les JUG continueront d'exister avec ou sans le soutien d'Oracle, mais voilà bien des remous qui n'étaient pas du tout nécessaires.

Aaron, revient !

Au cours de ses deux années d'activité, le BreizhJug s'est équipé en matos audio-vidéo, en particulier suite à de nombreux déboires avec les salles "tout équipées" qu'on nous prête : micro HS, piles essoufflées, ...

Je profite donc de ce beau grand week-end - pendant lequel je suis bloqué à la maison pour garder les enfants pour cause de concours hippique - pour mettre un peu d'ordre dans tout ça avec un flight-case : tout le matos bien à l'abri et pré-branché pour fonctionner out-of-the-box. Moins de prise de tête à chaque session du Jug et de risque d'oublier un truc (mais où j'ai mis ce %#@! de câble USB ?).

Un petit détour par Leroy-Merlin et SonoWest et c'est parti !

Step 1 : Assemblage du socle du flight-case dans les règles de l'art pour contenir le matos

(les cales sur la photo serviront à fixer le récepteur du micro sans-fil qui est au format rack 19")



Step 2 : Ajustage du couvercle pour une fermeture fiable et solide
Le couvercle ferme la caisse en plaquant les éléments via des blocs de mousse, paré pour les risques du transport. Les fermetures "papillon" assure une fermeture à toute épreuve. Les poignées sont dés modèles de cuisine, plus pratique que les modèles "Flight" standard (j'ai de mauvais souvenir de mon époque Sono-Supélec avec la régie de 30kg...)

Dire que j'ai failli acheter une boite de 50 rivets en pensant que ça suffirait... 108 rivets de posés !
(et il en manque ...)

Step 3 : Aménagement pour l'installation à poste fixe du matos


de droite à gauche :

• récepteur 4 micros HF 
• console de mixage 6 voies
• boitier de capture VGA
• (manque) switch VGA deux caneaux (pour basculer d'un speaker à l'autre sans débrancher le câble et donc interrompre la capture)

Au fond à gauche la zone "alims", loin du micro HF et des câbles audio (-> "bzzzz").
A l'arrière la zone "stockage" pour les accessoires mobiles (micros main et serre-tête).

La disposition est bien, reste à faire une cloison de séparation AV/AR, de belles découpes dans une mousse "qui va bien" pour les accessoires, trouver une astuce de rangement pour les câbles, et fixer le tout.

Step 4 : Soigner les finitions (TODO)

• pose d'une couche de moquette en fond comme amortisseur + esthétique plus "finie", 
• colliers plastique pour bloquer les cables en position, 
• casiers en mousse découpée "pile poil" pour le stockage des objets mobiles. NB : la mousse pour flight case est hors de prix, on va essayer de trouver un équivalent pas trop cher.
• 
  
  
  coinceurs pour les câbles afin qu'ils ne s'emmêlent pas pendant le transport : de bonnes vielles pinces à linge !

Step 5 : Tester en "live"

Rendez-vous le 7 juin pour la soirée Terracotta ! Et comme bon développeur, je laisse le soin à Julien de béta-tester ;)

Quand on manipule des services web, des schémas XSD et des louches entières de XML, on rencontre des développeurs qui sont complètement perdus dans les concepts de namespaces. Une idée trop largement répandue est que le namespace donne l'emplacement du schéma considéré, idée basée sur l'utilisation courante d'URL pour définir ces namespaces, lesquelles pointent effectivement assez souvent sur le schéma considéré.

Petit rappel donc.

En XML, les namespaces permettent de mixer plusieurs grammaires dans un même document, on associe donc un identifie chaque grammaire (schéma XSD) un namespace, auquel on associe un préfixe utilisé dans les balises du document XML.

Le namespace est un identifiant de la grammaire XSD. Techniquement parlant, c'est une URI, soit un identifiant unique répondant à des contraintes assez simple, mais en aucun cas un lien pour la consulter.

Une URI (Uniform Resource Identifier [FR]) est juste un formalisme commun pour l'écriture d'identifiants portables. La principale chose à en retenir est qu'elle commencent pas "préfixe:", ce que la norme appelle le 'scheme" -- "programme" , ou "plan", d'après google translate, parfois traduit par nom de shéma, mais alors on peut confondre avec le schéma XSD ...

Les URL (Uniform Resource Locator) sont une forme particulière d'URI qui permettent de définir une localisation pour une ressource (les fameux liens hypertexte du web). On PEUT donc les utiliser comme identifiant pour les namespace XML, et c'est d'ailleurs pratique pour faciliter la vie des développeurs si ce lien pointe en effet vers le schéma XSD, seulement rien ne l'impose.

Une autre option, ce sont les URN (Uniform Resource Name), une autre variante des URI qui permettent de définir un nom, et non un emplacement, qui par définition peut changer.

Que choisir ?

L'intérêt apparent des URL comme namespace introduit une incompréhension qui n'est pas bénéfique. Par ailleurs, le risque de voir l'URL ne plus pointer vers le schéma pour X raison (changement d'hébergement, changement de nom de domaine ...) est perturbant.

Les URN sont a priori plus adaptées, mais pas très courantes. Il est pourtant plus sain de définir un schéma comme
  urn:schema:monprojet.org:Domaine/1.0
que comme
  http://monhebergementpourlemoment.free.fr/xsd/Domaine_1.0.xsd

Pour aider le développeur (via son éditeur XML préféré) il suffit d'exploiter le mécanisme de localisation des schémas lui aussi prévu par la norme :


xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:schema:monprojet.org:Domaine/1.0
                    http://qqpart.org/xsd/Domaine_1.0.xsd"

Vous noterez en passant que les namespaces choisis pour les normes XML sont des URL, ce qui participe très activement à la confusion...


Pas convaincu ? lisez cette (traduction de la) note officielle du W3C : http://www.yoyodesign.org/doc/w3c/uri-clarification/

Java 5 apporte son lot de nouveautés, entre autre l'autoBoxing. Sauf qu'il ne s'agit pas d'une évolution au sein de la JVM mais uniquement au niveau de la syntaxe et du compilateur, donc écrire :

Double d = ...;
truc.setValue( d ); // signature : public void setValue( double );

se traduit (en pseudo-code) dans le .class compilé par

Double d = ...;
truc.setValue( d.doubleValue() );

Je serais le 11 mai au ParisJug pour présenter en compagnie de mon Arnaud Héritier préféré une synthèse rapide des nouveautés de Maven 3. Rapide parce que le ParisJug ne nous laisse que 30 minutes, aussi nous avons choisi pour notre sujet une formule ... inhabituelle.

Si vous avez aimé le bouquin, le ton que nous allons (essayer de) donner à cette intervention devrait vous plaire. Et pour ceux qui ne peuvent se contenter de 30 minutes, un petit détour par la troisième mi-temps devra combler ce manque.

Infos, inscriptions, et toute ce genre de choses sur ParisJug.org.

Depuis quelques années, je travaille à mettre en place des outils de "forge logicielle", mutualisés ou dédiés à un projet; voici les outils que j'aimerai assembler pour fournir un environnement clé en main sur projet :

• une machine dédiée (ou une VM) sous Ubuntu, système facile à installer, bien documenté. Le passage sur un Linux permet déjà de tester toutes les problématiques d'encodage de caractères et de séparateurs de fichiers;
• un SVN, un Git ou Mercurial, selon les goûts; 
• un Nexus pour la conservation des artefacts et l'économie de bande passante;
• un serveur Hudson, qui s'installe via un paquet DEB que c'est tellement simple que ça fait pleurer;
• un build Maven (sans blague ?);
• idéalement, une conf magique pour que le build n'ait pas accès au Net, par exemple via http.proxyHost. L'idée est d'empêcher le parser XML de récupérer les schémas XSD sur le Net - si, ça arrive !
• un serveur de démo/test/perfs, sur lequel la dernière version NIGHTLY est déployée automagiquement;
• un job dédié pour alimenter un Sonar en build nocturne; Je préfère prendre Sonar avec sa conf par défaut puis voir ce qui en émerge et comment ça évolue, pour voir là où l'équipe doit progresser et réduire la gravité des règles qu'elle considère inutiles APRES les avoir violées trop régulièrement (au moins, on s'est posé la question). En général, les indicateurs de complexité s'envolent rapidement ;)
• un wiki projet, j'aime bien xWiki qui est puissant et colle bien dans cette forge "tout java". Les plugins Eclipse et Office (pas testé) peuvent aussi aider à faire apprécier le principe du Wiki même aux plus classiques d'entre nous;
• un gestionnaire de tâches/bugs. Sauf à avoir un JIRA en centralisé, il peut être intéressant de le conserver sur la machine projet avec le reste et de gérer les sauvegardes d'ensemble de la forge. Je n'ai pas de préférence faute d'avoir pu tester autre chose que cette bouze de Quality Center;
• pourquoi pas un serveur iceScrum pour ceux qui pratiquent;
• un outil de revue de code, dans l'esprit de Crubicle, et dans l'idéal intégré à l'IDE... je n'ai pour l'instant rien trouvé;
• un environnement de dev prêt à installer. Pour l'instant je fais un gros ZIP d'Eclipse + JDK + Maven + Tomcat + ... mais c'est pas le top, surtout pour gérer les mises à jour.

Je suis sûr qu'il manque plein de briques intéressantes à rajouter à cette wishlist, j'attend vos suggestions ;)

La grande mode en ce moment en terme de gestionnaire de code c'est Git. La différence avec Subversion, la grande mode de juste avant, c'est que Git est distribué. Super, et alors ?

Prenons une journée type. Vous bossez sur un item qui vous fait modifier du code un peu partout et quelques refactorings bien sympatoches. Arrive alors une urgence bien trempée, un point fonctionnel pas clair qui oblige à temporiser, ou encore une soudaine envie de passer à autre chose parce que là, vraiment, ça n'avance pas.

Que faire ? Lancer un nouveau checkout pour partir sur autre chose et switcher entre deux workspaces Eclipse ? Idéalement, il aurait fallu travailler dans une branche, comme ça passer à autre chose se ferait sans perdre l'état en cours... sauf qu'il aurait fallu le prévoir à l'avance et que la manipulation ne dépende pas de votre réseau de %@! qui semble être basé sur des modems 56k.

Et bien c'est ce que propose Git ! 

Git gère un repository rien qu'à vous dans lequel vous pouvez brancher, switcher, commiter, comparer et tripatouiller tout ce que vous voulez. Etant 100% local, ces opérations sont extrêmement rapides, donc deviennent naturelles (alors que sous SVN elles sont méconnues)

Pour bosser, on commence par créer une branche pour la tâche considérée, et committer dessus à chaque fois qu'on le juge utile. A tout moment on peut changer de branche, tout annuler, revenir en arrière, etc.

Evidemment, à un moment il faut bien envoyer tout ça à ses petits camarades. Mais comme le repo Git est local, on peut remanier les commits effectués pour en faire quelque chose de plus cohérent, ce qui évite l'effet "fix" qu'on constate sur SVN : 1 gros commit suivi de quelques autres pour les fichiers "oubliés". Du coup la synchronisation entre repos Git est nettement plus atomique. Idem pour travailler à deux, on se synchronise entre binômes sans perturber le repository de référence (avec Git, personne ne fait particulièrement référence, mais dans la vraie vie il faut bien se mettre d'accord pour livrer !).

Bref, Git c'est une autre façon de bosser qui va rapidement devenir indispensable, comme à l'époque où on avait pas de SCM et où on partageait tous un montage réseau...

Les points faibles de Git ?

Outil en ligne de commande, il reste particulièrement obscur sur ces options. L'intégration dans les IDE est moyenne avec un retard notable d'Eclipse (quelle surprise). Enfin, le concept étant relativement nouveau il faut apprendre à l'apprivoiser.

Pourquoi se préoccuper de Git ?

Après tout, Subversion marche plutôt bien. Et bien, si le cas d'usage exposé ci-dessus vous laisse froid, sachez que la prochaine version suivante  de SVN (la N+2 quoi) incorporera un mécanisme de distribution, sans doute inspiré par le succès de Git et consorts. Ce n'est donc pas qu'un effet de Geekitude,  mais bien une évolution profonde des SCM, autant être dans les premiers à savoir en tirer partie.

Comment commencer avec Git ?


Pour faire mumuse, Google Code propose un hébergement Mercurial, assez comparable à Git mais qui a moins le vent en poupe ces temps ci (sans de raison évidente).
Le plus concret est d'utiliser Git au dessus de SVN. Le repo local Git peut en effet se synchroniser sur un SVN classique, ce qui permet d'en profiter sur son poste sans perturber l'organisation de l'équipe. Et une fois le pli pris...

Reste à apprendre les commandes assez obscures de Git et l'utilisation du GitBash sous Windows - plateforme qui n'est pas à l'honneur pour cet outil.

Une nouvelle licence vient de voir le jour, la plus restrictive jamais imaginée à ma connaissance (mais je peux me tromper)

Ce n'est pas de la GPL ou d'une de ses variantes, qualifiées de "virales" - terme qui semble taillé pour faire dresser les cheveux des DSI.

Ce n'est pas non plus d'une licence calculée au nombre de coeurs CPU, ce qui est pourtant un concept déjà assez étonnant qui oblige à acheter plusieurs machines là où une seule suffirait.

Non, je parle de la licence qui accompagne le lancement de l'iPhone de 4ème génération, licence qui dicte purement et simplement l'environnement de développement autorisé. Vous devez donc EXCLUSIVEMENT utiliser le SDK Apple et le langage de programmation ObectiveC pour avoir accès à l'AppleStore. Pas de traduction de langage, d'èmulateur ou d'interpréteur JIT, rien que du "made by Apple" et rien d'autre.

A ce rythme, la version 5 imposera de développer sur MacBook Pro 15" ou supérieur exclusivement, ou encore de disposer d'un abonnement internet d'un partenaire Apple pour uploader sur l'AppleStore, ou peut être de boire exclusivement de la Budweiser, qui sait.

Alors, oui, Apple dispose d'ergonomes de génie, d'un marketing à faire pâlir n'importe qui, mais faut pas pousser. Si c'est la seule arme de l'iPhone pour couper l'herbe sous le pied des développements compatibles iPhone + Android via un langage pivot, ça ne va pas dans le sens de belles applications innovantes et universelles à des prix accessibles.

Une grande majorité des projets basés sur Maven suit la convention de décomposer le projet en modules, selon l'architecture ou les domaines fonctionnels de l'application. Assez fréquemment on retrouve donc quelques modules bas niveau sur lesquels sont basés des module plus avancés, services web, batchs ou IHM web.

Un build "classique" enchaîne la construction de ces modules sans tirer parti du parallélisme de l'architecture de la machine. Si les I/O restent un élément important dans la vélocité du build (pour ma part, mon repository local est dans un RamDisk ce qui booste bien les choses), il est dommage de laisser nos quad-core dormir en attendant la prochaine compilation.

Depuis la semaine dernière, le trunk de Maven3 intègre une évolution qui était pour l'instant développée sur GitHub en pure expérimentation : il s'agit de la parallélisation du build. Pour expérimenter cette option, vous pouvez récupérer un nightly-build de maven 3 sur l'intégration continue du projet.

L'option -T permet de définir le nombre de threads qui vont supporter le build. Maven se charge de répartir la construction des modules du projet sur ces différents Threads et de réordonner le log pour qu'il reste lisible selon un ordre "classique".

Pour ma part, je n'ai pas réussi à le faire fonctionner sur des projets significatifs. Avec mon "gros" projet, je tombe sur une ConcurrentModificationException lors de la compilation AspectJ. Sur un build Archiva qui trainait sur mon disque (nostalgie...) c'est l'instrumentation JPox qui échoue.

Il est probable qu'aucun plugin maven ou outil impliqué dans le build n'ai prévu jusqu'ici d'être utilisé dans un cadre multi-threadé de ce type... il va donc y avoir une grosse campagne de test et d'évangélisation à prévoir. En attendant, Maven est à ma connaissance le seul outil de build a expérimenter cette voie, qui devrait prendre tout son sens sur les fermes d'intégration continue disposant de multi-coeurs et qui pourraient ainsi devenir très réactives.

Wait & See...

Les gars de Google se sont bien amusés avec Google GAG, mais l'idée était intéressante. Pour faire suite à mon billet sur le plugin Sonar de revue de code, passer directement par le code source sous SVN pour associer les commentaires de revue et le code considéré, c'est une solution pratique.

Je lance donc avec mes petits camarades du BreizhJUG une super top toute nouvelle librairie d'annotations : CRADoc. Les suggestions/contributions sont les bienvenues !

public class Sample
{
    /**
     * Moi y'en a faire du JavaDoc pour le fun qu'il décrit rien de
     * qu'est ce que dont ça fait la chose dessous là
     */
    @tesSouhaits( value = "t'as avalé un becherel de travers ?", 
                  reviewer = "jtoubon" )
    public void codeDeMerde()
    {
        @ttention( "il y a plus simple pour créer des double..." )
        double d = new Double( "1.0" ).doubleValue();

        @bracadabra( "fun, mais ça sert à quoi exactement ?" )
        double k = ( d + 2 - 2 );
    }
}

Koshuke Kawaguchi, développeur de génie a qui on doit (entre autre) le célèbre serveur d'intégration continue Hudson, annonce son départ de SUN/Oracle. Mauvaise nouvelle pour SNORCL, mais les utilisateurs d'Hudson n'ont pas de soucis à se faire car Koshuke se lance dans un nouveau projet visant à propulser son bébé à un autre niveau.

L'idée ne semble pas nouvelle, reste à savoir si ce pas aurait été franchi aussi rapidement sans le rachat de SUN... Il va y avoir quelques cadavres dans cette fusion.

Pour Pâques, méfiez vous des lapins-vampires.


Plus sérieusement (si on peut dire), et si la présence exceptionnelle d'Emmanuel Bernard ne suffit pas à vous motiver, le BreizhJUG va se transformer en chasse aux oeufs dans le grand amphi de Supélec. Contrairement à d'autres notre JUG a la chance de ne pas être limité en nombre de places, alors c'est l'occasion de le faire découvrir à vos collègues : passez le mot !

Ce week-end pascal est consacré à une longue réflexion pleine de conséquences. Dans ces cas là, j'ai une astuce : la tondeuse.

En plus d'entretenir le jardin, cet instrument possède un pilotage simple qui libère l'activité neuronale. Il m'arrive donc couramment d'avoir recours à cet ustensile - de jardinage a priori - pour réfléchir activement ou prendre des décisions.
J'ai trouvé une explication théorique à cette pratique : d'après cet article, le développement neuronal du jeune enfant est favorisé par le quatre-pattes et par les mouvements saccadés qu'il impose à la boîte crânienne. Ma théorie est donc qu'on peut extrapoler ce résultat à l'âge adulte, les vibrations d'un engin à moteur favorisant ainsi le bon fonctionnement de la matière grise et la résolution de problèmes qui paraissaient hors de portée.

Je propose donc qu'on équipe tous les bureaux d'études de grands espaces verts, en plus ça sera plus joli.

Vous avez été nombreux à colporter mon poisson d'avril 2010, ce qui a amené plus de 450 visiteurs à douter un court instant de la véracité de ma fausse page 01Net. Le pot aux roses était assez évident et je n'ai pas pris le temps de masquer un peu mieux l'URL pour laisser planer un peu le doute.


Une petite victoire tout de même, car parmi quelques collègues moins "geeks" que les habitués de ce blog, plusieurs se sont bien fait prendre au piège. Sans parler d'un client particulièrement réceptif qui a tellement plongé que personne n'a osé lui dire qu'il s'agissait d'un fake. Il faut tout de même qu'on lui dise la vérité, sans quoi la prochaine réponse à appel d'offre risque d'être comique.

De mon côté je me suis bien marré de voir l'inventivité des habitués de la bloggosphère, entre xebia qui nous invente des lunettes de réalité augmentée qui ajoutent des post-its partout, le touilleur qui se croit revenu en 1999 à l'aire des dot_com, et Google qui nous sort des librairies délirantes MAIS fonctionnelles - le poisson d'avril qui pourrait cacher une vraie bonne idée ? Je ne sais pas si quelqu'un a essayé Google Street View avec des lunettes 3D pour voir si ça marchait vraiment, mais on se demande si c'est un vrai pur gag ou une idée délirante qui deviendra notre quotidien dans 5 ans...

Quand au traducteur Français / Chien sur android, figurez vous que ça existe en vrai (mais pas sur android) - certes, pour les gogos fortunés qui n'ont plus que leur caniche comme amis.

Suite à l'action du gouvernement français pour sauver la langue française d'anglicisme honteux, Google se voit contraint de changer le nom de sa fonctionnalité Google Buzz dans la version française de gMail.


Reste à savoir si Google Ramdam connaîtra un meilleur accueil que son prédécesseur...

Avec la finalisation de Maven 3, Sonatype commence à sortir des outils autour de ce nouveau coeur, enfin extensible à souhait. MavenShell est un de ceux-ci, conçu pour les fans de la ligne de commande, mais qui veulent aussi un outil pointu et rapide.

Le secret de MvnShell c'est tout simplement qu'il conserve en cache les POM et la configuration des plugins déjà exécutés dans le shell. En pratique, une fois le premier build passé il permet de gagner un peu de temps sur les builds successifs.

Bien sûr, si la majorité du temps passé sur un build concerne le passage des tests ça ne va pas changer grand chose, mais c'est toujours ça de pris.

Autre bonus de ce shell, via l'intégration de JNA, il permet d'avoir une console colorée, agréable pour éplucher plus efficacement le log du build. Il faut dire qu'un log peut parfois être particulièrement inexploitable, avec un mix des divers plugins impliqués et de la sortie console des tests. Le log Maven3 dans le shell fait ainsi ressortir chaque plugin avec son exécution et le module maven considéré, ça aide bien.

Pas de quoi faire une révolution tout ça, mais tout de même un exemple de ce que va permettre Maven 3 : de nouveaux outils, de nouvelles extensions. Je pense au support dans les IDE bien sûr, mais aussi à l'intégration continue (plutôt que les hacks actuels pour scruter le build Maven2), à la manipulation des méta-données dans le repository, pouquoi pas aussi aux outils de Q&A, à une meilleure exploitation du parallélisme, etc.

Vous me direz, tout ça c'est pour les projets Maven3. Et bien détrompez-vous, je fais mes tests avec un projet qui utilise "officiellement" Maven 2 et je n'ai pour l'instant rencontré aucun problème de compatibilité, que ce soit avec ce shell ou avec la dernière mouture de m2eclipse.

Alors, c'est vrai, Maven 3 ce n'est pas encore pour tout de suite, mais ce n'est plus de la science fiction.

Je viens de lire cet excellent article qui compare le chemin parcouru par Spring et JBoss au travers de la normalisation de leurs technologies par le Java Community Process (JCP).

L'article sait garder un bon niveau de neutralité et expose très clairement ses arguments. Spring a toujours joué les pieds dans le plat et la critique - justifié dans de nombreux cas - alors que la ligne prise par JBoss a toujours été claire vers la normalisation d'Hibenate et de Seam par le JCP.

Si les deux protagonistes n'ont de toute façon pas toujours été très fair-play, il en sort :

• un Seam 3 basé sur les normes de JavaEE6, et une image de JBoss comme moteur sur ce sujet;
• un Hibernate, déjà standard de fait, sorti renforcé par la norme JPA (il y a encore des gens qui ne veulent pas entendre parler d'Hibernate, amusez vous bien les gars ...);
• un Spring 3 qui déçoit pour son peu de contenu (pour ceux qui n'ont que faire d'OSGi en tout cas);
• une norme @Inject qui a le mérite d'exister mais qui fait un peu court. Spring implémente bien cette norme mais elle ne suffit pas à bâtir une application;
• une image déplorable de Spring sur son intervention tardive et polémique dans le JCP. Autant la critique du modèle EJB était argumentée, autant la participation de SpringSource à la JSR JavaEE6 aurait pu être bien plus constructive. C'est bien de taper dans la fourmilière mais au bout d'un moment il faut aussi savoir reconstruire;

Sur l'adoption tardive des technologies par Spring je suis plus réservé. Les dates indiquées semblent montrer un retard à l'allumage de ~3 ans, je ne les met pas en doute, mais ces technologies nécessitent un temps d'appropriation et de maturation. Si Spring s'était jeté sur JSF 1.0 dès sa conception on aurait jamais eu SpringMVC. Le rôle que c'est donné Spring de ce point de vue est de proposer un regard critique et argumenté sur la mise en oeuvre de ces standards, je ne suis pas choqué que ça nécessite un peu de recul.

Quand on parle d'interface web sexy, on pense souvent à Flash. Il faut dire que les années IE6 (qui se prolongent pour certains) ont fait des dégâts pour la réputation de JavaScript et que Flash était la seule solution viable.
Aujourd'hui HTML5 est mature et bien supporté par les navigateurs récents. Le ralliement d' IE 9 est un signe des temps qui montre que c'est bien la plateforme du futur.

OK mais qu'en est-il de la productivité des développeurs ?

Personnellement je suis fan de GWT car il me permet de rester dans le même langage sur toute ma chaîne de développement. Mais ceux qui ont franchi le pas d'apprendre ActionScript et d'acheter FlexBuilder n'ont pas ce genre de considérations.

Je tombe via Ajaxian.com sur ce billet, qui décrit l'abandon de Flash pour HTML5 (canvas). L'intérêt de ce billet n'est pas la prouesse technologique de faire "aussi bien" que la référence Flash - quoi que c'est déjà intéressant pour ça - mais qu'il argumente le pourquoi et les avantages de cette migration.

• moins de code et un "livrable" plus compact. Une bonne baffe pour ceux qui voyaient dans le format binaire de Flash un argument de compacité;
• un meilleur support sous Linux (j'y ajouterais les plateformes mobiles, qui ne sont pas la cible ici);
• une chaîne de production plus simple, en l'absence de phase de compilation;
• une meilleure intégration avec le reste de la page web (événements clavier, gestion du curseur ...)

Cependant, le billet met aussi en évidence les points forts de Flash :

• support des polices de caractères embarquées;
• des manques dans HTML5 sur la manipulation de fragments HTML, le clipping et le rafraichissement

HTML5 n'est donc pas la solution miracle à tous les problèmes (chaque techno passe par une phase où tout le monde y voit le messie avant de comprendre qu'elle a ses limites et ses faiblesses). Par contre c'est une alternative viable et performantes à Flash pour de nombreuses utilisations. Dans certains cas, cela peut même être une solution plus universelle et plus performante (il n'y a toujours pas de lecteur Flash sur l'iPhone à ma connaissance)

Au premiers temps, j'ai géré un "maven_proxy", lequel s'est rapidement noyé sous une masse de jars hétéroclites. Il faut dire qu'à cet époque il n'y avait pas de consensus sur le référencement des apis Java, sans parler de la migration vers Maven2 qui s'est jouée pour nous à cette époque. Il en ressort un répertoire maven_repo avec des doublons, triplets, voir plus (6 versions de EJB2.jar).

Je cherche depuis un moment un outil pour accompagner la revue de code, autre chose que l'impression des listings et le stabilo. Il y a évidemment l'excellente suite Atlassian, mais bien sûr accompagnée de son tarif - sans doute justifié - qui limite sensiblement mes chances de le voir accepté dans la boite à outils standard.

Julien Viet m'a suggéré une évolution sur Fonzie : Utilise le processeur d'annotations (APT) de JavaC à la place du compilo AspectJ.

@Entity
public class User
{
public native void persist();
}

Pour un projet utilisant le JDK6 pour compiler, et sans rien faire sauf ajouter Fonzie-0.4-SNAPSHOT en dépendance, le fichier .class décompilé donne ceci :

@Entity
public class User
{
  public void persist()
  {
      Fonzie.instance();
  }
}

Pour ce premier jet, le code introduit dans la méthode n'est pas passionnant, mais au moins le squelette est en place. Reste à construire via l'AST le code d'invocation Fonzie qui va bien -- et ça, ça va être tout de suite plus toochy.