Les livres sur les frameworks Web Java orientés composants

Programmation GWT 2 est un livre écrit par Sami Jaber, consultant indépendant, qui s'est immergé dans le projet GWT 2 pendant son élaboration. Ceci lui a permis d'écrire cet ouvrage en avant première.

Il ne faut pas considérer ce livre comme un tutoriel évolué qui décrit comment développer une application GWT. L'auteur met plutôt l'accent sur les nouveautés du framework et décortique les prouesses technologiques de GWT.

La première partie du livre est une présentation rapide de GWT et de l'environnement de développement. On assiste ensuite à un tour très rapide des widgets disponibles dans GWT ainsi que les divers conteneurs. Ici, un développeur débutant désireux de prendre en main la technologie regrettera que l'auteur passe un peu rapidement sur ces points. Pour bien apprécier le livre, il faut à mon avis avoir déjà bricolé un peu la version 1.X de GWT.

On appréciera le chapitre 4 qui présente les bibliothèques tierces, comme GXT ou SmartGWT. Même s'il est assez succinct, cela donne un aperçu global des possibilités du marché.

Avec le chapitre 5, on entre dans les arcanes de GWT avec la présentation de JSO et des Overlay. Ce chapitre est un peu complexe à suivre mais on voit que l'auteur est impressionné par l'inventivité des créateurs du framework et a cherché à bien comprendre la magie qu'il y a dessous.

On lira avec intérêt le chapitre 7 sur les services RPC, éléments incontournables pour créer une vraie application.

Ensuite l'auteur décrit les nouveautés de GWT 2, comme les optimisations du chargement à la demande, la liaison différée ou la gestion des ressources et l'internationalisation.

On découvrira aussi ce qui se passe "sous le capot de GWT" avec notamment la génération de JS et les optimisations.

En fin de livre, on appréciera les chapitres qui parlent de comment créer des tests dans une application GWT 2 et qui présentent des designs patterns et bonnes pratiques pour le développement d'application GWT. Et, cerise sur le gâteau, l'avant dernier chapitre est consacré à UIBinder, une des grandes nouveautés de la version 2 et nous met l'eau à la bouche avec cet outil qui va grandement simplifier la création des interfaces graphiques.

Globalement, le livre est plutôt bien écrit et clair. Certains chapitres sont assez difficiles à comprendre et pas toujours indispensables à l'apprentissage de GWT. Par contre, ils sont très intéressant pour la culture ou pour maitriser complètement les arcanes de GWT.

Je recommanderai cet ouvrage dans un premier temps aux personnes ayant eu une première expérience dans le développement GWT et qui cherchent à utiliser avec profit les nouveautés de GWT 2. Les développeurs ne connaissant pas du tout GWT auront à mon avis besoin de beaucoup de travail personnel pour commencer à appréhender les subtilités de ce framework.

Pour diffuser des ressources sur une technologie, on peut soit traduire une ressource existante dans une autre langue, soit créer une nouvelle ressource de toute pièce. Sami Jaber a choisi, pour notre plus grand bonheur, la seconde solution. L'originalité de son ouvrage consiste à apporter des informations complètement inédites sur GWT 1.0 et 2.0.

Sur la forme, c'est un ouvrage technique qui se picore davantage qu'il ne se lit de bout en bout.

Sur le fond, c'est assez riche. Jugez plutôt :

1) Des chapitres "classiques" qu'on retrouve plus ou moins dans les autres livres GWT.

L'introduction intéressera particulièrement les décideurs puisqu'elle brosse une vue d'ensemble de GWT et le situe face aux autres frameworks Ajax.

Les chapitres "L'environnement de développement", "Les contrôles", "Le plug-in Eclipse pour Gwt" s'adresseront davantage aux développeurs débutants qui n'auraient pas préalablement lu de livre sur le sujet.

Le chapitre "Les bibliothèques tierces" est un peu tiède à mon goût, à la fois pas assez exhaustif (comment pourrait'il l'être ?) et trop détaillé pour un simple survol (Qu'est ce qu'apporte un seul exemple ?). Notez bien mon questionnement car à la place de l'auteur, je ne sais pas comment j'aurai fait ? Il ne pouvait pas passer dessus et il ne pouvait pas trop détailler non plus pour des contraintes éditoriales évidentes; il a donc opté pour une solution intermédiaire. Une fois le livre terminé, ma perplexité subsiste. Les librairies présentées sont intéressantes aujourd'hui mais comparé au potentiel de GWT 2, elles paraissent bien fades.

