Developpez.com

Plus de 14 000 cours et tutoriels en informatique professionnelle à consulter, à télécharger ou à visionner en vidéo.

Developpez.com - UML
X

Choisissez d'abord la catégorieensuite la rubrique :



Critiques des meilleurs livres UML


Dernière mise à jour : 20/04/2006

couverture du livre 'Introduction à UML'

note du livre : 3.5

Introduction à UML   fr  

de Sinan Si Alhir
Alexandre Gachet (trad.)

Public visé : Debutant


Pour tout projet informatique d'envergure, il est indispensable de parler un langage commun qui permette de formaliser les besoins et les exigences de l'utilisateur, mais également les solutions techniques envisagées par les développeurs. De ce langage commun, dépend la cohérence du produit fini. Le secteur informatique a adopté UML (Unified Modeling Language) comme langage pivot. Très complet, orienté objet et indépendant des langages de programmation (qui serviront à la réalisation effective du projet), il est désormais incontournable.

Dans cet ouvrage, Sinan Si Alhir présente UML et le remet en perspective afin de conduire le lecteur pas à pas vers la maîtrise du langage. Dans un premier temps, il explique la façon dont UML permet de modéliser la structure d'un système. De nombreux concepts clés, qu'il s'agisse des plus généraux (classes) ou des plus spécifiques (objets) sont illustrés dans le chapitre consacré aux diagrammes de classes et d'objets. Il explique ensuite comment utiliser un diagramme de cas d'utilisation pour modéliser les caractéristiques d'un système. Enfin, il montre comment utiliser les diagrammes de composants et de déploiement pour modéliser le déploiement d'un système dans un environnement physique.

Si la modélisation structurelle permet de répondre à la question " qui fait quoi " dans le développement d'un système, la modélisation comportementale répond aux questions " quand, comment et pourquoi ". Le lecteur découvrira les diagrammes de séquence et de collaboration, qui décrivent la façon dont les éléments interagissent dans le temps et dans l'espace, les diagrammes d'état, qui décrivent le cycle de vie des composants d'un système, et enfin les diagrammes d'activité, qui documentent le contrôle des flux et le partage des responsabilités entre les différents éléments.

Tout au long du livre, Sinan Si Alhir se concentre sur le langage lui-même et évite de se prendre au piège de la méthodologie. Sa présentation est claire et concise. Une étude de cas constitue le fil rouge et permet d'ancrer dans la réalité des notions a priori abstraites. Chaque chapitre se termine par des exercices qui permettront au lecteur de vérifier l'assimilation des connaissances.


Critique du livre par la rédaction ( Stessy ) :

UML est un langage devenu tellement important dans le monde informatique, qu'aucun professionnel impliqué dans des projets de développement ne puisse l'ignorer.

Malheureusement la plupart des ouvrages dédiés à ce langage ne répondaient pas à mes attentes.
Je cherchais un ouvrage simple expliquant les fondements du langage, donc un livre adressé aux néophites tels que moi.

Grâce à "Introduction à UML", toute personne souhaitant appréhender les concepts de bases de ce langage trouvera enfin chaussure à son pied. L'auteur de cet ouvrage passe en revue les 9 principaux diagrammes en expliquant comment les utiliser. Il explique également la syntaxe générale utilisée à l'intérieur même de chaque diagramme.
Après la lecture de chaque chapitre, une partie sera reservée à la résolution d'exercices en rapport aux diagrammes précédemment étudiés, pour vous permettre de vous entraîner et d'améliorer vos connaissances.

Le seul regret que j'ai à avoir est l'absence d'un glossaire reprenant les différents termes abordés dans chaque chapitre pour permettre au personnes, n'ayant pas encore ces termes techniques bien ancrés dans la tête, de s'y retrouver plus facilement.

En conclusion, je recommande cet ouvrage qui est à mes yeux l'ouvrage de référence pour toute personne souhaitant se former à UML


Sommaire

