Les livres françaisConsultez tous les livres

Cet ouvrage s'adresse à un public débutant souhaitant une introduction à toutes les notions utiles de SysML dans le cadre d'une problématique « ingénierie système ». Tout est présenté avec une vue haut niveau et bien que des outils soient présentés, rien de spécifique à la génération de code n'y sera abordé.

La présentation des concepts s'articule autour d'un fil conducteur : la conception d'un radio-réveil à projection. Travail qui a l'avantage de rester intuitif et loin de toutes tentations de surspécialisation dans un domaine d'application particulier. Ce microprojet sera enrichi au fur et à mesure pour illustrer les notions précédemment expliquées dans chaque chapitre.
Une fois terminée la modélisation en diagrammes d'états, deux animations du modèle afin de pouvoir présenter rapidement et visuellement la conception fonctionnelle sont effectuées. Toutefois aucun détail n'est fourni, cela dépassant le strict cadre de SysML pour entrer dans le fonctionnement spécifique des outils utilisés (respectivement Artisan Studio et Rhapsody).

Pour conclure, cet ouvrage est résolument pragmatique et se veut accessible pour un large public. Mais il sera rapidement insuffisant pour réaliser un projet dans un cadre professionnel.

De toute évidence, « Ergonomie des interfaces » constitue une référence dans son domaine. Il sera utile lors de toutes les phases d'un projet.

Tout d'abord, l'écriture est simple et claire, l'argumentation est précise et de nombreux exemples et références étayent les points abordés. Tout cela contribue à rendre la lecture agréable.

Le livre couvre tous les types d'interfaces : qu'il s'agisse d'applications Web ou de bureau, mais surtout, cette nouvelle édition prend en considération les applications tactiles (smartphones ou tablettes) rendant ainsi l'ouvrage particulièrement complet.

Découpé de façon intelligente (voir la table des matières), le livre mérite bien son sous-titre : « Guide pratique ». En effet, loin de se vouloir uniquement théorique, vous pourrez aller y chercher facilement toutes les informations utiles à chaque étape du développement. Dans le même esprit, les points abordés (parfois nombreux sur un même thème) sont parfaitement mis en valeur et donc aisément visualisables. Enfin, différentes « check-lists » vous seront très utiles dans vos projets.

Bien entendu, une bonne partie (si ce n'est la plupart) des conseils donnés pourront vous sembler évidents. Effectivement, même si certains points abordés reposent sur des études menées auprès d'utilisateurs, l'essentiel relève d'une certaine forme de bon sens. Néanmoins, lorsque l'on est plongé dans son projet (« la tête dans le guidon »), le fonctionnement de l'application nous semble tellement familière qu'il devient difficile de s'en détacher pour se mettre à la place d'un utilisateur découvrant le système. Dans ce cas, il est important de pouvoir s'appuyer sur ce livre pour prendre un peu de recul et voir les erreurs que l'on peut commettre.

Enfin, notez bien qu'il s'agit d'un livre sur l'ergonomie. C'est-à-dire l'utilisabilité d'une application : faire en sorte que n'importe quel utilisateur parvienne facilement à son but sans se perdre dans l'interface. En aucun cas, ne sont abordées les notions de design ou de graphisme. Vous apprendrez comment rendre votre application facile à utiliser, pas comment la rendre visuellement aboutie, ce qui est un tout autre sujet.

Pour conclure, ce livre est selon moi incontournable et à conseiller à tous les intervenants d'un projet. Il sera utile lors de toutes les phases du développement.

Commentez

Ce livre est la version française du grand classique de Steve Krug sur l'utilisabilité des sites web : « Don'k make me think ». L'éditeur a choisi d'ajouter un « .fr » sur la couverture pour le signaler. Par la même occasion, le sous-titre devient « Optimisez la navigation sur vos sites » et c'est regrettable. Car le sous titre original « A Common Sense Approach to Web Usability » est davantage révélateur de l'esprit de l'ouvrage. Partant du principe que les experts en utilisabilité ne sont pas les seuls à pouvoir réfléchir à l'ergonomie du web, Steve Krug a écrit un livre pour les non-spécialistes.

Le livre est court, simple et explique avec humour comment faire des sites web utilisables. Les 12 chapitres qui peuvent être lus indépendamment les uns des autres traitent d'un aspect particulier de l'utilisabilité du Web et des façons de l'aborder. Ayant déjà lu d'autres ouvrages sur le sujet, je n'ai pas vraiment appris de nouvelles choses si ce n'est comment réaliser des tests utilisateur à moindres frais. J'ai trouvé les exemples avant/après un peu vieillot graphiquement parlant mais sur le fond, ils illustrent des problèmes qui demeurent présents sur le web actuel.

Je recommande la lecture de ce livre à tous, aux novices et aux experts. Les premiers y trouveront une agréable introduction pour découvrir l'ergonomie du web. Les seconds apprécieront un auteur qui traduit en termes simples et en images concrètes ce qu'ils ont parfois du mal à expliquer.

1 commentaire

À ma connaissance, il n'existe pas de cursus scolaire pour devenir "Architecte logiciel", c'est un métier qui s'apprend par la pratique. Ce que j'ai aimé dans "Architecture logicielle", c'est davantage le livre dans son ensemble que ses chapitres pris individuellement. Il existe des ouvrages spécifiques plus approfondis sur chacun des sujets abordés. Ici, ce qui est intéressant, c'est l'approche de l'auteur qui vise à se concentrer sur le métier d'architecte et à tisser les liens entre les différentes disciplines conduisant à la réalisation d'un projet logiciel. Il navigue de manière transversale du fonctionnel au technique. Le livre intéressera particulièrement le développeur qui cherche à monter en abstraction et à se détacher de la technique.

Je regrette que certaines parties n'aient pas été plus développées mais c'était probablement le prix à payer. Développer une partie plutôt qu'une autre aurait créé un déséquilibre et toutes les développer aurait conduit à un ouvrage trop volumineux. Il suffit de jeter un coup d'oeil au sommaire pour constater le nombre de sujets abordés. C'est donc un livre généraliste pour donner une vue d'ensemble et après tout, c'est bien ce qu'on demande à un architecte !

Dans les formations de développeurs, la gestion de projet est généralement abordée de façon plutôt succincte et théorique. En se concentrant sur le cas pratique d'un projet web, Vincent Hiard partage son expérience de chef de projet fonctionnel web. Dans son livre, il passe en revue toutes les étapes : définition, lancement, conception, réalisation, exploitation et il décrit les types de livrables qui devraient être fournis à chacune d'elles. Il propose également un ensemble de bonnes pratiques.

J'ai aussi apprécié le choix de l'auteur de présenter la gestion de projet sous l'angle des projets web, cela met en avant leurs spécificités. En revanche, je regrette qu'il s'agisse principalement de l'approche classique ; j'aurais souhaité une comparaison avec une approche plus agile.

Si la gestion des projets web dans votre entreprise laisse à désirer ou si vous venez d'être nommé chef de projet web, la lecture de cet ouvrage vous sera profitable.

Peu prescriptives, les méthodes agiles semblent offrir moins de garanties que celles désormais "traditionnelles" et ont la fâcheuse réputation d'être incompatibles avec les processus déjà en place dans les organisations.
Mais bien que relativement à la traîne, le marché est de plus en plus demandeur d'agilité et de méthodes légères, bien au-delà des petites boîtes où le passage à l'agilité ne remet pas grand-chose en question.

Le livre : Choisir l'agilité de Mathieu Boisvert et de Sylvie Trudel constitue un concentré de l'expérience de ses deux auteurs en conseil d'adoption des méthodes agiles. Tout le monde devrait y trouver son compte, que ce soit du côté du développement proprement dit (développeurs, chefs de projets, etc.), ou du côté métier.

Très concret et pratique, le livre fait tout d'abord un point précis sur toute la terminologie qui entoure cette mouvance du brouillard de la mode mal cernée.
Puis, à force de mise en situation et d'exercices de pensées, le lecteur redécouvre les différents stades classiques de développement du point de vue de l'agilité.

Bien qu'il décrive les grandes lignes de certaines méthodes populaires, le livre ne prend le parti d'aucune d'entre elles. Ses auteurs incitent même les lecteurs-décideurs à se faire leurs propres "cocktails" des meilleures pratiques agiles pour leurs situations.

La lecture reste fluide et passionnante malgré tous les détails organisationnels qui n'intéressent pas forcément le développeur. Un livre à conseiller vivement.

Ce livre, co-écrit par Mathieu Boisvert et Sylvie Trudel, veut vous présenter ce qu'est l'agilité et les impacts humains et "organisationnels". Basés sur leurs expériences, les auteurs mettent en scène des situations vécues et des détracteurs illustrant les difficultés et interrogations éprouvées par les personnes (développeurs, architectes, clients, formateurs, administrateurs système,...) apportées par l'adoption des méthodes agiles. Ces anecdotes, où l'on peut souvent reconnaître facilement un collègue ou soi-même, permettent de rendre vivantes les explications et de pointer les difficultés généralement rencontrées.

Les chapitres sont regroupés par thème et peuvent être lus plus ou moins indépendamment. L'avant-propos de 14 pages vous permettra de cibler les chapitres qui vous intéresseront le plus. Les explications sont claires et assez bien agencées. Le style de ce livre vous permet une lecture ciblée pour vous focaliser sur les points qui vous sont importants. Vous pouvez lire en diagonale les parties qui vous semblent secondaires.

Si lorsque vous entendez "méthode agile" vous demandez qui est Gilles ou quand vos collègues parlent d'agilité vous faites une démonstration de jonglage, ce livre est clairement fait pour vous. Pour les autres cas, je pense que ce livre vous sera tout aussi utile et vous permettra :

• de mieux comprendre l'impacts humain et organisationnel ;
• de trouver des argument positifs et négatifs ;
• de mieux appréhender le changement qu'apporte l'adoption des méthodes agiles.

Derniers points positifs, le livre donne énormément de références qui vous permettront d'approfondir une partie particulière de ces méthodes. Une partie terminologie de l'avant-propos vous redéfinit les termes importants pour éclaircir et bien comprendre leurs significations.

Commentez

J'aime bien lire différents ouvrages sur les sujets qui m'intéressent. Aussi, lorsque j'ai commandé le livre "Ergonomie des interfaces", je n'étais pas conscient qu'il s'agissait de la nouvelle version d'un livre que j'avais précédemment lu : "Ergonomie du logiciel et design web".

Avec un nouveau titre, une nouvelle couverture et deux auteurs supplémentaires, l'erreur est compréhensible n'est-ce pas ? Quoi qu'il en soit, je l'ai relu avec plaisir. Il conserve tout ce que j'avais apprécié la première fois (je vous renvoie à ma précédente critique). Voyons plutôt les apports de cette édition.

Le contenu a été restructuré. La précédente édition était orientée dispositif avec une dichotomie logiciel/web. Celle-ci s'appuie sur le processus de conception. Je trouve cette nouvelle organisation plus fluide et elle permet de bien intégrer les nouveaux dispositifs que sont les smartphones et tablettes.

L'iconographie s'est enrichie : plus de couleurs, plus de figures. J'ai particulièrement apprécié celle qui nous montre la perception des couleurs selon le type de daltonisme.

Cette nouvelle édition ajoute également à chaque fin de chapitre un cas pratique. Un exemple concret avant/après est une bonne idée. En revanche, je suis moins fan de sa mise en oeuvre, je trouve que les éloges des clients, ça fait un peu too much.

En conclusion, un livre qui évolue avec son temps et que je recommande toujours autant.

1 commentaire

Un point très important d'une application est son ergonomie. Malheureusement, cet aspect est souvent mis de côté, voire totalement ignoré. De manière claire et précise, ce livre vous explique les aspects importants d'une IHM et pourquoi son ergonomie est un point important pour sa réussite. Vous y apprendrez entre autres à:

• repérer les zones d'interaction utilisateur les plus importantes;
• organiser les informations affichées sur vos écrans;
• améliorer l'interaction avec l'utilisateur;
• rendre cohérente la navigation dans votre application;
• concevoir plus facilement vos interfaces;
• comprendre les différences entre une application web, desktop, tablette et mobile.

Développant des applications graphiques sur desktop depuis plusieurs années et sur mobile depuis peu, je n'ai jamais eu de vrai cours ou d'explications sur l'ergonomie. Ce livre m'a permis de comprendre ce qui manque dans mes applications et d'appréhender comment rendre l'ensemble plus logique et agréable pour l'utilisateur. J'ai pu comprendre et corriger la majorité de mes erreurs de conception d'IHM. Après l'avoir lu, je pense que ce livre m'accompagnera régulièrement lors de mes futurs conceptions et développements d'applications.

Que vous soyez webmaster, développeur, chef de projet ou autres, vous trouverez dans ce livre toutes les bases pour bien démarrer et améliorer vos applications graphiques.

Cet ouvrage aborde un sujet trop souvent négligé dans l'univers du développement "non critique" : la validation, ici aperçue essentiellement via les tests fonctionnels (c'est d'ailleurs dans le titre).

La première partie resitue la phase de validation au sein du flot de conception et justifie son caractère indispensable, bien que trop souvent négligé. La seconde partie présente une démarche ayant pour but de mettre en place une méthodologie de tests fonctionnels au sein d'un projet industriel. La troisième et dernière partie expose trois études de cas et justifie le retour sur investissement (ROI) d'une phase de validation bien gérée.

La lecture est aisée, les concepts semblent décrits et illustrés via des schémas correctement. Les auteurs proposent même des exemples "pratiques" et des copies d'écran de l'utilisation de trois outils différents adaptés à cette tâche.
Toutefois, je regrette que cet ouvrage reste trop "haut-niveau" dans la pure description utile pour appréhender des concepts, mais totalement déconnectée d'une mise en place dans un contexte industriel contraint par un existant souvent conséquent. Par ailleurs, les illustrations "pratiques" ne sont souvent qu'une représentation via des outils relativement onéreux masquant, selon moi, beaucoup trop la réalité pour être utile aux personnes réellement en charge de cette mission. Au final, comme indiqué sur le site de l'éditeur, il est adapté pour les DSI et les responsables méthode, mais aurait gagné à l'être également aux personnes de terrain.

Commentez

Parmi les différents ouvrages sur l'expérience utilisateur, celui de Jesse James Garrett est plutôt atypique.

Il a pour principal avantage de donner une vue globale à travers cinq plans : Stratégie, Envergure, Structure, Ossature et Surface.

Il a aussi pour intérêt de clarifier des termes qui peuvent paraître très proches : Design d'interaction, Design d'interface, Design de navigation et Design sensoriel.

Mais ce que j'ai préféré, c'est au travers des cinq plans, la mise en parallèle des applications web et des sites d'informations ; les premières faisant référence au vocabulaire des logiciels et les seconds à celui des médias d'informations.

Attention toutefois, ce livre n'apporte pas de réponses, ce n'est ni un mode d'emploi, ni un ouvrage de développement. Il est fait pour se poser les bonnes questions et je le conseille comme une introduction au domaine avant d'aborder des ouvrages plus spécialisés.

Commentez

Comme son titre l'indique, ce livre traite des principes universels de design. Le public visé est évidemment large et les concepteurs d'interface graphique en font donc partie. Si vous êtes l'un d'eux, vous vous devez de connaître ces principes si vous voulez concevoir des IHM ergonomiques et agréables.

Si vous ne les connaissez pas, lisez ce livre ! Si vous les connaissez, vous apprécierez d'avoir cet ouvrage sous la main pour vous les rappeler. Ce livre est un ouvrage de référence car c'est à ma connaissance le seul ouvrage en français qui regroupe ces 125 principes de design.

Chacun d'eux est présenté sur une double page; c'est simple et suffisant puique les textes de références (souvent anglophones) sont toujours indiqués. J'ai également apprécié les liens vers les principes connexes ainsi que le sommaire thématique. Les exemples qui servent d'illustrations sont, à quelques exceptions, plutôt bien choisis.

Ajoutons que la forme ne gache rien puique les auteurs ont appliqué grand nombre de ces principes à leur ouvrage. Ce qui me pousse à le classer dans la catégorie "beaux livres" et à le recommander à tous les esprits curieux.

4 commentaires

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).

Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.

C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.

À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).

Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.

Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.

Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.

En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.

Vous avez lu ce livre ? Qu'en pensez-vous ? Commentez

Cet ouvrage permet d'appréhender des projets de systèmes d'information dans leur globalité. Tout y est, l'organisation des équipes et le pilotage, les calculs de retour sur investissement, les méthodes d'évaluation, la gestion des risques...

Ce livre est très appréciable pour sa rédaction claire et structurée, globalement agréable pour un livre technique et généreux en outils pratiques. Les exemples cités sont judicieux et donnent au contenu les caractéristiques d'un véritable outil pédagogique applicable dans les services souhaitant améliorer la qualité de leur « gestion de projet » pas seulement informatique. Il peut tout aussi bien s'adresser à des personnes travaillant dans la gestion.

Point fort : l'indépendance des chapitres permettant aux lecteurs de se diriger rapidement vers la ou les parties les intéressants. Ouvrage s'adressant à un public large, illustré par de nombreux schémas explicatifs.

Point faible : Quels sont les outils les plus pertinents parmi la pléthore citée ? Je n'ai pas trouvé d'avis tranché dans l'ouvrage.

Cet ouvrage est une très bonne approche sur ce qu'est la maîtrise d'ouvrage. Ce livre s'adresse à des personnes n'ayant pas beaucoup de connaissances en informatique, car il est orienté très opérationnel. Les exemples sont nombreux, mais on en redemande...

Les fiches récapitulatives sont plaisantes et synthétiques, malheureusement ce livre ne vous permettra pas de sauter le pas pour vous lancer dans un projet de bout en bout. Cet ouvrage permet de toucher du doigt le monde de la MOA/MOE tout en restant superficiel. Il reste cependant très bon pour s'informer et acquérir quelques connaissances générales supplémentaires sur la gestion des projets informatiques.

Je viens de terminer ce livre dans sa 4° édition et globalement, j'ai bien aimé.

La mise en forme des livres de cette collection est agréable et celui-ci ne déroge pas à la règle. De plus, il est, sujet oblige, abondamment illustré; des images viennent expliciter les bons et les mauvais usages.

On notera également en bonus :

• une check-list d'évaluation ergonomique
• une check-list de conception d'un site web
• une bibliographie de 9 pages
• une webographie de 6 pages

Pour ma part, je l'ai trouvé facile à lire, ce qui fait que je n'arrive pas vraiment à lui trouver de points négatifs. Bien au contraire, je trouve que l'auteur a appliqué à son livre certains principes dont il parle. Certes, on me fera remarquer que l'ergonomie d'un livre est différente de celui d'un logiciel. Mais de même qu'il existe des différences spécifiques entre logiciel desktop et site web, il y quand même de grands principes généraux.

Son livre répond aux trois critères de l'utilisabilité :

• Efficacité : Il permet au lecteur d'atteindre le résultat prévu (acquérir des connaissances sur le sujet)
• Efficience : Atteindre ce résultat avec un effort moindre
• Satisfaction : Confort et évaluation subjective du lecteur, auteur de cette critique