• Smart GWT étant un wrapper de code JS, on perd des avantages de GWT (comme le debug pas à pas, la prévention contre les fuites mémoires, ...)
• GXT quand à elle est une librairie full GWT mais tous ceux qui ont regardé son code vous diront qu'elle est loin déjà d'avoir intégré toute la puissance de GWT 1.0 (deferred binding). On a donc hâte qu'elle soit réécrite en tirant toutes les spécificités supplémentaires introduites par GWT 2.0.
• Gears est aujourd'hui abandonnée au profit d'une solution plus standard du W3C.
• Quand aux autres plus particulières, on a qu'un souhait : que leur intégration future à GWT se fasse le plus tôt possible.
  

Le chapitre "Les services RPC" ressemble pour l'essentiel à ce qu'on trouve ailleurs. Certes, l'auteur parle de deRPC, la nouvelle version du RPC, du mode hybride compatible RPC 1.X et RPC 2.X, de bonnes pratiques et du contournement de la règle SOP (Exemple du proxying) mais il m'a un peu laissé sur ma faim. J'aurai aimé dans ce chapitre une section "sous le capot" telle qu'on les trouve dans d'autres chapitres. J'aurai également aimé qu'il détaille la connexion d'un client RPC à un serveur non RPC.

2) Des chapitres qui détaillent des aspects de GWT comme aucun ouvrage ne l'a fait jusqu'à présent.

Le chapitre "L'intégration de code Javascript" est passionnant. En suivant la problématique, l'approche historique et les débats de l'équipe de développement GWT, on a l'impression d'être avec eux dans les coulisses.

Le chapitre "La création de composants personnalisés" est assez étoffée. On y apprend surtout pourquoi Javascript a des fuites mémoires et comment GWT s'y prend pour les éviter. A conseiller aux développeurs Javascript !!!

Le chapitre "L'intégration J2EE" fournit des pistes à ceux qui doivent s'interfacer avec du Spring et des EJB. Certains reprocheront que la liaison avec leur librairie préférée n'est pas abordée mais vu la richesse de J2EE, le choix de l'auteur se limitant aux deux principales est pertinent.

Les chapitres "La liaison différee" et "Sous le capot de GWT" détaillent les mécanismes utilisés par GWT pour générer du code multi navigateur et optimisé. Très intéressant !!!

Le chapitre "L'internationalisation" est très complet. Je note particulièrement la question des formes plurielles et des outils pour en écrire le moins possible (Feignant ? Non, productif !).

Dans le chapitre "Les design Pattern GWT", il est question à la fois des patterns MVC, MVP pour séparer les responsabilités et de bonnes pratiques concernant l'historique, les traitements longs et la sécurité. Cette dernière étant détaillée (injection sql, XSS, CSRF, authentification), elle pourrait peut être faire l'objet d'un chapitre séparé ?

3) Et "must have", des chapitres complètements inédits sur la version 2.0 qui est sortie en même temps que l'ouvrage.

Le chapitre "Les modèles de placement CSS" intéressera tous ceux qui ont galéré pour faire la mise en page de leur application GWT. La nouvelle solution est beaucoup plus propre et est donc à essayer d'urgence !

Le chapitre "Le chargement à la demande" décrit la nouvelle fonctionnalité qui permet de partitionner le code javascript généré. Sur le papier, elle semble intéressante mais reste à voir en pratique si elle n'apporte pas davantage de complexité. Mais bon, l'ami Sami vous aura prévenu !

Le chapitre "La gestion des ressources" répond également à une problématique d'optimisation des temps de chargements. On y apprend comment mettre en cache tout types de ressources et même comment faire de l'injection de styles CSS (Il faut dire que l'extension du mécanisme ImageBundle a permis d'introduire des directives dans les fichier CSS)

Le chapitre "L'environnement de tests" présente les styles de test introduits dans la nouvelle version. A se demander comment on faisait avant ?

Le chapitre "La création d'interface avec UIBinder" sera utile à tous ceux qui préfèrent coder leur vues en XML.

Comme je vous le disais dans ma critique du livre d'Olivier Gérardin, les francophones ont dû attendre plus de 3 ans les livres en français sur GWT mais une fois de plus, cela valait le coup d'attendre. Le hasard faisant bien les choses, je suis ravi de l'ordre de parution puisque après le premier livre en français sur GWT (plus didactique), les développeurs pourront continuer avec celui-ci (plus technique), le premier livre mondial sur GWT 2.0.

Lorsque Olivier m'a proposé de lire son bouquin, j'ai sauté sur l'occasion, ne connaissant pas du tout GWT sinon par quelques Hello John Doe !. De zéro ou presque donc, j'ai suivi sa présentation pragmatique, qui introduit les concepts principaux de GWT, et que l'on peut considérer comme un premier guide pour le développeur (francophone) qui souhaite se familiariser avec cette plateforme de développement made in Google.

