Cet ouvrage s'adresse à tous les professionnels, concepteurs et développeurs, qui souhaitent mieux maîtriser UML 2 et acquérir une démarche pratique de mise en oeuvre ainsi qu'aux étudiants en informatique.
Il propose une approche pédagogique de l'aspect normatif d'UML 2 et une démarche d'élaboration des diagrammes couvrant l'analyse et la conception des systèmes d'information. Le lecteur suit un apprentissage progressif fondé sur de nombreux exemples, exercices corrigés et de véritables études de cas se rapprochant de projets réels d'entreprise.
Cette édition sert trois objectifs :
présenter les treize diagrammes d'UML 2 en conciliant le respect strict de la norme avec une application centrée sur les SI des entreprises ;
décrire l'analyse et la conception des SI à l'aide des diagrammes d'UML 2 en s'appuyant sur des exemples et des exercices adaptés au contexte professionnel ;
proposer une démarche de mise en oeuvre d'UML 2 structurée en phases et activités, décrite à l'aide de fiches guides et illustrée par deux études de cas détaillées.
Critique du livre par la rédaction (Benwit)
(08/08/2011)
UML est un langage de modélisation décrit par une norme qui propose différents diagrammes. Le développeur qui souhaite utiliser UML doit connaître ces diagrammes pour les comprendre d'une part et les construire d'autre part. La première partie de ce livre (chapitres 1, 2 et 3) est une présentation théorique qui va à l'essentiel. De plus, bien conscients de l'importance de la pratique, les auteurs ont eût la bonne idée d'inclure des exercices corrigés.
UML n'étant pas une méthode, il n'y a pas de guide à suivre. La deuxième partie de ce livre (chapitres 4, 5 et 6) vise à combler cette lacune. Les auteurs décrivent leur démarche (UP7) basée sur UP (Unified Process) et tirée de leurs expériences. Cette partie est la plus intéressante car ils partagent 18 fiches guides qu'ils mettent en oeuvre dans deux études de cas.
En conclusion, j'ai particulièrement aimé dans ce livre son côté pragmatique et son apport d'une démarche d'élaboration des diagrammes UML qui le distingue des autres ouvrages sur le sujet.
Critique du livre par la rédaction (Fleur-Anne BLAIN)
(Avril 2010)
Après un enseignement du même type, j'ai souhaité lire cet ouvrage afin de péréniser mes connaissances et de découvrir les nouveautés UML proposées. Comme le précise la 4ème de couverture, ce livre est destiné à un public large : du débutant aux professionnels qui souhaitent rester à la page.
L'auteur met à notre disposition 10 chapitres d'une introduction à UML en passant par les différents diagrammes à leurs mise en oeuvre. Chaque chapitre est introduit très clairement à travers son sommaire détaillé et surtout des objectfs clairs. Des travaux dirigés complets (où vous pouvez même apprendre à faire une mousse au chocolat), avec corrections en fin d'ouvrage, permettent d'appliquer les connaissances acquises par chapitre. Nous pouvons y apprendre comment modéliser une même chose de manière différente via des significations implicites ou explicites d'UML. L'auteur nous démontre tout ce qu'il est possible de faire mais aussi ce qu'il ne faut pas faire. Nous apprenons à "lire et écrire l'UML".
Une plus value de cet ouvrage est la référence à la modélisation de bases de données relationelles via UML. Enfin nous avons l'explication afin de quitter MERISE et de tenter une approche via UML où nous est présenté une implémentation claire en SQL. Il en fait de même via une implémentation JAVA ou C++ ce qui peut être une barrière pour certains.
L'auteur ne cache pas les zones de flou de la norme UML, précise clairement les nouveautés d'UML2.2 ce qui est très pratique lorsque l'on a déjà pratiqué. Un vocabulaire précis et consciencieux est acquis au fil des chapitres.
Pour conclure, ce livre permet d'apprendre ou revoir pas à pas l'UML2 au travers d'une introduction orientée objet, tous les diagrammes y compris les nouveautés, le langage précis et beaucoup d'illustrations. Les références aux normes UML ainsi qu'à d'autres ouvrages permettent aux curieux d'aller plus loin.
Enfin, le chapitre intitulé mise en oeuvre d'UML permet une vision plus large de l'application d'UML avec une ouverture élargie via des méthodes actuelles telles que SCRUM, XP, ...
Sommaire
Chapitre 1 : Introduction à la modélisation objet
Chapitre 2 : Diagramme de cas d'utilisation
Chapitre 3 : Diagramme de clases
Chapitre 4 : Object constraint language (OCL)
Chapitre 5 : Diagramme d'états-transitions
Chapitre 6 : Diagramme d'activités
Chapitre 7 : Diagrammes d'interaction
Chapitre 8 : Diagrammes de composants et de déploiement
de Naouel KARAM - Fien VAN DER HEYDE - Laurent DEBRAUWER
Public visé : Débutants, Intermédiaires
Résumé de l'éditeur
Ces deux livres offrent au lecteur un maximum d'informations sur UML 2 et plus de 28 H de mise en pratique sous la forme de TP à réaliser (avec leurs corrigés). Le livre de référence de la collection Ressources Informatiques : UML 2 - Initiation, exemples et exercices corrigés [2e édition] Ce livre sur UML 2 s'adresse tout autant aux étudiants qu'aux développeurs pratiquant la modélisation de systèmes et de processus. Vous découvrirez, étape par étape, les éléments de modélisation à partir d'exemples pédagogiques issus... du monde des chevaux. Après une introduction à l'approche par objets, cet ouvrage introduit les différents diagrammes d'UML 2 depuis la description des exigences par les cas d'utilisation jusqu'au diagramme des composants en passant par les diagrammes d'interaction, de classes, d'états transitions et d'activités. Vous apprendrez comment les diagrammes d'interaction peuvent être utilisés pour découvrir les objets composant le système. Cette nouvelle édition du livre introduit le diagramme de structure composite. Le livre de la collection Les TP Informatiques : UML 2 - Entraînez-vous à la modélisation Ce livre sur UML 2 s'adresse tout autant aux informaticiens proches de la modélisation qu'à ceux proches de la conception et du développement et qui souhaitent maîtriser UML 2. Il propose de nombreux exercices pratiques de difficulté variable pour maîtriser les différents aspects des diagrammes principaux (modélisation d'une conférence scientifique, d'un parcours de document XML, d'un système de vente de billets de train). Un chapitre particulier présente l'utilisation d'UML en modélisation et en conception (réalisation d'un diagramme d'états-transitions) et une étude de cas complète (librairie en ligne) explique comment mettre en œuvre UML dans un cadre de commerce électronique.
Critique du livre par la rédaction (benwit)
(janvier 2010)
D'entrée de jeu, les auteurs précisent ce qu'est UML (Un support de modélisation par objets de systèmes et de processus) et ce qu'il n'est pas. Si vous cherchez un guide de modélisation, cet ouvrage ne vous conviendra donc pas, pas plus d'ailleurs que d'autres livres sur UML. Cependant, celui-ci a l'avantage de présenter les liens qu'UML entretient avec RUP et MDA.
Dans ce livre, l'idée de présenter UML en utilisant des exemples du même domaine (le monde équin en l'occurrence) est une bonne idée. Il est donc dommage qu'au chapitre 6, un exemple avec des voitures arrive de manière impromptue. Le graphisme de ces exemples étant par ailleurs différent, on peut se demander si ce n'est pas un ajout de dernière minute ?
Si vous cherchez des exemples de code, vous ferez l'impasse sur celui-ci qui en est dépourvu. D'autant que si les exemples proposés modélisent de vrais systèmes (au sens large du terme), on a parfois du mal à voir l'application informatique sous-jacente !
Si, en revanche, UML vous intéresse en tant que langage graphique de modélisation, indépendant de l'implémentation (PIM de MDA), cet ouvrage atteint son objectif. Et chose appréciable, il fournit des exercices avec corrigés, un glossaire des termes et même un lexique français/anglais.
Le seconde livre propose quant à lui de nous entrainer à la modélisation. Cette fois ci, les exemples sont de tous domaines et plus proche des systèmes informatiques, ce qui en fait un bon complément. Et comme tous les ouvrages de la collection TP informatiques, il est également un bon support de cours (test des prérequis et estimation de durée).
En conclusion, si c'est juste pour une vue générale d'UML, le premier livre peut vous suffire mais ci c'est pour apprendre à modéliser, l'offre groupée est intéressante.
Sommaire
Introduction
A propos d'UML
Les concepts de l'approche par objets
La modélisation des exigences
La modélisation de la dynamique
La modélisation des objets
La structuration des éléments de modélisation
La modélisation du cycle de vie des objets
La modélisation des activités
La modélisation de l'architecture du système
515 pages,
2ième édition édition,
6 juillet 2009
Éditions ENI,
ISBN10 : 2746049864,
ISBN13 : 978-2746049864,
17 x 21
Commandez sur www.editions-eni.fr :
46,55
EUR TTC seulement (au lieu de 49
EUR TTC : prix public)
UML 2 par la pratique : Etudes de cas et exercices corrigés
de Pascal Roques
Public visé : débutant à confirmé
Résumé de l'éditeur
Cette sixième édition mise à jour et augmentée de l'ouvrage UML 2 par la pratique constitue un support de cours exemplaire sur UML 2. Il traite les axes fonctionnel, statique et dynamique de la modélisation UML par des études de cas et des exercices corrigés donnant les bases d'une démarche méthodique. Chaque choix de modélisation est minutieusement commenté ; des conseils issus de l'expérience de l'auteur sont donnés et un glossaire reprend en fin d'ouvrage les définitions des principaux concepts étudiés. Les nouveaux concepts et diagrammes UML 2 sont traités en détail : diagramme de structure composite, nouveautés du diagramme d'activité et du diagramme de séquence, etc. Enfin, une étude de cas complète illustre le processus de développement itératif depuis la modélisation métier jusqu'à là conception détaillée en Java et C#. A qui s'adresse ce livre ? Aux étudiants en informatique (cursus génie logiciel ou modélisation UML) et à leurs professeurs, qui y trouveront un matériel précieux pour illustrer par des cas réels les concepts étudiés en cours. A toutes les personnes impliquées dans des projets de développement logiciel : maîtres d'ouvrage, chefs de projet, analystes et concepteurs, architectes logiciel, développeurs, etc.
Ce livre n'a pas pour objectif de vous apprendre à faire un diagramme UML, de nombreux livres et sites Internet le font déjà et certains le font très bien. Ce livre va plutôt tenter de vous apprendre à faire un bon diagramme UML, exercice bien plus délicat et subtil, et que peu de ressources décrivent. Ne vous attendez donc pas à y trouver des explications détaillées sur toutes les subtilités de chaque diagramme, mais il vous aidera à trancher entre plusieurs solutions de représentation en vous décrivant les avantages et les inconvénients de chaque technique.
A l'inverse d'une démarche théorique, ce livre se veut très concret et se base sur de nombreux exercices corrigés. La correction ne consistant pas à vous fournir directement une réponse, mais à argumenter les choix faits tout en proposant un processus de réflexion.
La « carte de référence UML2 » en couverture est un petit plus intéressant qui permettra de se remémorer en un seul coup d'oeil les principes de base des principaux diagrammes d'UML2.
A noter pour ceux possédant ou ayant lu la 5ème édition que les évolutions sont plutôt mineures pour cette dernière édition.
Sommaire
Point de vue fonctionnel
Modélisation fonctionnelle : étude de cas
Modélisation fonctionnelle : exercices corrigés et conseils méthodologique
point de vue statique
Modélisation statique : étude de cas
Modélisation statique : exercices corrigés et conseils méthodologique
point de vue dynamique
Modélisation dynamique : étude de cas
Modélisation dynamique : exercices corrigés et conseils méthodologique
Conception
Étude de cas complète : de la modélisation métier à la conception détaillée en java ou C#
Commandez sur http://www.eyrolles.com :
28.41
EUR TTC seulement (au lieu de 29.9
EUR TTC : prix public)
Commandez sur www.amazon.fr : 28.41 EUR TTC seulement (au lieu de 29.90 EUR TTC : prix éditeur)
-
Livraison Gratuite !
L'orienté objet
de H. Bersini, I. Wellesz
Résumé de l'éditeur
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.
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.
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
Uml2
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
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
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.
Commandez sur www.amazon.fr : 37.05 EUR TTC seulement (au lieu de 39.00 EUR TTC : prix éditeur)
-
Livraison Gratuite !
Introduction à UML
de Sinan Si Alhir
Traducteur(s) : Alexandre Gachet
Public visé : Debutant
Résumé de l'éditeur
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.
Ayant quelques bases en programmation orientée objet et voulant me lancer dans un projet d'envergure moyenne, je me suis intéressé au langage UML.
N'ayant jamais été déçu par des livres O'Reilly, j'ai décidé de me procurer "Introduction à UML".
Et là le choc. Le livre n'est pas du tout comme je l'attendais. L'exemple mis en place au long des chapitres n'est pas vraiment ce que l'on peut qualifier de passionnant mais a le mérite de couvrir toutes les facettes d'UML. Le style d'écriture utilisé est très précis, très clair et formel mais donne au lecteur une envie de s'assoupir.
Néanmoins, le livre couvre tout ce qu'une introduction doit couvrir et va même un peu plus loin. Très dense et complet, il est à recommander à tout ceux qui accrocheront. Une impression mitigée donc, tant le ton est sérieux et austère.
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
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.
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)
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.
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.
Un très bon livre, qui explique clairement et simplement les principes de bases d'UML 2.0 Si vous ne connaissez pas UML, alors je vous le recommande afin d'acquérir de bonnes bases.
Bien sur, c'est une version "concentrée" donc tous les sujets ne sont pas forcément abordés dans les moindres détails. Cependant, ce livre est vraiment parfait pour débuter !
De plus, il permettra aux développeurs ayant déjà des connaissances en UML 2.0, de se rafraichir la mémoire et consitue donc un excellent mémento en la matière.
UML est le langage de référence pour la modélisation des systèmes d'information. Il a l'avantage d'être complètement indépendant de la plateforme cible et de, par sa richesse, offrir des des moyens d'abstraction extrêmement puissants et abstraits.
Cependant les ressources fournies par l'OMG, bien que forcement très complètes, restent quelque peu indigestes, et en anglais, et il est bien souvent indispensable de passer par une ressource tierce afin de mieux comprendre et maitriser ce formidable langage. Dans cet ouvrage, Pascal Roques et Frank Vallée, véritables gourous du domaine, se sont appliqués à présenter la norme UML 2.0, avec son lot de nouveautés, en détaillant, à chaque étape du processus de développement, l'utilisation des diagrammes et leur intérêt. UML prend ici place au sein du processus itératif 2TUP (Two Track Unified Process) afin d'être mis en application dans un véritable modèle de développement évitant ainsi toute présentation « catalogue » d'UML.
UML 2 en action est un très bon ouvrage sur l'utilisation "en vrai" d'UML. Comme son nom l'indique, il vous
propose de découvrir, pas à pas, au travers d'une étude de cas, ce que UML peut apporter à vos développements.
Mais avant de se ruer sur l'achat de ce livre, il faut faire attention à deux choses. D'abord, contrairement à ce que
l'on peut lire dans le résumé de l'éditeur, cet ouvrage n'est pas à destination des débutants. Un pré-requis
inévitable est de connaître UML et sa notation avant de se lancer dans la lecture de ce livre. En effet, celui-ci
ne donne aucune indication quant à cette notation.
Ensuite, il faut être conscient que vous ne serez probablement pas interessé par l'entièreté de l'ouvrage. Tous les
chapitres ne sont pas pour tout le monde, et chacun est à destination de deux ou trois catégories de lecteurs :
analystes, architectes, concepteurs, etc.
Cependant, vous pourrez toujours avoir envie de tout lire, pour vous familiariser avec d'autres branches du métier de
l'informatique, ou simplement parce que vous touchez déjà à tout :-)
En dehors de cela, cependant, on ne peut rien trouver à redire à ce livre. Il explique en détails et avec une simplicité
déconcertante comment vous pouvez vraiment utiliser UML. Ressorti de ce livre, vous comprendrez les réels
intérêts d'UML pour toute la première partie du cycle de développement : de l'analyse des besoins à la conception
détaillée, comme le signale si bien le sous-titre de l'ouvrage.
C'est pourquoi je recommande fortement ce livre comme deuxième ouvrage sur UML ; après (ou avec) un premier qui
vous apprendra la notation de ce langage.
La différence avec les autres livres traitant d'UML ? Ici rien à voir avec un petit guide utilisateur en 13 leçons pour tout connaitre d'UML : les auteurs présentent une étude de cas grandeur nature, UML est intégré à une démarche globale, un processus itératif, 2TUP en l'occurrence, et voila toute la différence. Fini les concepts abstraits, vous avez la réflexion et la démarche, la modélisation et la conception, à chaque étape ses diagrammes, avec de multiples études de cas accompagnées de définitions, conseils et de « choses à ne pas faire ». Tout est détaillé pour vous permettre de mettre en œuvre ce langage dans vos propres projets, et est suffisamment clair pour ne pas vous perdre et vous éviter d'abandonner après le premier chapitre.
Quelque soit votre langage de prédilection, ne vous laissez pas arrêter par l'intitulé en J2EE: dans le cas qui nous intéresse, seuls les 2 derniers chapitres traitant de la conception sont avec les exemples écrits en Java. Avec UML2 en action, Vous avez en main le livre nécessaire pour appréhender UML dans un contexte pratique et professionnel et par chance il est en français. Tout étudiant, professionnel ou universitaire se doit de connaitre ce langage et pour ça le livre de Pascal Roques et Franck Vallée est le compagnon idéal.
A lire et a posséder absolument.
Sommaire
CHAPITRE 1 : INTRODUCTION 1
Prérequis
Structure de l'ouvrage
Comment lire UML en Action
Remerciements
CHAPITRE 2 : PROCESSUS ET ARCHITECTURE
Le processus 2TUP
Un processus itératif et incrémental piloté par les risques
Un processus piloté par les exigences des utilisateurs
Un processus de modélisation avec UML
Les diagrammes d'UML 2.0
Un processus par niveaux d'abstraction
Les points de vue de modélisation
Un processus centré sur l'architecture
Un processus orienté vers les composants
CHAPITRE 3 : ÉTUDE PRÉLIMINAIRE
Cahier des charges
Identifier les acteurs
Identifier les messages
Modéliser le contexte
CHAPITRE 4 : CAPTURE DES BESOINS FONCTIONNELS
Identifier les cas d'utilisation
Décrire les cas d'utilisation
Organiser les cas d'utilisation
Décrire les cas d'utilisation en identifiant les flux entre application
Identifier les classes candidates
Valider et consolider
CHAPITRE 5 : CAPTURE DES BESOINS TECHNIQUES
Spécification technique du point de vue matériel
Spécification d'architecture et influence sur le modèle de déploiement
Élaboration du modèle de spécification logicielle
Organisation du modèle de spécification logicielle
Développement des couches logicielles
Définition des concepts techniques
Description d'un cas d'utilisation technique
CHAPITRE 6 : DÉCOUPAGE EN CATÉGORIES
Notion de catégorie
Découpage en catégories
Dépendances entre catégories
CHAPITRE 7 : DÉVELOPPEMENT DU MODÈLE STATIQUE
Affiner les classes
Affiner les associations
Ajouter les attributs
Ajouter les opérations (optionnel)
Optimiser avec la généralisation
Encore un petit effort !
CHAPITRE 8 : DÉVELOPPEMENT DU MODÈLE DYNAMIQUE
Identifier les scénarios
Spécification Formaliser les scénarios
Construire les diagrammes d'états
Valider les diagrammes d'états avec les diagrammes d'interactions
Confronter les modèles statique et dynamique
CHAPITRE 9 : CONCEPTION GÉNÉRIQUE
Classes et frameworks techniques
Élaboration du modèle logique de conception
Introduction aux design patterns
Le design pattern « singleton »
Le design pattern « fabrication »
Construire de nouveaux design patterns
Conception dynamique d'un framework
Organisation du modèle logique de conception technique
Les contraintes de réutilisation dans la conception générique
Élaboration du modèle d'exploitation de la conception technique
Élaboration du modèle de configuration logicielle de la conception technique
Prise en compte de la génération de code
Développement d'un prototype
CHAPITRE 10 : CONCEPTION PRÉLIMINAIRE
Quand intervient la conception préliminaire ?
Développement du modèle de déploiement
Développement du modèle d'exploitation
Énumération des interfaces utilisateur
Développement du modèle logique
Définir l'interface des catégories
Concevoir la structure objet des IHM
Organiser la configuration logicielle
CHAPITRE 11 : CONCEPTION DÉTAILLÉE
Le micro-processus de conception logique
Concevoir les classes
Concevoir les associations
Concevoir les attributs
Concevoir les opérations
Conception de la couche de présentation
Conception de la couche Application
Conception de la couche métier distribuée
Conception du stockage des données
Développer la configuration logicielle
ANNEXE 1 : BIBLIOGRAPHIE
ANNEXE 2 : SYNTHÈSE DE LA NOTATION UML 2.0
ANNEXE 3 : SYNTHÈSE DES STÉRÉOTYPES UML
ANNEXE 4 : RÉCAPITULATIF DES CONSEILS ET DES PIÈGES
386 pages,
3ème édition,
juin 2004
Éditions Eyrolles,
ISBN10 : 2212114621,
Broché, 19 x 23, Noir et Blanc
Cet ouvrage est extrait du titre "UML2 - Initiation, exemples et corrigés" dans la collection Ressources Informatiques aux Editions ENI. Si vous pratiquez la modélisation de systèmes, il vous donnera les moyens d'apprendre UML 2 et de vous exercer. Si vous êtes débutant, aucun pré-requis particulier n'est nécessaire. Si vous connaissez déjà la première version d'UML, l'ouvrage vous apprendra à tirer profit des extensions apportées par la version 2. Si vous avez déjà travaillé avec le modèle entités-relations, vous découvrirez la puissance apportée par UML 2 en modélisation des objets.
Ce livre va vous montrer comment utiliser UML 2 pour modéliser des objets. Vous allez apprendre comment décrire dans le langage UML la statique des objets, mais aussi leur dynamique, ainsi que la définition de fonction d'un programme Pour faire cela, le livre va vous faire découvrir les diagrammes de cas d'utilisation, de classes, de communication et de séquence.
Ce livre ne se veut pas exhaustif, c'est une introduction qui vous permettra de débuter avec UML. Et de ce coté-là, il remplit tout à fait son but. En plus, il vous proposera même des exercices pour mettre en application ce que vous avez appris à chaque chapitre. On peut tout de même lui reprocher le fait d'avoir voulu mettre trop de choses dans peu de pages, ce qui se traduit parfois par des informations trop résumées et donc compliquées à comprendre. Mais en général, le style est plutôt agréable et les informations intéressantes. De plus, chaque nouvelle connaissance qui est abordée est expliquée à l'aide d'exemples concrets.
En conclusion, ce livre vous permettra de découvrir UML et de le mettre en application pour vos projets. Il ne vous permettra pas par contre de connaître l'entier du langage UML. Pour cela, dirigez-vous vers un ouvrage plus conséquent.
Sommaire
Chapitre 1 : A propos d'UML
Chapitre 2 : Les principes de l'approche par objet
La plupart des livres sur UML s'adressent avant tout aux concepteurs et architectes logiciels, selon une démarche "tout-modèle" dans laquelle la production de code est traitée comme une activité subalterne. Cette approche suscite évidemment des réticences chez les développeurs et déconcerte les étudiants, dont la formation reste axée principalement sur la programmation et qui mesurent mal les enjeux du formalisme UML.
UML 2 pour les développeurs prend le contre-pied de ces approches classiques. L'ouvrage montre comment articuler harmonieusement modélisation et programmation, en insistant sur les gains de productivité que permettent ces allers-retours entre les modèles UML et le code.
Chaque notion UML importante est introduite par un exemple et chaque chapitre se clôt par une série d'exercices corrigés (90 au total), qui permettront au lecteur de tester ses connaissances.
Pour illustrer concrètement les relations entre code et modèles, les auteurs font le choix du langage Java, les principes présentés étant naturellement transposâmes à d'autres langages.
Généralement, les livres sur la modélisation traite des modèles, et juste des modèles. Ou alors, dans le cas des patterns, on a une liste de recettes à appliquer pour des morceaux de son modèle. C'est là qu'intervient ce livre. La modélisation des applications orienté développeur n'était pas un sujet convert dans les ouvrages traditionnels, c'est fait maintenant.
L'approche proposée dans ce livre est de commencer par le code et de remonter l'arbre de la conception jusqu'à l'anayse des besoins, donc vraiment du point de vue d'un dévelloppeur. En fait, UML 2 pour les développeurs est une méthode de travail complète, exposée dans le dernier chapitre, pour qu'un développeur sache comment développer son application avec méthode.
Les diagrammes de classes, de séquence et de cas d'utilisation sont exposés, ce n'est donc pas tout UML 2, mais que la partie utile à un développeur. Ensuite, le code est orienté Java, mais en fait il suffit de connaître les limitations de son langage (ce qui est le cas d'un développeur normalement), et donc appliquer les lignes directrices à un autre langage est facile.
Les exercices de ce livre occupent une grande partie de l'ouvrage, ils font partie intégrante de la réflexion. Ils sont simples mais pertinents, et surtout indispensables.
Sommaire
Un curieux besoin de modèles
Diagrammes de classes
Reverse Engineering
Rétroconception et patrons de conception (design patterns)
Permettant à l'origine de modéliser et de développer des applications écrites dans un langage objet (C++, Java), UML s'est imposé depuis quelques années sur le terrain de la conception de bases de données relationnelles. Le marché a suivi cette tendance car aujourd'hui, tous les outils de modélisation utilisent cette notation. Destiné aussi bien aux étudiants qu'aux professionnels, cet ouvrage explique ainsi comment construire un diagramme de classes avec UML 2 en vue de concevoir une base de données relationnelle de type SQL2 ou objet-relationnelle de type SQL3. Chaque chapitre se clôt par une série d'exercices dont les corrigés figurent sur le site des éditions Eyrolles.
Une étude comparative des outils de modélisation
Le dernier chapitre du livre dresse un panorama des principaux outils du marché (Enterprise Architect, MagicDraw, MEGA, ModelSphere, MyEclipse, Objecteering, Poseidon, PowerAMC, Rational Rose, Together, Visio, Visual Paradigm, Visual UML et Win Design), en analysant pour chacun la manière dont il implémente différents critères de UML 2 : associations binaires et n-aires, classes-associations, agrégations, contraintes interassociations, héritage multiple avec contraintes, et rétroconception d'une base de données.
Cet ouvrage s'adresse aux étudiants en IUT, IUP, Deug et écoles d'ingénieur, ainsi qu'à leurs professeurs, aux professionnels souhaitant s'initier à la modélisation de bases de données avec UML, a tous les concepteurs de bases de données désirant migrer de Merise à UML.
Un livre très complet qui entraine ses lecteurs dans l'évolution de la conception des
bases de données d'une manière progressive et intéressante car basée sur des exemples clairs, précis et
adaptés au sujet en question. Après un historique toujours intéressant, l'auteur nous plonge directement
dans le vif du sujet en comparant les diagrammes mis à disposition par UML et Merise. D'ailleurs, un chapitre entier, à la fin du livre, est
consacré à un comparatif des meilleurs outils UML pouvant générer du code SQL.
L'approche des divers concepts (associations binaires, contraintes, agrégations, ...), d'abord théorique
devient vite pratique. Cette manière de présenter la modélisation permet aux développeurs/concepteurs de bien cerner
les différents problèmes rencontrés à tous les niveaux de la conception de leurs bases de données.
Chaque chapitre se termine par des exercices dont les corrigés sont disponibles via le site de l'éditeur.
Conclusion : Un livre qui touche un très grand public : développeurs, enseignants, concepteurs, ...
et qui ne se limite pas à décrire UML 2 puisqu'il place le langage de conception UML face aux autres méthodes existant déjà. Les
programmeurs habitués à utiliser Merise peuvent s'y référer s'ils désirent migrer vers UML.
Comme d'habitude, l'auteur nous livre un ouvrage très bien construit qui englobe beaucoup de références
au niveau de la conception/modélisation mais aussi au niveau SQL.
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.
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
DE L'IMPORTANCE DES CAS D'UTILISATION... Première étape de la modélisation UML, les cas d'utilisation jouent un rôle essentiel dans le processus de développement d'une application, car ils répertorient tous les scénarios d'utilisation possibles de cette application .
... ET DE L'ART DE BIEN LES REDIGER ! Malgré son apparente simplicité, la rédaction de cas d'utilisation est une tâche difficile. Que faut-il décrire ? Avec quel niveau de détail ? Comment ne rien oublier ? Cet ouvrage, écrit par l'un des meilleurs spécialistes du sujet, répond à ces questions en proposant une méthodologie claire, illustrée par 40 exemples détaillés et commentés.
QUELQUES CAS D'UTILISATION TRAITES Acheter des actions sur le Web - Traiter une demande d'indemnisation - Enregistrer l'arrivée d'un colis - Acheter quelque chose - Ajouter un nouveau service - Entrer et actualiser les demandes - Inscrire une nouvelle demande de service - Actualiser une demande de service - Inscrire une demande actualisée - sérialiser l'accès à une ressource - Appliquer une règle de conversion des verrous - Appliquer une règle de compatibilité des accès - Appliquer une politique de sélection des accès - Faire patienter le Client du service avant de lui accorder un accès à la ressource - Évaluer les conséquences d'un accident du travail - Enregistrer un sinistre
A QUI S'ADRESSE CE LIVRE ? À tous les utilisateurs d'UML ; Aux chefs de projets, maîtres d'œuvre et maîtres d'ouvrage ; Aux analystes-concepteurs et aux développeurs.
Ce livre nous explique tout ce qu'il faut savoir sur les cas d'utilisation. Il s'avère extrêmement simple à comprendre pour un débutant et nous fait passer par toutes les étapes de la créations des cas d'utilisation. L'auteur nous propose aussi quelques exercices dans le livre pour tester si les connaissances ont bien été acquises.
L'auteur commence par nous donner une vision globale de ce qu'est un cas d'utilisation et à quoi ils servent. Il continue ensuite en nous détaillant chaque partie d'un cas d'utilisation (portée, intervenants, niveaux...). Tout cela, toujours de manière très organisé et facile à suivre. On ajoute à chaque fois une couche de connaissance à nos propres cas d'utilisation. Il parcourt ainsi toutes les parties des cas d'utilisation. Pour en arriver ensuite aux différents formats des cas d'utilisation.
Ensuite dans las partie 2 du livre, on va parler de comment intégrer ces cas d'utilisation dans le processus global, de la gestion de nombreux cas d'utilisation en même temps. Et enfin, une liste très utile de choses à ne pas faire.
La partie 3 est consacrée à toute une série d'aide-mémoire qui reprennent les points importes de chaque chose inhérente aux cas d'utilisation.
La dernière partie nous montrer comment sont faits les cas d'utilisation en UML et nous donne les corrections de certains exercices et aussi à un glossaire très utile.
Tout au long du livre, nous avons droit à des exemples réels, à des histoires vraies et à des citations de personnes très impliquées dans les cas d'utilisation. Tout cela concrétise encore nos idées sur les cas d'utilisation. je conclurai en disant que ce livre est très bien pour toutes personnes ne sachant pas ce qu'est un cas d'utilisation ou croyant que c'est juste deux petits bonhommes et des flêches
Sommaire
Introduction
Les cas d'utilisation comme contrat de comportement
Portée
Intervenants et acteurs
Trois niveaux d'objectifs designés
Préconditions, déclencheurs et garanties
Scénarios et étapes
L'héritage
Les extensions
Variantes de technologies et de données
Création de liens entre cas d'utilisation
Formtas de cas d'utilisation
Quand en avons-nous fini ?
Gérer de nombreux cas d'utilisation
Cas d'utilisation CRUD et paramétrés
Modélisation des processus métier
Les exigences manquantes
Les cas d'utilisation dans le processus global
Résumé de cas d'utilisation et programme extrême (XP)
Correction d'erreurs
Aide mémoire pour chaque cas d'utilisation
Aide mémoire pour l'ensemble des cas d'utilisation
Aide mémoire pour la création des cas d'utilisation
Annexe A : Les cas d'utilisation en UML
Annexe B : Exercices - Quelques réponses
Annexe C : Glossaire
Annexe D : Référence bibliographique
287 pages,
1ère édition,
Décembre 1999
Éditions Eyrolles,
ISBN10 : 2212092881,
Broché, 2 x 19 x 23cm