Pour conclure, disons que celui qui connait déjà le sujet n'apprendra pas grand chose de nouveau mais qu'il est à recommander au néophyte. Et quand on voit le nombre de logiciels peu utilisables, on se dit que le nombre de lecteurs potentiels est énorme !

Jean-Luc Baptiste, nous livre ici un livre sur la méthode « Merise » orientée modèle de données. Ce livre est destiné à un public ayant déjà une petite notion de la méthode. En effet l'auteur, tout au long des quatorze chapitres, navigue dans les rappels de la méthode.

Dans le premier chapitre, nous retrouvons les étapes d'une analyse de projet avec la méthode « Merise », en passant par l'interview, la lecture des documents internes/externes, les informations calculées, les traitements, les différents niveaux conceptuels, organisationnels, logiques et physiques.

Le deuxième chapitre nous apprends les dépendances fonctionnelles, les contraintes d'intégrité et, élément essentiel, le dictionnaire des données.

Les trois chapitres suivants se concentrent sur la génération des MCD,MLD et MPD, le tout agrémenté de nombreux exemples et graphiques afin de faciliter la compréhension de la matière.

Le sixième chapitre est vraiment très bien structuré et explique de façon claire et précise les cinq premières formes normales. Celles-ci sont suivies d'un exemple nous aidant à assimiler cette partie de façon pédagogique.

Les chapitres suivants font une rapide introduction sur les modèles conceptuels et organisationnels des traitements.

Au chapitre dix, nous avons droit à une introduction sur Merise 2 et l'apport de l'héritage dans le système d'analyse.

Un excellent chapitre sur l'analogie des méthodes Merise et UML est également présent.

Nous terminerons le livre sur une introduction au langage SQL. Ici nous regrettons le choix des outils proposés pour s'exercer, MySQL au travers de Wamp Server, ainsi que PhpMyAdmin pour l'outil de manipulation de données.

En conclusion, nous avons ici un livre qui fait une rapide découverte de l'analyse via la méthode « Merise », qui permet de se remémorer les bases de cette méthode, avec un gros plus sur les formes normales et l'analogie UML/Merise

Ecrit par un consultant renommé et expert en méthodes agiles, Claude Aubry, cet ouvrage constitue un guide dans la découverte et l'approfondissement de la méthode SCRUM.

Dès les premiers chapitres, on ressent la pédagogie de l'auteur (également professeur à l'université) où il explique clairement les points clés de la méthode et parle en détail du backlog de produit.

Il décrit les différents rôles de cette dernière en insistant notamment sur le Product Owner et sur ScrumMaster en couvrant l'étendue des responsabilités de chacun. Il propose également des conseils issus de ses expériences pour éviter certains pièges et proposer des axes d'amélioration de ces rôles.

On lira avec intérêt les chapitres sur la planification de release et la planification des sprints qui sont très clair et très pragmatique et constituent un élément important pour tout "chef de projet en transition".

Il met ensuite en avant les rituels SCRUM (daily scrum meeting, revue de sprint, rétrospective de sprint, ...) en détaillant leurs fonctions et leurs buts. Ici encore, on retrouve le style léger et pédagogue de l'auteur.

J'ai été par contre un peu plus déçu par les paragraphes suivants où l'auteur essaie de nous décrire comment passer de la vision aux stories et des stories aux tests d'acceptation. Le style devient un peu moins précis et perd en clarté.

Cependant, on appréciera le chapitre sur les indicateurs, toujours utile pour rassurer la direction ainsi que l'aperçu de l'outil IceScrum qui donne envie d'être découvert.

Enfin, l'auteur propose des pistes pour une transition à SCRUM et son intégration dans les processus d'ingénierie logiciel à ne pas négliger.

En conclusion, j'ai beaucoup apprécié cet ouvrage que je recommande chaudement à toute personne souhaitant découvrir ou approfondir la méthode SCRUM. Il est le compagnon idéal pour toute équipe SCRUM qui souhaite être efficace et éviter les pièges de la conduite de projet informatique "à l'ancienne".

Hasard ou non, cette publication de Claude Aubry coïncidait la semaine passée avec ma participation à une formation ScrumMaster, sanctionnée par un examen (certes discutable) pour une certification de même nom. J'étais donc déjà plongé dans Scrum depuis plusieurs semaines lorsque l'on m'a proposé cette lecture. Lors de cette formation j'avais rencontré des consultants de Akka TechnologiesAkka Technologies, vecteurs d'une bonne dynamique Scrum dans le bassin toulousain, avec qui j'ai eu l'occasion de parler des projets de Claude Aubry et de son investissement sur le sujet. Entre les guides officiels, la littérature de Schwaber, Sutherland et Cohn, il ne me manquait donc plus qu'un livre en français. C'est chose faite, et plutôt bien faite suis-je tenté de souligner.

Bien sincèrement, le livre de Claude Aubry aborde Scrum d'une manière moins dogmatique, mais assurément plus pragmatique. En fait je n'avais pour le moment pas encore lu d'ouvrage structuré qui dispense de manière aussi complète des conseils sur la pratique de Scrum. Le retour d'expérience de l'auteur sur chaque précepte Scrum (les artefacts, les rôles, meetings) est très intéressant, et chaque ScrumMaster ou membre d'une équipe Scrum y trouvera des éléments de réflexion de qualité (comme la vie du backlog, la phase de conception, la planification de release, etc.). Je pense que je serais amené à relire certains chapitres ou paragraphes sur des sujets précis si je suis pris en défaut, car les explications et exemples sont clairs et invitent à l'essai.