Le plan est simple et efficace, on enchaîne relativement rapidement et naturellement les chapitres, largement illustrés. Olivier Gérardin a choisi d'aborder le contexte d'apparition de GWT sur le marché, puis détaille l'architecture (arborescence, installation) d'un projet GWT. Le livre aborde ensuite les différentes APIs disponibles (widgets et UI, Events, I18N, JSNI, DON XML, Ext-GWT, SmartGWT), et les différentes méthodes de communication (GWT RPC, HTTP/JSON, WS) offertes. Enfin un dernier chapitre s'attarde sur les nouveautés de GWT 2.0, comme UIBinder, le Code Splitting et SOYC, OOPHM, etc.

J'ai aimé lire ce livre synthétique (200 pages) et très accessible, démystifiant GWT et proposant une bonne introduction au développement GWT. Merci Olivier pour cette agréable lecture !

Pour disposer d'un livre sur GWT dans leur langue, les développeurs francophones auront dû patienter trois ans. Cela peut paraître long mais cette attente s'avère finalement bénéfique. D'une part, Olivier Gérardin, l'auteur, a pu acquérir durant cette période suffisamment d'expérience sur divers projets réels pour maîtriser son sujet. D'autre part, GWT a gagné en maturité et c'est maintenant qu'il faut des ressources pour diffuser cette technologie au delà des early adopters. Le livre "GWT" d'Olivier Gérardin est en bonne voie pour être une de ces ressources.

Dans sa préface, Didier Girard note qu'il n'est jamais aisé de présenter une technologie car soit on va trop loin, soit pas assez. L'exercice est donc difficile et c'est vrai qu'Olivier a trouvé le bon équilibre.

Chapitre 1 : De HTML à GWT En exagérant à peine, Google fait croire que GWT va permettre à quiconque de développer une superbe application web 2.0. Il faut, avouons le, de bonnes bases et trop souvent, je me rend bien compte dans les forums GWT, qu'elles font parfois défaut. Pour m'être essayé à l'exercice, il faut dire qu'il n'est pas facile de présenter toutes les notions indispensables sans craindre de perdre son lecteur. En choisissant l'approche historique, Olivier Gérardin y parvient brillamment.

Chapitre 2 : Hello, GWT Contrairement aux livres anglo-saxons qui souvent paraphrasent la doc d'installation de GWT par scripts de commande, celui-ci s'est mis au goût du jour pour l'installation de GWT en utilisant le plugin de Google. Ce qui lui permet de passer plus de temps sur les différents fichiers d'un projet GWT et les liens qu'ils entretiennent entre eux. J'ai également bien aimé sa manière de créer un nouveau projet en privilégiant le standard "dynamic web project".

Chapitre 3 : Développer avec GWT Les différences entre le mode de développement et le mode de production sont bien expliquées ainsi que les contraintes sur le code Java. A recommander à tous ceux qui demandent pourquoi leur projet GWT ne compile pas !!!

Chapitre 4 : Widgets Une présentation des différents widgets GWT avec des exemples. J'ai bien aimé l'indication des styles css impliqué dans le rendu des composants; le débutant pourra regretter qu'il l'ait réservé aux widgets les plus complexes.

Chapitre 5 : Communiquer avec le serveur Un exemple concret avec toutes les étapes nécessaires. Un bon point également pour les chapitres sur la sérialisation et les exceptions.

Chapitre 6 : Internationalisation L'internationalisation "statique" n'aura plus de secret pour vous. On ressent bien la pratique de l'auteur car il y a pleins de trucs et astuces. Pour ma part, je regrette que les solutions alternatives n'aient pas été développées (même si elles sont considérées comme moins propres par Google lui-même).

Chapitre 7 : Mécanismes avancés du compilateur Il est question ici de JSNI et de Deferred Binding, sujets très intéressants mais un peu court à mon goût. Ceci dit, il faut reconnaître que ces techniques ne concerneront qu'une minorité des cas d'utilisations de GWT.

Chapitre 8 : Le mécanisme d'historique de GWT Une fois ce chapitre lu, cela paraît tellement simple que j'aurai eu envie de l'utiliser un maximum si sa remarque de prudence (oh combien juste) n'était venu freiner mon enthousiasme.

Chapitre 9 : Envoyer des requêtes HTTP Un chapitre bien sympathique pour parler d'XML, de JSON et de la contrainte de sécurité "Same Origin Policy" et de son contournement.

Chapitre 10 : Créer ses propres Widgets Un panorama des différentes possibilités.

Chapitre 11 : Bibliothèques Tierces Ce chapitre a l'intérêt de montrer qu'il existe également tout un écosystème GWT. Parce que pendant une période, elle fût le seul complément crédible et parce qu'elle met en perspective les deux autres librairies concurrentes, EXT-GWT et SmartGWT, il est compréhensible que GWT-EXT ait été abordée. Cependant, selon moi, l'auteur aurait du en rester là et ne pas aborder son utilisation concrète à l'heure où elle est abandonnée et où des alternatives plus pérennes existent. C'est mon plus gros reproche, espérant que les débutants ne l'utiliseront pas. En revanche, j'ai apprécié le paragraphe sur les Google API en général et sur Google Gears en particulier. Maintenant que Chrome OS a été présenté, cette librairie gagne en intérêt.