Préface

    Partie I : Principes de base

    • Chapitre 1 -- Introduction
    • Chapitre 2 -- Modélisation orientée objet

    Partie II : Modélisation structurelle

    • Chapitre 3 -- Diagramme de classes et d'objets
    • Chapitre 4 -- Diagrammes de cas d'utilisation
    • Chapitre 5 -- Diagrammes de composants et de déploiement

    Partie III : Modélisation comportementale

    • Chapitre 6 -- Doagrammes de séquences et collaboration
    • Chapitre 7 -- Diagrammes d'état
    • Chapitre 8 -- Diagrammes d'activité

    Partie IV : Au-delà du langage UML

    • Chapitre 9 -- Mécanismes d'extension
    • Chapitre 10 -- Le langage OCL

    Partie V : Annexes

    • Annexe A -- Références
    • Annexe B -- Solutions des exercices
    • Index

    221 pages, 1ère édition, Editions O'reilly, ISBN: 2-84177-279-9

    Commandez sur www.amazon.fr :
    38.00 EUR TTC seulement(au lieu de 40.00 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'UML et les Design patterns'

note du livre : 4.5

UML et les Design patterns   fr  

de Craig Larman


UML et les Design Patterns fournit aux développeurs et aux étudiants les connaissances indispensables pour comprendre et maîtriser l’analyse et la conception orientées objet (A/COO). Son objectif ne se limite pas à la création de diagrammes et à la notation UML ; il vise à leur application réelle dans le contexte de la conception de systèmes logiciels. Craig Larman, expert de renom en technologie objet et en méthodes itératives, présente ici une unique étude de cas homogène, exposant progressivement les techniques capitales de l’analyse et de la conception orientées objet, tout en mettant l’accent sur les activités, les principes et les patterns les plus essentiels.


Critique du livre par la rédaction ( Petrus ) :

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.


Sommaire

  • Chap. I Analyse et Conception Orientée Object (A/COO)
  • Chap. II. Développement Itératif et Processus Unifié
  • Chap. III.Etude de Cas : Système NextGen
  • Chap. IV. Initialisation
  • Chap. V. Comprendre les besoins
  • Chap. VI. Modèle de Cas d'Utilisation : rédaction des spécifications dans un contexte
  • Chap. VII. Identification des autres besoins
  • Chap. VIII. De l'initialisation à l'élaboration
  • Chap. IX. Modèle de cas d'utilisation : création de DSS
  • Chap. X. Modèle du domaine : les concepts
  • Chap. XI. Modèle du domaine : les associations
  • Chap. XII. Modèle du domaine : les attributs
  • Chap. XIII. Les Contrats d'opération
  • Chap. XIV. Des besoins à la conception dans l'itération en cours
  • Chap. XV. Notation des diagrammes d'interaction
  • Chap. XVI. GRASP : conception objet et reponsabilités
  • Chap. XVII. Modèle de conception : réalisation des cas d'utilisation avec les patterns GRASP
  • Chap. XVIII. Déterminer la visibilité
  • Chap. XIX. Diagrammes de classes de conception
  • Chap. XX. Modèle d'implémentation
  • Chap. XXI. Itération 2 et ses exigences
  • Chap. XXII. GRASP : autres patterns
  • Chap. XXIII. Conception et patterns GoF
  • Chap. XXIV. Itération 3 et ses exigences
  • Chap. XXV. Mise en relation des cas d'utilisation
  • Chap. XXVI. Modélisation de la généralisation
  • Chap. XXVII. Affinement du Modèle du domaine
  • Chap. XXVIII. Nouveaux DSS et contrats
  • Chap. XXIX. Modélisation du comportement et diagrammes d'états-transitions
  • Chap. XXX. Conception de l'architecture logique avec des patterns
  • Chap. XXXI. Organisation des packages
  • Chap. XXXII. Introduction à l'analyse architecturale
  • Chap. XXXIII. Autes réalisations de cas d'utilisation avec des objets et des patterns
  • Chap. XXXIV. Conception d'un framework de persistance
  • Chap. XXXV. Dessin et outils
  • Chap. XXXVI. Introduction à la planification itérative et à la conduite de projets
  • Chap. XXXVII. Commentaires sur le développement itératif et UP
  • Chap. XXXVIII. Compléments sur la notation UML

660 pages, 1ère édition, 20 juillet 2003 Editions CampusPress, ISBN: 2-74401-623-3

Commandez sur www.amazon.fr :
40.85 EUR TTC seulement(au lieu de EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'CMMI'

note du livre : 3.5

CMMI   fr  

Un itinéraire fléché vers le Capability Maturity Model Intégration

de Richard Basque

Public visé : avancé, expert


La qualité en informatique, tout le monde la souhaite, beaucoup en parlent, certains l'appliquent, mais rares sont ceux qui peuvent réellement la mesurer. Aujourd'hui la situation est en train de changer avec l'entrée du CMMI (Capability Maturity Model Integration) dans la pratique des entreprises. Ce modèle d'évaluation des processus de développement d'un produit logiciel permet de classer en cinq niveaux de maturité les pratiques de l'entreprise en termes de délai, de qualité, de coûts et de fiabilité. Rédigé par l'un des meilleurs spécialistes francophones du sujet cet ouvrage est une synthèse précise et précieuse sur ce sujet stratégique.


Critique du livre par la rédaction ( Petrus ) :

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

Sommaire

  1. La genèse d'un modèle de meilleures pratiques
  2. L'étoile CMMI dans la galaxie des modèles
  3. Une échelle de maturité organisationnelle
  4. Terminologie particulière au CMMI
  5. L'architecture du modèle
  6. Le niveau 2
  7. Le niveau 3
  8. Le niveau 4
  9. Le niveau 5
  10. Un cas concret
  11. Les bénéfices pour l'industrie du logiciel et ses clients
  12. Utilisations possibles du CMMI

216 pages, 1ère édition, Octobre 2004 Editions Dunod, ISBN: 2-10-008308-2

Commandez sur www.amazon.fr :
33.25 EUR TTC seulement(au lieu de 35.00 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'MDA en action'

note du livre : 3.5

MDA en action   fr   CD disponible

Ingénierie logicielle guidée par les modèles

de Xavier Blanc

Public visé : moyen, avancé


Nouvelle approche d'ingénierie logicielle élaborée par l'OMG, MDA (Model Driven Architecture) prône l'utilisation systématique de modèles dans toutes les phases du cycle de vie des applications informatiques, de l'analyse et conception à la génération de code et au déploiement.

Pour une meilleure productivité et une plus grande pérennité des développements, la logique métier d'une application est modélisée indépendamment de toute plate-forme d'exécution, un mécanisme de transformation de modèles permettant ensuite de produire automatiquement les modèles et le code spécifiques à chaque plate-forme (J2EE, NET, PHP... ).

Mise en œuvre pratique de MDA, illustrée par une étude de cas : Après une description détaillée des standards sur lesquels repose MDA, tels que UML, MOF, OCL et XMI, l'ouvrage insiste sur les aspects pratiques de sa mise en oeuvre. Il montre comment construire des transformations de modèles en java à l'aide de l'API )MI et du framework EMF, et présente deux outils MDA du marché IBM Rational Software Modeler et Objecteering/MDA Modeler. L'ouvrage décrit enfin comment MDA prend en compte les plate-formes d'exécution, en détaillant plus particulièrement les environnements J2EE/EJB et PHP. Tous ces aspects de l'approche MDA sont illustrés par une étude de cas, une application de commerce électronique développée simultanément en J2EE et en PHP


Critique du livre par la rédaction ( Petrus ) :

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.


Sommaire

Avant-propos

    • Objectifs de l'ouvrage
    • Organisation de l'ouvrage
    • A qui s'adresse l'ouvrage

    L'architecture MDA

      Pérennité des savoir-faire

        • Modèles et niveaux méta
        • UML2.0
        • Les standards OCL et AS
        • Les modèles en XML

        Gains de productivité (frameworks et outils)

          • Manipuler des modèles avec JMI et EMF
          • Transformation de modèles
          • Les outils MDA

          Prise en compte des plates-formes d'exécution

          • Les plates-formes d'exécution
          • La plate-forme J2EE
          • La plate-forme PHP

          Etude de cas

          • MDA en action avec l'application Petstore

          Annexe

          • Contenu du CD-ROM et procédures d'installation
          • Index

          270 pages, 1ère édition, avril 2005 Editions Eyrolles, ISBN: 2-212-11539-3

          Commandez sur www.amazon.fr :
          37.05 EUR TTC seulement(au lieu de 39.00 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'UML - Modéliser un site e-commerce'

note du livre : 5.0

UML - Modéliser un site e-commerce   fr  

Les Cahiers du Programmeur

de Pascal Roques

Public visé : Débutant, Initié


Ce cahier montre à tous les programmeurs combien UML est un outil simple et universel : nullement réservé aux applications Java ou C++, il s'applique parfaitement à des sites Web marchands, dont la complexité en fait des candidats naturels à la modélisation.

Du cahier des charges au code, ce livre vous offrira les meilleures pratiques de modélisation avec UML sous la forme d'une étude de cas. Toutes les étapes de conception sont décrites, abondamment illustrées et expliquées, à travers une démarche située à mi-chemin entre processus lourd et processus léger.


Critique du livre par la rédaction ( jérôme ) :

UML est à la mode. L'appliquer au WEB ne coulait pas de source, et pourtant l'auteur parvient à nous démontrer son utilité dans un développement WEB complexe, à travers la modélisation d'un exemple complet (une librairie électronique).

Après un rapide historique de la modélisation et des différentes méthodes de modélisation, l'auteur entre dans le vif du sujet avec l'écriture du cahier des charges puis l'étape de spécification des besoins utilisateurs. Viennent ensuite la description des différents cas d'utilisation et leur diagramme associé.

Tous les diagrammes d'UML ne sont pas utilisés, et l'auteur à pris le parti de n'en traiter que la moitié, insistant plus particulièrement sur les diagrammes de classe et de séquence. Ceci n'est aucunement handicapant, bien au contraire. L'organisation du livre et les nombreux schémas et diagrammes clairs qui parsèment ce livre le rendent très agréable à lire et ne noient pas le néophyte sous des concepts théoriques parfois imbuvables en UML.

Ceux qui connaissent déjà UML trouveront quelques différences puisque certaines notations sont introduites pour coller au contexte du WEB. Ce livre est d'ailleurs à utiliser en complément d'un livre plus référentiel sur UML.

Cet ouvrage didactique devrait prendre sa place dans la bibliothèque de tout programmeur WEB, la clarté des propos tenus et la démonstration que la modélisation est (quasi) inévitable dans un développement WEB professionnel le rendant indispensable. Ceci est d'autant plus vrai à l'heure où PHP5 fait un bond en avant formidable vers le full objet.

La dernière partie regroupe l'ensemble des diagrammes utilisés tout au long du livre, et appliqués avec des exemples de code en Java (pour des pages JSP), en ASP.NET, et en PHP. Cela permet de se faire une idée des possibilités de chacun de ces trois langages pour la conception d'applications WEB complexes.

Critique du livre par la rédaction ( ovh ) :

La collection "les cahiers du programmeur" d'Eyrolles se veut orientée pratique, et l'objectif est atteint. Pour ce genre de sujet assez abstrait par définition je trouve que c'est essentiel. Trop souvent on l'aborde de manière théorique avec une série d'exemples d'école non liés entre eux. Ici on part d'une application concrète qu'est le développement d'un site web d'e-commerce, que l'auteur va décortiquer et analyser entièrement, pas à pas. Bien sûr nous ne verrons pas la réalisation complète, mais chaque diagramme important d'UML est abordé dans un cadre pratique avec pour objectif permanent la réalisation finale et la satisfaction des besoins utilisateur.

Mais UML n'est qu'un langage de modélisation, il faut lui associer une méthode pour lier les diagrammes entre eux et réaliser l'application. La méthode choisie par l'auteur est un mélange d'UP simplifié (processus unifié, classiquement associé à UML) et d'XP (eXtreme Programming), ce qui aboutit à une méthode simple, compréhensible et suffisante dans beaucoup de cas.

Le livre est très bien structuré : un schéma de base liant tous les diagrammes pour chaque étape est conçu dès le départ, et tous les chapitres suivants correspondent à une étape et un type de diagramme UML, à chaque fois replacée dans son contexte par rapport au schéma général.

La phase finale est donc la réalisation technique de l'application, mais on peut regretter que l'exemple choisi n'utilise pas les bases de données. En effet l'auteur a choisi d'illustrer la programmation du panier qui par définition ne stocke rien de manière permanente. C'est dommage car le lien entre classes d'analyse et relations en base de données est intéressant et essentiel pour bien comprendre le lien entre analyse et programmation.

Plusieurs plateformes techniques sont présentées : scripts PHP, Java (J2EE) avec le framework Struts et pages JSP et la technologie acutelle de Microsoft .NET avec les pages en ASP.NET.

Malgré ce manque dans la dernière partie, ce livre n'en demeurre pas moins une excellente lecture à conseiller, et qui aidera bon nombre de développeurs à mieux appréhender le lien entre analyse et programmation. De plus, les ouvrages d'analyse ciblent généralement des applications de type standalone (GUI), or avec les sites web actuels de plus en plus riches en fonctionalités une analyse préalable aussi poussée que pour une application classique est vraiment une nécessité et un gage de qualité du développement, ce que démontre brillamment ce livre.


Sommaire

QUELLE DEMARCHE POUR PASSER DES BESOINS AU CODE ?

  • Pourquoi modéliser ?
  • Un processus simplifié pour l'e-commerce.

UNE LIBRAIRIE EN LIGNE : L'APPLICATION COTE UTILISATEUR.

  • Exigences fonctionnelles : recherche, découverte, sélection, commande
  • Exigences non-fonctionnelles : qualité et performances
  • Contraintes de conception : panier, paiement sécurisé.

SPECIFICATION DES EXIGENCES D'APRES LES CAS D'UTILISATION.

  • Identification des acteurs
  • Identification des cas d'utilisation
  • Relations entre cas d'utilisation

ANALYSE DES OBJETS METIER.

  • Identification des concepts du domaine
  • Généralisation
  • Structuration en packages de classes.

SPECIFICATION DETAILLEE DES EXIGENCES.

  • Description textuelle des cas d'utilisation : scénarios, préconditions et postconditions
  • Spécification détaillée des cas d'utilisation du site Web : maintenir le catalogue, rechercher des ouvrages, gérer son panier, effectuer une commande.

REALISATION DES CAS D'UTILISATION : LES CLASSES D'ANALYSES.

    MODELISATION DE LA NAVIGATION.

    • Structuration de la navigation dans le site Web.

    CONCEPTION OBJET PRELIMINAIRE.

    • Notation des diagrammes d'interactions
    • Classes de conception préliminaire.

    CONCEPTION OBJET DETAILLEE.

    • Architecture des applications Web : patterns architecturaux, client Web léger
    • Solutions techniques : PHP, J2EE, .NET.

    ANNEXE.

    • Récapitulatif du modèle UML.

    152 pages, 1ère édition, septembre 2002 Editions Eyrolles, ISBN: 2-212-11070-7 , Format : 21 x 23,5

    Commandez sur www.amazon.fr :
    19.95 EUR TTC seulement(au lieu de 21.00 EUR TTC : prix éditeur) - Livraison Gratuite à partir de 20 EUR !!!
couverture du livre 'L'orienté objet'

note du livre : 4.5

L'orienté objet   fr  

de H. Bersini, I. Wellesz


L'approche objet est enseignée dans les universités dès les premiers niveaux des cursus informatiques, car sa compréhension est le prérequis indispensable à toute pratique économe, fiable et élégante de la plupart des techniques informatiques qui en sont dérivées, depuis Java et Python, jusqu'à UML 2, en passant par C# et C++.

Ce livre sera lu avec profit par tous les étudiants de disciplines informatiques liées à l'approche objet (programmation orientée objet, modélisation UML, Java, Python, C#/C++...) et pourra être utilisé par leurs enseignants comme matériel de cours.

Il est également destiné à tous les développeurs qui souhaitent approfondir leur compréhension des concepts objet sous-jacents au langage qu'ils utilisent.


Critique du livre par la rédaction ( ovh ) :

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.


Sommaire

  • Principes de base : quel objet pour l'informatique
  • Un objet sans classe... n'a pas de classe
  • Du faire-savoir au savoir-faire... du procédural à l'OO
  • Ici Londres : les objets parlent aux objets
  • Collaboration entre classes
  • Méthodes ou messages ?
  • L'encapsulation des attributs
  • Les classes et leur jardin secret
  • Vie et mort des objets
  • UML
  • Héritage
  • Redéfinition des méthodes
  • Abstraite, cette classe est sans objet
  • Clonage, comparaison et assignation d'objets
  • Interfaces
  • Distribution gratuite d'objets : pour services rendus sur le réseau
  • Multithreading
  • Programmation événementielle
  • Persistance d'objets
  • Et si on faisait un petit flipper ?
  • Les graphes
  • Petite chimie OO amusante

450 pages, 14/10/2004 Editions Eyrolles, ISBN: 2212115385

Commandez sur www.amazon.fr :
28.50 EUR TTC seulement(au lieu de 30.00 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'UML 2 et les Design patterns'

note du livre : 4.5

UML 2 et les Design patterns   fr  

de Craig Larman


UML et les Design Patterns fournit aux développeurs et aux étudiants les connaissances indispensables pour comprendre et maîtriser l’analyse et la conception orientées objet (A/COO). Son objectif ne se limite pas à la création de diagrammes et à la notation UML ; il vise à leur application réelle dans le contexte de la conception de systèmes logiciels. Craig Larman, expert de renom en technologie objet et en méthodes itératives, présente ici une unique étude de cas homogène, exposant progressivement les techniques capitales de l’analyse et de la conception orientées objet, tout en mettant l’accent sur les activités, les principes et les patterns les plus essentiels.

Critique du livre par la rédaction ( Petrus ) :

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.

Sommaire

  • Chap. I Analyse et Conception Orientée Object (A/COO)
  • Chap. II. Développement Itératif et Processus Unifié
  • Chap. III.Etude de Cas : Système NextGen
  • Chap. IV. Initialisation
  • Chap. V. Comprendre les besoins
  • Chap. VI. Modèle de Cas d'Utilisation : rédaction des spécifications dans un contexte
  • Chap. VII. Identification des autres besoins
  • Chap. VIII. De l'initialisation à l'élaboration
  • Chap. IX. Modèle de cas d'utilisation : création de DSS
  • Chap. X. Modèle du domaine : les concepts
  • Chap. XI. Modèle du domaine : les associations
  • Chap. XII. Modèle du domaine : les attributs
  • Chap. XIII. Les Contrats d'opération
  • Chap. XIV. Des besoins à la conception dans l'itération en cours
  • Chap. XV. Notation des diagrammes d'interaction
  • Chap. XVI. GRASP : conception objet et reponsabilités
  • Chap. XVII. Modèle de conception : réalisation des cas d'utilisation avec les patterns GRASP
  • Chap. XVIII. Déterminer la visibilité
  • Chap. XIX. Diagrammes de classes de conception
  • Chap. XX. Modèle d'implémentation
  • Chap. XXI. Itération 2 et ses exigences
  • Chap. XXII. GRASP : autres patterns
  • Chap. XXIII. Conception et patterns GoF
  • Chap. XXIV. Itération 3 et ses exigences
  • Chap. XXV. Mise en relation des cas d'utilisation
  • Chap. XXVI. Modélisation de la généralisation
  • Chap. XXVII. Affinement du Modèle du domaine
  • Chap. XXVIII. Nouveaux DSS et contrats
  • Chap. XXIX. Modélisation du comportement et diagrammes d'états-transitions
  • Chap. XXX. Conception de l'architecture logique avec des patterns
  • Chap. XXXI. Organisation des packages
  • Chap. XXXII. Introduction à l'analyse architecturale
  • Chap. XXXIII. Autes réalisations de cas d'utilisation avec des objets et des patterns
  • Chap. XXXIV. Conception d'un framework de persistance
  • Chap. XXXV. Dessin et outils
  • Chap. XXXVI. Introduction à la planification itérative et à la conduite de projets
  • Chap. XXXVII. Commentaires sur le développement itératif et UP
  • Chap. XXXVIII. Compléments sur la notation UML

850 pages, 3è édition, 20 Mars 2005 Editions Pearson Education, ISBN: 2-7440-7090-4

Commandez sur www.amazon.fr :
42,75 EUR TTC seulement(au lieu de EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'UML 2 en concentré'

note du livre : 4.5

UML 2 en concentré   fr  

Manuel de référence

de Dan Pilone avec Neil Pitman
Denis Priou (trad.)

Public visé : Moyen


Développé à l'origine pour la conception et la modélisation de logiciels. le langage de modélisation unifié UML peut être utilisé dans un cadre beaucoup plus large et constitue un outil de communication pour des domaines allant de l'organisation d'une entreprise à la description d'un processus économique et financier ou d'un logiciel d'entreprise distribué. Véritable lingua franca, UML permet aux différents protagonistes d'un projet, qu'il s'agisse d'informaticiens, d'experts métiers ou d'utilisateurs, de communiquer efficacement. Pour répondre à cette mission, UML dispose d'une palette très étendue de concepts et de symboles dont la signification et l'usage sont parfaitement définis et qu'il convient de maîtriser. Cet ouvrage contient une présentation exhaustive de la version 2.0 d'UML, mais il se veut surtout pédagogique et illustratif. Loin d'être un exposé purement descriptif et froid, ce livre adopte une approche résolument pragmatique et propose des pratiques efficaces. UML permet en effet de spécifier une information dont la teneur peut varier considérablement d'un domaine à l'autre. Il est donc bien naturel que certaines parties d'UML ne s'appliquent pas à un problème particulier ou qu'elles n'apportent rien à la vue qu'un concepteur se propose de réaliser. Il est donc inutile, voire contre-productif, d'utiliser sans discernement tous les outils fournis par UML pour la conception d'un modèle. Il n'est pas nécessaire non plus d'utiliser toutes les notations proposées pour un diagramme. Le modélisateur se doit d'utiliser les seuls symboles et les seuls diagrammes utiles à la clarté de son propos. Le lecteur pourra donc effectuer des choix en toute connaissance de cause et comprendre les modèles qui lui sont proposés. Au sommaire : une description rigoureuse des différents diagrammes qui composent UML et le type d'information pour lequel ils sont le mieux adaptés ; une présentation détaillée des différents symboles, notations et types de ligne qui accompagnent chaque diagramme ; des explications sur le recours aux valeurs marquées, aux stéréotypes et aux profils qui servent à personnaliser UML pour un domaine d'application spécifique ; une introduction à l'architecture pilotée par modèle (MDA) et au langage de contraintes d'objets (OCL). Cet ouvrage s'adresse aussi bien à des lecteurs débutants, qui souhaitent apprendre la syntaxe et la sémantique d'UML, qu'à des lecteurs familiers du langage, qui ont besoin d'un ouvrage de référence.


Critique du livre par la rédaction ( Lionel Roux ) :

Quel que soit le niveau d'un développeur, il sera un jour ou l'autre amené à lire et peut-être réaliser une conception décrite en UML.

Une bonne compréhension et une bonne utilisation d'UML passent avant tout par une compréhension de l'esprit et la maitrise des finesses de cet outil.

Dan son ouvrage "UML 2 en concentré", Dan Pilone, un spécialiste reconnu dans le domaine, à l'origine de multiples livres sur le sujet, s'attache à détailler tout ce qu'il faut savoir d'UML, et en particulier les nouveautés introduites par la révision 2.0 d'UML.

Après avoir fait un bref rappel des notions fondamentales, il passe ne revue chacun des diagrammes de la norme en détailant chacune des spécificités. Il s'attache particulièrement à donner des exemples concrets pour chaque nouveau trait (attribut par exemple). Ceci rend la compréhension incrémentale voire presque intuitive.

En fin d'ouvrage, Dan Pilone introduit un chapitre visant à prôner la bonne utilisation des diagrammes UML et notamment les "anti-utilisations". Enfin, il tente une ouverture rapide vers MDA, une méthodologie permettant de générer du code à partir de modèles. Toutefois celle-ci mérite à elle seule un livre entier.

Cet ouvrage est à recommander à tous les informaticiens ou chefs de projets voulant améliorer leur compréhension d'UML ou voulant se mettre à jour vers la révision 2.0. Il se veut être un modèle didactique et pédagogique en la matière.


Sommaire

  • Notions fondamentales
  • Diagrammes de classes
  • Diagrammes de paquetage
  • Structures composites
  • Diagrammes de composants
  • Diagrammes de déploiement
  • Diagrammes de cas d'utilisation
  • Diagrammes d'état
  • Diagramme d'activités
  • Diagrammes d'interaction
  • Valeurs marquées, stéréotypes et profils UML
  • De l'utilisation efficace des diagrammes
  • L'architecture MDA (Model-Driven Architecture)
  • Le langage OCL (Object Constraint Language)

238 pages, 1 ère édition, janvier 2006 Editions O'Reilly, ISBN: 2-84177-373-6

Commandez sur www.amazon.fr :
38 € EUR TTC seulement(au lieu de 40 € EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'Extreme programming'

note du livre : 2.5

Extreme programming   fr  

précis et concis

de Chromatic
Michel Casabianca (trad.)

Public visé : Débutant, Moyen, comfirmé


L'Extreme Programming, ou XP, est une nouvelle approche du développement logiciel. Cette méthode met l'accent sur la simplicité, le feedback et l'implication de tous les membres d'un projet. Si vous êtes en retard dans votre projet, si vous avez dépassé votre budget, si vous avez perdu des heures et des heures à déboguer votre code, pourquoi ne pas envisager l'approche XP ? Ce guide présente ce qu'est XP et vous montre comment elle peut améliorer réellement votre manière de travailler. Il explique les différentes composantes de cette méthode les règles de base, les bonnes pratiques, la manière de coder (du code simple et réutilisable), l'organisation du travail en équipe, les relations avec le client, la gestion du calendrier. Si vous rencontrez des difficultés pour mener à bien vos projets, que vous soyez développeur, manager ou client, ce précis & concis vous montrera que XP peut vous aider à créer de bons systèmes répondant aux attentes métier et cela avec les ressources à votre disposition. XP a quelque chose à vous apprendre, ne serait-ce qu'à retrouver le plaisir de la programmation.


Critique du livre par la rédaction ( Lionel Roux ) :

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.


Sommaire

  • Pourquoi XP ?
  • Pratiques de l'Extreme Programming.
  • Evénements XP
  • Les artefacts de l'XP
  • Les rôles de l'XP.
  • Style de développement XP.
  • Adopter XP.
  • Ressources.

103 pages, 1ère édition, mars 2005 Editions O'Reilly, ISBN: 2-84177-358-2 , 11 x 1 x 18

Commandez sur www.amazon.fr :
9 EUR TTC seulement(au lieu de 8,55 EUR TTC : prix éditeur) - Livraison Gratuite à partir de 20 EUR !!!
couverture du livre 'Design Patterns'

note du livre : 3,5

Design Patterns   en  

Elements of Reusable Object-Oriented Software

de Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

Public visé : Avancé


Maintenant sur CD, the bestseller renommé internationallement a plus de valeur que jamais!

Utilisez le contenu de ce CD pour créer vos propres documents de design et vos composants réutilisables. Le CD contient 23 patterns que vous pouvez copier et coller dans vos propres documents de design, du code d'exemple démontrant l'implémentation du pattern, le contenu complet de Design Pattern au format HTML avec de nombreux liens hyper-textes croisés, accès grâce à un navigateur standard, mécanisme de recherche dynamique en Java, , environnement utilisateur graphique facilitant la navigation.

Publié en 1995, ce travail de fond sur le design de logiciel orienté objet présente un catalogue de solutions simples et succintes aux problèmes de design communs. Créés par 4 designers expérimentés, ces 23 patterns contenus dans ce livre sont devenus une ressource essentielle pour quiconque développe du logiel orienté objet réutilisable. En réponse à la demande des lecteurs, le texte complexe et le catalogue de pattern est maintenant disponible sur CD-ROM. Cette version électronique de Design Patterns permet aux programmeurs d'installer le livre sur un ordinateur ou un réseau pour une utilisation comme référence en ligne pour créer une logiciel orienté objet réutilisable.

Les auteurs décrivent dans un premier temps ce que sont les patterns et comment ils peuvent vous aider dans le processus de design. Par la suite, ils nomment, expliquent, évaluent et cataloguent systématiquement les designs récurrents dans les systèmes orientés objet. Chaque pattern est extrait d'exemple du monde réel et incluent du code qui montrent comment ils peuvent être implémentés dans des langages orientés objet tels C++ ou Smalltalk. Les lecteurs qui ont le livres choisiront le CD pour tirer parti de son mécanisme de recherche dynamique et des patterns prêt à l'installation.


Critique du livre par la rédaction ( Miles ) :

Tout d'abord, je préfère les livres aux versions électroniques, c'est comme ça, c'est personnel, mais ça enlève beaucoup du charme - la version papier est plus difficle à trouver, pas dispo sur Amazon, par ex -. On est obligé d'être scotché à son ordinateur au lieu de pouvoir en profiter dans le train, ... Ensuite, c'est un catalogue de patterns, comme indiqué dans la description, donc on a le droit 23 fois à la même chose, dans le même ordre, juste le contenu qui change, c'est parfois un peu difficile à lire d'une traite, d'où le concept de catalogue !

Passé la première impression un peu limite, on se dit que c'est bien fait. 3 grandes parties pour classer les patterns les plus utilisés. En plus, on commence par un exemple concret où on utilise plusieurs de ces patterns. Enfin, on dit plutôt qu'on peut utiliser tel pattern pour faire ceci ou cela, c'est vrai que c'est pas la même chose. Mais pour celui qui n'a jamais entendu parler de pattern, c'est important de voir comment on peut les utiliser.

Chaque pattern est agrémenté d'un diagramme UML pour savoir comment ça se passe. Mais on est pas obligé de connaître l'UML, un rapide récapitulatif est aussi disponible sur cxe qui sera utilisé dans les diagrammes, ce qui fait que j'ai même compris ce qui se passait :) Un exemple d'implémentation est à chaque fois donné, en C++ et en SmallTalk, ça change du sempiternel Java. Y'a pas que ses programmeurs qui peuvent bénéficier des patterns... Et aussi une petite explication sur ce qu'on fait et comment, c'est bien aussi.

Avec un peu de recul, ce catalogue est bien. Il n'a pas vieilli, la preuve d'une qualité de son contenu, ces patterns sont toujours encore utilisables et à utiliser. D'autres existent aussi, les auteurs en sont bien concients, et c'est bien, ils ne considèrent pas avoir la science infuse. Donc pour conclure, c'est sans doute LA référence en terme de pattern, même si on aurait préféré une version papier.


Sommaire

  • 1. Introduction.
    • What Is a Design Pattern?
    • Design Patterns in Smalltalk MVC.
    • Describing Design Patterns.
    • The Catalog of Design Patterns.
    • Organizing the Catalog.
    • How Design Patterns Solve Design Problems.
    • How to Select a Design Pattern.
    • How to Use a Design Pattern.
  • 2. A Case Study: Designing a Document Editor.
    • Design Problems.
    • Document Structure.
    • Formatting.
    • Embellishing the User Interface.
    • Supporting Multiple Look-and-Feel Standards.
    • Supporting Multiple Window Systems.
    • User Operations.
    • Spelling Checking and Hyphenation.
    • Summary.
  • 3. Creational Patterns.
    • Abstract Factory.
    • Builder.
    • Factory Method.
    • Prototype.
    • Singleton.
    • Discussion of Creational Patterns.
  • 4. Structural Pattern.
    • Adapter.
    • Bridge.
    • Composite.
    • Decorator.
    • Facade.
    • Flyweight.
    • Proxy.
    • Discussion of Structural Patterns.
  • 5. Behavioral Patterns.
    • Chain of Responsibility.
    • Command.
    • Interpreter.
    • Iterator.
    • Mediator.
    • Memento.
    • Observer.
    • State.
    • Strategy.
    • Template Method.
    • Visitor.
    • Discussion of Behavioral Patterns.
  • 6. Conclusion.
    • What to Expect from Design Patterns.
    • A Brief History.
    • The Pattern Community.
    • An Invitation.
    • A Parting Thought.
  • Appendix A: Glossary.
  • Appendix B: Guide to Notation.
    • Class Diagram.
    • Object Diagram.
    • Interaction Diagram.
  • Appendix C: Foundation Classes.
    • List.
    • Iterator.
    • ListIterator.
    • Point.
    • Rect.

CD-ROM pages, 1 ère édition, juin 1997 Editions Addison-Wesley Professional, ISBN: 0201634988

Commandez sur www.amazon.fr :
39,83 EUR TTC seulement(au lieu de 39,83 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'Test-Driven Development'

note du livre : 4,5

Test-Driven Development   en  

By Example

de Kent Beck

Public visé : Intermédiaire


Du code propre qui fonctionne - tout de suite. Ceci est apparemment une contradiction responsable de beaucoup de souffrances en programmation. Test-Driven Development, ou développement basé sur les tests, répond à cette contradiction par un paradoxe : testez le programme avant de l'écrire.

Une nouvelle idée ? Pas du tout. Depuis l'aube des calculs sur ordinateur, les programmeurs ont spécifié les entrées et les sorties de leur programme avant de l'écrire précisement. TDD reprend cette vieille idée, la mixe avec les langages modernes et les environnements de programmation et en fait un mets vous garantissant d'être rassasié de code clair qui fonctionne - tout de suite.

Les développeurs font tous les jours face à des défis, pourtant ils ne sont pas toujours préparés à trouver la meilleure solution. Le plus souvent, de grands projets génèrent beaucoup de stress et du mauvais code. Pour obtenir la force et le courage de surmonter cette tâche apparemment herculéenne, les programmeurs devrait regarder vers TDD, un jeu de techniques qui encourage les designs simples et les tests qui inspirent confiance.

En développant avec des tests automatiques puis en éliminant les doublons, chaque développeur peut écrire du code dans lequel on peut avoir confiance, sans bug quelque soit sa complexité. De plus, TDD encourage les programmeurs à apprendre rapidement, communiquer plus clairement et à obtenir un feedback constructif.

Les lecteurs apprendront à: Résoudre des tâches compliquées, commençant par la simplicité et continuant vers plus de complexité. Ecrire des tests automatiques avant de programmer Définir un design en refactorant pour ajouter des éléments petit à petit. Créer des tests pour de la logique plus complexe. Utiliser des patterns pour décider quels tests doivent être écrits. Créer des tests à l'aide d'xUnit, l'architecture au coeur de plusieurs outils de tests orientés vers les programmeurs.

Ce livre suit 2 projets à l'aide de TDD, du début à la fin, illustrant les techniques que les programmeurs peuvent utiliser pour améliorer facilement et de manière importante la qualité de leur travail. Les exemples sont suivis de références aux patterns TDD et au refactoring. Avec son accent sur les méthodes dites agiles et les stratégies de développement rapide, TDD encouragera les lecteurs à embrasser ces techniques sous-utilisées mais puissantes.


Critique du livre par la rédaction ( Miles ) :

On parle Java dans tout le livre, mais chaque conseil est pour tous les langages. De plus, le framework a été porté pour fonctionner avec presque tous les langages. L'approche de Kent Beck est agréable et didactique. On construit vraiment au fur et à mesure, petit pas par petit pas. Le premier exemple est simple, gérer de l'argent dans différentes devises, et ce petit exemple nous mène déjà loin.

En fait, les exemples servent juste à bien nous asséner le principe de Beck, tester en construisant progressivement. Si on a compris qu'on doit toujours tout tester et qu'aucun code ne doit être buggé quand on arrête le travail, on a compris le livre. Ensuite, l'auteur nous donne des astuces, des patterns pour avancer, comme écrire des tests isolés, ne dépendant pas de toute l'architecture afin de ne pas déprimer - important... -, faire des raisonnements inductifs pour généraliser une réponse, ...

Depuis la lecture de ce livre, je me suis mis aux tests. J'avoue qu'avant, c'était la dernière de mes préoccupations. Maintenant, mon code est plus propre - on dirait une pub de lessive, là -, et surtout bardé de tests au cas où j'aurai une modification au niveau de l'architecture à faire - refactoring, et ça arrive souvent -. En même temps, je n'applique pas sa solution à 100%, c'est tout de même très difficile, ça demande du temps d'écrire le test avant d'avoir la solution qui va avec, mais on voit aussi comment on avance, c'est bien ;)


Sommaire

  • I. THE MONEY EXAMPLE.
    • 1. Multi-Currency Money.
    • 2. Degenerate Objects.
    • 3. Equality for All.
    • 4. Privacy.
    • 5. Franc-ly Speaking.
    • 6. Equality for All, Redux.
    • 7. Apples and Oranges.
    • 8. Makin' Objects.
    • 9. Times We're Livin' In.
    • 10. Interesting Times.
    • 11. The Root of All Evil.
    • 12. Addition, Finally.
    • 13. Make It.
    • 14. Change.
    • 15. Mixed Currencies.
    • 16. Abstraction, Finally.
    • 17. Money Retrospective.
  • II. The xUnit Example.
    • 18. First Steps to xUnit.
    • 19. Set the Table.
    • 20. Cleaning Up After.
    • 21. Counting.
    • 22. Dealing with Failure.
    • 23. How Suite It Is.
    • 24. xUnit Retrospective.
  • III. Patterns for Test-Driven Development.
    • 25. Test-Driven Development Patterns.
    • 26. Red Bar Patterns.
    • 27. Testing Patterns.
    • 28. Green Bar Patterns.
    • 29. xUnit Patterns.
    • 30. Design Patterns.
    • 31. Refactoring.
    • 32. Mastering TDD.
  • Appendix I: Influence Diagrams.
  • Appendix II: Fibonacci.

240 pages, 1 ère édition, novembre 2002 Editions Pearson Education, ISBN: 0321146530

Commandez sur www.amazon.fr :
22,77 EUR TTC seulement(au lieu de 22,77 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'Design Patterns Tête la première'

note du livre : 4.5

Design Patterns Tête la première   fr  

de Eric Freeman, Elisabeth Freeman, Kathy Sierra, Bert Bates, Marie-Cécile Baland

Public visé : Débutant


Si vous souhaitez vous distinguer des développeurs ordinaires et devenir une force de proposition pour les architectures d'applications, vous vous devez de maîtriser les design patterns. Pour cela, rien ne vaut l'expérience de ceux qui ont déjà été confrontés aux mêmes problèmes. Vous profiterez à la fois de leur savoir-faire et de ce qui se fait de mieux en matière de conception. Qui plus est, vous gagnerez un temps précieux que vous occuperez bien mieux à autre chose de plus complexe et de plus amusant, ce qui fera le bonheur de vos chefs. Le plus important demeure que vous ne voulez pas vous endormir en apprenant les design patterns.

Si vous connaissez déjà la collection Tête la première, vous savez déjà à quoi vous en tenir. Voici les principaux bénéfices que vous tirerez de cet ouvrage : Distinguer les principaux patterns (Fabrique, Singleton, Adaptateur, Itérateur, Composite, etc.); Apprendre à les utiliser : quand et comment les appliquer dans vos conceptions, sans pour autant vous laisser gagner par la patternite Contrôler l'accès aux objets avec des proxies Maîtriser les mécanismes MVC et de son acolyte Web : MVC 2 Ne plus se sentir désoeuvré face à des problèmes de conception en apprenant à réaliser des conceptions souples qui s'adaptent à vos besoins Arriver à reconnaître les design patterns qui vous entourent au quotidien dans les API Java, les frameworks ou autres applications, et comprendre enfin comment ils fonctionnent Réaliser des conceptions bien pensées et faciles à maintenir.

Sous des dehors amusants et ludiques, cet ouvrage n'en demeure pas moins un guide d'apprentissage pas à pas. L'approche des auteurs est axée sur la pédagogie. Les concepts s'appuient sur des images et des exercices qui stimulent le cerveau. Jeux, images, interviews, mots-croisés, sont autant de moyens de vous amener à exploiter intelligemment les design patterns et de vous transmettre une vision claire et pragmatique des problèmes de conception. L'heure est venue de vous plonger dans les design patterns, tête la première !


Critique du livre par la rédaction ( Farscape ) :

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 œuvre 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.

Critique du livre par la rédaction ( Miles ) :

Quand on passe d'un livre-catalogue tel Design Patterns à celuic-i, on sent un grand soulagement. C'est agréable à lire, c'est clair, structuré. Chaque chapitre présente un pattern ou une famille de patterns, par exemple les Factories. A chaque fois, on a une petite histoire, un mini projet à suivre et qu'il faut construire. L'avantage est clairement qu'on sait où on pourrait appliquer ces méthodes, ça permet de gagner du temps.

Il y a pleins de petits exercices à faire, simples mais efficaces. Les illustrations sont des diagrammes - il le faut bien - ou des petites photos ou caricatures humoristiques. L'humour a une place primordiale, les auteurs ont bien compris que pour intéresser, il faut accrocher, et aussi accrocher par l'humour. On est vraiment plus dans un catalogue.

Par rapport à la référence en la matière, Design Patterns, ce livre ne présente que la moitié de ces mêmes patterns - on ne réinvente pas la roue -, la "bonne" moitié peut-être. En tout cas, si tous ces patterns avaient été abordés, on se serait retrouvé avec un pavé de 1200 pages, pas facile à lire et à assimiler, ce qui n'est pas le but non plus. Celui-ci est clairement d'aider les gens à commencer à les utiliser. Par la suite, on pourra toujours feuilleter un catalogue.

Le seul vrai inconvénient à mon avis est d'avoir traduit le nom des patterns. Ca fait français, OK, mais l'avantage de l'anglais est qu'on peut en discuter avec n'importe qui dans le monde. Comment va-t-on traduire patron de méthode ? Pense-t-on directement à Template Method ? Pas forcément, je pense. Le langage utilisé est le Java, mais ce n'est pas problématique. Si on sait que les pointeurs n'existent pas, que abstract, c'est virtual et que implements est un héritage, on comprend le livre.


Sommaire

  • Bienvenue aux Design Patterns
  • Tenez vos objets au courant : le pattern Observateur
  • Décorez les objets : le pattern Décorateur
  • Un peu de cuisine orientée objet : les pattern fabriques
  • Des objets uniques en leur genre : le pattern Singleton
  • Encapsuler l'invocation : le pattern Commande
  • Savoir s'adapter : les patterns Adaptateurs et Façade
  • Encapsuler les algorythmes : le pattern Patron de méthode
  • Des collections bien gérées : les patterns Itérateurs et Composite
  • L'état des choses : le pattern Etat
  • Contrôler l'accès aux objets : le pattern Proxy
  • Patterns de Patterns : patterns composés
  • Les patterns dans le monde réel : Mieux vivre avec les patterns

639 pages, 1 ère édition, septembre 2005 Editions O'Reilly, ISBN: 2841773507

Commandez sur www.amazon.fr :
51,30 EUR TTC seulement(au lieu de 54,00 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'Refactoring'

note du livre : 4,5

Refactoring   en  

Improving the Design of Existing Code

de Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts

Public visé : Débutant


Pendant que l'application de technologies objet - particulièrement dans le langage de programmation Java - devient courant, un nouveau problème est apparu dans la communauté du développement logiciel. Un nombre significatif de programmes mal designés ont été créés par des développeurs moins expérimentés, se traduisant par des applications qui sont inefficaces et difficiles à maintenir et à étendre. Les professionnels des systèmes logiciels découvrent de plus en plus la difficulté de travailler avec ces applications héritées, "non optimales". Pendant plusieurs années, les programmeurs objets d'un niveau d'expert ont employés une collection grandissante de techniques pour améliorer l'intégrité et la performance de ce genre de programmes existants. Connus sous le nom de "refactoring", ces pratiques sont restées dans le domaine des experts car aucune tentative avait été menée pour les transcrire dans une forme que tous les développeurs pouvaient utiliser... jusqu'à aujourd'hui. Dans Refactoring: Improving the Design of Existing Code, Martin Fowler, mentor renommé de la technologie objet ouvre une nouvelle voie, démystifiant ces pratiques avancées et démontrant comment les développeurs peuvent se rendre compte des bénéfices de ce nouveau processus.

Avec un entraînement adéquat, un designer aguerri de système peut prendre un mauvais design et le transformer en code robuste, bien designé. Dans ce livre, Martin Fowler nous montre où sont traditionnellement les opportunités pour le refactoring et comment passer d'un mauvais design à un bon. Chaque étape de refactoring est simple - apparemment trop simple pour mériter d'être effectuée. Refactorer peut impliquer déplacer un champ d'une classe à une autre, extraire du code d'une méthode pour en faire une nouvelle ou même modifier une hierarchie. Si ces étapes individuelles peuvent sembler élémentaires, l'effet cumulatif de ces petits changements peut améliorer grandement un design. Refactorer est un moyen efficace pour empêcher un logiciel de pérécliter.

Outre les discussions sur les différentes techniques de refactoring, l'auteur donne un catalogue détaillé de plus de 70 étapes avec des références judicieuses pour nous apprendre quand les appliquer, des instructions pas à pas pour chaque application d'un tel pattern et un exemple illustrant comment fonctionne le refactoring. Les exemples illustratifs sont écrits en Java, mais les idées sont applicables à tout langage orienté objet.


Critique du livre par la rédaction ( Miles ) :

Une référence, voilà ce qu'est devenu ce livre pour moi. Le catalogue de patterns - parce que je considère ces petites étapes comme des patterns - est dense, presque exhaustif - je suis sûr qu'on pourrait en trouver d'autres -, mais il y a les patterns les plus simples et les plus utiles. Comme le texte au dos du livre le dit, certaines étapes semblent vraiment trop simples, et c'est le cas. Tout le monde sait inliner une fonction. On a un peu plus de mal en extrayant une méthode d'une autre méthode, mais de manière générale, on serait tomber tôt ou tard sur ces patterns.

L'avantage du livre, ce n'est pas de nous redire ce qu'on sait, c'est de nous montrer une étape à laquelle on n'a pas pensé et qui résoud le problème qu'on a. Enfin, c'est pas un problème, c'est juste que le code commence à sentir mauvais. D'ailleurs, l'odeur du code, c'est une des caractéristiques de ce livre, Martin Fowler nous donne des pistes pour apprendre à reconnaître l'odeur d'un code. Ca m'a fait sourire de se dire que le code avait une odeur. Et c'est vrai que lorsqu'on regarde le code qu'on faisait quand on était plus jeune, on se rend compte qu'il pue.

Un autre point de ce livre, c'est qu'il met l'accent sur les tests, principalement unitaires. Et effectivement, pour un livre qui parle de refactoring, c'est important. Il faut bien que le code après modification ait le même effet que sans modification ! L'exemple qui est donné est aussi explicite, on utilise plusieurs méthodes au fur et à mesure de l'avancement de la procédure, c'est très intéressant de voir comment ça marche.

Enfin, le code est du Java, mais pour quelqu'un qui connait le C++, ça passe sans problème. Chaque opération est suffisemment simple pour être presque identique à son équivalent en C++. Enfin, un petit topo sur ce qui existait à l'époque sur le refactoring est donné, et même s'il est un peu dépassé, ce topo est très instructif.


Sommaire

  • 1. Refactoring, a First Example.
    • The Starting Point.
    • The First Step in Refactoring.
    • Decomposing and Redistributing the Statement Method.
    • Replacing the Conditional Logic on Price Code with Polymorphism.
    • Final Thoughts.
  • 2. Principles in Refactoring.
    • Defining Refactoring.
    • Why Should You Refactor?
    • When Should You Refactor?
    • What Do I Tell My Manager?
    • Problems with Refactoring.
    • Refactoring and Design.
    • Refactoring and Performance.
    • Where Did Refactoring Come From?
  • 3. Bad Smells in Code.
    • Duplicated Code.
    • Long Method.
    • Large Class.
    • Long Parameter List.
    • Divergent Change.
    • Shotgun Surgery.
    • Feature Envy.
    • Data Clumps.
    • Primitive Obsession.
    • Switch Statements.
    • Parallel Inheritance Hierarchies.
    • Lazy Class.
    • Speculative Generality.
    • Temporary Field.
    • Message Chains.
    • Middle Man.
    • Inappropriate Intimacy.
    • Alternative Classes with Different Interfaces.
    • Incomplete Library Class.
    • Data Class.
    • Refused Bequest.
    • Comments.
  • 4. Building Tests.
    • The Value of Self-testing Code.
    • The JUnit Testing Framework.
    • Adding More Tests.
  • 5. Toward a Catalog of Refactorings.
    • Format of the Refactorings.
    • Finding References.
    • How Mature Are These Refactorings?
  • 6. Composing Methods.
    • Extract Method.
    • Inline Method.
    • Inline Temp.
    • Replace Temp with Query.
    • Introduce Explaining Variable.
    • Split Temporary Variable.
    • Remove Assignments to Parameters.
    • Replace Method with Method Object.
    • Substitute Algorithm.
  • 7. Moving Features Between Objects.
    • Move Method.
    • Move Field.
    • Extract Class.
    • Inline Class.
    • Hide Delegate.
    • Remove Middle Man.
    • Introduce Foreign Method.
    • Introduce Local Extension.
  • 8. Organizing Data.
    • Self Encapsulate Field.
    • Replace Data Value with Object.
    • Change Value to Reference.
    • Change Reference to Value.
    • Replace Array with Object.
    • Duplicate Observed Data.
    • Change Unidirectional Association to Bidirectional.
    • Change Bidirectional Association to Unidirectional.
    • Replace Magic Number with Symbolic Constant.
    • Encapsulate Field.
    • Encapsulate Collection.
    • Replace Record with Data Class.
    • Replace Type Code with Class.
    • Replace Type Code with Subclasses.
    • Replace Type Code with State/Strategy.
    • Replace Subclass with Fields.
  • 9. Simplifying Conditional Expressions.
    • Decompose Conditional.
    • Consolidate Conditional Expression.
    • Consolidate Duplicate Conditional Fragments.
    • Remove Control Flag.
    • Replace Nested Conditional with Guard Clauses.
    • Replace Conditional with Polymorphism.
    • Introduce Null Object.
    • Introduce Assertion.
  • 10. Making Method Calls Simpler.
    • Rename Method.
    • Add Parameter.
    • Remove Parameter.
    • Separate Query from Modifier.
    • Parameterize Method.
    • Replace Parameter with Explicit Methods.
    • Preserve Whole Object.
    • Replace Parameter with Method.
    • Introduce Parameter Object.
    • Remove Setting Method.
    • Hide Method.
    • Replace Constructor with Factory Method.
    • Encapsulate Downcast.
    • Replace Error Code with Exception.
    • Replace Exception with Test.
  • 11. Dealing with Generalization.
    • Pull Up Field.
    • Pull Up Method.
    • Pull Up Constructor Body.
    • Push Down Method.
    • Push Down Field.
    • Extract Subclass.
    • Extract Superclass.
    • Extract Interface.
    • Collapse Hierarchy.
    • Form Template Method.
    • Replace Inheritance with Delegation.
    • Replace Delegation with Inheritance.
  • 12. Big Refactorings.
    • Tease Apart Inheritance.
    • Convert Procedural Design to Objects.
    • Separate Domain from Presentation.
    • Extract Hierarchy.
  • 13. Refactoring, Reuse, and Reality.
    • A Reality Check.
    • Why Are Developers Reluctant to Refactor Their Programs?
    • A Reality Check (Revisited).
    • Resources and References for Refactoring.
    • Implications Regarding Software Reuse and Technology Transfer.
    • A Final Note.
    • References.
  • 14. Refactoring Tools.
    • Refactoring with a Tool.
    • Technical Criteria for a Refactoring Tool.
    • Practical Criteria for a Refactoring Tool.
    • Wrap Up.
  • 15. Putting It All Together.

464 pages, 1 ère édition, Juin 1999 Editions Pearson Education, ISBN: 0201485672

Commandez sur www.amazon.fr :
42,17 EUR TTC seulement(au lieu de 42,17 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'Le projet d'urbanisation du S.I.'

note du livre : 4.0

Le projet d'urbanisation du S.I.   fr   CD disponible

Démarche pratique avec cas concret

de Christophe Longépé

Public visé : Intermédiaire


La notion d’urbanisme se situe bien évidemment dans le prolongement de celle d’architecture des systèmes d’information. Cet ouvrage montre comment organiser le S.I. d’une entreprise de façon suffisamment modulaire pour pouvoir rénover une fonction par exemple la gestion des stocks sans paralyser l’ensemble de l’entreprise tout en définissant les principes et les protocoles permanents qui assureront la cohérence et le fonctionnement de l’ensemble sur le long terme. Les principes de l’urbanisation ainsi que la démarche méthodologique sont illustrés dans ce livre par la mise en oeuvre d’un cas concret.
Public concerné : Directeurs des S.I - Directeurs informatiques - Maîtres d’ouvrages - Consultants.

Christophe Longépé est directeur de l'urbanisme, de l'architecture fonctionnelle et des référentiels à la Société Générale et chargé de cours à VIMI (Institut du Management de l'Information - Université de Technologie de Compiègne). II était précédemment directeur associé au sein de SchlumbergerSema Consulting en charge de la practice " Stratégie, urbanisme et architecture des systèmes d'information ".


Critique du livre par la rédaction ( Pierre Chauvin ) :

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é.



Sommaire

Le projet d'urbanisation du S.I.

  • Partie I. Les fondements
  • Partie II. Illustration de la démarche: le cas du tour-opérateur
  • Partie III. La démarche méthodologique
  • Partie IV. La dynamique des acteurs

284 pages, 2ème édition, 15 Janvier 2004 Editions Dunod, ISBN: 2100073761

Commandez sur www.amazon.fr :
33,25 EUR TTC seulement(au lieu de EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'UML 2'

note du livre : 4.0

UML 2   fr   CD disponible

Modéliser une application web

de Pascal Roques

Public visé : Debutant,Intermédiaire


Ce cahier montre à tous les programmeurs combien UML est un outil simple et universel : nullement réservé aux applications Java ou C++ ou C#, il s'applique parfaitement à des applications web telles que des sites marchands, dont la complexité en fait des candidats naturels à la modélisation.

Du cahier des charges au code, ce livre vous offrira les meilleures pratiques de modélisation avec UML 2.0 sous la forme d'une étude de cas. Toutes les étapes d'analyse et conception sont décrites, abondamment illustrées et expliquées, à travers une démarche située à mi-chemin entre processus lourd et processus léger.


Critique du livre par la rédaction ( jeromek ) :

A l'heure où l'univers des applications web est en plein essor, il est de plus en plus évident que le développement d'applications web robustes et pérennes passe par une phase de modélisation s'appuyant sur une méthodologie correcte. L'auteur nous guide, de chapitre en chapitre dans le processus de modélisation d'une application web en utilisant 6 des 13 diagrammes proposés par UML 2.0 qui sont utiles pour la modélisation d'une application web.

Ce livre est la réedition de l'ouvrage « UML, Modéliser un site e-commerce » (dont des critiques sont disponibles) dans lequel l'auteur à remis tout ces diagrammes à jour suivant les nouveautés d'UML 2.0.

A noter la présence d'une annexe reprennant les diagrammes UML 1.4 de la précédente edition (utile pour les lecteurs de la précédente édition qui desireraient comparer les 2 types de diagrammes).

Je conseille ce livre à tout developpeur web, c'est très bien écrit, très pédagogique, et l'exemple pratique à été particulièrement bien choisi.


Sommaire

UML 2 - Modéliser une application web

  • Introduction
  • Quelle démarche pour passer des besoins utilisateur au code de l'application ?
  • Fonctionnalités d'une librairie en ligne : l'application côté utilisateur
  • Spécification des exigences d'après les cas d'utilisation
  • Spécification détaillée des exigences
  • Réalisation des cas d'utilisation : classes d'analyse
  • Modélisation de la navigation
  • Conception objet préliminaire
  • Conception objet détaillée
  • A : résumé du sous-ensemble de la notation UML 2.0 utilisé dans ce livre
  • B : récapitulatif du modèle UML 2.0 illustrant la démarche de modélisation d'un site e-commerce
  • C : modèle UML 1.4 de la précédente édition (réalisé avec Rational/Rose 2002)
  • Index

236 pages, 1ère édition, Février 2006 Editions Eyrolles, ISBN: 2212117701

Commandez sur www.amazon.fr :
23,75 EUR TTC seulement(au lieu de 25,00 EUR TTC : prix éditeur) - Livraison Gratuite !!!
couverture du livre 'Refactoring to Patterns'

note du livre : 4.5

Refactoring to Patterns   en  

de Joshua Kerievsky

Public visé : Débutant, Intermédiaire


Ce livre traite du mariage du refactoring - le processus d'amélioration du design du code existant - avec des patterns, les solutions classiques aux problèmes récurrents de design. Refactoring to Patterns suggère que l'utilisation des patterns pour améliorer un design existant est meilleur que l'utilisation des patterns tôt dans un nouveau design. Ceci est vrai, que le code soit jeune ou vieux. Nous améliorons les designs avec des patterns en appliquant des séquences de transformations de design de bas niveau, aussi connu sous le nom de refactorings.


Critique du livre par la rédaction ( Miles ) :

Une sorte de suite à Refactoring de Martin Fowler, puisque tous les processus décrits ou presque utilisent des patterns décrits dans ce livre. Les différentes catégories sont aussi bien séparées l'auteur n'oblige pas à aller jusqu'aux patterns décrits dans Design Patterns, on n'en a pas toujours besoin - vive les surpopulations de singletons par exemple -. Selon ce qu'on a à faire, plusieurs solutions sont utilisables, plus ou moins loin de ces patterns.

Le code proposé est du Java, il est parfois un peu difficile de faire le lien avec d'autres langages orientés objet offrant des outils différents. En revanche, pour chaque refactoring to pattern, un petit topo sur pourquoi et comment faire est proposé. Ces petites étapes permettent de s'en sortir. L'introduction du livre est très importante, par exemple, un accent y est mis sur l'élémentarité des étapes, simples de préférence.

Comme précisé ci-dessus, ce livre fait la part belle à Fowler, le livre fait aussi partie de la collection Fowler. Ensuite est-ce que c'est pour la signature Fowler qu'il y a autant de référence au livre Refactoring ? Non, ce dernier est une base, un fondement que Refactoring to Patterns utilise pour aller plus loin, plus vite. Ce que Refactoring ne pouvait aborder par manque de place, Refactoring to Patterns l'aborde et va au bout. Sans imposer, juste en proposant.


Sommaire

  • 1. Why I Wrote This Book.
    • Over-Engineering.
    • The Patterns Panacea.
    • Under-Engineering.
    • Test-Driven Development and Continuous Refactoring.
    • Refactoring and Patterns.
    • Evolutionary Design.
  • 2. Refactoring.
    • What Is Refactoring?
    • What Motivates Us to Refactor?
    • Many Eyes.
    • Human-Readable Code.
    • Keeping It Clean.
    • Small Steps.
    • Design Debt.
    • Evolving a New Architecture.
    • Composite and Test-Driven Refactorings.
    • The Benefits of Composite Refactorings.
    • Refactoring Tools.
  • 3. Patterns.
    • What Is a Pattern?
    • Patterns Happy.
    • There Are Many Ways to Implement a Pattern.
    • Refactoring to, towards, and away from Patterns.
    • Do Patterns Make Code More Complex?
    • Pattern Knowledge.
    • Up-Front Design with Patterns.
  • 4. Code Smells.
    • Duplicated Code.
    • Long Method.
    • Conditional Complexity.
    • Primitive Obsession.
    • Indecent Exposure.
    • Solution Sprawl.
    • Alternative Classes with Different Interfaces.
    • Lazy Class.
    • Large Class.
    • Switch Statements.
    • Combinatorial Explosion.
    • Oddball Solution.
  • 5. A Catalog of Refactorings to Patterns.
    • Format of the Refactorings.
    • Projects Referenced in This Catalog.
    • A Starting Point.
    • A Study Sequence.
  • 6. Creation.
    • Replace Constructors with Creation Methods.
    • Move Creation Knowledge to Factory.
    • Encapsulate Classes with Factory.
    • Introduce Polymorphic Creation with Factory Method.
    • Encapsulate Composite with Builder.
    • Inline Singleton.
  • 7. Simplification.
    • Compose Method.
    • Replace Conditional Logic with Strategy.
    • Move Embellishment to Decorator.
    • Replace State-Altering Conditionals with State 166
    • Replace Implicit Tree with Composite.
    • Replace Conditional Dispatcher with Command.
  • 8. Generalization.
    • Form Template Method.
    • Extract Composite.
    • Replace One/Many Distinctions with Composite.
    • Replace Hard-Coded Notifications with Observer.
    • Unify Interfaces with Adapter.
    • Extract Adapter.
    • Replace Implicit Language with Interpreter.
  • 9. Protection.
    • Replace Type Code with Class.
    • Limit Instantiation with Singleton.
  • 10. Accumulation.
    • Move Accumulation to Collecting Parameter.
    • Move Accumulation to Visitor.
  • 11. Utilities.
    • Chain Constructors.
    • Unify Interfaces.
    • Extract Parameter.

400 pages, 1 ère édition, août 2004 Editions Addison-Wesley Professional, ISBN: 0321213351

Commandez sur www.amazon.fr :
42,72 EUR TTC seulement(au lieu de 42,72 EUR TTC : prix éditeur) - Livraison Gratuite !!!

Voir également:
Tous les livres de DVP
Les cours de la rubrique UML
La FAQ UML

Valid XHTML 1.1!Valid CSS!


Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2005 Developpez LLC Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Contacter le responsable de la rubrique UML