Vous retrouverez ainsi les rappels des fondamentaux de ce processus empirique, une description des différents rôles (Product Owner, ScrumMaster, l'équipe), du Product Backlog, des différents timeboxes (planification de release, planification de sprint, daily scrum, rétrospective de sprint), mais aussi des définitions pratiques comme la notion de travail fini, le contexte du projet, les mesures et indicateurs. On notera également le chapitre sur les outils pour Scrum, ou IceScrum est présenté, ainsi qu'un chapitre utile pour les décideurs : "La transition à Scrum".

J'ai apprécié ce livre en français de Claude Aubry, qui apporte une contribution de qualité à la compréhension, à une application pragmatique, et à l'adoption de Scrum en France. Je pense ne pas me tromper en précisant que se livre est relativement accessible à tout acteur de l'IT, sensible aux méthodes agiles et à l'optimisation des développements logiciels, qu'il soit décideur, chef de projet, développeur, ou futur "Product Owner".

Ce livre très attendu est écrit par Claude Aubry, un représentant particulièrement actif de la communauté agile française, et préfacé par Francois Beauregard, un "agiliste" francophone de la première heure.

J'ai découvert avec plaisir un livre clair et passionnant sur un processus de développement, ce qui est rare : la simplicité et l'élégance de SCRUM y contribuent certainement, mais l'auteur a fait preuve de beaucoup de pédagogie. En particulier tous les concepts, entités, rôles, responsabilités sont clairement expliqués et bien reliés les uns aux autres, et leurs aspects temporels et dynamiques sont bien couverts. L'ouvrage montre donc bien la grande cohérence de SCRUM.

Et l'auteur a fait des choix appréciables : les chapitres courts et faciles à lire, les nombreux schémas qui facilitent la compréhension du texte, les dessins humoristiques... Il a également tiré parti de son expérience considérable pour mettre en garde le lecteur contre divers risques et pièges qui l'attendent dans la mise en pratique : bien que simple, Scrum n'est pas facile à pratiquer.

Les 11 premiers chapitres, soit environ 150 pages, décrivent complètement Scrum. Suivent ensuite 7 chapitres qui donnent des conseils pratiques sur de nombreux aspects, comme l'adaptation au contexte de votre entreprise, l'élaboration de la vision d'un produit (avant donc les sprints), la relation features-stories-tests, la traçabilité, l'ingénierie du logiciel, les indicateurs. Le dernier chapitre est un panorama de Scrum en France.

Un livre assez orienté "processus" tout de même, et qui passe peut-être un peu vite sur les aspects "équipe" et "individuel", auxquels on est forcément conduit à s'intéresser si l'on veut tirer complètement parti de Scrum : peut-on faire l'économie d'approfondir ce que veut dire être un développeur professionnel dans ce nouveau contexte ? Ken Schwaber a d'ailleurs mis en garde contre le fait qu'appliquer Scrum avec des gens qui faisaient du sale boulot avant permettait juste de produire du sale boulot à intervalles réguliers !

Un regret au niveau de la bibliographie : elle est un peu légère. Je trouve dommage de ne pas voir cités des auteurs essentiels comme les Poppendieck (Lean Software Development), Esther Derby (les rétrospectives), Larman et Vodde (Scaling Scrum), Lencioni (les dysfonctionnements d'une équipe), Robert C. Martin (sur Clean Code), Lisa Crispin, Janet Gregory (Agile Testing). Une meilleure bibliographie aurait contribué au caractère de référence que va prendre cet ouvrage.

En conclusion, ce livre est un excellent guide pour démarrer avec Scrum, ou pour revisiter les bases si vous avez déjà pratiqué. Il contient suffisamment de matière pour vous accompagner pendant de nombreux sprints. Même si vous vous intéressez déjà à des questions qui relèvent plus de la bibliographie ci-dessus, vous achèterez certainement le livre pour vos collègues et partenaires !

"Gestion de projet : vers les méthodes agiles" est un livre décrivant les rôles du chef de projet (au sens large) et les différentes façons d'appréhender les problématiques liées aux projets informatiques.
Il montre l'apport des méthodes agiles (Scrum, XP, DSDM, Crystal...) par rapport aux méthodes classiques et compare leurs avantages et leurs faiblesses.

Ce livre est illustré par de nombreux témoignages de spécialistes qui répondent à des problématiques courantes dans la vie d'un projet. Un véritable retour d'expérience qui ne manquera pas de vous faire évoluer.
Véronique Messager Rota nous amène à réfléchir aux sources d'échecs d'un projet et définit des bonnes pratiques organisationnelles, humaines et techniques.
Elle détaille également les différentes étapes d'un projet et identifie leur but et les problèmes récurrents.
Pourquoi le client n'arrive t-il pas à exprimer son besoin ?
Pourquoi seulement 30% de l'application sont réellement utilisés ?
En quoi le pilotage par les tests est un facteur de réduction des coûts ?
Comment estimer la charge d'un projet ?
Quelle doit-être la charge allouée à l'estimation d'un projet ?

Bien que ce livre soit tourné vers la découverte des méthodes agiles, certaines notions de pilotage de projet sont parfois complexes pour un débutant.

Pour conclure, ce livre est un très bon outil.
Il répond à beaucoup de questions que se posent les chefs de projet informatique et constitue un recueil d'expériences très enrichissant. Attention tout de même à ne pas tomber dans l'apologie aveugle des méthodes agiles.
Ayez toujours en tête que ce ne sont que des bonnes pratiques, que vous devez les utiliser si vous en sentez l'utilité, et non parce que vous pensez que c'est à la mode.

Si vous désirez en savoir plus sur la plateforme Team Foundation Server, ou encore apprendre à la mettre en ouvre, l'administrer ou tout simplement l'utiliser, Microsoft Team Foundation Server vous sera d'une réelle utilité. L'ouvrage peut faire office de manuel aussi bien pour un administrateur serveur qui trouvera tout ce qu'il faut savoir pour administrer entièrement la plateforme Team Foundation Server, que pour un développeur qui découvrira comment utiliser correctement les différents outils mis à disposition, ou encore pour un chef de projet qui pourra suivre au mieux le cycle de vie d'un projet.

Concernant le contenu du livre, on commence par une introduction au concept ALM (Application Lifecycle Management) et à Visual Studio Team System avec sa gamme qui en découle pour ensuite en arriver à la présentation de Team Foundation Server, la plateforme qui héberge différents services comme la gestion de code source, la gestion des éléments de travail, le service de compilation, celui de la gestion de la documentation et pour finir le service de gestion des rapports.

Les deux chapitres suivants vous en apprendront plus sur l'installation et l'administration de Team Foundation Server suivant différentes architectures données. Chacun des services cités précédemment est ensuite détaillé dans un chapitre dédié. L'ouvrage se finit avec deux annexes intéressantes sur le système de notifications du serveur ainsi que les outils et liens qu'il ait indispensable de posséder.

Au final, bien que je sois développpeur de métier, la lecture de cet ouvrage a été très facile, rapide et claire. Même si l'ouvrage m'a semblé orienté pour les administrateurs serveurs et dans une moindre mesure pour les développeurs (heureusement !), les chefs de projets et simples utilisateurs pourront aussi y retrouver des informations utiles pour mieux comprendre comment interagir avec la plateforme Team Foundation Server et les outils qui l'accompagnent dans le cycle de vie d'une application.

Ce livre m'a étonné de bien des manières. J'attendais à la fois une présentation de la solution TFS mais également une vision globale de l'outil et une mise en avant de ses fonctionnalités pour répondre aux besoins que je rencontre tous les jours dans mes projets. Je n'ai été déçu sur aucun de ces deux points.

Dans son livre, Florent commence par une présentation de la gestion de vie des applications (ALM) qui est fort bien écrite, mais un peu courte à mon goût. Puis vient la partie qui nous intéresse : Team Foundation Server. Ici, rien à dire, les chapitres du livre correspondent au processus idéal d'une configuration d'un nouveau projet. Or, si parfois l'on se demande par où comment avec une solution aussi complexe et complète, la question ne se pose plus ici. On se laisse guider par le livre et on se retrouve au final avec exactement ce qu'il convient à notre projet. Tout y est, gestion des comptes, compilation, rapport, contrôle de code source, documentation, etc.

L'un des points que j'ai particulièrement apprécié dans ce livre est la façon dont Florent présente l'ensemble de la solution. De par mon métier (développeur), j'ai tous les jours affaire à la problématique de l'usine de développement, et dans le cas de projet tactiques (!= commando), l'argument qui bien souvent m'empêche d'utiliser TFS est son coût (financier et de mise en place). Pourtant, ici, tout semble facile et rapide. Adieu l'image d'usine à gaz que l'on prête souvent à ce produit et bizarrement, c'est plutôt les solutions que j'utilise, tel que CruiseControl, qui me semblent maintenant relever de la "bidouille"

Je connais Florent depuis quelques années et surtout ses compétences et la seule chose que je pourrais reprocher à ce livre, c'est qu'il n'ait pas mis plus en avant son retour d'expérience personnelle. J'aurais aimé une partie bonnes pratiques ou des apartés sur ses conseils personnels. Maintenant, il est vrai que cet exercice n'est pas évident, car chaque projet a ses spécificités et l'inclure dans un ouvrage est d'autant plus compliqué. C'est pour cela que je n'en tiendrai pas rigueur au livre et en garderai l'idée qu'il s'agit sûrement du livre le plus clair et le plus agréable à lire que j'ai lu sur le sujet.

Cette 3e édition de ce livre a le mérite de couvrir de façon générale et détaillée l'architecture logicielle ainsi que les concepts clés en relation avec ce domaine de l'ingénierie informatique.

Particulièrement dédié aux architectes, aux décideurs DSI, aux maîtres d'ouvrage et auxchefs de projet, cet ouvrage présente les problématiques de l'architecture logicielle, les concepts fondateurs, les principes des architectures fonctionnelles logiques ou encore les propriétés fondamentales des architectures.

L'approche adoptée par l'auteur permet au lecteur de découvrir progressivement les principes des modèles d'architectures, éléments importants pour le choix d'un modèle dans un projet. En voulant cerner tous les aspects de ce domaine assez vaste, l'auteur, à mon avis, nous livre un document trop théorique, voire même superficiel pour les profils assez techniques.

J'ai particulièrement apprécié la partie sur les propriétés d'une bonne architecture ainsi que l'introduction d'un exemple complet de système complexe de la famille C4ISTAR et l'impact des récents modèles cloud computing et virtualisation, qui sont les nouveautés phares de cette édition.

J'estime qu'il serait intéressant de compléter la lecture de ce livre par un document entièrement dédié à un concept architecturale(BPM, SOA, clients serveurs, etc.).

Ce livre est très riche, il aborde de nombreuses notions théoriques. Pour autant, l'auteur n'entre pas dans le détail de chacune d'entre elles, il les présente pour les intégrer dans une vue d'ensemble de l'architecture logicielle.

L'approche à certes quelques inconvénients. Elle peut paraitre indigeste à celui qui voudrait tout enchaîner d'une traite ou bien superficielle à un informaticien spécialisé (compilateur, ETL, MVC, SOA, ...)

Cependant, l'approche a également ses avantages. Elle fait découvrir une palette de sujets plus ou moins connexes et laisse le soin au lecteur intéressé de se reporter aux ouvrages indiqués dans la bibliographie. Elle explique bien les objectifs, les motivations, les propriétés de ce qu'est l'architecture logicielle ou tout du moins de ce qu'elle devrait être.

J'ai trouvé la deuxième partie qui analyse deux chefs-d'oeuvres d'architecture la plus intéressante. Certes, elle m'a un peu laissé sur ma faim mais comme il est fort probable qu'on pourrait écrire un ouvrage rien que pour chacun d'eux, je comprends les contraintes éditoriales.

A noter également dans cette deuxième édition un tout nouveau chapitre dédié au métier d'architecte logiciel dans lequel j'ai particulièrement apprécié la description qui en est faite.

Ce livre très érudit, très théorique, est difficile et s'adresse plutôt à un public averti, des professionnels qui veulent comprendre le fonctionnement d'un système d'information complexe d'une grande entreprise ou bien qui recherchent un ouvrage de référence, synthétique sur le sujet.

Wouf ! Voici probablement le livre traitant d'informatique le plus théorique que j'ai jamais lu ! Certainement pas adapté à tout le monde, cet ouvrage est particulièrement dédié aux architectes, maîtrises d'ouvrage ou d'oeuvre, tout à fait professionnels. Il ne conviendra pas au développeur amateur. Il s'agit bel et bien d'une étude théorique des acteurs, comportements, risques, coûts, etc., qui surviennent dans le monde du développement à grande échelle.

Cet ouvrage est écrit sous une forme très scientifique, théorique, et est remarquable sur ce plan. On notera une excellente bibliographie, ainsi que la présence fort appréciée d'un glossaire complet et d'une table des sigles et acronymes utilisés.

La plupart - si ce n'est l'entièreté - des problèmes et difficultés liés au métier d'architecte y sont traités. On regrettera peut-être, malgré cela, un peu plus de conseils pratiques. Le 100 % théorie est malgré tout peu digeste, bien que d'un intérêt certain.

Je recommanderais donc cet ouvrage à tout professionnel de l'informatique ayant à gérer de grandes équipes de développement. Mais probablement pas à une autre catégorie de lecteurs.

Ce livre est avant tout une compilation de bonnes pratiques (12 pour être précis). On y trouve ce qui va apporter au chef de projet une efficacité de manière pragmatique. Néanmoins aucune des bonnes pratiques n'est détaillée pour montrer son intérêt de mise en oeuvre. Cet aspect m'amène à penser que la cible de ce livre est bien le chef de projet débutant qui souhaite partir sur de bonnes bases. Les interventions de chefs de projets aguerris agrémentent les bonnes pratiques et une fois de plus le lecteur ne manquera pas de retrouver une de ses expériences dans ces témoignages. Un plus : vous pouvez téléchargez gratuitement le "Ebook gestion du temps PDF" (guide de 20 pages) sur le site de l'auteur.

Avant de lire ce livre, Cloud Computing et SaaS étaient pour moi des termes que j'avais entendu, sans jamais vraiment clairement comprendre le concept.
La lecture de ce livre dévoile petit à petit ces définitions, et en ce sens remplit tout à fait son rôle. Les schémas aident beaucoup à comprendre les architectures basées PaaS.
En tant que développeur, j'aurais aimé une approche beaucoup plus technique, pourtant promise dans les derniers chapitres d'après l'introduction. On nous parle de mashups, de solutions PaaS offertes par Amazon, Sun, Google, Microsoft, etc. Je suis personnellement resté sur ma faim et aurais aimé voir une application concrète désossée. J'enlèverais une étoile pour cet aspect.
Pour le reste, ce livre développe bien les définitions clés liées au Cloud computing, comme les différentes architectures logicielles existantes et leurs modèles économiques.

Dans cet ouvrage, l'auteur présente sa vision des Saas et du Cloud Computing. Celle ci est très enthousiaste et présente ces aspects comme l'avenir de l'informatique en révolutionnant le modèle "software".

Le livre est bien écrit, facile à lire et présentant ces concepts de manière claire et précise. Pour autant, ce contenu ne méritait peut-être pas un livre entier et on peut parfois avoir l'impression que l'auteur brode un peu et se répète pour couvrir les 250 pages de l'ouvrage. Nonobstant cet aspect, le livre est plutôt intéressant et apporte des précisions pour quelqu'un cherchant à en savoir plus sur le cloud computing et les SaaS.

En tant que développeur, j'aurai aimé que la partie sur le développement sur environnement PaaS soit plus détaillée et agrémentée d'exemples d'applications, mais cela n'était pas le propos du livre qui se veut très général et ouvert au plus grand monde.

En conclusion, un livre intéressant mais laissant un sentiment mitigé.

Ce livre, d'une part plaide, auprès des responsables des services informatiques donneurs d'ordre, la cause du métier de développeur en leur proposant une perception différente des développements informatiques.

Et d'autre part, s'adresse principalement aux informaticiens en quête d'efficacité, sans avoir à imposer à leur équipe de développement, une méthodologie projet de plus.

La méthodologie de l'auteur ne nécessite pas de modifier l'organisation d'un service ou d'une équipe, ce qui est appréciable.
L'objectif est d'acquérir une démarche méthodique, ce qui est loin d'être le cas pour tous les développeurs comme certains peuvent le constater au cours de leurs différentes missions (je parle d'esprit méthodique pas d'incompétences).

Cet ouvrage est un condensé de ficelles du métier, voir un vade-mecum de méthodes. Les plus expérimentés en retrouveront certaines sans avoir conscience que leurs pratiques constituent une méthode en soi.
Un livre que je conseille aux débutants qui y trouveront des méthodes de travail simple et efficace. Par exemple la méthode d'écriture analytique, ou comment réfléchir tout en avançant dans le travail, est judicieuse.
Les expérimentés envisageant de travailler en indépendant y trouveront, je pense, de bonnes pratiques préventives contre certains risques liés à leur pratique, car comme le dit l'éditeur au dos de l'ouvrage, l'important n'est pas connaître les méthodes, mais de les appliquer quotidiennement !
De mon coté j'aurais aimé une liste d'ouvrage annexe ayant nourri la réflexion de l'auteur, car on peut apercevoir lors de la lecture que le développement logiciel est d'abord le déroulement d'idées avant d'être une production de code.

Je dois avouer que j'ai eu envie de lire "Coder proprement" suite aux critiques dithyrambiques précédentes mais contrairement à elles, la mienne sera un peu moins élogieuse.

Non pas que je n'ai pas aimé, bien au contraire ! Si je me fie à ma règle de proportionnalité intérêt/vitesse de lecture, je dois conclure comme eux mais venant après, mes attentes plus élevées ont aiguisé mon sens critique.

Mes attentes étaient probablement excessives mais j'ai appris moins de choses que je l'imaginai. Ceci s'explique peut être par le fait qu'avec l'expérience, j'ai découvert par moi même de nombreuses règles édictées.

L'intérêt pour moi est donc tout autre. Perfectionniste à la base, j'ai tendance à être un peu pinailleur, à chercher le meilleur nom, à faire chauffer le refactoring, à casser du code qui fonctionne parce que je vois une meilleure solution, ... N'ayant que rarement rencontré pareille obsession chez mes collègues, je croyais être atteint d'une curieuse maladie ! Ce livre a agit un peu comme une thérapie en me montrant que je n'étais pas seul, que je suis en train de muter en développeur professionnel !!!

Le livre est bien structuré :

• Il explique d'abord pourquoi il faut être propre (je suis un lecteur convaincu)
• Il montre ensuite comment faire à travers des exemples (le papier n'est peut être pas le meilleur support pour cet aspect dynamique ? vivement une version électronique avec animation intégrée !)
• Il récapitule les règles (à garder à l'esprit).

Coder proprement n'est pas spécifique à un langage donné mais il faut reconnaître que les langages typés statiquement et les outils adéquates aident grandement. J'ai donc particulièrement aimé que les exemples soient en Java.

Reprendre le code de quelqu'un d'autre pour l'améliorer n'est pas chose aisé et cela pourrait froisser plus d'un égo. Il prend donc des précautions oratoires dans le chapitre où il expose fièrement une de ses oeuvres et il a bien fait car on peut également lui appliquer la règle du boy-scout! Il est donc appréciable que l'auteur modère son point de vue en parlant d'école de pensée. Néanmoins, il manque de cohérence avec sa règle J1 sur l'importation des classes dans Java. D'une part, il dit qu'une longue liste d'importation effraie le lecteur mais c'est oublier que les chers IDE modernes (qu'il invoque quand ça l'arrange) les cachent automatiquement. D'autre part, dire que le caractère générique crée moins de dépendance que l'import spécifique d'une classe, je vois vraiment pas en quoi ???

Mon autre petite reproche est quelques petites erreurs de traductions.

En conclusion, ce livre est à mettre entre les mains de tous débutants, cela ne fait aucun doute. Pour les développeurs plus aguerris, c'est déjà plus discutable, je leur conseillerai cependant pour découvrir l'argumentaire de cette école de pensée ou pour soulager leur névrose.

Un livre tout simplement indispensable pour apprendre à coder proprement. En plus de nous apprendre à coder proprement, il nous apprend également pourquoi il faut le faire, ce qui est indispensable pour motiver quelqu'un à programmer proprement. Ce livre m'a beaucoup appris sur la bonne manière de coder. Tous les éléments théoriques du livre sont mis en pratique via des exemples concrets de code. En plus de cela, un chapitre entier est consacré au remaniement d'une classe et un autre au remaniement d'un petit programme.

Le premier chapitre tente de spécifier ce qu'est un code propre. Vous y trouverez l'avis de nombreuses personnes (Bjarne Stroustrup ou Grady Booch) sur ce qu'est un code propre. Ensuite, le chapitre suivant traite de l'importance d'utiliser des noms significatifs pour les variables, classes et méthodes. Le chapitre 3 est à mon avis l'un des chapitres les plus importants du livre. En effet, il traite des fonctions et de l'importance de les faire le plus court possible, de leur faire faire une seule chose et à un seul niveau d'abstraction, ce qui augmente clairement la lisibilité des méthodes.

On passe ensuite aux commentaires. On y apprend notamment quels sont les commentaires vraiment utiles et quels sont ceux qui ne font que surcharger le code. On passe ensuite à la mise en forme de votre code, c'est à dire l'indentation, la taille des fichiers, la largeur d'une ligne, ...

Après cela, on en vient aux objets et structures de données, à la gestion des erreurs et à la gestion des limites. Puis on passe à un autre chapitre très important, les tests unitaires. Ce chapitre m'a fait redécouvrir les tests unitaires et leur utilité.

On apprend ensuite à concevoir de bonnes classes. Avant de passer au niveau supérieur, celui du système. Avec lequel, on apprendra à concevoir également les préoccupations transversales. Puis on passe à un ensemble de règles permettant de faciliter l'émergence d'un code propre.

Le chapitre suivant est consacré à la concurrence et à la conception d'un code concurrent propre et fonctionnel. Ce chapitre sera poursuivi en annexe par un deuxième chapitre sur la concurrence.

Puis, on passe à 3 chapitres pratiques. Le premier traitant des améliorations successives d'un programme fonctionnel, mais pas propre. Le chapitre suivant est entièrement consacré au refactoring d'une classe de JUnit et enfin le troisième chapitre va traiter du remaniement de la classe SerialDate de JCommon.

Le dernier chapitre fournit une liste d'indicateurs et d'heuristiques permettant d'avoir rapidement à portée de mains une liste de bonnes pratiques pour coder.

En conclusion, ce livre vous permettra, soit de commencer à bien coder, soit de redécouvrir la façon de coder, suivant que vous soyez débutant ou expérimenté. L'auteur pouvant parfois être très radical dans ces dires, il est possible que certaines de ses recommandations ne vous plaisent pas du tout ou vous semblent trop extrémistes. Néanmoins, ces recommandations viennent, comme l'auteur l'indique, d'une école de pensée. Il est donc possible que d'autres systèmes de code propre vous satisfassent plus que celui-là, mais pour ma part, j'ai trouvé ce système de code propre des plus intéressants.

Je ne vois pas ce que l'on peut reprocher à ce livre. Véritable guide de la programmation propre, il commence par justifier au lecteur l'utilité d'un code propre. Ensuite, il explique ce qu'est un code propre, avant de démontrer comment il est possible de rendre propre un code qui ne l'est pas.

La structure et le fil conducteur du livre sont limpides, et les explications d'une clarté irréprochable. Avec peu d'efforts, le lecteur intègre les besoins et les solutions liés à la propreté du code.

Il me faut toutefois noter que l'auteur adopte un point de vue très radical (pour ne pas dire extrémiste). Certains lecteurs pourront être rebutés contre l'une ou l'autre recommandation. Cependant, je les invite à essayer de suivre scrupuleusement les conseils de ce livre dans un projet, si petit soit-il, avant de juger. J'ai moi-même eu l'occasion d'appliquer pleinement ces notions dans un concours, très réputé pour voir fleurir des codes illisibles en peu de temps : le code construit en suivant les techniques de cet ouvrage est resté d'une clarté exceptionnelle, sans perte de temps.

Pour ceux qui, malgré cela, ne peuvent accepter un point ou l'autre, l'auteur signale explicitement que son enseignement est celui d'une école de pensée, et qu'il est parfaitement possible que d'autres systèmes de code propre fonctionnent aussi bien.

C'est donc un livre à mettre en toutes les mains, du plus jeune débutant afin qu'il prenne de bonnes habitudes dès le début, au plus expérimenté qui redécouvrira une autre manière de coder : plus simple, plus claire, plus durable.

Un livre pour nous présenter 40 outils de gestion d'un projet de A à Z sous forme de condensé ? Oui c'est bien de ce livre que nous parlons. Les auteurs nous rappellent les concepts du projet. Depuis l'idée jusqu'au bilan d'un projet, toutes les phases et jalons nous sont présentés. Chaque chapitre est présenté de manière sobre et efficace! Mes plus : le résumé en fin de chapitre avec les "a éviter" (que nous avons tous déjà rencontré dans certains projet!), les bons conseils...
Ce n'est pas un livre spécialisé pour des spécialistes de gestion de projet mais bien un livre de bonnes recettes.
On pourra reprocher le coté "passe partout" des documents présentés mais cela permet d'avoir une présentation formelle du concept présenté.

Pour moi, ce livre est quasi indispensable pour toute personne commençant à développer sérieusement des solutions Sharepoint. En effet, malgré la notoriété grandissante de l'outil, la documentation francophone pour les développements avec Sharepoint est encore difficile à trouver, plus encore pour des développements qui sortent d'un workflow basique ou de customisation de feuilles de style.

Ce livre montre pas à pas comment créer des web parts, des pages web, des customs actions, comment manipuler les requêtes CAML, la BDC, tout en gardant un style pédagogique et didactique. De plus, une partie déploiement, à mon avis obligatoire à maitriser, est incluse.

Ma seule critique sur ce livre est que l'API aurait pu être abordée plus en profondeur, mais au vu de la quantité d'information, du nombre de fonctionnalités abordées et de l'effort pédagogique, c'est une toute petite critique (parce qu'il fallait bien en trouver une).

En conclusion, si vous avez déjà un peu d'expérience en développement Asp.Net, que vous devez vous mettre à Sharepoint, et que vous avez déjà une connaissance, même très légère, du fonctionnement de Sharepoint, vous avez tout intérêt à acheter ce livre, et à découvrir à quel point Sharepoint, c'est trop bien.

D'habitude, un livre sur les méthodes de développement d'un système d'information est assez basique : on parle du cycle en V, on fait le tour du propriétaire et voilà.

Ici, aucun parti n'est pris. Les cycles en V côtoient SCRUM et XP, ce qui est rassurant. Avant les exemples, les différentes étapes de la gestion de projet sont envisagées. Estimation des charges, planification, gestion de l'équipe, pilotage et surtout qualité.

Les exemples sont organisés comme des exercices basés sur des cas réels. L'intérêt par rapport à d'autres ouvrages est que ces exemples prennent la majeure partie de celui-ci. On a donc une bonne description de la théorie, mais la pratique n'est pas le maillon faible. Et surtout, on a un corrigé "type" (même si les avis peuvent toujours légèrement diverger), avec argumentation, ...

Donc ce livre est un vrai ouvrage de référence (à mon avis) pour quelqu'un qui débute. Il ne devrait pas avoir de difficulté à utiliser les différents exercices et exemples pour gérer son propre projet.

Cet ouvrage écrit par G. Bueno, professeur enseignant en Master et en BTS propose une introduction à la conception des bases de données en s'appuyant sur le modèle Merise. Ce modèle souvent remplacé par l'UML de nos jours, reste pourtant une référence dans la conception de base de données. Au cours de la lecture on apprendra que sont les formes normales et comment les respecter. Plus qu'un apprentissage théorique, l'ouvrage propose aussi des exercices de difficultés croissantes qui permettent de tester et se confronter à des problèmes de conception particuliers. Conscient de la réalitée de la conception, l'auteur ne se contente pas d'expliquer les bonnes pratiques totalement théoriques en restant fermé à une conception "parfaite", mais explique pourquoi et comment nous pouvons dégrader le modèle afin de gagner en performance, ou s'adapter à un contexte particulier. Par ailleurs l'auteur ne limite pas son explication de merise au modèle conceptuel de données, mais s'attaque aussi au modèle logique de données, ainsi qu'à l'élaboration de dictionnaires de données. Différents outils de conception tels que les associations ternaires et d'arité supérieur, héritage d'entité, identification relative, agrégation, mais aussi moins connu et pourtant très utile : les contraintes d'intégrité statique sont expliqués en détail. Chaque chapitres se clos par une série d'exercices corrigés permettant de s'entraîner et valider nos connaissances fraîchement acquises. A la fin de l'ouvrage on nous propose de résoudre différentes études de cas complètes. Etant un ancien élève de cet auteur durant mon cursus de BTS, je ne peux pas nier que cet ouvrage regroupe clairement les connaissances d'analyse demandé pour ce diplôme, et que les exercices préparent directement à cette épreuve. Je recommande vraiment sa lecture à toutes les personnes qui partent de zéro et veulent apprendre rapidement à construire une base de données solide qui tient la route. En revanche, il n'apprendra rien ou peu aux personnes plus expérimentés.

Ce livre présente tout d'abord les concepts de Subversion (SVN), ensuite, il traite de l'utilisation de SVN, de la configuration d'un serveur SVN et enfin de la programmation avec SVN.

La première partie du livre est consacrée au fonctionnement et à l'utilisation de SVN. Cette partie est elle-même composée de 4 chapitres. Le premier chapitre est une introduction au contrôle de version d'un projet. Il présente de manière générale les différentes caractéristiques d'un logiciel de contrôle de version et quelles sont les particularités de SVN et ses avantages par rapport à d'autres projets équivalents. Le chapitre suivant présente en détail les caractéristiques et les concepts de SVN. Les 2 derniers chapitres de cette partie parlent de l'utilisation, de base et avancée, de Subversion. Ces 2 chapitres traitent de tout ce qu'il est possible de faire pour un utilisateur exploitant un référentiel SVN.
Cette première partie est extrêmement intéressante pour les utilisateurs purs de Subversion. Elle permet de bien comprendre tous les concepts inhérents à l'utilisation de SVN et de découvrir les commandes permettant de gérer son projet de manière collaborative.

La deuxième partie traite de l'administrateur d'un serveur SVN. Le premier chapitre traite essentiellement de l'administration du ou des référentiels et le deuxième chapitre traite de l'administration du serveur en lui-même et des choix technologies auxquels tout administrateur SVN sera confronté lors de l'installation d'un tel système.
Au contraire du premier chapitre qui était clairement orienté utilisateur, cette partie est faite pour les administrateurs.

La dernière partie est consacrée à la programmation avec Subversion. Cette partie va vous permettre d'apprendre à faire des scripts en divers langages (Shell, Perl, Ruby, Python, Tcl) permettant d'interagir avec un référentiel Subversion. Cette partie traitera également de l'organisation du code de Subversion.
Cette partie peut se révéler utile pour tout un chacun.

Ces 3 premières parties sont suivies par une série d'annexes. La première de celle-ci est une référence complète de toutes les commandes SVN. La seconde traite de la compilation de Subversion et la troisième est un guide à la migration depuis CVS. Et enfin, la dernière annexe contient toute une série de liens internet vers des outils graphiques pour SVN, des outils complémentaires ou encore d'autres logiciels de gestion de contrôle de version.

En conclusion, ce livre est excellent pour parfaire ses connaissances de Subversion. Il permettra à un développeur utilisant SVN de bien comprendre les concepts de SVN et de connaître les commandes qui sont utilisables pour gérer son référentiel. Il permettra également à un administrateur de savoir ce qu'il est nécessaire de savoir pour installer et administrer un serveur SVN. De plus, l'annexe de référence sur les commandes SVN est un plus non négligeable pour trouver rapidement les options possibles d'une commande ou simplement la syntaxe de cette dernière.

Présenté comme une approche pragmatique des architectures orientées services, ce livre tente d'allier théorie et pratique afin d'initier le lecteur aux SOA (Service-Oriented Architectures).

Le découpage en 4 parties (architectures orientées services, standards et technologies, processus métiers et une étude de cas) semble tout d'abord adéquat, mais un déséquilibre évident entre ces parties ne rend pas l'approche aisée.

En effet, la présentation des SOA est très brève, vraiment très brève (7 pages sur environ 300 !). Difficile dans ce cas d'appréhender le reste de l'ouvrage principalement axé sur la pratique. Très vite, le lecteur se retrouve face à plusieurs codes sources dans différentes technologies (PHP, Java, C#) et sans baggage théorique solide, difficile de s'y retrouver. L'intention était bonne, la réalisation beaucoup moins.

Je continue ainsi de m'interroger quant à l'utilité des 100 pages d'annexes contenant principalement du code source et du code XML. Il aurait été plus intéressant de proposer ces ressources sur le site de l'éditeur.

Dommage d'avoir raté cette partie, car le reste du livre est plutôt bon : de bons exemples présentent l'intérêt concret des SOA, et plusieurs illustrations (parfois illisibles cependant) permettent une approche pratique intéressante.

Débutant dans le monde des SOA, je n'ai pas vraiment trouvé mon compte avec ce livre, j'attendais une approche théorique plus fournie pour pleinement apprécier le côté pratique.

Malgré ce point négatif, l'approche pratique en vaut vraiment la peine, car la mise en oeuvre concrète des SOA est bien abordée, notamment dans le cas du langage BPEL4WS. J'ai particulièrement apprécié la présentation d'un projet C# de recherche de livre à l'aide du service Amazon : l'explication est claire et l'intérêt des SOA est alors frappant.

Mon avis concernant ce livre est donc mitigé. Je ne recommande pas ce livre pour les débutants, mais plutôt pour les étudiants ou professionnels disposant d'une bonne connaissance des SOA, et qui souhaitent un complément pratique.

Ce livre est assez incroyable par la manière dont il aborde un sujet aussi délicat que la programmation orienté objet ! Le lecteur est plongé dans une histoire fascinante ou chaque début de chapitre commence par un petit dialogue mettant un avant le problème à résoudre par la suite ! Chaque sujet est aborde dans divers langages (dont chaque subtilités sont mises en avant) et on ne manquera pas de remarquer la précision de chaque exemples. Puis pour clôturer un chapitre le lecteur est amené à exécuter divers exercices pour assimiler le tout. Chaque lecteur y trouvera son bonheur puisqu'il s'adresse a tout ceux qui désirent découvrir ou approfondir la POO tant pour ceux qui connaissent un langage en particulier que ceux qui n'en connaissent aucun. On ne se lasse pas de parcourir les pages et malgré le volume de papier on sera très vite a la fin du livre qui mêle programmation mais aussi petits rappels culturels (lies à l'informatique évidement) qui ne manqueront pas de surprendre ceux qui n'ont pas connu les débuts de l'informatique. En conclusion un excellent livre, très complet pour aborder le sujet délicat de la POO.

Se rapporte à une édition précédente.

Ce livre est une étude complète du développement orienté objet, abordé de la manière la plus pratique possible. L'auteur prend littéralement le lecteur par la main à la manière d'un professeur particulier, pour nous expliquer de manière simple et progressive le monde orienté objet, en illustrant par des cas didactiques concrets.

Les premiers chapitres peuvent paraître simplistes, surtout si le lecteur a déjà une expérience en programmation orienté objet, mais ils insistent beaucoup sur les bases essentielles de l'OO (nom intime pour "orienté objet"). Un des aspects les plus pédagogiques du livre est la présence abondante de code source qui illustre parfaitement la matière, et ce à chaque fois dans 3 langages : Java, C# et C++. Ainsi, contrairement à trop d'ouvrages théoriques sur le sujet, celui-ci reste agréable à lire, instructif et surtout pratique grâce aux exemples de programmation. Ces exemples restent souvent fort "didactiques" au début, mais une fois que la matière se complexifie, les bouts de programme présentés deviennent plus "réels" en simulant des jeux ou des applications informatiques classiques. L'aspect analyse n'est pas oublié non plus avec un chapitre entier consacré à UML et la traduction concrète de ses diagrammes principaux en code Java, C# et C++. Une série d'exercices à la fin de chaque chapitre permet au lecteur de s'auto-évaluer; ce livre est donc parfait comme support de cours.

A la fin de l'ouvrage on aura passé en revue tous les aspects de la programmation orientée objet, des plus simples au plus complexes, en terminant par les graphes. Plusieurs chapitres traitent de sujets modernes et intéressants pour le développeur tels que la sauvegarde de données (le passage d'une classe à un fichier, ou une base de données), la réalisation d'applications distribuées via RMI, Corba, webservices... Sont aussi traités d'autres sujets d'actualité comme la programmation événementielle caractéristique des interfaces utilisateur modernes, et le multithreading.

Bref un excellent ouvrage qui satisfera aussi bien le débutant complet que le programmeur ayant déjà des notions objet et souhaitant les approfondir et voir leur mise en oeuvre dans des applications concrètes. Un must pour tout développeur OO.

La programmation orientée objet a eu autant d'effets dans le monde du développement logiciel que le C à son époque : une révolution ! Et comme toute révolution, celle-ci trouve ses sources dans les problèmes du modèle précédent : c'est ce que souhaite nous montrer l'auteur avec la première partie de ce livre, qui va expliquer les raisons de l'approche objet et les bénéfices que l'on peut en tirer.

Ces principes sont expliqués pas à pas et dans les détails à l'aide du langage Eiffel. Mais connaître un langage est une chose, bien l'utiliser en est une autre. C'est pourquoi on retrouve ensuite une série de chapitres présentant conseils et méthodologie pour le développeur. Enfin, les derniers chapitres traitent des problèmes modernes (GUI, threads, SGBD) et de l'utilisation de la programmation orientée objet dans d'autres langages (C,Ada,Simula,...).

Mais ce tableau idyllique est terni par plusieurs points. D'abords une partie du code du livre n'est plus à jour, puisqu'il provoque des erreurs de compilation. Ensuite, certains passages du livre, principalment ceux qui abordent d'autres langages, peuvent être sujet à critiques, certains étant même faux.C'est par exemple le cas quand il affirme que friend est un mot clé du langage [C++] permettant d'appeler des fonctions C depuis un code en C++. Il en va de même pour certaines références du livres datant de la première édition et qui sont dépassées. Enfin, sur le plan purement pratique, le livre est lourd (2.1 Kg) et l'emmener en voyage relève d'un réel choix.

En conclusion, cet ouvrage est un très bon livre sur la conception orientée objet, mais nécessite quand même de savoir prendre du recul sur certains points.

On ne trouve pas un livre comme celui-ci tous jours !

Cet ouvrage est véritablement un chef-d'oeuvre. Une découverte, emmenée pas-à-pas, de la méthode orientée objet, de ses motivations, des solutions qu'elle apporte aux problèmes connus de génie logiciel.

C'est surtout cette partie-là, l'explication des motivations de l'avènement du développement orienté objet, qui fait de ce livre une référence unique. Au lieu de présenter bêtement les apports de l'OO, l'auteur commence par nous faire prendre conscience des problèmes liés au développement. Ensuite, il explique pas-à-pas les éléments de la méthode OO qui répondent à ces problèmes.

En plus de cela, l'auteur nous fournit de nombreux conseils, une méthode complète, pour la bonne utilisation de l'orienté objet. C'est un élément d'une extrême importance, d'autant que l'on peut observer que de nombreux développeurs OO font plus ou moins n'importe quoi avec cette technologie.

Cette nouvelle édition a, entre autres, ajouté de nouveaux sujets sur les technologies qu'on utilise désormais beaucoup plus que du temps de la première. En particulier, l'usage d'Internet, de la concurrence et du calcul distribué. D'autres sujets ajoutés sont une théorie assez mathématique des ADT (Abstract Data Type, ou Type Abstrait de Données), ainsi que le bon usage de l'héritage, pour ne citer que ceux-ci.

Je terminerai par un petit mot aux "experts" : vous ne l'êtes pas tant que ça ! Ne vous dites pas : "Moi, je sais déjà tout sur l'orienté objet, je l'utilise très bien ; je n'ai pas besoin d'un tel livre." J'étais comme cela avant la lecture de celui-ci, maintenant plus. Il y a énormement de choses que ce livre a à nous apprendre, à tous.

N'hésitez donc pas : ce livre en vaut la peine !

Sébastien Doeraene

Cette critique se rapporte à la première édition.

Ce livre est une véritable référence, que dis-je: une BIBLE !

L'auteur nous fait découvrir tous les principes de la programmation orientée objet, des concepts les plus simples aux plus compliqués.

L'auteur nous permet, en plus, de découvrir le langage qu'il a inventé: le langage Eiffel.

Bref, ce livre constitue la référence en matière de POO, même si sa lecture nécessite tout de même d'avoir quelques notions dans ce domaine.

Un conseil: Achetez-le !.

Cette critique se rapporte à la première édition.

Quand on prend ce livre dans les mains, on s'attend à une lecture studieuse et attentive. Mais en lisant le début, on se rend déjà compte que Bertrand Meyer a pensé à nous. Une première partie est consacrée aux bases de l'orienté objet, en gros ce dont il faudra absolument retenir en reposant ce livre.

Réutilisabilité et modularité sont les maître-mots de ce livre, et toutes les techniques actuelles pour y parvenir sont analysées dans les détails. De la généricité au garbage collector, on se rend compte qu'il n'y a aucun langage qui réponde à tous les critères de ce livre. Plusieurs langages sont étudiés pour voir ce qu'il aurait fallu améliorer - le garbage collector en C++ -, c'est très intéressant.

En ce qui concerne la méthodologie objet, le livre est à nouveau complet, comment pourrait-il en être autrement ? Une partie consacrée à des problèmes spécifiques montre que l'auteur sentait sans doute venir l'évolution actuelle, la programmation concurrente étant de plus en plus utilisée depuis les annonces d'Intel et AMD. La dernière partie permettra de voir un peu mieux comment appliquer ce qu'on a appris pendant tout le livre.

Malgré les passages que l'on peut passer en première lecture, le livre est tout de même d'une difficulté certaine. La lecture de chaque chapitre entraîne une réflexion qu'on doit mener pour bien assimiler les concepts. Eu égard à la quantité et la qualité des propos dans ce livre, on peut être décourager par le temps nécessaire pour une lecture en détail complète, d'où l'étoile en moins.

N'étant pas familier de la collection "Tête la première" et compte tenu de la présentation très spécifique des ouvrages qui compose cette collection, je me sens obligé de séparer ma critique en 2 parties distinctes : le fond et la forme.

Concernant le fond, rien à redire. Le livre fait ce que l'on attend de lui. Il délivre les recettes afin de réaliser un bon logiciel et ceci de manière progressive ; en commençant par de petites applications (à créer ou à corriger) jusqu'à la grosse application.

Les exemples sont réalisés dans le langage Java. N'étant pas développeur Java mais plutôt les .net, ils ne sont pas un frein à la compréhension des concepts étudiés.

La forme est par contre pour le moins originale. Des personnages fictifs dialoguent afin de faire avancer la réflexion du lecteur. Il se retrouve ainsi acteur du livre. Le livre est une succession de schémas, diagrammes, annotations, dialogues, interviews ... Rien à voir avec le livre théorique classique. Du fait, de cette structure une lecture non linéaire est difficilement envisageable.

Donc pour conclure, si vous voulez vous familiariser avec l'analyse et la conception objets, ce livre est un bon choix. Néanmoins, je vous conseille vivement d'aller dans une librairie afin de feuilleter un livre de la conception "Tête la première" afin de bien comprendre conscience du style utilisé qui peut être perturbant.

Si je devais retenir une phrase de ce livre, ce serait "Assurez-vous que le logiciel fait ce que le client veut qu'il fasse", voilà une chose très importante que je commençais tout doucement à oublier. A chaque projet, une bonne dose d'analyse made in Jérôme et en avant le développement avec de beaux objets qui font ce que je demande... Oui mais et cette partie-là de l'application, est-ce que mon modèle pourra la supporter ?! Et ces décisions orientées objet, sont-elles les "meilleures" qui soient ?! Oui mais avec toutes ces questions, est-ce que le programme fait vraiment ce que le client a demandé ?!... Et qu'en est-il du futur ? Mon application va-t-elle survivre aux changements ?! Tant de questions qui pour la plupart restent sans réponse et pourtant c'est le quotidien du développeur ! Alors, si vous êtes toujours là et que vous désirez apprendre à concevoir (notez que je n'ai pas dit "développer") de bonnes applications, des applications qui font ce que les clients désirent :

• Tout en résistant aux changements ;
• Avec une bonne dose d'analyse ;
• Couplée avec un bon paquet de conception ;
• Et des principes Orientées Objets à mettre en oeuvre ;

Je ne peux que vous recommander ce livre ! Pensez à tout ces livres techniques que vous avez pu lire, un rien ennuyeux après quelques pages et très difficiles à digérer après une vingtaine... Combien de fois avez-vous abordé une partie technique dans un livre qu'au final vous n'avez pas compris du tout ? Dans "Analyse et Conception Orientées Objet - Tête la première", c'est la même chose... Sauf que le livre se pose lui-même vos questions après chaque partie délicate... Et si ça ne vous suffit pas, vous aurez des explications... Et encore des explications sous forme de définitions, questions/réponses, schémas, des illustrations, codes,... Sans compter sur des mises en scène de personnages tout au long de l'ouvrage pour nous aider à y voir plus clair.

Les projets qui vous sont proposés comme fils conducteurs du livre sont vraiment plaisants à suivre : on commence tout doucement avec un projet de gestion d'inventaire pour instruments, pour ensuite attaquer un système de trappe automatique pour chiens et finir avec un framework pour le développement de jeux sur plateaux. Tout au long de chacun de ces projets, vous participerez à des discussions avec les clients des projets, avec vos collègues analystes, programmeurs, architectes. Vous serez sans cesse mis à contribution afin de proposer vos propres idées et les comparer à celles du livre, le tout afin de mettre en oeuvre les principes abordés car c'est ça le but : comprendre facilement et intelligemment et non lire sans retenir.

Au final, je n'ai pu donner qu'une note maximale pour un ouvrage de la série "Téte la première" qui innove une fois de plus et qui est un plaisir à lire.

Je commence à être un familier des livres la tête la première, et je dois dire que ce nouvel opus ne déroge pas à la règle de qualité perçue dans mes autres lectures.

Si vous ne connaissez pas cette collection, le style risque de vous surprendre un peu...

Tout est fait pour que la lecture soit agréable, c'est un vrai livre d'apprentissage avec une méthode pédagogique originale.

De ce point de vue toute la collection tête la première est basée sur le même principe d'apprentissage :

Les auteurs utilisent beaucoup d'images, de graphiques, des jeux sous forme de mots croisés, ou de collages de vignettes, des interviews imaginaires avec les méthodes mise en ouvre, discussions et point de vue entre programmeurs imaginaires etc .., chaque chapitre se clôture par un bref résumé des connaissances acquises sous forme de billet ou de liste nommées « points d'impact ».

Le livre s'appui e sur des études de cas en Java, mais le public visé est beaucoup large et pourra s'adresser sans problème à une population de programmeurs pratiquant le C++ , le C++/CLI et le C#

Utilisant moi-même ces trois langages je n'ai eu aucun problème de compréhension avec les exemples de ce livre.

Les auteurs citent quelques fois comme référence le livre design pattern tête la première, il est vrai que si vous n'avez pas l'habitude des patterns la lecture de ce livre sera un plus pour comprendre et mieux apprécier la démarche d'analyse développée dans ce nouvel ouvrage.

Voila pour les remarques préliminaires.

J'en viens maintenant au sujet du livre l'analyse et la conception orientée objet, Etant moi-même concepteur d'applications dans le domaine de la gestion je suis très souvent au contact des clients à toutes les phases de développement analyse, conception, livraison et maintenance.

De prime abord, à la lecture on sent le vécu !, nombres de situations décrites sur la perception des exigences d'un client, l'écriture et la livraison d'un programme ainsi que son évolution m'ont tout de suite parlées tellement mon quotidien y ressemble!

Ce livre se concentre sur notre métier, sur la définition et la construction d'un bon logiciel qui doit satisfaire le client, s'en suit ensuite une réflexion sur le changement, tout change : les clients changent d'avis (sic) et le merveilleux programme qui a parfaitement fonctionné jusqu'ici, peut être amené à évoluer pour de nouvelles fonctionnalités pouvant remettre en cause l'existant.

Une bonne conception permettra une évolution agile, une mauvaise dans la douleur.

c'est le sujet de ce livre qui nous distille au fur et à mesure des chapitres des concepts et méthodes d'analyses et met en lumière quelques écueils classiques en conception objet.

Les cas d'études utilisés dans le livre peuvent sembler simplistes ou loufoques (gestion d'une trappe pour chien par exemple), et c'est tant mieux ! , les exemples sont très simples pour que le sujet parle à tout le monde.

Enfin la notation UML est utilisée de manière très simple pour représenter les diagrammes de classes, une brève initiation est proposée en annexe du livre et de fréquents rappels sont faits dans les différents chapitres, on trouvera même une antisèche UML très basique.

En conclusion :

Ce livre cible en priorité les débutants en conception objet, mais la partie analyse des besoins du client avec les méthodes proposées (basées sur les exigences, les cas d'utilisations etc) , les concepts et les conseils en architecture OO intéresseront aussi sans aucun doute le programmeur expérimenté souvent confronté au monde réel...

Pour ma part ce fut un réel plaisir de lire ce livre comme ce fut le cas avec les précédents de la même collection.

Cet ouvrage, en grand partie destiné aux débutants dans l'analyse et la conception orientées objet, met l'accent sur 2 grands thèmes : la méthodologie d'une part, et la conception / mise en oeuvre d'autre part.
A travers un style à la "Tête la première", une introduction progressive des différentes notions, et de nombreuses études de cas, le lecteur est guidé et mis dans les meilleures conditions pour apprendre à concevoir de bons logiciels qui répondront aux besoins de ses clients / utilisateurs.

Les études de cas et leurs exemples reposent en grande partie sur l'utilisation du langage Java, et il est donc recommandé de ne pas faire l'impasse dessus car tout l'intérêt de l'ouvrage sera perdu.
A l'inverse, les développeurs ou concepteurs Java trouveront dans ce livre un excellent complément en terme de méthodologie et ne regretterons pas l'investissement.

Bien qu'excellent d'un point de vue pédagogique et très instructif, il manque un zeste d'UML dans le livre, et certains développeurs / concepteurs aguerris pourraient rester sur leur faim.
Néanmoins, l'objectif est pleinement atteint et le livre reste très agréable à lire et ne peut qu'être bénéfique.

Retrouvez la critique complète ici.

Comment gérer un projet informatique ? N'importe quel développeur s'est inévitablement posé cette question un jour ou l'autre. La gestion de projets informatique, sujet vaste et complexe, est traitée avec pragmatisme dans cet ouvrage au titre concis. En effet, la structure de ce livre est particulièrement efficace : chaque étape essentielle d'un projet est analysée dans un chapitre qui lui est dédié.

Sans expérience professionnelle, c'est avec appréhension que j'ouvrais les premières pages de ce livre. Manque de connaissance, manque de recul, tant de facteurs qui pouvaient me faire passer à côté de l'essentiel.

Malgré cela, la lecture s'est avérée agréable, facilitée par les nombreuses définitions et explications concrètes des auteurs.

Voilà pour le point "personnel". En tant que développeur, le livre a parfaitement répondu à mes attentes, c'est une excellente introduction à la gestion de projets : expression des besoins, cycle de vie, qualité, droit juridique, gestion des finances, même le facteur humain est analysé (les auteurs donnent par exemple quelques conseils pour une bonne organisation de vos réunions de suivi de projet).

L'ouvrage reste modeste et ne s'enlise pas dans des sujets trop vastes qui alourdiraient la lecture, mais on peut remercier les auteurs d'avoir pertinemment préciser les références de nombreux livres qui satisferont les assoiffés de connaissance.

S'il faut trouver un défaut, ce sera sur la couverture. Couleurs peu attrayantes, textes mal présentés, l'apparence n'est définitivement pas représentative de l'excellent contenu de ce livre.

Moins de 300 pages pour expliquer comment manager un projet informatique, c'est la difficile mission de ce livre à l'intitulé surprenant d'imagination "Manager un projet informatique". Difficile car les étapes d'un projet sont nombreuses, leurs approches différentes, et ce ne sera sûrement pas le sujet de discussion majeur sur la plage cet été.

"Manager un projet informatique" est structuré très simplement : c'est un balayage de toutes les phases et informations relatives à la gestion d'un projet informatique. Le livre explique donc l'avant-projet, présente quelques cycles de vie (à vous de choisir celui qui convient le mieux au type d'exercice), les ressources documentaires et contractuelles, le suivi, les chiffrages (charges, risques, ROI, etc.), les aspects décisionnels, la sécurité, le droit, la qualité, l'intégration de progiciels, bien connue dans nos chères SSII, etc. Je pense avoir trouvé dans cet ouvrage toutes les phases que j'ai pu expérimenter dans les projets où je suis intervenu, expliquées très simplement mais aussi très précisément (attention ce n'est cependant pas exhaustif, et ce n'est pas le but, on peut par exemple trouver des oeuvres entières sur la méthode XP), je trouve que l'équilibre est parfait. Les illustrations sont claires, le contenu jamais ennuyeux à lire, la mise en page aérée, et quelques bonnes idées (sous la forme d'encarts "Conseil" et "Bon à savoir") viennent agrémenter le fil pédagogique. J'ai découvert aussi plus en détail ce qu'était la méthodologie Scrum, un exemple parmi les nombreuses informations du livre qui ont comblé mes lacunes.

Ce livre s'adresse donc aux chefs de projet en herbe, aux expérimentés qui désirent se mettre à jour, aux développeurs qui souhaitent mieux comprendre leur hiérarchie. Encore une fois, "Manager un projet informatique" est extrêment accessible, des contenus orientés "pratique" permettent une application directe à la réalité du travail (formules de ROI, tableaux de suivi, méthodes d'estimation des charges, etc.).

Vous l'aurez compris, j'ai adoré ce livre et je mets donc la note maximale pour ce qui constitue selon moi le meilleur moyen de comprendre comment gérer un projet de A à Z. Merci beaucoup aux auteurs pour ce petit OVNI !

J'ai hésité un moment avant de me procurer ce livre car j'avais peur qu'il ne me concerne pas suffisamment, moi, simple développeur. Et pourtant, à sa lecture, je me suis vite rendu qu'il m'aiderait à participer aux projets auxquels je suis attaché.
Au fur et à mesure que les mots défilent, le lecteur ressent l'expérience des auteurs par rapport à la gestion de projet et y retrouve le descriptif des siens, qu'ils soient de petits projets ou des grands. Le livre commence en effet par décrire la vie d'un projet, de l'idée qui émerge dans la tête de quelqu'un, jusqu'au déploiement et mise en production dudit projet. Peu à peu, il nous fait repérer les principaux points faibles d'un projet, ceux que l'on rencontre un jour où l'autre dans la vie de chef de projet et qui font, qu'à un moment donné, le projet prend soit du retard, soit est carrément mis en péril.

Le reste du livre est encore plus captivant, il reprend chaque étape en expliquant les intérêts de celle-ci, ses points forts et faibles, et les moyens de la mener à bien de la façon la plus réussie possible. Ce livre n'est pas la solution miracle pour réussir sans soucis tous vos projets mais il est pour sûr, la recette qui vous permettra de bien encadrer vos projets pour les réussir au mieux.

Ainsi donc, je conseille ce livre à toutes les personnes faisant partie d'un projet informatique, qu'elles soient MOE, MOA, chefs de projet ou simples développeurs car elles y trouveront beaucoup d'informations pour mieux comprendre le pourquoi des adaptations qu'on leur demande.

Tout sur le développement logiciel de Jean-François Pillou est un livre de poche de 240 pages que l'on peut emporter partout. De plus, pour moins de 10 euros, je n'ai pas pu m'empêcher d'aller voir ce qu'il valait réellement.

Tout d'abord, je pense que l'on peut faire confiance à la description du livre. Je me permets d'en extraire un passage :

"L'objectif de cet ouvrage est de permettre à tous de se former au développement logiciel, d'acquérir le vocabulaire et les compétences pour s'initier à n'importe quel langage de programmation, tout en ayant une vue d'ensemble des technologies et méthodologies actuelles."

Ce livre est accessible à tous et cible aussi bien les développeurs que les personnes extérieures à l'informatique. L'acquisition de vocabulaire est un des atouts majeurs de cette collection. Le terme complexe sont expliqués ce qui permet à n'importe qui d'étudier une technologie sans avoir à connaître le jargon du développeur. J'insisterais aussi sur le fait que ce livre reste assez généraliste et ne vous permet pas de vous spécialiser dans un langage en particulier.

Je parlerais plus d'un tour d'horizon du monde du développement car vous allez découvrir les fondamentaux (système binaire, algorithme, ...), les bases communes à tous les langages (variables, opérateurs, conditions, boucles, fonction, ...), les fonctionnements avancés (pointeurs, expressions régulières, surcharge de fonction, programmation orientée objets), la modélisation (UML, base de donnée) et plein d'autre chose comme SQL, XML, CVS, ...

Je conseillerais tout de même au débutant d'attaquer ce livre étape par étape afin de bien assimiler l'univers de la programmation. Prenez le temps de vous arrêter sur certaines notions de ce livre et de pratiquer le plus possible.

Moins de 200 pages, mais pas le plus facile à lire ;-).
Le francophone Richard Basque s'attaque à un exercice peu évident: démystifier CMMI (Capability Maturity Model Integration) et CMM en général. Ses explications, ses retours d'expérience emprunts de modestie sont très enrichissants. On comprend mieux les enjeux de ce que l'auteur présente comme un "compendium de bonnes pratiques" pour le développement de systèmes basés sur le logiciel.

Un chapitre complet détaille la terminologie utilisée dans les spécifications des "normes" CMM (CMMI, SW-CMM) du SEI (Software Engineering Institute) et permet de mieux assimiler les chapitres suivants. CMM se basant en partie sur la représentation "étagée" d'une organisation en matière de développement logiciel et de maîtrise des processus, chaque "étage" ou "niveau" est défini et détaillé dans un chapitre (domaines de processus, objectifs, pratiques, produits de sortie typiques, sous-pratiques...).

Si votre organisation souhaite développer une approche orientée CMM, le chaptitre 10 "Un cas concret" est fait pour vous, et pourrait pratiquement être lu en introduction (évaluation SCAMPI...).

Un ouvrage dans l'ensemble trés théorique et destiné aux décideurs, ingénieurs en qualité logicielle, et curieux des pratiques, méthodes et approches en matière de développement et d'intégration logicielle.

Les sites pour mieux comprendre CMMI:

• Le site du SEI (Software Engineering Institute)
• CMMI et SW-CMM
• Alcyonix

Lorsque que MDA (Model Driven Architecture) est apparu il y a quelques années, bon nombre de développeurs l'a considéré comme un acronyme dissimulant un niveau d'abstraction supplémentaire à la modélisation UML et apportant une complexité peu implémentable dans l'industrie logicielle. Mais voila, UML a évolué, les enjeux de la modélisation, les outils de conception en entreprise ont changé et l'approche MDA peut-être exploitée, même si la spécification reste floue sur une méthode claire et formelle d'utilisation.

Après la lecture du livre MDA en action, on comprend bien que, sans appliquer tous les concepts avec exactitude, on peut mettre en place une approche de pilotage des applications basée sur les modèles. Il en résulte une définition plus formelle de l'application, un processus de conception maitrisé et (c'est ce qui interesse les décideurs), davantage de productivité.