Chapitre 12 : GWT 2.0 L'auteur n'oublie pas les principales modifications apportées par la dernière version, ce qui en fait à l'heure de cette critique le livre le plus à jour sur GWT ! Il se paye même le luxe d'expliquer comment récupérer la version 2.0 ... ... mais il y a plus simple puisque la Release Candidate est sortie le jour de publication du livre.

En conclusion, si vous voulez découvrir GWT ou si certains des points précédents ont éveillé votre curiosité, je vous recommande ce livre.

Ce livre s'adresse aux développeurs Java qui veulent rapidement développer une application Web riche en utilisant la librairie Ext-GWT.

Le point fort des ouvrages de cette collection, c'est de suivre l'évolution technologique au plus près. Celui-ci ne déroge pas à la règle et utilise les librairies GWT et Ext-GWT dans leurs dernières versions. Pour GWT, c'est la 1.6 et pour Ext-GWT, c'est la 2.0 (encore au stade M2). Si vous envisagez de l'acheter, c'est donc le moment !

Ce livre a une approche didactique classique, il commence par une présentation générale, explique comment installer cette librairie, présente les composants simples et avancés et termine avec un exemple concret.

Le premier chapitre présente à la fois les librairies Ext-GWT et GWT. Comme le sujet de ce livre est Ext-GWT, c'est d'abord elle qui est présentée. On sent bien que cette librairie n'est qu'une sur couche de GWT car l'auteur a beaucoup plus de généralités à dire sur GWT. Si cette présentation de GWT ne remplace pas un livre dédié, elle en demeure néanmoins un bon résumé.

Le deuxième chapitre est un tutoriel très pratique qui vous explique comment configurer un environnement de développement Ext-GWT sous eclipse et comment commencer une première application. L'auteur a semble t'il préféré le côté didactique des batchs de GWT à la simplicité du plugin Eclipse-GWT.

Les troisième et quatrième chapitres présentent les composants de la librairie, des plus simples ou plus avancés. La présentation est progressive et la lecture facile. Quelques captures d'écran et exemples de code viennent compléter les explications.

Le cinquième chapitre présente les composants Ext-GWT qui font le lien entre les widgets graphiques et le serveur. Comme la librairie, l'auteur fait le choix du "full gwt" et ne traite donc que du mode RPC de GWT. Ne cherchez donc pas dans ce livre d'exemple d'échanges de données avec XML ou JSON, vous n'en trouverez pas !

Le sixième et dernier chapitre se veut être un exemple concret qui reprend un peu tout ce qui a été présenté dans les chapitres précédents. Bien que synthétique, il apporte également les quelques informations complémentaires nécessaires à la construction d'une application réelle.

Avant de lire ce livre, j'avais réalisé des applications Ext-GWT en utilisant tous les composants qu'elle propose. L'avantage pour vous, c'est que j'ai pu écrire une meilleure critique vis à vis de ce que dit ou ne dit pas l'auteur ! L'inconvénient pour moi, c'est que du coup, ce livre m'a un peu laissé sur ma faim ... Il faut croire que je ne suis pas la cible !

Ceci dit, ce qui est super dans ce livre, c'est toutes les remarques, trucs et astuces qu'il recèle. J'ai été agréablement surpris de voir qu'il dresse tous les pièges dans lesquels je suis tombé moi-même. Je le recommande donc principalement à ceux qui veulent écrire leur première application avec Ext-GWT.

English version :

This book is intended for Java developers who want to quickly develop a rich web application using GWT-Ext library.

The particularity of this collection is to follow technological developments as closely as possible. This book is not an exception to the rule and uses GWT and GWT-Ext in their latest versions (GWT is 1.6 and GWT-Ext is 2.0). If you plan to buy, so this is the moment !

This book has a didactic style, it begins with an overview, how to install this library, introduces the simple and advanced components and ends with a concrete example.

The first chapter describes both GWT-Ext and GWT. Since the topic of this book is Ext-GWT, author begins with it. We can see that this library is a layer of GWT because the author has much more to say about general GWT. If this presentation of GWT does not replace a book dedicated, it remains a good summary.

The second chapter is a useful tutorial that explains how to configure a development environment GWT-Ext in Eclipse and how to start a first application. The author seems to prefer the didactic GWT batches to the simplicity of the GWT Eclipse-plugin.

The third and fourth chapters gradually introduces the components of the library, from the simplest to the more advanced one. The presentation is progressive and easy reading. Some screenshots and code examples complement the explanations.

