Outils Java

Maven est aujourd'hui un outil incontournable pour assurer la gestion d'un projet informatique (même s'il n'est pas le seul et loin de faire l'unanimité), notamment pour le monde Java.
Je connais Maven pour l'avoir utilisé sur quelques projets, par le maintien de la FAQ Maven sur le site Developpez.com et également par la lecture de quelques ouvrages sur l'outil.
C'est donc avec grande curiosité que je souhaitais lire "Apache Maven" d'Arnaud Héritier et Nicolas De Loof, un ouvrage en français et atypique selon les dires.
Je dois dire tout de suite que je n'ai pas été déçu car voilà un ouvrage informatique que j'ai dévoré comme un roman, par petits bouts tous les jours, vraiment !

Ce livre raconte donc l'histoire d'un projet, petit et désordonné au départ (sauvegardé sur une disquette), qui deviendra par la suite le produit phare de la multinationale Geegol au travers des bonnes pratiques que le projet distille avec son utilisation de Maven.
On apprendra alors tout au long de l'histoire comment utiliser Maven pour répondre aux incontournables des projets en entreprise, depuis la création du projet jusqu'à sa livraison.
On prendra alors connaissance des nombreuses fonctionnalités de Maven, comme sa gestion des dépendances, la convention plutôt que la configuration, les profils, etc. Mais également sa possibilité d'intégration avec d'autres produits, comme les IDE, les serveurs d'intégration continue, etc.
Très pragmatique, le livre fournit des exemples de configuration directement utilisables dans vos projets.
J'ai aimé également l'ouverture des auteurs sur le produit, on trouvera bien sûr les avantages de Maven mais aussi ses points faibles, les alternatives (ex : Graddle, Ant) ainsi qu'un avant goût du futur, avec Maven 3.
Vous l'aviez peut être deviné : j'ai énormément apprécié ce livre et j'y retrouve l'esprit pédagogique présent également dans la collection "Tête la première" (pour moi une référence en matière de pédagogie informatique).
Les grands intérêts du livre passent par le style employé, très jovial, jamais ennuyant. On y retrouve les grandes lignes principales permettant de mener à bien un projet Java mais également de nombreuses astuces qui pourront parfaire vos réalisations.
Nous avons donc au final un très bon livre en français sur Maven, que je conseille à tous ceux qui auront à travailler avec cet outil formidable.

Ce livre est une vraie merveille au niveau de la présentation. Il se démarque clairement de la plupart des livres d'informatique que j'ai pu lire. Contrairement à ceux-ci (qui sont beaucoup plus formels, présentant de manière tout à fait neutre leur sujet) Apache Maven est beaucoup plus vivant et dynamique. Ici, le livre est écrit comme une retranscription de la vie d'une équipe qui a choisi Maven. Nous avons droit à une dose d'humour, mais aussi à des débats où chacun défend son point de vue. Et le résultat est étonnant, car il nous donne l'impression de vivre cette aventure avec eux, nous donnant envie de continuer d'avancer dans le livre sans attendre.
Du point de vue du contenu, Apache Maven couvre les fonctionnalités les plus importantes et/ou les plus intéressantes de Maven, le tout réparti en trois parties :

Premiers pas avec Maven
Dans cette partie, c'est tout d'abord le choix de Maven face à d'autres outils similaires qui est introduit. Sa force principale est les conventions apportées car elles permettent à n'importe quel développeur connaissant Maven de retrouver ses repères rapidement sur n'importe quel projet basé sur Maven. Dans cette partie on découvre également la gestion de dépendances, les premiers plug-ins et comment générer des livrables.

Maven en entreprise
Dans cette seconde partie, l'intégration de Maven dans les trois plus importants IDE (Eclipse, Netbeans et Idea) est présentée, le tout sous la forme d'un débat, dont la conclusion est particulièrement intéressante ! La notion de dépôt d'entreprise est également introduite, permettant de réduire considérablement la bande passante vers Internet, mais également d'avoir une gestion plus fine de ce qui est permis ou non au sein des projets. Et pour finir, les auteurs présentent un plug-in permettant de simplifier considérablement la livraison d'un livrable (deux commandes !)

Encore plus loin avec Maven
Maven, c'est aussi tous ses plug-ins. Mais comment faire quand il n'en existe aucun qui correspond à nos besoins ? Les auteurs nous montrent qu'il n'est pas sorcier de créer nos propres plug-ins Maven. C'est ensuite la notion d'archétype qui est présentée : ceux-ci sont une espèce de template de projet préconfiguré. Exit le copier-coller d'un projet et de renommer à la main les fichiers qui vont bien. Les archétypes proposent une solution beaucoup plus élégante !
Les auteurs terminent finalement par le chapitre certainement le plus intéressant : des best practices basées sur leurs propres expériences

Conclusion
Au final, j'ai réellement dévoré ce livre. Je connaissais et utilisais déjà Maven mais sans avoir pris le temps de regarder toutes ses possibilités. À la fin de ce livre, j'avais qu'une seule envie : tester par moi-même ! Je conseille donc vivement ce livre à toute personne ne connaissant pas (ou mal) Maven. Par contre pour les très bons connaisseurs, je doute que ce livre soit très intéressant, sauf pour convaincre leur management d'utiliser Maven.

On peut s'en douter en lisant le titre, cet ouvrage va nous faire découvrir Maven, l'outil de construction de projets Java d'Apache.
Il ne faut pas s'attendre ici à trouver LA bible sur Maven, mais plutôt d'apprendre à utiliser cet outil au sein d'une organisation.
Pour ce faire, Nicolas de Loof et Arnaud Héritier nous racontent l'histoire d'une équipe de développeurs, qui va être confrontée à différentes situations - qui ne manqueront pas de nous rappeler nos propres expériences.
Le livre se divise en trois grandes parties.
La première se destine à nous familiariser avec Maven et ses principaux concepts.
La seconde aborde des concepts plus poussés, en particulier concernant l'utilisation de Maven au sein d'une entreprise.
Enfin la dernière partie regroupe différents sujets, par exemple des cas atypiques d'utilisation de Maven.

1e partie : Premiers pas avec Maven
Cette première partie se destine à nous familiariser avec Maven et ses principaux concepts.
Les auteurs en profitent pour poser le décor de leur histoire. Nous suivrons donc l'équipe de développement d'un petit projet nommé noubliepaslalistedescourses !
Autrefois construit par un simple fichier .bat, cette application va rajeunir en étant migré vers Maven.
C'est ici que l'on constate les premiers bénéfices de l'outil d'Apache : gestion simplifiée des dépendances, cycle de vie de construction d'un projet, création des livrables (fichier JAR final par exemple), etc.
Les auteurs s'attaquent à d'autres problématiques, telles que la gestion des versions du JDK, l'intégration d'autres langages (Groovy par exemple).
Un chapitre est également consacré à la politique de tests, en mettant en lumière les différents types de tests (unitaires, fonctionnels, d'intégration, etc.) et même l'intégration continue.
On le voit dès cette première partie : ce livre n'est pas là uniquement pour nous parler de Maven, mais bien de tout ce qui a trait à l'environnement de développement.

2e partie : Maven en entreprise
Cette seconde partie aborde des questions plus poussées, des aspects de Maven qui prennent tout leur sens dans un environnement d'entreprise.
Ainsi, la première problématique abordée est la gestion avancée des dépendances, et en particulier l'introduction des dépôts d'entreprises (les repositories).
Par la suite, on s'attaque aux concepts des projets multi-modules et de l'héritage, très utiles dès que les projets prennent de l'importance !
Il est également question de la construction de livrables plus complexes, en particulier les WAR, les EJB ou les EAR.
Un chapitre est dédié à l'intégration de tout ceci au sein du principal outil du développeur : l'IDE (l'environnement de développement).
Qu'il s'agisse d'Eclipse, de NetBeans ou encore d'IntelliJ, ils sont tous étudiés par les auteurs du livre, qui nous montrent aussi bien la facilité d'utilisation de Maven directement dans l'IDE, que les petits plus qu'ils ont à offrir au développeur pour faciliter son travail quotidien.
Cette seconde partie s'achève sur un point crucial de la vie d'un projet : la livraison !
Cette étape, trop souvent bâclée, peut faire échouer un projet. Les auteurs nous donnent donc les moyens proposés par Maven pour simplifier, automatiser et fiabiliser ce processus.

3e partie : Encore plus loin avec Maven
Cette dernière partie aborde différents sujets qui n'ont pas encore été vus dans les chapitres précédents.
Tout d'abord, les auteurs nous expliquent comment il est possible de lancer des tâches par Maven alors qu'aucun plugin spécifique n'existe pour cela.
Il est ainsi question de développement de plugin Maven, mais aussi de l'intégration d'Ant au sein de Maven.
Un autre sujet connexe est abordé ici : la surveillance de la qualité du code.
Là aussi, Maven peut apporter des solutions - essentiellement grâce à des plugins ou à Sonar - et les auteurs ne manquent pas de nous le montrer.
C'est également le bon moment pour introduire la fonctionnalité de génération de site - et de rapports techniques - offerte par Maven !
Par la suite, un chapitre est entièrement consacré au démarrage d'un nouveau projet.
C'est ici l'occasion de voir les recommandations que l'on peut faire sur de nouveaux projets, et non plus de parler de migration de projets existants vers Maven.
On passe ainsi en revue certaines bonnes pratiques à mettre en place dès le début d'un projet, on apprend également à utiliser les archetypes de Maven, ces plugins qui nous permettent de créer le squelette d'un projet en fonction de son type.
Maintenant que nous avons fait le tour des principales fonctionnalités de Maven, les auteurs se posent une question un peu déroutante, mais tout de même intéressante : "Avons-nous fait le bon choix ?".
C'est ici que l'on fait une sorte de bilan, de savoir si finalement Maven est véritablement l'outil à utiliser au sein de nos projets, d'en définir les limitations et les problèmes.
Les auteurs nous parlent ensuite de l'écosystème autour de Maven : ses concurrents (Ant, Ivy et Gradle en première ligne), les sociétés qui gravitent autour de l'outil (en particulier Sonatype), etc.
Enfin, on termine avec quelques pages nous montrant les nouveautés de Maven 3.
Avant de conclure cet ouvrage, les auteurs décident de nous offrir leurs précieuses recommandations vis-à-vis de l'utilisation de Maven, leurs 10 commandements.

Mon avis
Apache Maven est un livre plutôt atypique.
Il s'apparente plus à un roman qu'à un livre technique traditionnel, et ne doit pas être pris pour une sorte de "bible" sur l'outil d'Apache.
Le fait que Nicolas de Loof et Arnaud Héritier aient abordé le sujet de Maven en racontant la vie et l'évolution d'une équipe de développement est une excellente idée, car cela nous montre un usage très réel et concret de cet outil.
Cela nous permet également de voir tous les à-côtés qui ne sont habituellement pas traités par des ouvrages informatiques sur un outil.
Ici, au-delà de Maven, les auteurs évoquent le TDD (Test Driven Development ou Développement piloté par les tests), les différentes façons de tester son application, le suivi de qualité, l'intégration continue, l'aspect livraison, les bonnes et mauvaises pratiques en général, etc.
C'est forcément un autre bon point pour ce livre !
Alors certes mon niveau en Maven, qui est plutôt bon, ne m'a pas permis de sortir de cette lecture avec beaucoup de nouvelles informations.
Toutefois, cela m'a conforté dans mes idées, m'a rassuré sur mes bonnes pratiques, et m'a appris quelques astuces plutôt sympathiques.
Le fait que ce livre aborde vraiment tous les aspects de la vie d'un projet est un énorme plus, et pourra, à mon avis, intéresser des personnes n'ayant pas un profil de développeur !
Selon moi, ce livre doit être vu comme un indispensable complément à une "bible" Maven, par exemple Maven: The Definitive Guide, d'autant que ce dernier vient tout juste d'être traduit en français.
Vous trouverez une critique complète de cet ouvrage, ainsi que tous les détails relatif à ce livre à cette adresse : http://linsolas.developpez.com/critiques/apache-maven/

Critique en français
Vous avez entendu parler d'OSGi mais vous ne savez pas ce que c'est ? Ou vous pensez que cela est trop compliqué ? Alors le livre de Daniel Rubio est surement un moyen d'appréhender OSGi de manière simple grâce à Spring Dm.
Ce livre est bien écrit et permet d'avoir une première approche sur le sujet. Dès les premiers chapitres, OSGi est expliqué très simplement et vous apprendrez quels sont les avantages de cette technologie face à JEE.
Ensuite, Spring Dm sera présenté. Celui-ci apporte la simplicité POJOs dans le monde OSGi, à la manière des projets Spring.
Vous ne connaissez pas du tout Spring ? Pas de soucis ! Une introduction succincte mais suffisante du Framework sera faite, ce qui vous permettra de suivre correctement le reste du livre sans problème.
D'autres sujets, toujours gravitant autour de OSGi et Spring seront abordés. C'est le cas du serveur de SpringSource par exemple. C'est ainsi que vous apprendrez les extensions d'OSGi qu'il apporte pour faciliter le développement, en particulier avec JPA. L'utilitaire bnd sera lui aussi au sommaire, afin de vous expliquer comment rendre un JAR compatible OSGi sans trop d'effort.
Bref, c'est un excellent livre pour débuter avec OSGi et Spring Dm, mais pour moi il ne va pas assez en profondeur pour un livre de la collection "Pro".

English review
You've heard about OSGi but do not know what it is? Or do you think this is too complicated? Then the Daniel Rubio's book is probably a simple way to learn OSGi thanks to Spring Dm.
This book is well written and gives a first approach on the subject. In the first chapters, OSGi is explained very simply and you will learn what are the benefits of this technology face to JEE.
Then Dm Spring will be presented. This brings the simplicity of POJOs in the OSGi world, like all the Spring projects.
You do not know anything of Spring? No worries! A brief but sufficient introduction of the Framework will be made, allowing you to follow the book without difficulty.
Other subjects, always revolving around OSGi and Spring, will be covered. This is the case SpringSource server for example. Thus you will learn the extensions it provides to OSGi to facilitate development, especially for JPA.
The tool 'bnd' is also introduced in summary, to explain you how to make a OSGi-compatible JARs without too much effort.
In short, it is an excellent book to start with OSGi and Spring Dm, but for me it does not go deep enough for a book of the "Pro" collection.

"Maven : the definitive guide" est un livre adoptant une pédagogie très progressive sur l'outil Maven. Commençant par une présentation en surface de l'outil (son orientation déclarative, quelques commandes de base, les plugins connexes) pour continuer sur un descriptif de ses possibilités plus étendues (extension par l'écriture de plugin, intégration dans Eclipse, etc.).

Les plus

• Un guide très complet
• Deux échantillons de projet Maven utilisables immédiatement : une première structure simple et une autre découpée en modules comme dans le monde réel de l'entreprise (web, modèle, services, etc.)
• La découverte de nombreux outils en dehors de Maven (Spring, Hibernate, Geronimo…)
• Le plaisir de la découverte de l'outil, l'écriture agréable et jamais ennuyante (voire même amusante)
• On trouvera aussi de nombreuses astuces et des conseils qui trouveront je suis sûr une place dans vos projets existants

Les moins

• Comme Eric le soulignait précédemment, il est parfois étrange de se voir référer un schéma qui se trouve 2 ou 3 pages plus loin, mais ça c'est du détail sur la mise en page
• Je ne trouve pas d'autres points négatifs…juste peut être que j'aurais voulu en avoir plus encore (par exemple une ouverture à d'autres systèmes de gestion de repositories d'entreprise, mais seul Nexus est retenu, compréhensible car développé par Sonatype)

A qui s'adresse ce livre ?

• A tous ceux qui ne connaissent pas Maven, car cet ouvrage est une très bonne introduction pour ce fabuleux outil, mais aussi aux intéressés qui chercheraient à aller plus loin encore (pour ce qui concerne l'optimisation par exemple)
• Mais également aux autres qui chercheraient à convaincre des équipes de développement réfractaires (beaucoup pensent encore que seul l'outil Ant existe) ou à trouver l'argumentaire pour convaincre des décideurs hésitants sur cette option technologique pouvant apporter bien des indicateurs au niveau d'un projet.

Voilà donc un ouvrage que j'ai vraiment apprécié et dont je conseille vivement la lecture ! A noter au final aussi la sympathique (ou pas) métaphore du fourmilier en couverture…

Ce livre porte bien son nom. Non seulement il est destiné à tout public, mais en plus il constitue vraiment un guide complet sur Maven 2.
En effet, il aborde tous les aspects de Maven 2 (cycle de vie, gestion de dépendances, outils, extensions, etc.) en fournissant au lecteur suffisamment d'éléments pour que celui-ci puisse approfondir s'il le souhaite.

Le découpage de l'ouvrage est bien fait et permettra à ceux qui ont déjà un peu d'expérience avec Maven de se focaliser sur l'un ou l'autre chapitre de la partie Maven by Example avant d'aller parcourir la partie Maven Reference qui se propose d'approfondir les connaissances de base.
Les premiers chapitres sont vraiment écrits dans une approche progressive et illustrent les possibilités de Maven 2 via des applications exemples représentatives.

J'ai été impressionné par le nombre d'astuces et de conseils prodigués, permettant d'utiliser Maven 2 de manière intelligente et non en suivant une simple mécanique de déclaration pure et dure de dépendances.

Si j'ai trouvé le chapitre sur les assemblies un peu plus indigeste que les autres, celui sur m2eclipse devrait ravir ceux qui sont lassés par l'édition de fichier XML et ne se sentent pas assez productifs dans leur utilisation de Maven 2 (on regrettera juste que les illustrations soient parfois à 1 ou 2 pages de la description, la faute au nombre important de visuels nécessaires à ce chapitre).
Les chapitres plus avancés sur Nexus et la création de plugins sont également intéressants, même si sans doute moins utiles à la majorité des lecteurs. On a notamment droit à un éventail complet de l'utilisation et configuration de Nexus, excellent point de départ pour vous aider à initier un proxy/repository d'entreprise.

Enfin, on appréciera la présence des 2 annexes permettant respectivement d'avoir un aperçu des éléments de configuration pouvant être déclarés dans le fichier de configuration global (settings.xml), ainsi que les artefacts du serveur Geronimo qui vous permettrons de pallier à l'indisponibilité (via les repositories) de ceux correspondants à la spécification Java EE (vous évitant de devoir installer ces derniers à la main).
En conclusion, Maven: The Definitive Guide est un livre bien écrit, assez complet, et dans lequel tout lecteur devrait s'y retrouver.
Ce qui est vraiment appréciable, c'est que les auteurs ne masquent en aucun cas les défauts et problématiques courantes survenant avec Maven 2, mais surtout qu'ils fournissent au lecteur les outils et pratiques pour traiter ces derniers.
Un livre à recommander.

Introduction
Poussé par la notoriété grandissante des dernières versions 5.x et de la très attendue version 6, Rich Client Platform : Plugging into the Netbeans Platform est le deuxième livre présentant Netbeans comme plateforme de client riche. Apportant une nouvelle expérience du développement d'application RCP, le site Netbeans.org restait jusqu'à aujourd'hui la principale source d'information pour apprendre à profiter de la plateforme : API très riche, documents techniques, nombreux tutoriaux offerts par la communauté, sans oublier la mailing-list très active. Cependant, il manquait une introduction aux concepts de base de l'architecture et c'est le défi que les auteurs ont su relever avec qualité au travers des 22 chapitres de ce livre.

Les auteurs
Tim Boudreau, aujourd'hui évangéliste pour la plateforme,il fût un des auteurs du premier livre sur Netbeans RCP; Jaroslav Tulach, garant du projet OpenIDE, il fût un des fondateurs de Netbeans dans les années 1997; enfin Geertjan Wielenga, rédacteur technique des branches module et RCP de Netbeans, son blog https://blogs.oracle.com/geertjan/ n'est plus à présenter aux développeurs ayant déjà utilisé la plateforme.

La critique
Le livre commence par 4 chapitres proposant de faire nos premiers pas avec Netbeans et l'architecture modulaire. Vous y découvrirez d'abord comment créer un nouveau module, puis comment il est structuré (layer.xml, bundle.properties, …). Les auteurs décrivent ensuite les intérêts à découper une application en plusieurs modules et les avantages que Netbeans apporte dans ce domaine : les différents types de modules qui coexistent au sein du contrôleur et les différentes façons de les faire communiquer.

Les 7 chapitres suivants détaillent les principales API au coeur de Netbeans. Vous découvrirez la puissance des Lookups, fournissant entre autre un moyen de dialoguer entre modules, les Filesystems offrant un accès unifié aux sources de données (répertoire/ fichier, jar, xml, …) et l'intégration d'une structure d'information grâce aux Nodes. C'est aussi au travers de ces chapitres que vous apprendrez à utiliser les vues de Netbeans, à organiser les fenêtres et à adapter l'interface en fonction des éléments sélectionnés.

Suivent 8 chapitres qui traitent des API plus spécifiques à l'IDE. Tout d'abord vous apprendrez à réaliser un support complet d'un type de fichier dans l'éditeur de code, exemple basé sur les fichier manifest (.mf) : vues multiples et représentation graphique, coloration syntaxique, auto complétion, liens inter document, mise en évidence des erreurs et drag & drop grâce à la palette. Puis vous verrez comment apporter une meilleure expérience utilisateur avec le panneau des options, la mise à disposition d'une documentation et le centre de mise à jour.

Pour finir, les 4 derniers chapitres proposent une approche plus concrète des concepts étudiés tout au long du livre. Vous verrez tout d'abord avec quelle facilité il est possible d'ajouter le support d'un framework au projet Web standard ; Comment faire communiquer un module et un WebService avec moins de 10 lignes de codes ; Pour finir, 2 exemples fonctionnels complets sont détaillés : le support de l'outil Tidy via un plugin Netbeans et une application RCP de manipulation d'une bande sonore. Le livre se clôt enfin par 3 appendices ciblés sur les bonnes pratiques de design et de performances à privilégier lors du développement de module Netbeans.

En conclusion, ce livre est une parfaite introduction à la prise en main de la plateforme Netbeans. On peut regretter l'oubli des Wizards, formulaire à étapes multiples, bien qu'introduits dans plusieurs chapitres (et sur le blog de Geertjan). Néanmoins ce livre couvre les aspects vitaux pour maîtriser la puissance de la plateforme. Il englobe aussi la version 5,5 et chaque point est décrit par un code source clair et illustré (aussi dispo sur le cdrom). Captivant, structuré et d'un anglais largement abordable, ce livre est indispensable à tous les développeurs de plugins et d'applications RCP et je le conseille vivement aux personnes qui souhaitent en connaître davantage sur la plateforme.

A la vue de la biographie des auteurs on s'attend à un livre d'un très bon niveau, et c'est le cas. Ce livre vous permet d'entrer dans le monde d'Eclipse de manière progressive, logique et pratique. Même si l'entrée en matière est progressive, ce livre s'adresse à un public averti ayant déjà de solides bases en Java et plus généralement en programmation orientée objet.
Je suis assez sensible à la manière dont les sujets sont organisés dans un livre : les chapitres sont souvent courts, ne traitant qu'un sujet à la fois, on ressent ici le talent des auteurs en terme de modélisation. Par conséquent, ce livre est probablement le meilleur moyen pour commencer à développer des plugins Eclipse.

Alors pourquoi seulement la moyenne pour ce livre ? Pour les choix de traduction qui ont été faits :
Les plus :

• Les copies d'écran utilisent une version française (d'ailleurs ce choix ne tient pas sur la longueur du livre) ;
• Les noms des Design Pattern, ainsi que le nom des règles qui sont les fondements sur lesquels se base Eclipse, ont été traduits. On se retrouve à aller chercher la traduction anglaise (qui est quand même fournie dans le livre) pour comprendre de quoi ils parlent. Ce choix me paraît une vrai fausse bonne idée.
  

J'ai trouvé ces choix très déstabilisant et cela m'a vraiment gaché la lecture. Ils encouragent à regarder le code existant, or ce code est en anglais ! Il me parait utopique de penser que l'on puisser contribuer à Eclipse sans être capable d'au moins se retrouver dans une documentation dans la langue de Shakespeare.
Il est clair que ce livre ne couvre pas la totalité du sujet, bien trop immense au vue du sujet. Cependant, il permet par la suite de se retrouver plus aisément dans la documentation de Eclipse.

En conclusion, je dirais que la traduction trahit l'esprit du livre, et je recommanderais plutôt sa VO !

Voici un livre qui permet une prise en main ultra-rapide mais néanmoins avancée de l'IDE Eclipse, outil de développement multi-plateforme écrit en java en vogue auprès de la communauté. Ce livre, construit sur quatre parties (Cercles 0,1,2,3), vous permettra avant tout de vous familiariser avec le développement et l'intégration de plugins Eclipse.
Bien sûr, cela nécessite une connaissance déjà avancée du langage Java, et des notions de développement GUI avec SWT/JFace seraient un plus pour aborder ce livre, mais on peut apprendre sur le tas.

Parlons un peu des deux auteurs : Erich Gamma et est un des quatre auteurs du livre design patterns, communéments appelés le GoF (pour Gang of Four ).
C'est aussi l'un des initiateurs de l'environnement de tests unitaires en Java JUnit, et de l'IDE Eclipse.
Quant à Kent Beck, c'est LE môssieur de l'eXtreme Programming ! Autant vous dire qu'ils savent ce qu'ils racontent.
D'ailleurs, sachez que le projet autour duquel ce livre s'articule est un plugin, simple, certes, mais pleinement fonctionnel, intégrant une interface graphique claire et implémentant JUnit sous Eclipse.

Cela doit se ressentir, j'adore ce livre. Je l'ai lu deux fois et il reste mon livre de référence pour le développement de plugins simples.
Ce n'est pas un ouvrage vraiment de référence mais un GROS tutoriel pourrait-on dire, bourré de détails et dont la méthode d'apprentissage ne lasse pas.

Ce livre au format poche contient l'essentiel de ce qu'il faut savoir sur les expressions régulières. Au cours des chapitres on trouvera une alternance en explication et mise en application directe par des petits exercices rapides (les corrigés sont disponibles à la fin du livre).
L'approche est progressive. Le premier chapitre introduit par un exemple simple les différentes notions.
Le deuxième chapitre va un peu plus loin en expliquant le fonctionnement des différents opérateurs basiques.
Le chapitre 3 explique de manière plus concrète les expressions régulières via des cas d'utilisations.
Le chapitre 4 donne des conseils de bonnes pratiques avec les expressions régulières.
Le chapitre 5 fait un tour d'horizon des langages proposant des outils pour les expressions régulières.

Deux annexes dans ce livre :

• les solutions aux exercices du livre
• que faire quand ça ne marche pas !

J'ai trouvé l'ouvrage très intéressant dans ses premiers chapitres, où il expose les différents types de refactoring à considérer, les manières de les mettre en oeuvre.
De plus, les façons d'analyser l'existant sont bien expliquées, et de nombreux outils sont proposés pour arriver à nos fins. Bien qu'il date de 2005, son contenu reste tout à fait d'actualité.
Après, j'ai trouvé que ça s'est gâté. On passe de hors sujet en hors sujet, même si ceux-ci s'avèrent agréables à lire. Une bonne partie du livre nous explique comment utiliser Eclipse pour renommer les méthodes, réorganiser le contenu des classes, présente quelques design patterns et la POA, la façon d'écrire des tests unitaires… Je trouve qu'on s'écarte souvent du sujet principal.

J'espérais trouver un livre dans lequel obtenir plus d'informations sur la manière de refondre le code plus en profondeur. Ceci dit, le livre précise bien qu'un refactoring s'applique à du code dont les fondements sont sains, mais cela ne suffit pas à combler ma déception.
La lecture de ce livre n'aura cependant pas été une perte de temps, car de nombreuses idées traversent l'esprit pendant la lecture de ce dernier par rapport à mon cas personnel, et les techniques/outils présentés le sont très bien.

On finit tous un jour par se retrouver sur un projet avec du code hérité au lourd passif… Le genre de code qui évolue au jour le jour. Le code pour lequel personne ne trouve le temps de prendre du recul pour essayer de l'alléger, réécrire les morceaux peu performant, redondant ou trop contraignant… C'est alors que cet ouvrage est utile.

Il présente une approche progressive du refactoring. On commence avec les choses de bases (renommage de variable, changement de nom de méthode) pour finir sur des choses plus compliquées (applications de pattern, refactoring de la base de données …). L'approche est très graduelle, on ne se sent pas perdu et les outils (audit de code ou test) sont clairement expliqués.

Ce qui est intéressant, c'est que l'auteur pose toutes les conditions pour que cela se passe bien. Il explique comment déterminer les points sensibles qui seront soumis à refactoring, comment s'assurer que le comportement du logiciel sera le même après refactoring. Il détaille bien les outils de mesures mais aussi leur piège et faux positifs. Pour chaque technique il indique quand l'utiliser et quels sont les risques qui lui sont propres. Par exemple, vous avez sans doute déjà utilisé les fonctions de renommage de votre IDE, mais qu'en est-il en cas de chargement dynamique de la classe ou d'introspection sur la méthode ?

Chaque technique est accompagnée d'un exemple et de capture d'écran pour Eclipse.
Enfin, ce qui ajoute beaucoup de valeur à ce livre, c'est l'étude de cas qui occupe environ un cinquième du volume. On a tous lu des livres avec des exemples (parfois à peine plus complexes qu'un "Hello World"). On pense avoir compris et quand on arrive sur un vrai cas, on se pose encore des questions, on hésite, on ne sait plus … Ici l'étude de cas se fait sur une vraie application, pas juste trois classes et deux JSP. Cette étude de cas permet de mettre en application les techniques décrites dans la première partie de façon guidée. Et si vous ne voulez pas faire les premières étapes (renommage) mais uniquement la refonte des DAO ou des actions Struts, il existe une version de chacune des étapes sur le CVS.
En conclusion, un livre obligatoire à lire si l'on se retrouve un jour avec du code hérité.

Un excellent ouvrage sur le refactoring.

Ce livre est un bijou, une merveille, un joyau.
Je me suis vraiment régalé à la lecture de ce livre. Il commence tout d'abord par vous expliquer la raison d'être du refactoring, ce que c'est et ce que ce n'est pas.
Ensuite, il vous explique les préparations à faire (création de branches, de clichés, s'assurer qu'on a bien les tests unitaires, …) avant d'effectuer un refactoring de votre application.
Puis, il vous explique la mise en oeuvre du refactoring, à l'aide de l'EDI Eclipse.
Il vient ensuite vous montrer comment combiner les tests unitaires avec le refactoring, et l'utilisation de simulacre d'objets avec EasyMock, mais également l'analyse de couverture avec EMMA.
Toute un chapitre est également consacré aux design patterns, et comment ils peuvent vous venir en aide dans le cas du refactoring.
L'auteur aborde également, avec élégance, la problématique du refactoring avec les bases de données. Et cela est vraiment enrichissant.

La troisième partie du livre est entièrement consacrée à l'étude de cas: un programme de généalogie.
A travers cette étude de cas, l'auteur vous apprendra comment, grâce à une analyse quantitative et une analyse qualitative, trouver les parties de code nécessitant un refactoring.
Une fois ces parties détectées, il va appliquer différents refactoring appris lors de la deuxième partie du livre.
Conclusion :Sans discussion, un excellent achat.

Quelle personne ne s'est jamais retrouvée en face d'un code qu'elle avait ou n'avait pas produit et qui parfois se révèle être une cochonnerie en terme de maintenance et d'évolutivité.
Eh bien moi je me suis retrouvé dans le cas ou ce code ne m'appartenait pas et, qui plus est, était mal agencé pour me permettre de le faire évoluer sereinement sans devoir tout réécrire de A à Z.
Je me suis donc retroussé les manches et ai commencé à proprement parler le refactoring de l'application.
Je dois bien avouer que je ne m'en serait jamais sorti si je n'avais pas suivi les conseils précieux distillés dans cet ouvrage.
L'auteur commence d'abord par expliquer le pourquoi du refactoring.
Ensuite viennent les pré-processus indispensables pour effectuer un refactoring robuste tels que le versioning des différentes ressources, la mise en oeuvre des tests unitaires,…
Le troisième chapitre est pour moi le plus théorique. Il aborde les méthodes qui permettent d'analyser le code tant de manière quantitative que qualitative.
Je dois bien avouer que j'ai du relire ce chapitre une seconde fois pour bien comprendre à quels moments, et quels endroits du code, le refactoring devenait une nécéssité voire même une obligation.
Chapitre 4. Là, on rentre réellement dans la mise en oeuvre du refactoring. Chaque technique de refactoring abordée dans ce chapitre est basée sur un plan bien précis. Ce plan est décomposé en 4 parties :

• les objectifs de cette technique ainsi que les risques pouvant survenir
• les moyens de détection
• le refactoring proprement dit
• un exemple concret de mise en oeuvre

Le chapitre suivant traite de l'utilisation de test unitaires en combinaison avec le refactoring. Il explique également comment créer des simulacres d'objets qui permettront, comme le terme l'indique, de simuler des objets.
C'en est terminé avec la première partie de l'ouvrage.
La seconde partie traite des techniques avancées pour effectuer le refactoring d'une application telles que les design patterns, SOA.
Ce qui m'a le plus surpris dans cette partie, c'est le refactoring de la base de données.
Comme quoi on en apprend tous les jours.
La dernière partie reprend une étude de cas complète. Cette partie de l'ouvrage met en pratique la totalité des techniques abordées lors des chapitres précédents, en passant :

• par l'analyse quantitative et qualitative,
• par le refactoring de l'application,
• par la mise en oeuvre des tests unitaires

En conclusion, cet ouvrage est un petite merveille. A recommander chaudement.

Cet ouvrage, écrit par l'un des acteurs majeurs de la communauté Hibernate, vous présente la démarche de mapping Objet/Relationnel, et en particulier l'implémentation Hibernate 3.0.

Après quelques rappels historiques et l'évocations des solutions passées et présentes, l'auteur nous fait partager toute sa connaissance d'Hibernate à travers des exemples simples et pertinents.
Suffisamment détaché de la documentation officielle, ce livre vous apprendra Hibernate 3.0 de A à Z en illustrant le propos par de nombreux exemples, dans un style agréable à lire et efficace.

Il y en a pour tous les goûts : que ce soit le débutant qui souhaite s'initier à cette solution de gestion de la persistance, le connaisseur qui est à la recherche de conseils et de bonnes pratiques, ainsi que l'expérimenté toujours à l'affût des nouveautés, améliorations, notions avancées, fonctionnalités à venir.

En conclusion, cet ouvrage complet ne devrait pas vous décevoir, et vous accompagnera dans votre démarche de gestion de la persistance avec l'une des (futures) implémentations de la norme EJB 3.0.
Retrouvez la critique complète ici.

Le couple Java/XML est désormais un incontournable pour le développeur J2EE. La découverte des intéractions entre ces deux technologies est le but avoué de cet ouvrage. La tâche est difficile, mais l'auteur, Renaud Fleury, en viens à bout de manière fort élégante.
Ce ouvrage est destiné à toute personne désirant faire du développement web avec J2EE et XML. Que vous soyez un développeur J2EE débutant désirant vous ploger dans le développement web, un développeur J2EE confirmé désirant découvrir (ou redécouvrir) la technologie XML ou encore un chef de projet désirant avoir un apercu clair des possibilités offertes par le couple J2EE/XML, ce livre est fait pour vous.
Le parti pris de cet ouvrage est de faire découvrir les vastes possibilités de Java/XML grâce à la réalisation, tout au long du livre, d'un projet de site web totalement axé sur XML : le projet Octopuss.
Le principal atout de cet ouvrage est justement le projet Octopuss. Il est particulièrement agréable de découvrir de manière pratique ces technologies, parfois complexes. Ainsi, l'auteur commence tout simplement par un cahier des charges : exposition des besoins, spécifications fonctionnelles et techniques, méthodologies de développement, etc. Vous pouvez d'ailleurs découvrir ce premier chapitre sur le site d'Eyrolles : extraits du livre Java / XML.
Après une partie dédiée à l'installation des outils de développement (Eclipse, Tomcat, Log4j, etc.), on passe dans le vif du sujet : le développement de l'application. Chaque chapitre va vous permettre de découvrir une nouvelle facette de XML et son application pratique avec le projet Octopuss. Vous pourrez ainsi faire le tour du monde XML : les notions et API fondamentales (XML, XSL, XML Schema, JAXP, SAX, DOM, etc.), le data-binding (JAXB, Castor, etc.), les frameworks d'application (Struts, Cocoon, Barracuda), les bases de données XML natives et la conception de services Web.
On pourra aussi apprécier la mise en page claire, la présence de nombreux schémas explicatifs et de nombreux cadres présentant des définitions, liens web intéressants, etc.
La seule chose que l'on pourra regretter après la ecture de cette ouvrage est l'absence d'un CD. Celui-ci aurait pu contenir les outils de développement (outils libres et gratuits), ainsi que les codes sources du projet Octopuss. Je pense que cela aurait renforcé le côté pratique de l'ouvrage et aurait permis de se focaliser plus directement sur le côté technique.
Les codes sources de l'application sont téléchargeables : Java/XML Téléchargements.
Une dernière remarque que l'on pourrait faire est le fait que certaines technologies ne sont que survolées. A dire vrai, j'aurais lu avec plaisir quelques chapitres de plus. ;-)
Pour conclure, je dirais que cet ouvrage devrait trouver sa place dans la bibliothèque de tout développeur J2EE : un guide utile, agréable et pratique des technologies Java/XML.

Ant est devenu un outil indispensable au développeur Java, quel que soit son domaine de prédilection : J2SE, J2EE, etc. Sa portabilité, sa facilité d'utilisation et son intégration à de nombreux EDI/RAD du marché (grâce à des plugins, voir même par défaut avec NetBeans), en font un outil incontournable. Voici quelques liens grâce auquels vous pourrez en apprendre un peu plus :
Une courte introduction à Ant par l'équipe Java
Forum d'entraide Ant
Autres outils pour le développeur Java

O'Reilly nous offre ici un livre d'un peu plus de 500 pages, destiné à nous apprendre à utiliser XSLT avec Java.
On pourrait se poser la question suivante : que peut-on raconter sur Java et XSLT en 500 pages ? Et bien, beaucoup de choses très intéréssantes dans ce cas.
Les exemples sont simples, pratiques, sans fioritures inutiles mais permettent de comprendre rapidement les notions exposées. Les textes sont clairs et agréables à lire.
Ce livre n'est pas uniquement centré sur son sujet annoncé mais s'étend un peu sur des sujets annexes, tels que les servlets, la sécurité de ces mêmes servlets par rapport aux threads, aussi bien que par rapport aux utilisateurs. Les notions de bases de XML et des parseurs sont rappelées rapidement mais pas baclées. La génération du XML, par exemple à partir de bases de données est aussi évoquée. Ainsi que bien d'autres sujets périphériques.
En conclusion, un livre complet, assez dense mais très clair et tout à fait abordable, même par des débutants un peu curieux (tels que moi) qui couvre bien son sujet et ses interconnections avec d'autres technologies.

J'avais appris la grande qualité de son prédécesseur Apache Maven sans jamais avoir pu le lire. J'ai décidé de me laisser tenter en lisant sa nouvelle version centrée sur Maven 2 et 3. J'utilise Maven depuis quelques années au sein de divers projets (client lourd, client web, Eclipse RCP, ..) mais n'avais jamais vraiment tenté de découvrir les fonctionnalités que je ne connaissais pas.

L'approche de ce livre est très intuitive. On y apprend l'évolution d'un logiciel de gestion de liste de courses qui aux grès de son évolution industrialise ses processus de build, de test et de packaging.

La difficulté est croissante et correctement dosée. On démarre sur les bases de Maven (la gestion des librairies et de la compilation). On apprend au fur et à mesure :

• à stabiliser notre logiciel en y intégrant des tests,
• à rationaliser les différentes étapes de notre build,
• à sécuriser notre processus de livraison,
• à tendre vers une intégration continue,
• à réutiliser ces concepts au sein d'autres projets,
• puis à voir encore plus loin que Maven en y synthétisant ses limitations et ses axes d'évolutions.

Les plus :

• Situations concrètes avec une difficulté correctement dosée,
• Couvre un très large panel de bonnes pratiques (on ne se limite pas qu'à Maven mais également son intégration avec des outils pour favoriser l'industrialisation),
• Pas d'évangélisme, le discours ne cache pas les faiblesses ou les limitations (on sent que le livre se base sur des expériences réelles),
• On retrouve forcément son projet dans l'une des phases d'intégration de Maven dans ce livre (de la plus archaïque à la plus industrialisée),
• Livre en français 100% authentique et au ton ludique voir humoristique.

Les moins (et franchement j'ai du mal à en trouver) :

Manque peut être un projet d'exemple : "Application de liste de courses"

En conclusion, si vous êtes français et que vous voulez comprendre Maven (dans ses versions 2 et 3), ce livre est un must. En plus, il n'y a pas besoin de lire son prédécesseur pour s'y plonger.

Ce livre m'a beaucoup surpris, car il ne commence pas du tout comme tous les autres livres d'informatiques puisque tout est détaillé dans une histoire du début à la fin du livre, il se lit donc comme un roman, de plus c'est assez humoristique. C'est une chose absolument géniale puisque l'on est très vite pris par cette histoire. Pour faire très simple, l'histoire décrit plusieurs personnes, arrivant au fur et à mesure de l'histoire, qui travaillent sur un projet et chaque chapitre représente un problème dans ce projet dans lequel l'on décrit la solution.

Une chose aussi bien appréciée est le fait que les auteurs prennent vraiment leur temps pour expliquer les parties compliquées de Maven. J'ai particulièrement apprécié le chapitre traitant du couple Maven et serveur d'intégration, parfaitement détaillé. Chose assez rare quand l'on regarde les différents tutoriels existant sur Internet.

Ce livre aura le don de vous faire comprendre Maven de la façon la plus ludique et simple possible. On se laisse très facilement prendre par l'histoire en se mettant à la place des personnages et en se disant que cette situation nous est déjà arrivée. Un livre que je recommande à toute personne faisant du développement en Java.

Le livre "Programmation orientée aspect pour Java / J2EE" définit dans un premier temps ce qu'est la POA (assez succinct, mais précis et suffisant. Pour information, POA c'est AOP en anglais), présente et compare ensuite 4 outils/implémentations de POA (AspectJ, JAC, JBOSS AOP et AspectWerkz) et finit sur une partie concernant les domaines d'application de ce paradigme (Design Patterns, cas concret…)

J'ai apprécié l'approche pragmatique de cet ouvrage, chaque solution est présentée avec une même structure dans ses sous-chapitres. Les solutions sont ensuite utilisées par la suite pour présenter les cas d'utilisation (même si au cours de la lecture j'ai ressenti la préférence des auteurs pour leur bébé JAC). Vous trouverez également dans cet ouvrage des explications sur comment appliquer la POA à votre proche métier ou dans vos techniques habituelles et conventionnelles de programmation. Un bon point pour le style d'écriture des auteurs, l'attention du lecteur est bien entretenue et sa compréhension améliorée. La mise en page est bien conçue dans l'ensemble, les codes sources sont disponibles sur le site de l'éditeur, bref tous les ingrédients sont là.

Ce livre constitue donc, à mon sens une bonne introduction sur le sujet de la POA : assez général pour couvrir un spectre de plusieurs outils, et détaillé pour vous accompagner à comprendre et utiliser les solutions présentées pour une application concrète dans vos projets. Malgré tout (mais je ne pense pas que les auteurs avaient la prétention d'être exhaustif), pour aller plus loin une exploration unitaire des frameworks présentés sera nécessaire. Au final, un livre que je vous conseille pour découvrir la POA.

Dans un style simple et clair, cet ouvrage s'applique à expliquer de manière très didactique les concepts avancés de la POA, avant de passer en revue les principaux outils permettant d'utiliser ce paradigme avec Java. Par ailleurs, il est très pédagogique et au fil des chapitres, l'on se rend compte qu'il distille habilement les bonnes pratiques nécessaires à une bonne appréhension de la POA.

Un soin particulier est apporté à la description des design patterns réécrits en utilisant ce nouveau paradigme, ainsi qu'à l'installation des outils utilisés dans l'ouvrage.

Enfin, l'étude de cas complète permet de fixer les idées afin de maîtriser le concept.
Ce (gros) livre de 446 pages s'avère très complet et permettra au novice de la POA comme à l'expert de trouver ce qu'il cherche. Attention toutefois, une maîtrise parfaite du paradigme objet est nécessaire pour le comprendre aisément.
En conclusion, un ouvrage à recommander aux programmeurs Java / J2EE professionnels désireux d'évoluer.