Xavier Blanc est Maître de conférence à l'Université Pierre et Marie Curie. Il enseigne les techniques de modélisation, et représente également le LIP6 à l'OMG. Sa contribution est notamment mesurable au sein du projet "IST ModelWare", destiné à améliorer l'interopérabilité des outils de modélisation.

L'auteur présente tout d'abord l'architecture MDA et les concepts qui y sont inhérents (modèles CIM, PIM, PSM, MOF, UML, XML). Ce premier chapitre est essentiel à la compréhension des autres chapitres qui amènent plus de profondeur au sujet. Le chapitre 2 "Modèles et niveaux méta" aborde les points les plus abstraits et les fondements de MDA. On apprécie d'ailleurs, bien que l'effort de lecture soit important, une certaine concision et recherche de la justesse des définitions, illustrés par des exemples. Ce chapitre étudiera donc les notions de modèle, méta-modèle, métaméta-modèle. Cette représentation des modèles est ensuite encrichie au chapitre 3 avec l'étude des méta-modèles d'UML2.0 (UML2.0 Superstructure et UML2.0 Infrastructure, profils UML), qui conjuguent la modélisation de la notation UML et de MOF. OCL et AS sont ensuite présentés succintement. J'aurais aimé un dossier plus complet sur le sujet, peut-être dans une version future du livre.