The fifth chapter describes the GWT-Ext components which link the graphical widgets to the server components. As the library does, the author decided to follow a "full GWT" way and therefore does only cover the GWT RPC mode. Do not try to find in this book an example of data exchange with XML or JSON, you won't find any !

The sixth and final section provides a concrete example which aims to sumamarize all the things presented in previous chapters. Although synthetic, it also provides some additional information needed to build a real application.

Before reading this book, I had built GWT-Ext applications, using all the Ext components. The benefit to you is that I could write a better review with respect to what is said or not by the author! The downside for me is that suddenly, I'm left wanting more ... Must believe that I am not the target !

What is great in this book is all the comments, tips and tricks it contains. I was pleasantly surprised to see that it gives all the traps in which I fall myself. I therefore recommend mainly to those who want to write their first application with GWT-Ext.

Seam veut dire suture en anglais. Mais depuis 3 ans, ce mot revêt une autre signification pour les développeurs puisqu'il désigne aussi un framework. C'est un framework assez récent, la version 1.0.0 Beta 1 date de septembre 2005, dont le project leader est Gavin King (l'un des créateurs d'Hibernate), qui intègre JSF et les EJB 3, et c'est donc avec beaucoup d'intérêt et de curiosité que j'ai lu ce livre. L'auteur, Dan Allen, sait de quoi il parle puisqu'il est un committer sur le projet. On apprend qu'à l'origine le terme Seam a été choisi pour désigner l'effort d'intégration entre JSF et les EJB 3. Les applications JBoss Seam peuvent tourner sur Websphere, Weblogic, Tomcat. Le livre se veut pratique puisqu'il propose de développer une application de golf (Open 18) pour illustrer les fonctionnalités de Seam. Le livre est divisé en 4 parties.

Dans la 1ère partie (chapitres 1, 2), l'outil seam-gen est détaillé et utilisé dès le départ pour la mise en place de l'environnement de développement, à partir d'une base de données Hypersonic H2.

Dans la 2ème partie (chapitres 3, 4, 5, 6), l'auteur explique ce que Seam apporte à JSF, en corrigeant certaines « lourdeurs », tel qu'un fichier XML trop verbeux (faces-config.xml), en supprimant les tags <managed-bean> du fichier. On peut grâce à Seam se passer de définir les backed beans dans un fichier XML. Le cycle de vie JSF avec Seam est décrit également pour expliquer les avantages de Seam. Le chapitre 4 traite des components, les annotations concernées (@Name, @Scope ...), le cycle de vie des components, etc. Dans le chapitre 5 les tags du fichier de configuration components.xml (une alternative aux annotations) sont largement détaillés. Le chapitre 6 traite des interceptors et de la notion de bijection (= injection + outjection, avec les annotations @In, @Out) en introduisant le nouveau terme outjection qui désigne la possibilité de mettre une propriété de component dans une variable de contexte pour être ensuite utilisée dans un autre component, une vue JSF ... Avec la bijection, les valeurs sont injectées depuis les variables de contexte quand le component est invoqué et réinjectées vers les variables de contexte. Une distinction nette est faite entre injection statique (assignation d'une variable quand le component est instancié) et injection dynamique (chaque fois qu'une méthode d'un component est invoquée).

Dans la 3ème partie (chapitres 7, 8, 9, 10), un chapitre entier (chapitre 7) est dédié à l'état Conversation, un des 2 états/contextes introduits par Seam (l'autre état étant business process, qui est plus long que la session), en plus des 4 états classiques que sont Request, Page, Session, Application. Cet état permet de lier des requêtes individuelles. Les 6 états classés par portée croissante sont donc : Request (event), Page, Conversation, Session, Business Process, Application. La notion de conversation, les page flows et les annotations concernées (@Begin, @Conversational, @End etc) sont systématiquement et largement expliquées avec des extraits de code s'articulant autour de l'application Open 18. Le chapitre 8 est un rappel nécessaire sur JPA et Hibernate. J'ai particulièrement apprécié le rappel sur l'extended persistence context et les différences entre ces 2 APIs car c'est bien expliqué. Le chapitre suivant aborde la gestion de la persistence et les transactions avec Seam, notamment dans la conversation, et est largement illustré par des extraits de code. Le chapitre 10 présente le Seam Application Framework au travers d'un exercice.

Dans la 4ème partie (chapitres 11, 12, 13), on apprend que Seam s'appuie sur JAAS pour l'authentication (chapitre 11). Un exemple avec une page de login JSF est utilisé. Une distinction est faite entre les authorisations basées sur des rôles et les authorisations basées sur des règles. Le moteur de règles Drools (qui tire son nom du terme "Dynamic rules") est présenté et utilisé pour créer des règles. Un exemple rapide d'utilisation du component org.jboss.seam.captcha pour l'affichage d'un CAPTCHA dans une page web est expliqué. Le chapitre 12 met l'accent sur AJAX et les solutions existantes qui tournent autour (Ajax4jsf, ICEfaces, GWT ...) Enfin, le chapitre 13 présente divers components Seam tel que <s:fileUpload> pour uploader des fichiers à partir d'un form JSF, <s:graphicImage> pour le rendu dynamique d'images , des UI components pour la génération de PDF à travers des templates de Facelets, mais aussi le module Seam de génération de graphique basé sur JFreeChart, l'envoi de mail avec un component mail Seam etc