L'interopérabilité et la manipulation des modèles sont abordés aux chapitres 5 et 6, ou l'on étudiera le standard XMI et les frameworks JMI et EMF. Un exemple de transformation des modèles est donné à titre d'exemple ; même remarque, c'est concrètement l'un des éléments qui amène davantage de productivité à MDA en entreprise , et j'aurai apprécié une étude de cas professionnelle.

Bien entendu, l'un des grands intérêts de l'ouvrage est de consacrer 2 chapitres à MDA avec la plateforme J2EE et MDA avec la plate-forme PHP, illustrés d'exemples de mise en oeuvre, d'utilisation des Profils UML pour EJB et des transformations de PIM en PSM. Une étude de cas, certes légère puisque il s'agit du célèbre "PetStore" clos l'ouvrage. Il s'agit donc d'un bon livre, relativement théorique, qui pourra interesser les architectes et concepteurs d'applications, les chefs de projets et décideurs en quête d'informations sur l'élaboration de processus de développements.

L'ouvrage est packagé avec un CD-ROM contenant les outils pour MDA IBM Rational Software Modeler et Softeam MDA Modeler.

L'extreme programming (XP), plus qu'une méthodologie, est une approche globale, presque une religion.

Mener un projet grâce à l'XP relève plus du bon sens que du processus systématique: c'est ce que l'on appelle une méthode agile.

Les crédos de l'XP sont faire simple, coller aux besoins, et réagir au plus tôt en collaboration avec tous les intervenants d'un projet.

En suivant ces préceptes, vos projets devraient être menés à bien dans les délais et budgets prévus, et ce avec une qualité acceptable.

Au delà des aspects opérationnels, XP est aussi un moyen de créer de la valeur pour l'entreprise en assurant la cohésion des équipes et l'élévation du niveau global.

En résumé, XP apporte un regard neuf sur les cycles d'un projet logiciel.

L'ouvrage Extreme programming - précis et concis n'est pas une référence en la matière. Il se veut plus être un aide mémoire. Les concepts de l'XP y sont brièvement exposés et catalogués sans valeur ajoutée particulière pour qui connait déjà l'XP, et sans suffisamment d'exemples pour le néophyte.

En conclusion, il s'agit d'un ouvrage (trop ?) concis qui peut s'avérer utile mais pas indispensable pour tous les acteurs d'un projet informatique.

Que dire à part que mon impression est mitigée après avoir lu cet ouvrage.

L'eXtreme Programming n'est en rien comparable à tout autre processus de développement logiciel.
Pas de documentation ou très peu, un feedback permanent de la part de l'ensemble des acteurs actifs au sein du projet, travail en binôme, propriété intellectuelle du code,...

Ce qui me choque (je ne suis pas outré mais étonné) c'est que, si je suis la ligne de conduite de la démarche, tous les développeurs peuvent être amenés à développer ou modifier toute partie de code. Donc prenons l'exemple d'une application multi-tiers basée sur jsp, javascript, css, servlet, ejb,... les web designers ainsi que les spécialistes métiers doivent pouvoir maitriser l'ensemble des domaines d'expertises faisant partie de ce projet informatique. Je suis sceptique !!
A moins que je me trompe et cela est tout à fait possible.
Mais c'est la première réaction que j'ai après la lecture de ce condensé sur la méthode XP.

Je pense que je vais devoir approfondir mes recherches, pour confirmer ou infirmer mes dires.

Voilà la raison pour laquelle mon impression est mitigée.

Soit je me trompe et alors cet ouvrage est trop condensé que pour arriver à expliquer pleinement la démarche logicielle.
Soit ma première impression est la bonne, et je reste dubitatif sur le bien fondé de cette technique de développement.

Ce livre constitue une présentation de la méthode XP (eXtreme Programming). Bien que le titre du livre soit « gestion de projet », les thèmes récurrents de la gestion de projet classique (planification, gestion, suivi, pilotage ...) ne sont pas abordés. Il s'agit plutôt d'un ensemble de conseils et de bonnes pratiques coordonnées autour d'une méthode qui permet de faciliter la réussite d'un projet. En tous cas, c'est ce que ce livre se propose de vous démontrer.

Bien que relativement ancien (2002), ce livre est toujours d'actualité dans un monde où la gestion de projet classique semble atteindre ses limites. Les auteurs passent en revue toutes les pratiques d'XP en se focalisant dans un premier temps sur le développeur, qui est au centre de la réalisation d'un projet. Un fort accent est mis sur la programmation en binôme ainsi que sur le développement dirigé par les tests. Les valeurs d'une conception simple ainsi que le refactoring sont mises en avant.

Une deuxième partie se consacre à la présentation de l'adéquation de la méthode XP avec l'entreprise (culture d'entreprise, processus de qualité, ...). Enfin, les auteurs présentent des études de cas concrets où des projets ont suivi avec succès (et déboires) la méthode XP.

Tout au long de la lecture de cet ouvrage, on est transporté au cour de cette méthode. L'envie d'appliquer les préceptes d' XP se fait grandissante au fur que l'on tourne les pages. Ce livre détaille non seulement les différents concepts de la méthode mais permet aussi d'obtenir des arguments très précieux lorsqu'il s'agit de convaincre un public (responsables, membres de la future équipe) des bienfaits de la méthode.

Très agréable à lire et bien écrit, je recommande vivement ce livre aux personnes désireuses d'en apprendre plus sur la méthode XP. On notera quand même un manque d'illustrations, même si l'organisation synoptique des paragraphes facilite son appréhension.

Un ouvrage très bien organisé, alliant théorie et cas concret, qui devrait convenir à n'importe quel profil.
Le guide de lecture en début de livre est extrêmement appréciable et saura vous guider si vous souhaitez aller à l'essentiel.

Ce livre décrit très bien les valeurs et concepts de l'XP et les illustre de fort belle manière.
Vous y trouverez toutes les réponses à vos questions, et bien plus, des acteurs aux pratiques, en passant par les aspects contractuels.

Les études de cas en fin d'ouvrage sont très précieuses et permettent de se voir matérialiser sur des cas concret une large partie de ce qui a été introduit tout au long du livre.

Un véritable livre de chevet qui saura vous accompagner dans votre quête des pratiques Agiles.

Retrouvez la critique complète ici.

L'auteur souhaite guider le lecteur, déjà habitué aux méthodes traditionnelles de gestion de projet, vers l'utilisation des méthodes agiles. Vaste ambition.

On commence par un sommaire qui annonce une didactique plutôt encourageante. Cependant, on déchante assez rapidement pour se retrouver avec un livre somme toute classique, quoique bien écrit. Certains outils de gestion de projet classique y sont plutôt bien décrits (planification, suivi, pilotage, gestion des ressources ...) mais le lecteur déjà familiarisé avec les méthodes traditionnelles de gestion de projet connaît normalement déjà tout ca. On retrouve de temps en temps un petit pont pour se lancer dans les méthodes agiles, mais à mon avis, les accents n'y sont pas assez pragmatiques.

On appréciera tout de même les nombreuses interventions d'experts en méthodes agiles (coach xp, ScrumMaster, ...) qui viennent ponctuer les propos de l'auteur.

Ayant lu ce livre en étant déjà convaincu par les méthodes agiles, peut-être n'y ai-je pas vu assez d'enthousiasme pour ces méthodes, mais il est vrai qu'une migration doit se faire en douceur avec des chefs de projets peu enthousiastes ou des directions réfractaires.

Je reste sur une impression plutôt mitigée car je m'attendais à ce que cet ouvrage contienne plus de conseils pratiques.

Ciblant plutôt une population de chefs de projets, managers, clients ou experts métiers, décideurs, cet ouvrage se propose de faire découvrir les méthodes agiles en partant de constats faits sur les méthodes appelées traditionnelles.
Saupoudré par des interventions de professionnels reconnus du monde agile, l'ouvrage propose un guide méthodologique autour de la mise en oeuvre de projets agiles allant du recueil de besoins jusqu'à la gestion contractuelle et la gestion du changement.

C'est une gestion de projet moderne qui nous est proposée, redonnant un rôle plus humain au chef de projet qui devient un "facilitateur", centré sur une collaboration, une autonomie des intervenants et une responsabilité collective.
Les différents courant de pensée agile sont présentés, notamment Scrum, XP et UP, avec un focus progressif sur la méthode Scrum (l'auteur étant ScrumMaster et membre d'une organisation mettant en oeuvre cette méthode).
L'auteur n'oublie cependant pas de présenter de nombreux concepts agiles, la plupart du temps communs aux différentes méthodes agiles, notamment les techniques d'estimation ou les indicateurs (avancement, coût, etc.), ou encore le suivi des risques.

Scrum étant centré sur les process et les hommes, l'absence de description d'un outillage (qui peut sans doute manquer à un lectorat plus technique) s'explique assez aisément.
La présence de ces fréquentes interventions d'experts permet de conserver une portée plus globale, donnant même l'opportunité au lecteur de comparer les différentes pratiques sans que la comparaison n'ait à se matérialiser par un tableau comparatif.

Je ne sais pas si l'absence de tout nom de méthodologie agile dans le descriptif de l'ouvrage est volontaire, mais tout du moins Scrum aurait mérité de figurer de manière plus explicite sur la couverture ou le sommaire.
Cet ouvrage introduit la gestion de projet agile de manière progressive et sur un ton pédagogique, fournissant un guide de découverte très intéressant aux non initiés. Les connaisseurs de pratiques agiles y trouveront sans doute des compléments sans passer par une lecture linéaire mais en veillant à lire le premier chapitre.
Ces 230 pages, saupoudrées par des interventions régulières et appréciables d'expert dans les méthodes agiles, constitue un condensé d'informations et un tout permettant de s'initier à la gestion de projet agile. Le lecteur pourra de plus revenir régulièrement sur l'ouvrage dans sa mise en pratique des méthodes agiles.

Partant du constat que seul un faible pourcentage des projets informatiques sont de véritables réussites, de nouvelles méthodologies projet ont vu le jour pour pallier les manques et améliorer les méthodes dites traditionnelles. "Gestion de projet : vers les méthodes agiles" a donc pour vocation principale la synthèse des principales méthodes agiles utilisées actuellement (Scrum, XP...), présentées au travers de toutes les étapes qui constituent un projet informatique.

L'auteur commence par dresser le portait-type du chef de projet (à qui s'adresse principalement ce livre), et liste les composantes d'un projet (besoins, développements, rôles...). Vient ensuite une définition des méthodes agiles et une comparaison avec les méthodes traditionnelles, puis l'application dans le monde concret de la gestion projet.