Ce que j'ai aimé dans ce livre : Le ton de l'auteur. On a l'impression d'assister à une présentation en live de Seam, l'auteur passe beaucoup de temps à introduire les choses, à peser le pour et le contre des solutions existantes et ensuite à expliquer comment Seam peut être une solution possible. Le thème du golf, omniprésent et instructif ;-)

Ce que j'ai moins aimé dans ce livre : La prise en compte d'une version antérieure de JBoss AS : 4.2 au lieu de 5 (Java EE 5)

Le code source du livre est bien entendu disponible sur le site du livre, ainsi que deux chapitres "bonus" format PDF concernant l'intégration avec Spring d'une part et la gestion du business process (jBPM) d'autre part : http://www.manning.com/dallen/

Le site de l'auteur : http://www.mojavelinux.com/ Un errata est disponible à l'adresse http://www.manning.com/dallen/excerpt_errata.html

Enfin, le code source du livre est aussi disponible sur : http://code.google.com/p/seaminaction/

English version :

A seam is a joining of 2 things, like 2 fabrics for example. But for 3 years now, it has had another meaning for developers since it also refers to a framework. It is a rather new framework, the 1.0.0 Beta version was released in September 2005, the project leader was Gavin King (one of the creators of Hibernate), it uses JSF and EJB 3, and so it is with some big interest and curiosity that i read this book. The author, Dan Allen, knows what he is talking about since he is a committer on the project. We learn that the term Seam was chosen to refer to the work put on to facilitate the collaboration between JSF and EJB 3. JBoss Seam applications may run on Websphere, Weblogic, Tomcat. The book has a practical approach since it is based on an application centered on the game of golf (Open 18), to illustrate the features of Seam. The book is divided into 4 parts.

In the 1st part (chapters 1, 2), the seam-gen tool is explained and used from the beginning to set up the development environment, using a Hypersonic H2 database.

In the 2nd part (chapters 3, 4, 5, 6), the author explains what Seam brings to JSF, correcting some defects, such as a verbose XML file (faces-config.xml), by removing the <managed-bean> tags from the file. With Seam it is possible to define the backed beans in an XML file. The life cycle of JSF with Seam is also detailed to explain the advantages of Seam. Chapter 4 introduces the components, its related annotations (@Name, @Scope ...), the life cycle of components, etc. In chapter 5, the tags of the configuration file components.xml (the alternative to annotations) are explained in details. Chapter 6 is about interceptors and the concept of bijection (= injection + outjection, with annotations @In, @Out) by introducing the new term outjection which refers to the possibility of injecting the property of a component into a context variable, which can be re-used inside another component, a JSF view ... With bijection, the values are injected from context variables when the component is called and injected again into the context variables. A clear distinction is made between static injection (the value is injected when the component instance is created) and dynamic injection (the value is injected when a method on the component is executed).

In the 3rd part (chapters 7, 8, 9, 10), an entire chapter (chapter 7) is dedicated to the Conversation scope, one of the 2 scopes/contexts introduced by Seam (the other scope being business process, which is longer than the session), as an addition to the 4 classic scopes which are Request, Page, Session, Application. This scope ties together individual requests. So the 6 scopes ordered by ascending scope are : Request (event), Page, Conversation, Session, Business Process, Application. The term of conversation, page flows and related annotations (@Begin, @Conversational, @End, etc) are systematically and largely explained with code snippets around the Open 18 application. Chapter 8 is a necessary reminder of JPA and Hibernate. I have particularly liked the quick presentation on extended persistence context and the differences between these 2 APIs because it is well explained. The next chapter is about the persistence and the transactions with Seam, in particular within the conversation, and is largely illustrated with code snippets. Chapter 10 explains the Seam Application Framework with an exercise.

In the 4th part (chapters 11, 12, 13), we learn that Seam relies on JAAS for authentication (chapter 11). A sample with a JSF login page form is used. A clear distinction is made between role-based authorizations and rule-based authorisations. The rules engine Drools (the name Drools is derived from the term "dynamic rules") is explained and used to create the rules. A quick sample of use of the org.jboss.seam.captcha component to display CAPTCHA inside a web page is explained. AJAX and existing solutions (Ajax4jsf, ICEfaces, GWT ...) are empasized in chapter 12. Finally, chapter 13 introduces a few Seam components such as <s:fileUpload> to upload files from a JSF form, <s:graphicImage> for the dynamic rendering of images, UI components to generate PDF files using facelets templates, but also the Seam module for graphic generation based on JFreeChart, composing email with a Seam component mail etc

What I liked about this book : The author's tone. It makes you feel like you are attending a live presentation on Seam, the author spends a lot of time introducing things, weighs the pros and the cons of existing solutions and then explains how Seam can be a possible solution. I also liked the golf theme, omnipresent, and instructive ;-)

What I liked the least in this book : The referring to an older version of JBoss AS : 4.2 instead of 5 (Java EE 5)

The source code of the book is of course available on the book's website, along with 2 extra chapters in PDF format regarding the integration with Spring and the use of business process (jBPM) : http://www.manning.com/dallen/

The author's website : http://www.mojavelinux.com/ An errata is also available at http://www.manning.com/dallen/excerpt_errata.html

Finally, the code source of the book is also available at : http://code.google.com/p/seaminaction/

Le livre en lui-même est bien présenté et agréable à lire. Les chapitres sont courts et bien découpés, ce qui facilite son usage comme référence pour plus tard.

Il a été écrit par deux des principaux Core Developers de Wicket depuis qu'il est OpenSource. On peut donc leur faire confiance quand ils donnent des conseils ;-) . Les parties de code sont assez claires même si j'ai eu un peu de mal à comprendre où rattacher quoi à certains moments.

Les auteurs détaillent le framework progressivement même si l'application est déjà bien lancée au chapitre 3. Chaque partie est expliquée en détail mais pas trop. Je ne me lancerai quand-même pas dans la publication d'un composant sans y regarder à deux fois mais les principes et les bases sont évoqués.

Le chapitre sur Spring est bien présenté, on voit différentes façons de l'intégrer, y compris par les annotations. La partie sur « Aller en production » est vraiment intéressante car on y apprend que Wicket peut exposer des Mbeans pour se reconfigurer à chaud. Il est aussi expliqué comment tester ses composants et ses pages.

J'aurais aimé un chapitre sur les projets annexes que l'on retrouve côté Wicket Stuff.

Par exemple, dans le chapitre sur la sécurité, Acegi n'est pas évoqué. Certes c'est un livre sur Wicket, mais quelques paragraphes pour montrer les extensions annexes auraient été les bienvenus.

De plus, le livre ne revient pas sur les changements qui ont eu lieu au fil des versions. Pourquoi ne pas parler de Wicket 2 qui est mort-né ? Et Wicket 1.4, quelles seront les nouveautés ? Allez, je demandais juste un bout d'introduction. Cette version est à peine évoquée au fil des pages.

Le livre a répondu à beaucoup des questions que je me posais. Son spectre n'est pas très large (pas de Wicket Stuff) mais largement suffisant pour démarrer rapidement. Je le recommande à ceux qui veulent tester Wicket et se lancer dans leur premier projet.
Mais d'ailleurs, vous devriez déjà être sur Amazon pour commander votre exemplaire.

Retrouvez la critique originale (et complète) ici

« Wicket In Action » ou comment mélanger la théorie et la pratique de façon agréable. Si vous souhaitez aborder le développement Web sous un nouvel angle, Wicket est la solution. Ce framework permet une réelle séparation de la partie HTML et de la partie JAVA. Cependant, l'approche étant fondamentalement différente, sur quel livre se baser pour réaliser l'apprentissage de ce framework ?

« Wicket in Action » livre publié chez Manning, sorti récemment, présente le framework avec beaucoup de pertinence, en ne sautant aucune étape, et en laissant encore un peu de travail au lecteur pour l'acquisition de certains composants.

Après une brève présentation du pourquoi, du comment, le livre s'attache à nous faire comprendre le fonctionnement intrinsèque du framework via une petite application Web (« Boutique de vente de Fromage ») mettant en ?uvre les concepts fondamentaux. Cette approche très pragmatique du sujet permet au lecteur de comprendre en douceur le raisonnement qu'il devra acquérir pour réaliser lui-même des services. La présentation pas à pas des différents composant de l'application, de la méthode de mise en ?uvre, et de la manière de séparer visualisation pour un graphiste et intégration pour un développeur, donne indéniablement envie d'en savoir plus.

Les chapitres suivant permettront d'approfondir les sujets, parfois abordés rapidement au cours de l'exemple (comme la notion de modèles), via une judicieuse montée en puissance, pour finir par l'intégration de composants Ajax dans les pages. Tous les composants de Wicket ne sont pas détaillés laissant au lecteur le plaisir de chercher pour voir plus loin.

Ce livre est écrit en autre par Martjin Dashorst, un collègue de Jonathan Locke (créateur de Wicket), qui connait très bien le sujet pour avoir travaillé sur les toutes premières versions du framework, et qui participé aux orientations sur les concepts et développements.