Véronique Messager Rota fait donc naviguer le lecteur sur les différentes étapes d'un projet informatique en expliquant les pratiques agiles à mettre en place pour gérer, entre autres, son équipe, le client, le planning, les ressources, autrement dit : l'avant, le pendant et l'après-projet. Tout au long de ces étapes on lira les témoignages, sous la forme d'interviews, d'acteurs et d'utilisateurs reconnus de ces méthodes, expliquant leur retour d'expérience sur des questions précises de la vie d'un projet. Côté logiciel, quelques pages en fin d'ouvrage listent les outils incontournables (payant ou gratuit) pour la gestion d'un projet, une bonne base pour se jeter dans le grand bain.

Au final, ce livre est un bon compagnon pour introduire les concepts agiles (même si on sent (trop ?) la partie prenante de l'auteur pour Scrum), pour connaître les erreurs à éviter ainsi que les implications humaines et techniques qu'il faut absolument considérer. C'est cependant un livre un peu court (232 pages) qui reste une introduction et qui parfois enfonce des portes ouvertes en expliquant que le bon sens et la pratique sont nécessaires au succès d'un projet. La lecture est aisée car l'ouvrage est vraiment très proche de la réalité. Et même si le sujet s'adresse principalement aux chefs de projet (ou futurs chefs de projet) à convertir, le développeur trouvera également matière à satisfaire sa curiosité dans le domaine.

Un projet d'urbanisation d'un système d'information (S.I) est une tâche complexe. Trouver une adhésion de tous les membres de l'organisation n'est pas aisé, mais cela fait partie du jeu: vous devez montrer les besoins réels d'une urbanisation, les lacunes du système existant, et ainsi construire un dialogue impliqué et aboutissant sur un projet de bénéfice global pour l'entreprise.
C'est cette démarche méthodologique que Christophe Longépé vous propose. Il explique de quelle manière on peu structurer un tel projet, d'un point de vue de l'organisation et de planification de l'implémentation.

Le livre est bien structuré, la terminologie utilisée est claire et expliquée. Sans entrer dans une critique de fond que ne peux objectivement fournir, les différents chapitres m'ont appris un certain nombre de choses: par ou doit-on commencer ? qui doit travailler sur un projet d'urbanisation ? quel dialogue doit on avoir ? quelles étapes faut-il respecter ?. On comprendra donc davantage les objectifs de l'urbanisme, son périmètre et son intérêt pour les différents composants d'une entreprise, ou encore comment procéder à une cartographie efficace de l'existant, quelles bonnes pratiques sont à adopter afin de maitriser les processus métier et de trouver une convergence avec la stratégie et l'architecture déja mise en place.

Cette seconde édition mérite beaucoup d'attention. Sans y trouver une "Bible", vous y puiserez certainement de riches idées et des explications de qualité. Je conseille cet ouvrage aux (futurs?) urbanistes, architectes, DSI, chef de pojets, ingènieurs qualité.

Consulter la critique et le descriptif complet...

Trés interessé et investi dans la conduite de projet d'urbanisation du S.I, j'ai entamé une recherche bibliographique sur le sujet (cf. Le Projet d'urbanisation du S.I. de Christophe Longépé). Dunod m'a donc fait parvenir se livre, "Urbanisation et BPM", que j'ai dévoré.

J'y ai retrouvé la plupart des fondamentaux sur le sujet, et des discussions sur les problématiques que je peux observer professionnellement sur des initiatives de "refonte" du S.I. On y redécouvre un descriptif souvent oublié des qualités attendues d'un S.I et de son cycle de vie (amenant l'anti pattern d'informatique "spaghetti").

Yves Caseau, s'appuyant sur sa trés forte expérience et sur du bon sens, définit les enjeux de la démarche d'urbanisation, et de l'importance de son alignement stratégique, bien loin du simple projet de migration technologique. Des remarques pertinentes sont notamment faites sur les modèles métier, les modèles des processus, le génie logiciel et la distribution d'applications, de la compatibilité des composants fonctionnels, du découplage temporel ou encore des différentes formes de bus d'échange.

Le chapitre 6 interessera le DSI et la direction en général, en abordant l'essentiel ROI (Retour sur investissement) de l'urbanisation et les risques de ce type de projet. J'ai beaucoup apprécié la lecture des chapitres 7, 8 (BAM, SLA), et le chapitre 9 dédié à l'architecture des données (différent de la modélisation des données), discipline fondamentale et souvent ignorée (SPT : Single Point of Truth, FMC, re-synchronisation, QoS : qualité de service, principe du rasoir d'Occam).

En conclusion, un ouvrage signé Yves Caseau que je conseille à tout bon DSI, architectes, mais plus que jamais aux DG qui y trouveront certaines remarques et rappels indispensables pour comprendre l'importance d'un projet d'urbanisation, de son alignement stratégique, et de l'investissement nécessaire d'une entreprise dans son ensemble.

A l'heure où SAP entend répondre à la demande cliente par le biais du modèle ESA, je me devais de me procurer Urbanisation et BPM afin de vous exposer ma modeste critique. En effet, l'ouverture des progiciels intégrés est aujourd'hui une opportunité pour toute entreprise. Elle permet aux éditeurs spécialisés d'étendre leur marché et aux grands comptes, de mieux gérer leur infrastructure.

Dans cet ouvrage, Yves Caseau nous livre les recettes pour nous puissions, selon notre position, lutter contre une informatique dîte "Spaghetti". Il nous offre la clé d'une urbanisation des SI réussie. Nous pourrons ainsi, si ce n'est déjà le cas, prendre conscience des contraintes économiques, stratégiques et technologiques de l'entreprise. Des principes qui selon moi doivent être assimilés pour identifier un ensemble de problématiques auxquelles nous devons faire face quotidiennement. Ouvrir les yeux en comprenant le pourquoi du offshore et du dictat d'un ROI nous permet de nous positionner au sein de l'entreprise. Pourquoi dois-je subir ou établir un tel positionnement stratégique ?

Par la pluralité des approches, l'auteur s'adresse à tous. Il "démystifie" des concepts dont nous entendons parler chaque jours comme SOA ou EAI. Il nous confronte aux réalités. Il nous aide à cerner ce qui se cache derrière des slogans marketing tels que le "on-demand" d'IBM. En bref, un livre à lire impérativement.

Cet ouvrage dédié au management par les processus vise un public large et hétérogène. Toutefois il ne s'agit pas d'un ouvrage « de plus » aux objectifs si larges que le travers du manque de concret ne serait pas évité.

Au-delà de la notion de processus, de nombreux concepts y sont traités : différences et liens entre visions métier, S.I et informatique, méta modèle, découpage de processus, représentation à l'aide de langages et similitudes langages/méta modèle, évaluation, amélioration etc.
Le découpage de l'ouvrage est clair et progressif. Chaque phrase est porteuse de sens. Chaque notion présentée de façon précise est illustrée par des exemples amenant le lecteur à ne jamais sentir un concept lui échapper. Ainsi, la présentation des notions de processus vues sous les angles métier, SI et informatique permettra aux différents acteurs de comprendre les points de vues respectifs de leurs interlocuteurs.

Les chapitres 1 à 3 introduisent les éléments nécessaires à la communication entre MOA, DSI, consultants, architectes, urbanistes, et direction d'entreprise dont le rôle clef est mis en avant.
Le chapitre 4 apporte une vision claire de l'évaluation des processus d'entreprise, de leur amélioration continue et de l'apport de l'approche processus à la stratégie d'entreprise. Les objectifs des modèles de maturité et des approches qualité: CMMI, ITIL, COBit y sont également présentés.
Les chapitres 5, 6 et 7 précisent les notions de processus et mettent en regard les possibilités offertes par différents langages de modélisation (UML, MERISE, IDEF0, OSSAD). Une illustration par des cas concrets fait apparaître les relations étroites entre ces langages et apporte la réponse à l'une des questions phares d'UML : comment modéliser à l'aide d'un langage alors même que celui-ci n'est pas inclus dans une « méthode ».
Le dernier chapitre démontre le support offert par les principaux outils de modélisation du marché à la modélisation des processus.
On notera enfin la présence de deux annexes et de plusieurs documents supplémentaires téléchargeables sur le site de l'éditeur qui permettra d'approfondir les points clefs de l'ouvrage.

En conclusion, il s'agit d'un livre précieux pour tous les acteurs des systèmes d'information, à lire au moins deux fois pour en tirer tous les secrets.

Mon troisième ouvrage sur le sujet chez Dunod, après Urbanisation et BPM de Yves Caseau et Le Projet d'urbanisation du S.I. de Christophe Longépé. Les deux premiers étaient plus attachés à la notion d'urbanisation, mais ont introduit inévitablement l'approche par processus. Ce nouvel ouvrage traite davantage des processus métiers et de l'approche qualité.

Les 4 co-auteurs rappellent quelles grandes théories ont été exprimées depuis près de un siècle, sur l'amélioration de la qualité, sur l'organisation du travail et sur l'approche orientée processus. On y retrouve les anciennes doctrines comme le JAT (juste-à-temps), la qualité totale, fr les kanban, le reengineering de processus, et les normes plus récentes comme ISO 9000:2000. Une large bibliographie est ainsi proposée sur le sujet, et dessine le point de convergence entre l'approche processus et la définition d'un système d'information. Comment analyse t-on un S.I ? à partir d'un évènement (H.Chelli)? à partir des objectifs stratégiques (C.Longépé) ?. Peut-on les (le S.I. et les processus) modéliser de manière standardisée ?. Vous trouverez de nombreuses directions qui vous aideront à créer votre méthode d'analyse agile pour votre architecture de système d'information.

Le chapitre 3 propose une définition du processus et les variantes communes d'interprétation, ainsi qu'une typologie des processus pour l'Organisation. Le chapitre 4 est lui destiné à la prise de conscience d'un "cycle de vie" des processus. Si il est inévitable de les modéliser à l'étape 0, il est indispensable de les évaluer continuellement et de les améliorer. Leur maitrise temporelle est indispensable tout comme la maitrise de la gestion du changement.

La seconde partie de l'ouvrage est consacré à la modélisation des processus. Un métamodèle est judicieusemnt présenté et sert de référentiel de modélisation. Un modèle de processus comporte également certains types d'entités qui sont décrits : les activités, les acteurs, les rôles, les transitions, les tâches, les événements, les résultats, les entrées, les ressources. Cette terminologie est la base des différents notations qui sont ensuite détaillées au Chapitre 6. Les auteurs expliquent de quelles façons la modélisation des processus à été implémentée par différents méthodes, comme le célèbre IDEF0 (SADT), OSSAD, UML, ou encore Merise. Enfin, la dernière partie contient un cas d'étude pratique (le cas Logitic) qui applique les méthodes évoquées dans chapitres précédents, et un chapitre de présentation d'outil de modélisation : fr PowerAMC, Clarify, en Oracle Workflow.

Si ce dernier chapitre n'est pas apparu indispensable, je dois dire que les aspects historiques et plus larges (étendus à l'industrie) des 4 premiers chapitres m'a beaucoup interessé. Vous y releverez sans doute comme moi des références bibliographiques de référence. Il est également interessant de lire (à nouveau) la terminologie standardisée (ou au moins consensuelle) de la modélisation des processus et les manières dont différents méthodes l'ont implémentées, avec plus ou moins de succès.

Poste à haut risque et siège éjectable, la fonction de DSI réapparaît sur les devants de la scène. Impossible aujourd'hui de parcourir une revue spécialisée sans remarquer un article identifiant leurs préoccupations. En effet, du fait de la nécessité pour tous d'hurbaniser les infrastructures, de coordonner le déploiement, d'optimiser la production informatique, de gérer les relations fournisseurs/clients et plus encore, la position de DSI se voit revaloriser.

Dans ce contexte, les auteurs exposent 21 études de cas ayant pour trait commun, les préoccupations de ces hommes au pouvoir décisionnel. Ils définissent des scénari bien réels et posent les jalons d'une réflexion que devra mener le lecteur tout au long de ce livre. Tâche difficile si l'on souhaite se prendre au jeu. Doit-on ou non externaliser le système d'information ? Comment y procéder et en mesurer le ratio gains/risques ? Comment établir des indicateurs clé ou encore gérer la communication intra-entreprise lors de phases délicates ?

A mon sens, tout comme l'éditeur l'indique, ce livre s'adresse avant tout aux "DSI actuels et futurs". J'imagine qu'il sera aussi une réelle source d'informations pour ceux qui ne le sont pas. En revanche, je déplore une certaine légèreté des notes d'accompagnement, qui combinées à davantage de théorie, auraient offert un formidable outil pédagogique.

ITIL est un sujet d'actualité, et est de plus en plus demandé par les sociétés.
Cet ouvrage permet aux non initiés de découvrir ses bases et son écosystème, pour les connaisseurs, cela reste un référenciel.
Avec une structure simple mais néanmoins efficace, les auteurs expliquent points par points les différentes notions d'ITIL.
A l'aide de nombreux schémas et beaucoup de "redondance" (ce qui est normal), le lecteur est guidé de la théorie à la pratique, avec de nombreuses études de cas.
Bien que le livre ne contienne "que" 300 pages, il reste très complet et il faudra l'ouvrir plus d'une fois soit pour bien comprendre les notions soit pour se rafraichir la mémoire.
En un résumé, si vous souhaitez aborder ITIL, n'hésitez pas, c'est le livre qu'il vous faut...

Très à la mode actuellement, j'ai voulu en savoir plus sur ITIL. Pour rappel, ITIL est un référentiel de bonnes pratiques pour la gestion d'un système d'information, un choix à faire parmi tant d'autres qui existent comme COBIT, CMMI, PMI...un choix que ce livre vous permettra sûrement d'éclairer.

Après une préface du directeur informatique de France 3 expliquant très bien la nécessité d'utiliser un tel référentiel de bonnes pratiques, l'ouvrage présente globalement ce qu'est ITIL et traite ensuite principalement de la gestion par les services au travers des points suivants (qui ne sont pas les seuls dans les bonnes pratiques d'ITIL) :

1. Le centre de services
2. La gestion des incidents
3. La gestion des problèmes
4. La gestion des changements
5. La gestion des mises en production
6. La gestion des configurations

J'ai trouvé la structure du livre idéale puisqu'une définition précise de chaque notion est faite en début de chapitre, une explication pour les nuls utilisant une situation de la vie réelle permet de faire un parallèle, le tout agrémenté de schémas aérés facilitant la compréhension dans la navigation des processus présentés. J'ai également apprécié les cas pratiques pour mettre en oeuvre ITIL (la théorie des priorités par exemple, c'est bien mais savoir comment les définir, c'est mieux) directement applicables dans le monde réel. La mise en page est très agréable, aérée, et les auteurs ne manquent pas d'humour (j'avais quelques préjugés au début quant au fait de traiter ce sujet de manière attrayante).

Je repprocherai juste quelques textes copiés/collés d'un chapitre à un autre (notamment les explications des traitements réactifs et proactifs) mais néanmoins cela permet de mieux le graver en mémoire mais vous l'aurez compris, si vous voulez découvrir ce qu'est ITIL je vous recommande vivement de lire ce livre !!!

La méthode ITIL fait aujourd'hui référence au sein des DSI par rapport à sa légèreté de mise en ouvre et surtout par le découpage des actions à entreprendre permettant une application rapide bien que fondamentale aux SI existants.

Ce livre révèle son intérêt dès lors qu'il est considéré comme un ensemble de bonnes pratiques et non comme un objectif à atteindre. Cependant, un certain nombre de points sont abordés au niveau processus (gestion des incidents, des problèmes, du changement, de la production et des configurations) avec comme fil rouge d'ITIL, l'amélioration continue des SI tout en conservant un degré de qualité adéquat. La maîtrise des couts n'est toutefois pas mise de côté et plusieurs exemples de mises en place chiffrées parsèment l'ouvre.

La mise à jour de la méthode ITIL v3 est détaillée, celle-ci se résume néanmoins à une simplicité d'application accrue (notamment pour permettre l'externalisation des services) ainsi que qu'une meilleure intégration de la méthode par les PME. Concernant les certifications, celles-ci ne semblent pas l'objectif de ce livre puisqu'autant pour ITIL que pour la norme ISO 20000, seulement deux chapitres d'entrainement sont proposés.

Pour résumer, cet ouvrage s'inscrit clairement dans les problématiques actuelles des systèmes d'information et télécom. Il permettra de simplement s'initier ou d'appliquer en profondeur la méthode ITIL en maitrisant les points clés généralement transverses des processus d'entreprise. Cette pratique est abordée graduellement et les responsables SI, qualité, managers et chefs de projet souhaitant déclencher des démarches progressives au sein de leur organisation, y trouveront nombre d'informations pour les guider.

Cette critique se rapporte à la seconde édition.

Parmi la floraison des méthodes, approches autour de l'activité informatique (ITIL, CMMi, COBIT, SPICE, ISO), ITIL m'a séduit par la légereté de son application. En effet ITIL (Information Technology Infrastructure Library) est organisé en "livres", c'est à dire des référentiels de bonnes pratiques pour la gouvernance du S.I.

Christian Dumont détaille donc les différents concepts d'ITIL et les différentes facettes de son application pour un service informatique "optimal". Avant toute chose, il rappelle les principales motivations d'ITIL, et les réponses que se support propose. Vous apprendrez également comment se déroule une certification ITIL et les différents degrés de reconnaissance.

Tous les processus préconisés par ITIL (gestion des configurations, centre de services, gestion des incidents, gestion des problèmes, gestion des changements, gestion des mises en production, gestion des niveaux de service, gestion de la capacité, gestion financière des S.I, gestion de la disponibilité, gestion de la continuité de service, gestion de la sécurité, gestion de l'infrastructure TIC), sont ensuite approfondis, et de nombreux conseils sont donnés. Inutile par exemple de tenter l'implémentation de tous les processus sans passer par la phase logique de conception d'une CMDB ! (Configuration Management DataBase).

Un certain nombre de recommandations sont fournies, notamment sur la mesure du RSI (Retour Sur Investissement, ou ROI) lors de la mise en place d'un processus ITIL particulier, ou encore les surcoûts générés par cette mise en place. Enfin une étude de cas est réalisée pour illustrer d'un point de vue plus concret un projet ITIL.

J'ai apprécié la lecture de ce livre, qui comporte parfois certaines longueurs, même si l'auteur a fait l'effort de structurer l'ouvrage de manière trés pratique. Je conseille ce livre à tous les DSI, ingénieurs qualité et chefs de projet.

Présenté pour un public de décideurs, je recommanderai ce livre pour un public technique de type chef de projet ou architecte MOE ayant déjà eu un conctact avec la modélisation des SI. Le livre se compose de trois parties : une première pour faire les rappels, la seconde pour la présentation de la SOA, la dernière pour les aspects purement techniques.

Dans la première partie les concepts de l'urbanisation des SI, la représentation d'un SI sont bien présentés et montrent l'évolution des pensées sur le sujet. Dans la seconde partie certains aspects de la SOA sont présentés d'une manière claire mais tellement simpliste que la mise en pratique sur un cas réel ne s'avère pas aussi simple, et que par conséquent on a le sentiment que les objectifs attendus ne sont pas atteints. La troisième partie traite quasi exclusivement de mise ouvre technique. C'est cette partie qui m'a surprise car elle se détache des deux autres parties par sa grande technicité.

J'apprécie grandement les livres qui démocratisent les concepts informatiques parfois nébuleux mais je conseillerai plus ce livre pour un public coté MOE que MOA.

Ce livre est un guide complet pour la compréhension et l'établissement d'une solution SOA en entreprise.

A travers cet ouvrage, les auteurs décrivent précisément ce que représente le terme SOA et ce qu'il ne représente pas. En début de livre, on trouve une présentation très claire de l'architecture SOA ; les auteurs ne s'arrêtent pas là et fournissent ensuite toutes les clés d'une démarche SOA.

A chaque début de chapitre, on retrouvera les objectifs clairement exprimés et, en fin de chapitre, un résumé avec une synoptique qui rend ceux-ci faciles à appréhender. Cette présentation constitue un point très positif du livre.

Cependant, le style des auteurs n'est pas toujours évident, certaines parties sont très claires et dans d'autres on est noyé sous les sigles. Il est vrai que c'est un exercice difficile dans la mesure où ces derniers sont omniprésents dans ce domaine.

J'ai quand même trouvé cet ouvrage très complet, les auteurs abordent bien toutes les facettes d'une démarche SOA. On regrettera que le cas d'école qui sert de fil rouge ne soit pas abordé suffisamment en profondeur.

Par contre, on appréciera avec intérêt le chapitre où les auteurs présentent le modèle MVC revu pour SOA, étant donné la présence de ce pattern dans les frameworks d'entreprise. La partie sur les bus de service (ESB) est également bienvenue. C'est en général un domaine où il n'est pas toujours facile d'obtenir des informations. Le chapitre présentant les solutions SOA du marché est également intéressant pour décortiquer les éléments pertinents à travers les enveloppes marketing.

Destiné à un public d'architectes, de MOA ou MOE, le développeur pourra ne pas trouver d'intérêt à l'ensemble du livre. Je le recommande à toute personne intéressé par les architectures SOA et plus précisément les architectes ou urbanistes devant la mettre en oeuvre.

Cette critique se rapporte à la première édition de ce livre.

SOA, c'est très loin d'Harry Potter ou du Seigneur des anneaux. Et pourtant "SOA, le Guide de l'architecture" se lit comme un roman.
Mais SOA c'est avant tout un ensemble de concepts dont tout le monde parle mais qui n'est pas clair pour tous. Ce livre a le mérite de répondre aux questions que l'on peut se poser et de clarifier les concepts liés à l'architecture orientée services.

Au travers de ces 300 pages, nous découvrons tout d'abord comment le monde de l'entreprise s'y prend pour gérer ses données sans l'utilisation des architectures orientées services. Ainsi, en lisant ces premières pages, pour peu que l'on ait déjà rencontré la problématique des données dispersées, nous n'apprenons rien de bien nouveau. Mais elles permettent de se replacer dans le contexte de l'entreprise et de s'imprégner des problématiques rencontrées dans ce cadre.

Ensuite, passage aux choses sérieuses... Le livre présente les concepts de ce type d'architecture et pour cela, quoi de mieux qu'un exemple concret pour comprendre ces principes ?
Tous les intervenants, qu'ils soient humains ou techniques, sont présentés. Ainsi, tout au long du livre, nous avançons progressivement vers la solution idéale en implémentant petit à petit la solution répondant à des besoins concrets.

L'exemple aurait cependant pu aller un peu plus loin, mais ce manque n'a pas d'impact ni sur la compréhension, ni la qualité du livre.

On notera également la qualité globale de l'ouvrage : du papier et une couverture d'une solidité inégalable.
Avec une mise en page telle que celle là, la lecture s'avère d'autant plus aisée.

Cette critique se rapporte à la première édition de ce livre.

SOA cuisiné à toutes les sauces, je voulais en savoir plus sur ce qui se cachait derrière ce mystérieux acronyme et je souhaitais de "SOA, le guide de l'architecte" toutes les réponses à mes interrogations.

Après un historique des modèles du passé, une présentation des besoins des SI actuels (exemple:indicateurs de rentabilité), les différents concepts de SOA sont dépeints pour présenter les caractéristiques d'une architecture orientée service. A ce moment de la lecture, ce modèle m'est devenu moins étranger, et j'ai apprécié les explications sur ce qu'est réellement SOA et sur ce qu'il n'est pas, ainsi que les idées reçues existantes autour de ce modèle. Le livre montre ensuite les méthodes pour appliquer SOA, les documents nécessaires à produire au sein d'une équipe projet, les acteurs, les interactions entre tous ces éléments. Un exemple concret basé sur une entreprise fictive fournissant des accès au gaz permettra de mieux comprendre et d'appliquer SOA à des cas concrets que nous rencontrons au quotidien (du moins sur nos projets informatique). L'ouvrage présente également les outils, les implémentations et les acteurs du monde logiciel oeuvrant pour la maturité et l'unification de SOA.

C'est ma seconde lecture provenant de chez Dunod et j'apprécie beaucoup la mise en page très claire (encadré gris pour les résumés, schémas aérés...), elle facilite grandement la lecture. Globalement, je dois dire que je n'ai pas été déçu et que j'ai trouvé dans ce livre ce que j'attendais au départ, je reprocherai cependant aux auteurs de ne pas avoir poussé l'explication des cas pratiques plus loin car même après la lecture des chapitres dédiés le syndrôme de la page blanche sera sûrement inévitable. Quelques fautes d'orthographe se sont également glissées, mais trois où quatre, c'est insignifiant. J'ai apprécié également la franchise des auteurs expliquant que l'on ne claque pas des doigts pour mettre en oeuvre ce modèle est également gageure d'honnêteté. Je conseille donc vivement d'acheter ce livre très complet pour comprendre SOA dans son ensemble.

Tout bonnement excellent !! Un livre à posséder, à lire et à relire. « Tout sur les systèmes d'information » est un livre simple et complet. Il vous apprend énormément de choses sur le Système d'Information (SI).

Jean-François Pillou vous apporte des années d'expériences et de connaissance avec une simplicité remarquable. Il a réussi à s'adapter à un public novice, tout en couvrant de nombreux domaines plus ou moins complexe. Découvrir les fondements d'un SI en détails et en toutes simplicité, c'est le résultat de ce livre de poche.

Des notions de e-entreprise à la gestion de projet, en passant par la sécurité, la qualité, le réseau, les technologies pour l'entreprise, vous trouverez tous pour comprendre votre SI.

Des centaines de termes professionnels sont expliqués simplement et des schémas simples permettent d'apprivoiser rapidement des notions complexes. Cette encyclopédie de poche s'adresse à tous, informaticiens ou non, professionnels ou étudiant ...

Avec un prix si petit, je vous déconseille de vous en passer.

Le sujet ne fait pas légion en littérature française, et pour cause, le concept de PCA (Plan de Continuité d'Activité) reste une idée jeune pour l'entrepreunariat hexagonal. Elle l'est moins pour les anglo-saxons et l'industrie américaine, du sans doute aux catastrophes en série qui on eu lieues ces dernière années (Terrorisme, catastrophes naturelles, accidents écologiques). Une première partie de l'ouvrage s'appuie sur un certains nombre d'études (Eagle Rock Alliance, CLUSIF, Ernst and Young, BCI, OCDE) relatives à l'impact de sinistres, à l'interruption de SI et aux seuils de tolérance. Puis, Matthieu Bennasar énumère quelques exemples de réglementations et normes qui existent sur le sujet dans divers mileux industriels et financiers (Bâle II, CRBF-2004-02, le trés à la mode Sarbanes-Oxley Act, ISO/TS, TL9000, Good practices Guidelines du BCI). Enfin il redéfinit clairement le vocable utilisé et les nuances entre PCA (BCP), PGC (CMP), PRA (IT Contingency Plan), PCO, et Risk Management. Ces 3 premières parties sont vraiment trés intéressantes et doivent faire partie de votre bagage culturel. La seconde partie s'attache à décrire les méthodes et outils de la continuité d'activité et fourni les clés pour bien piloter la mise en oeuvre et le cycle de vie d'un PCA. J'ai particulièrement apprécié la lecture des chapitres 4 et 5 ou de nombreux éléments concrets sont donnés, comme les avantages/inconvénients des solutions de secours du SI (Cold Sites, Warm Sites, Hot Sites, Mirrored Sites, Mobile Sites), les enjeux des modes de disponibilité et de tolérance aux sinistres, les stratégies de sauvegarde et de restauration des données (RAID, Electronic Vaulting, Remote Journaling, Shadowing, Mirroring, Virtualisation du stockage : SAN, NAS, DAS). Le livre est trés bien écrit, le plan est clair, pas évident sur ce type de sujet. Si vous êtes en charge d'un projet orienté BCM/PCA, directeur informatique, ingénieur qualité, ce livre est fait pour vous !.

Un excellent ouvrage qui présente 23 modèles de conception courants. Pour en apprécier pleinement le contenu il est nécessaire que le lecteur/développeur maîtrise au moins un langage OO et est une réelle maturité dans la pratique de la POO.

Chaque modèle de conception est présenté de la façon suivante :

• Nom de modèle et classification
• Intention
• Alias
• Motivation
• indications d'utilisation
• Structure (représentation graphique : notation OMT, diagramme d'interaction)
• Constituants
• Collaborations (comment les constituants collaborent-ils pour assumer leurs responsabilités?)
• Conséquences
• Implémentation
• Exemples de code (C++ et/ou Smalltalk)
• Utilisations remarquables (présentation d'au moins deux exemples appartenant à des systèmes existants)
• Modèles apparentés

Le point de ce livre est de ne pas se contenter de présenter les modèles et leur structure, mais également de les situer dans un contexte concret pour en apprécier les effets, d'en détailler les avantages et inconvénients, et de montrer de quelle façon plusieurs modèles peuvent travailler ensemble.

Le CD-ROM accompagnant ce livre contient le texte électronique de l'édition originale (Addison Wesley), ainsi que le code de tous les exemples décrits.

Agréable à lire, ce catalogue de design patterns se veut très complet et surtout très orienté sur les aspects pratiques de l'utilisation des modèles de conception. Chaque modèle est étudié sur le plan théorique et sur le plan pratique, en présentant des exemples d'implémentations, la plupart du temps en C++. De nombreuses variantes de ces modèles sont également présentées, permettant ainsi de mieux comprendre leurs problématiques et les solutions qu'ils y apportent.

La première partie du livre fournit un résumé efficace de la POO et des problèmes qu'on y rencontre. Puis il traite d'un exemple concret pour mettre en avant les problématiques liées à la conception objet et pour finir il présente le catalogue des modèles de conception proprement dit. Ainsi, ce livre n'est pas exclusivement réservé aux concepteurs chevronnés. Tous les concepts abordés, y compris les concepts de base de la POO, sont d'abord expliqués et présentés de manière simple. Par contre les apprentis concepteurs risquent de pas avoir le recul nécessaire pour profiter pleinement de tous les concepts et de toutes les solutions présentées.

Cet ouvrage n'est pas fait pour être lu d'une traite du début à la fin, c'est un ouvrage prévu pour qu'on s'y réfère en cas de doute, pour résoudre un problème de conception ou pour vérifier l'implémentation d'un modèle particulier. Bref, il fait partie des livres à posséder dans sa bibliothèque.

Voilà un livre de haut niveau.

Dès le début, malgré un rappel théorique sur des notions de programmation orientée objet qui se révèle très intéressant, on se rend compte qu'il est nécessaire d'avoir déjà une forte connaissance de la programmation OO et pas mal d'expérience dans la conception informatique.

Ce livre est une référence dans la mesure où sont décrit 23 patterns connus. C'est un livre à usage sporadique dont il faut se servir comme d'un catalogue.

A ne pas lire d'une traite, on peut commencer par lire les descriptions et les motivations des patterns. Une fois l'aperçu global des patterns assimilé, on pourra revenir de nombreuses fois approfondir le sujet lorsque le besoin de tel pattern se faire sentir dans notre conception.

Point fort : on appréciera la description de chaque pattern en termes de motivations et d'implications, les cas concret où ils peuvent être rencontré et leur classification sémantique en 3 groupes qui permet de mieux les appréhender et de les retrouver.

Point faible : on regrettera la complexité de lecture, les tournures techniques et abstraites. Le livre manque également d'exemple concret, pour se faire une première idée proche de choses familières du quotidien.

Ce livre est destiné à un public confirmé et est à mon avis à déconseiller aux débutants qui auront tout intérêt à se familiariser avec certains patterns autrement, pour commencer. Par contre, il se révèle indispensable pour les concepteurs avertis qui veulent tirer le maximum de la puissance de ces patterns et des années d'expériences et de maturité.

J'aurais donc du mal à commenter la qualité de la description et/ou la présentation des différents patterns rencontrés dans ce livre mais je peux néanmoins juger de la qualité de l'approche des auteurs de ce livre. Ils ont réussi à me faire voir la programmation objet d'une toute autre manière ainsi que l'idée que j'avais de l'utilisation des design patterns.

Ce livre n'est sûrement pas la référence comme le serait le livre du "Gang des quatres" (Erich GAMMA, Richard HELM, Ralph JOHNSON, John VLISSIDES), mais reste pour moi un des meilleurs livres pour commencer l'approche des design patterns. En effet, chaque pattern est présenté dans des cas d'utilisations simples et clairs, mais surtout, l'auteur cherche à montrer comment utiliser conjointement différents patterns afin de rendre vos applications plus stables et évolutives.

Il risque de fort de rester mon livre de chevet pour les mois à venir.

La majorité des ouvrages sur les patterns, ou modèles de conception, sont des catalogues. Des catalogues plus ou moins intéressants, expliquant le fonctionnement de ces patterns, mais c'est tout. Ici, on n'expose que quelques patterns, mais les modèles de conception ne sont pas seuls. On expose aussi en détail le pourquoi de l'orienté objet et de ses liens avec les patterns et comment ils peuvent s'imbriquer.

Outre cet aspect que je n'ai trouvé dans aucun autre livre sur les patterns, il y a aussi l'intérêt du lecteur dans l'ouvrage qui est entretenu par l'entrelacement d'explications et de présentation des patterns. Ces changements sont très utiles pour aérer un livre et peu d'auteurs en profitent, à tort.

Enfin, c'est tout de même un livre sur les patterns, et on en expose ici que 10, ce qui est peu. On pourra dire que ce sont les modèkes de conception les plus courants, mais les autres patterns du Gang of Four sont aussi intéressants. Il aurait été intéressant d'en ajouter.

Pour conclure, ce livre est à mettre entre toutes les mains qui ne connaissent pas les patterns ET leur utilité dans le concept orienté objet.

Ce livre de par son approche très pratique permet à tout le monde de découvrir les designs patterns, concepts ô combien nécessaire à tout programmeur qui se respecte.

Ce livre ne va seulement nous faire découvrir différents patterns, mais va aussi nous expliquer le pourquoi de la nécessité de ceux-ci et donc la limite de la programmation orienté objet traditionnelle. Il va aussi nous montrer la manière de penser en termes de pattern et la méthodologie à adapter. Tout cela illustré par de bons exemples qui nous permettent de comprendre directement le comment et de ne pas nous perdre dans de trop grosses théories.

Son seul défaut est peut-être le nombre restreint de patterns qu'il expose (10). Les plus importants ont certes été cités, mais d'autres patterns auraient eu leur place dans ce livre.

En conclusion, je dirais que ce livre offre à tout un chacun la possibilité de comprendre les designs patterns, par des exemples simples et précis. Ce livre n'est pas un catalogue de patterns qui se contente d'expliquer à quoi sert tel ou tel pattern et la manière dont il fonctionne, ce livre est construit de manière plus pédagogique pour nous permettre de comprendre l'utilité réelle des designs patterns.

Ce livre constitue une introduction aux design patterns.

C'est dans un style très original et très didactique que les auteurs ont l'ambition de nous plonger dans le monde des design patterns.

Leur but : nous apprendre les designs patterns les plus courants et nous donner le gout d'aller plus loin, d'en découvrir d'autres.

La méthode : des exemples originaux, proche du quotidien et de l'humour pour expliquer des concepts malgré tout très abstraits, qui peuvent vite devenir rébarbatif. Ainsi, ce livre se lit très facilement, à l'image d'un roman où au fil des pages, on est curieux de découvrir la suite des aventures de nos héros, les design patterns.

Cependant, il est à noter que ce livre ne constitue pas un catalogue de référence, il n'est pas non plus exhaustif. Ce qu'on va y trouver c'est vraiment l'apprentissage associé à la détente.

Ainsi, à la fin de la lecture, on ressort sans peine avec des concepts en tête et une boite à outils facilement disponible pour des conceptions élégantes.

Il est à noter que des notions en conception orientée objet sont un plus pour suivre ce livre.

Je recommande ce livre à toute personne qui souhaite débuter dans la connaissance des designs patterns et qui souhaite tirer parti des expériences éprouvées en termes de conception.

Vraiment un très bon livre !

Comment enseigner les Design Patterns sans être fastidieux ni ennuyeux à mourrir ?

C'est la solution utilisée par le livre Design Patterns Tête la Première, les explications de ce livre sont très pédagogiques, il y a une réelle réflexion qui permet au lecture d'être dans de très bonnes conditions pour assimiler tous ces concepts le plus simplement possible. La lecture de ce livre est un plaisir, cela devient un jeu d'apprendre et de comprendre les Design Patterns.

Pour appréhender correctement ce livre, il faut néanmoins des bonnes bases en langage objet (quelque soit le langage : java, actionscript...). Je conseille ce livre à tous ceux qui souhaite approfondir leurs connaissances dans les différents concepts de programmation, ces connaissances vont seront très utiles (voir indispensable) lors de vos projets informatiques

une fois que l'on connaît les Design Patterns et que l'on a appris à les utiliser à bon escient, il n'est plus possible de s'en passer!

Bienvenue à toi futur lecteur dans le monde des Design Patterns.

Voici un livre qui sort de l'ordinaire, comme le montre la couverture "Apprenez comment la vie amoureuse de Jim s'est améliorée depuis qu'il préfère la composition à l'héritage". Comment faire de l'humour avec un sujet aussi sérieux que les design patterns ?

La réponse n'étant pas évidente les auteurs ont décidé de consacrer une dizaine de pages au début du livre pour se justifier selon eux l'Homme retient mieux ce qui le surprend, pourquoi pas ? Mais c'est surtout lorsque l'on entame le sujet proprement dit que l'on comprend l'intérêt de leur méthode, en effet les exemples pleuvent, les ré-explications aussi : tout est fait pour que le lecteur comprenne et retienne : des exemples sous formes de dialogues, d'images et de schémas. Personnellement c'est en connaisseur que j'ai abordé ce livre, je pouvais donc cerner le problème dès le premier exemple. J'ai donc demandé à d'autres personnes et c'est un fait : tout le monde arrive à identifier le problème et comprendre l'intérêt de la solution proposée, pas forcément au premier exemple d'où l'intérêt des nombreuses ré-explications. Les patterns proposés sont nombreux et variés et l'on peut en dénombrer une bonne quinzaine. Les auteurs prennent bien le soin d'expliquer que les patterns sont des pratiques éprouvées que l'on ne doit surtout pas utiliser partout mais après avoir lu ce livre vous serez atteints de patternite aigüe et essaierez d'en placer le plus possible ! Attention ce livre cible avant tout les amateurs en pattern : si vous souhaitez un ouvrage faisant office de référence passez votre chemin !

Une fois de plus, un opus très réussi dans la collection Tête la première. Tout simplement titré "Design patterns", ce livre aurait pu s'appeler "Comment faire passer la pilule design patterns en douceur et efficacement". En effet le sujet de la conception par patron n'est pas toujours évident à traiter et ce livre le fait très bien dans un style propre à la collection Tête la première.

Pour ceux qui ne connaissent pas cette collection, la mise en page est déroutante et amusante (on apprend mieux comme ça!), on se croirait sur un bout de feuille dans un bureau avec un collègue nous expliquant le pourquoi du comment des patrons de conception. Cependant les explications sont claires et toujours agrémentées de schémas qui dans leur simplicité attirent naturellement l'intérêt du lecteur, on trouvera également en fin de chapitre un petit contrôle de connaissance, une bonne jauge pour contrôler ses acquis. Au final, des informations pertinentes sur les design patterns, une pédagogie qui a déjà fait ses preuves, aucune place à l'ennui et je suis sûr pour ceux qui liront ce livre une très bonne maîtrise des principaux design patterns.

Une grande réussite pour ce guide d'apprentissage auquel je ne mettrai pas la note maximale (rien n'est parfait, et ce n'est pas LE guide de référence), mais qui est un incontournable dans le domaine de la conception, vous pouvez donc l'acheter les yeux fermés.

Ce livre est un plaisir à lire !

Si vous ne connaissiez rien aux design patterns, alors ce livre est celui qu'il vous faut.

Clair, simple à lire et à comprendre, ce livre (et ses exemples) sont réellement pédagogiques et fournissent une parfaite connaissance du sujet.

Il y a longtemps que je n'avais pas pris un tel plaisir à lire un livre comme celui-là: ce fut un réel bonheur et je le recommande vivement !

Ce livre n'est pas un livre comme les autres !

Les auteurs appliquent des méthodes d'apprentissage résultants des dernières recherches en sciences cognitives afin de faciliter la lecture et la mémorisation ; c'est le crédo de la collection "tête la première". De ce point de vue je trouve le résultat plutôt réussi, le livre se lit comme un roman !

Les auteurs utilisent pour cela beaucoup d'images, d'exercices, des jeux sous forme de mots croisés, des interviews imaginaires avec les différents patterns, discussions et point de vue entre programmeurs imaginaires. Sous ses dehors ludiques et pas mal d'humour, «Tête la première design patterns » n'est donc pas un livre de référence (souvent ennuyeux) ou un catalogue de solutions sur les patterns mais un vrai livre d'apprentissage. Il aborde progressivement les différents patterns en imaginant à chaque fois un problème fictif à résoudre.

Fidèles à leur engagement pédagogique exposé en début de livre, les auteurs ont favorisé la mise en application et l'étude pratique du pattern plutôt qu'une approche théorique classique, les exemples étudiés sont simples et s'appuient sur le langage JAVA, mais pas de panique, le code mis en ouvre dans ce livre est très simple et ne causera aucun problème à un programmeur utilisant le C# ou le C++. Seule exception : le pattern proxy s'appuie sur des fonctionnalités propres à JAVA avec l'utilisation du système RMI, il ne pourra donc pas être transposé directement en C++ pour l'exemple donné.

Pour les programmeurs C++, les exemples de ce livre ont été transposés et sont disponibles à l'emplacement : Head First Design Patterns in C++ : http://sourceforge.net/projects/hfdp-cpp

Les chapitres du livre correspondent aux principaux patterns étudiés (excepté les trois derniers chapitres) soit au total 14 chapitres pour 630 pages. Le chapitre premier, sur l'introduction aux design patterns, est un modèle du genre en termes d'apprentissage pédagogique et donne le ton pour le reste du livre. Le lecteur se sent vraiment intégré à la discussion sur le sujet traité, les principes de conceptions sont abordés progressivement jusqu'à la solution finale utilisant le pattern. Il en sera de même tout au long des autres chapitres : à chaque fois les nouveaux principes de conceptions sont cités. Exemples : « identifiez les aspects de votre application qui varient et séparez-les de ceux qui demeurent constants » ou encore « préférez la composition à l'héritage »

En conclusion : Vous vous intéressez aux patterns ? Vous voulez progresser dans la conception de vos systèmes logiciels et concevoir des solutions souples évolutives et maintenables ? Vous n'avez pas envie d'un livre aride et prise de tête ? Alors assurément avec « Design patterns - Tête la première » vous ne serez pas déçus. Il deviendra vite votre livre de référence vous permettant par la suite d'aborder sereinement d'autres livres traitant de catalogue de patterns.

Voilà un gros ouvrage (plus de 1000 pages) traitant des Services Web : une première partie définit les concepts autour des Services Web, une seconde plus technique couvre les technologies et spécifications, et le livre s'achève avec l'utilisation des Services Web sur les plateformes Java et .Net.

Le livre "Services Web avec J2EE et .Net" est très complet pour comprendre les nombreux intervenants des Services Web, on y trouvera une explication à de nombreux acronymes satellites (SOAP, WSDL, UDDI...la liste est longue), comme un dictionnaire en somme, c'est d'ailleurs je pense son optique d'utilisation première. La majeure partie de ce livre est donc théorique, le reste laisse place aux cas pratiques J2EE et .Net, avec des exemples que j'ai trouvé légers pour ces deux plateformes, donc à vos claviers pour allez plus loin.

La mise en page est claire, de nombreux schémas et échantillons de codes viennent agrémenter la théorie dispensée. Donc, un livre bien utile pour se rappeller l'utilisation et la mise en oeuvre de Service Web, mais également un bon point de départ pour comprendre la technologie. Je le conseille finalement à ceux qui débutent dans les Web Services, aux décideurs pour acquérir une vue d'ensemble tout en gardant à l'idée qu'à posteriori une exploration technique sera nécessaire.

Bonne lecture !

Si vous souhaitez tout savoir des Web Services, alors ce livre est pour vous !

Très complet, il vous permettra d'apprendre tout d'abord les bases, puis vous vous tournerez ensuite vers des notions plus complexes.

L'étude de cas est un vrai régal: en effet, dans beaucoup de livres, on vous explique ce que vous devez faire, mais il arrive très souvent que cela manque... d'exemples. Cette étude comble cette lacune et on ne peut que l'apprécier.

Bref, encore un livre que ne je peux que conseiller !

Je le dis tout de suite : ce livre est un petit bijou sur le sujet! Addictif à souhait (je l'ai terminé en quelques jours), son contenu est une véritable mine d'informations sur l'outil Subversion. Tous les thèmes relatifs à Subversion sont abordés, de l'utilisation à l'administration, en passant par le tuning de l'outil, vous y touverez toutes les réponses (au moins la plupart) que vous vous posez sur ce système de gestion de versions. De nombreux exemples d'utilisation de l'outil sont fournis dans le contenu, pour ma part des exemples pratiques sont toujours les bienvenus dans ce type de livre (et ce qui ne gâche rien, c'est qu'ils s'adaptent parfaitement à une réalité métier).

L'organisation du livre est très intéressante, en effet il est possible de le lire comme un didacticiel mais aussi de l'utiliser comme une foire aux questions et retrouver ainsi facilement une information plus tard. La lecture est facile et attrayante et quelques anecdotes et blagues à part ne manqueront pas de ponctuer votre lecture, entretenant par la même occasion l'intérêt du lecteur. Mais attention, lecture facile ne signifie pas pauvreté du contenu! Au contraire j'ai pu trouver de nombreuses réponses aux questions que je me posais sur Subversion.

Il est toujours rare de trouver une perle, c'est vrai aussi pour la littérature informatique qui demande de l'exactitude, de la logique, mais aussi une certaine dose de découverte et d'amusement, pour toutes ces raisons je vous conseille vivement ce livre qui a vraiment le mérite d'être bon.

Cet ouvrage répondra à la fois à la curiosité du débutant et aux interrogations de l'utilisateur avancé. La diversité du propos permet ainsi de répondre aux attentes de tout lecteur intéressé par le suivi de version, et fait partie des livres qu'on est amené à lire par morceaux au fur et à mesure qu'on progresse sur le sujet.
Très complet, il propose même un guide de référence qui couvre bon nombre de commandes Subversion.

Ce livre est assez particulier dans son genre puisqu'il prodigue des informations à tout niveau : des fondements du suivi de version à des thématiques avancées de configuration de Subversion, en passant par des notions intermédiaires comme les branches et la fusion. Il y en a pour tous les gouts et les auteurs, vraisemblablement conscients du risque de perdre le lecteur en route, commencent l'ouvrage en ciblant les chapitres à lire selon le profil du lecteur.

A travers cet ouvrage, vous apprendrez ou réapprendrez les fondements de la gestion de versions, les différences entre Subversion et le désormais célèbre CVS, son architecture et les méthodes d'accès au référentiel. Mais surtout, vous aurez l'occasion de vous imprégner de la philosophie Subversion, séduisant de plus en plus de développeurs et administrateurs, et ayant un meilleur répondant que CVS aux problématiques actuelles.

Que vous soyez adeptes de CVS ou simple débutant dans le domaine de la gestion de sources, je vous recommande sans hésitation cet ouvrage qui porte un regard nouveau sur cette problématique qui gagne en influence sur la réussite et l'organisation de projets informatique. Et n'oubliez pas de suivre les conseils des auteurs et de mettre de côté (pour mieux les attaquer plus tard) les chapitres qui ne devraient pas vous intéresser dans l'immédiat.

Pour conclure, n'oublions pas de préciser que les auteurs de ce livre sont des (voire les) acteurs principaux du projet Subversion. On pourra donc leur faire confiance, d'autant plus que la traduction est presque irréprochable, ce qui n'est pas le cas de tous les ouvrages traduits de la langue anglaise. Après la lecture de quelques chapitres, je n'ai qu'une envie : mettre en pratique pour constater par moi même l'efficacité de Subversion !

Tous les développeurs ont été confronté aux problème lié au travail en équipe, en particuliers les problèmes lié à la modification en parallèle des fichiers sources. C'est afin de rationnaliser ces opérations que les gestionnaire de versions ont été inventés, ils font aujourd'hui partie de la boite à outils indispensable du développeur.

Ce livre est une excelente introduction à la gestion de version à l'aide de l'outils subversion. Allant de l'installation à l'administration en passant par l'utilisation. Toutes opérations de bases et la plus part des opérations avancés que l'on peut faire avec Subversion y sont décrite. Y compris l'utilisation de Tortoise, interface indispensable pour les développeurs étant sous Windows.

Une fois que l'on maitrise l'utilisation de Subversion on gardera ce livre à portée de main puisqu'il inclues une référence de toutes les commandes ainsi qu'une liste de comment faire ... donnant un aperçu de la commande à utiliser ainsi qu'une référence vers le chapitre traitant de cette partie.

Avec un style agréable, un contenu complet et technique qui ne sombre pas dans l'énumération, Mike Mason a rédigé un livre qui a tout pour plaire.

Tout d'abord, l'esthétique : j'apprécie tout particulièrement les couvertures des livres de la "Collection Blanche" d'Eyrolles. Toujours soignées, sobres et élégantes. La qualité des feuilles est tout à fait appréciable, la police est bien choisie. Tout est fait pour une lecture agréable.

Bien, revenons maintenant au contenu du livre. Comme le titre l'indique, ce livre est un guide pratique à l'utilisation de Subversion. Cet outil, incontournable pour le développement collaboratif, est présenté d'une façon assez technique.

L'auteur présente tout d'abord l'intérêt d'un système de contrôle de version, puis nous explique les différents arguments en faveur de Subversion. Enfin, la suite du livre se résume à la présentation des différentes fonctionnalités de l'outil : création et gestion de projets, propriétés, gestion des conflits, importation de projets sous CVS, tout y passe.

Mais l'intérêt majeur de ce livre, en plus de la très bonne présentation de Subversion (si vous doutiez de son utilité, une lecture de ce livre balayera ces doutes), est la partie qui concerne l'administration et la sécurisation du serveur. Superflue pour un développeur "amateur" (et encore), cette partie ravira les administrateurs chevronnés qui aiment les systèmes propres et sécurisés. L'auteur explique donc comment coupler un serveur Apache avec le serveur Subversion, comment implémenter une authentification efficace, ou encore comment sécuriser les communications avec un tunnel SSH.

Enfin, une annexe regroupe intelligemment les commandes, fournissant ainsi un guide très pratique si vous oubliez la syntaxe d'une commande.

En tant que "débutant" dans le monde des systèmes de contrôle de version, ce livre m'a parfaitement convenu, répondant à toutes mes attentes. Ce n'est pas une simple liste des fonctionnalités offertes par cet outil, chaque fonctionnalité est remise dans son contexte; l'auteur nous dit pourquoi et quand l'utiliser, ou au contraire quand l'éviter.

Ce livre aidera tout développeur participant à un projet collaboratif, ou ayant besoin d'un système de contrôle de version efficace.

Grand débutant - pour ne pas dire complet ignorant - des logiciels de gestion de versions et de Subversion en particulier, je suis ressorti de ce livre avec une connaissance approfondie de SVN.

Ce livre de Mike Mason, traduit par Isabelle Hurbain, apprend à ses lecteurs à utiliser Subversion au quotidien, à l'installer et l'administrer, à utiliser ses fonctionnalités avancées, etc. Mais surtout, il apprend au lecteur à comprendre la philosophie de Subversion. Comprendre pourquoi la gestion de version est intéressante - sinon nécessaire -, pourquoi telle et telle commande existe, et pourquoi l'utilise-t-on.

J'ai trouvé cette explication très facile d'accès, y compris pour des concepts quelque peu avancés comme la création de branches pour la livraison du produit. L'auteur répète souvent les mêmes informations, parfois jusqu'à recopier un paragraph complet. Mais ces redites ne sont pas désagréables du tout : elles ancrent d'autant plus l'information dans notre cerveau.

Si les débutants pourront ainsi apprendre en douceur à utiliser Subversion, les utilisateurs avertis bénéficieront également de moults conseils visant à les perfectionner.

On appréciera également la présence, en fin d'ouvrage, d'un résumé des instructions en ligne de commandes de Subversion, avec leur description. J'ai toutefois regretté que cette section ne détaille pas avec précision les paramètres de chaque commande : ils sont décrits, mais pas de façon formelle.
Outre ce résumé des commandes, une liste de "Comment faire pour" est proposée, récapitulant de façon concise tout ce que vous avez appris au long de l'ouvrage.

Si vous me demandez une remarque négative sur ce livre, je vous dirai qu'un comparatif avec CVS se trouve absent. Seuls quelques conseils aux ex-utilisateurs de ce système sont prodigués pour un passage plus facile à Subversion.

Ce livre est donc, selon moi, un indispensable pour tout développeur qui doit utiliser Subversion dans son développement.

Sébastien Doeraene

Incontournable ! Un ouvrage à la hauteur de l'experience de Craig Larman, l'un des plus grands spécialistes de génie logiciel et d'Unified Modeling Language nous gratifie d'un excellent livre, pour chefs de projets ou développeurs concernés et/ou confirmés. Une profonde analyse du développement itératif à l'aide de la notation UML et des Design Patterns nous est ainsi livrée sous une forme trés pédagogique.

Une étude de cas unique est suivie tout au long des chapitres et sert de référence pour chaque exemple. Néanmoins, il ne faut pas que le développeur s'attende à trouver une étude exhaustive de la notation UML ou des diagrammes ultra-complets, en effet, l'ouvrage s'attache essentiellement a présenter l'intérêt du recours à UML dans un cycle de développement itératif comme Unified Process. des analogies au RUP de Philipe kruchten ou XP sont également introduites. Côté Patterns, nous retrouvons les modèles de responsabilités (Pattern GRASP) et GoF (Gang Of Four).

On regrette cependant l'absence d'un CD avec des documentations ou des logiciels de modélisation UML en version d'évaluation (Together ou Rational), mais aussi que le titre ne reflète pas de façon adaptée le réel contenu de l'ouvrage.

Incontournable ! Un ouvrage à la hauteur de l'experience de Craig Larman, l'un des plus grands spécialistes de génie logiciel et d'Unified Modeling Language nous gratifie d'un excellent livre, pour chefs de projets ou développeurs concernés et/ou confirmés. Une profonde analyse du développement itératif à l'aide de la notation UML et des Design Patterns nous est ainsi livrée sous une forme trés pédagogique.

Une étude de cas unique est suivie tout au long des chapitres et sert de référence pour chaque exemple. Néanmoins, il ne faut pas que le développeur s'attende à trouver une étude exhaustive de la notation UML ou des diagrammes ultra-complets, en effet, l'ouvrage s'attache essentiellement a présenter l'intérêt du recours à UML dans un cycle de développement itératif comme Unified Process. des analogies au RUP de Philipe kruchten ou XP sont également introduites. Côté Patterns, nous retrouvons les modèles de responsabilités (Pattern GRASP) et GoF (Gang Of Four).

On regrette cependant l'absence d'un CD avec des documentations ou des logiciels de modélisation UML en version d'évaluation (Together ou Rational), mais aussi que le titre ne reflète pas de façon adaptée le réel contenu de l'ouvrage.

"Conduite de projet Web" est avant tout un retour d'expérience de 4 professionnels, chacun spécialisé dans ses domaines. Ils nous montrent les enjeux d'un projet web, les différentes phases de la conduite de projet, le rôle de chacun, les choses à faire et celles à éviter, les aspects techniques, organisationnels, financiers, marketing, juridiques... L'ouvrage est très bien structuré ce qui le rend extrêmement facile à intégrer. Vous disposez d'un guide de lecture qui vous permet de sélectionner certains chapitres selon votre profil (étudiant, chef de projet, dirigeant, etc.), et selon vos objectifs (sensibilisation, maîtrise des aspects juridiques, etc.). Beaucoup d'apartés vous sont proposés en plus, on trouve par exemple les multiples définitions, les questions clés, les repères, les check-lists, les bonnes pratiques, ainsi que les avis d'expert.

Un des atouts de ce livre est le travail fait autour des livrables. Après avoir vu la spécification technique, le cahier des charges, la maquette graphique, l'étude de faisabilité (...) vous allez directement pouvoir les réutiliser en entreprise grâce au Cd-rom d'accompagnement qui contient 60 modèles de document.

Pour finir, les études de cas (site institutionnel, B-to-B, portail d'entreprise) présentes dans les derniers chapitres apportent une dimension pratique à ce livre porté principalement sur la théorie.