Il s'agit d'un très bon livre d'introduction à GWT.
Il est bien écrit et didactique.
Je dois avouer que la structure des chapitres m'a d'abord déconcerté, chacun de ces chapitres est scindé en quatre parties:

• Présentation
• "Time for action"
• "What's just happened"
• "There's more / summary"
  

Le fait de commencer par réaliser le code puis ensuite de donner l'explication du code réalisé, peut surprendre mais finalement cela permet de ne pas réserver ce livre à un public restreint. Pour le débutant, le fait que le code soit clairement séparé des explications permet de se concentrer sur les faits importants et de ne pas se disperser entre le code et les explications.
Pour un lecteur expérimenté, cela permet de retrouver rapidement l'information recherchée ou de passer rapidement sur les notions qu'il maitrise.
La section "There's more /summary" est très intéressante, elle permet de voir les petits plus existants, et de recentrer les notions déjà vu.

La qualité du code donné, ainsi que les méthodes de réalisation fournies sont de très bon niveau.

Pourquoi ne pas mettre 5 étoiles ?
C'est un très bon livre d'introduction et d'aide mémoire, mais il n'est pas totalement complet.
Il manque pour moi trois notions pour qu'il soit complet.
D'abord un peu d'information sur les conventions de nommage, nottament pour les styles CSS.
Ensuite, l'utilisation du protocole JSON n'est pas abordé, ce protocole peut-être utile pour permettre de mélanger un application GWT avec un autre langage PHP par exemple.
Enfin, un exemple d'utilisation du framework GWT, avec un autre framework de type Struts, pour l'intégration avec des applications existantes.

Ce livre est une merveille, il est à la fois précis et concis, détaillant chaque élément du framework sans se perdre dans de longues explications, tous les textes sont très courts et entrecoupés de code fonctionnel et réutilisable. Les codes et les erratas pourront être téléchargés sur le site du livre.

JSF est un framework qui a la réputation d'être complexe à appréhender au premier contact pour le novice. Vous pourrez grâce à ce livre prendre la main sereinement et developper rapidement des applications en profitant de la puissance et de la souplesse des JSF. Il est important de noter que l'on peut aborder ce livre sans avoir de connaissance particulière sur les JSP/Servlet, seule une connaissance de la programmation Java est nécessaire.

Tous les exemples de code sont complets, ce qui permet d'être opérationnel très rapidement. Et surtout ce livre sera une formidable référence à conserver sous le bras tout au long du développement. Je conseille la lecture de ce livre à toute personne aillant l'intention de développer des applications utilisant les JSF.

Kent Tong a une façon très didactique de présenter le framework Tapestry. Il explique les grands principes, montre leurs applications de façon générale puis donne des exemples précis et pertinents.

Dans son livre, il présente d'abord le fonctionnement intrinsèque de ce framework, puis montre des explications pertinentes d'intégration avec des framework tiers, tels Hibernate ou HtmlUnit. Cela permet donc vraiment d'aborder la conception de site web de façon globale. La pertinence est telle que j'ai réutilisé ces exemples d'intégration dans d'autres contextes. En effet, Kent Tong explique tant les détails de réalisation que la portée de ceux-ci avec clarté et précision.

A noter également que Kent Tong a régulièrement fait parvenir des corrections ou mises à jour de son pdf. Par exemple, la version que j'avais acquise l'année passée couvrait uniquement Tapestry 4.0. Puis Tapestry 4.1 est apparu, et peu de temps après Kent Tong a communiqué une version à jour de son livre couvrant Tapestry 4.1 (qui introduit des changements notables).

Au final, personnellement, c'est le meilleur livre d'introduction à un framework que j'ai vu jusqu'à présent.

NB : Je tiens toutefois à préciser que je n'ai pas retenu ce framework.

Kent Tong has a very didactic way of explaining the Tapestry framework. He explains the fundamental aspects behind the framework from a general point of view, and then provides very consistent and precise examples.

In his book, Kent Tong shows first the Tapestry framework and its way of doing things. Then he explains how to integrate the framework with others, like Hibernate or HtmlUnit. Thus, with this book, one can approach web design in all its aspects, which is fairly important. The interest of Kent Tong examples are such that I've used them in different contexts than Tapestry. Indeed, he explains both the details of the implementation as well as the impacts, all being done with clarity and precision.

Important to notice as well, Kent Tong has regularly provided updates or corrections of his book. For example, when I bought the book, only Tapestry 4.0 was covered. Then Tapestry 4.1 appeared. Short after, Kent Tong provided an updated version of his book covering Tapestry 4.1 (which introduces some fairly important changes).

Finally, personally, it's the best framework introduction book I've read until now.

NB : Just a last notice : eventually, I didn't retain Tapestry.