Note de lecture : Succeeding with Use Cases, Working smart to deliver quality par Richard Denney

Note : 6 ; Excel à la rescousse des cas d’utilisation, ou comment les colorier au-delà du trait.

Ce livre ne va pas vous apprendre à modéliser avec les cas d’utilisation, mais il va vous apprendre à les utiliser plus avant, notamment dans une optique qualitative. Ce livre est découpé en 4 parties indépendantes, qui constituent autant de facettes d’utilisation améliorée des cas d’utilisation.

La première partie est consacrée aux « QFD » ou Quality Function Deployment, qui permet non seulement de tracer les cas d’utilisation vers les « business drivers » ou vers les exigences, mais permet d’en calculer les priorités. La méthode est simple et adaptable, et si l’on considère que l’auteur va jusqu’à montrer concrètement comment la matrice QFD se construit avec Excel, on ne voit guère ce qui empêche d’exploiter cette technique.

Excel est également utilisé dans la seconde partie dédiée aux SRE (Software Reliability Engineering), dont le but est d’adapter l’effort de développement et de test à la « qualité perçue » et à l’usage opérationnel réel des cas d’utilisation, ces ratios d’usage réel étant construit d’après les étapes de UC effectivement parcourues, et d’après la nature des relations entre cas d’utilisation lorsqu’il y en a. Si l’usage opérationnel réel est utile, entre autre pour se fixer des objectifs de disponibilité opérationnel et de fiabilité, les méthodes de calcul liées à l’effort de test sont complexes et la pertinence de leur mise en œuvre limitée à certains types de projets.

La troisième partie est dédiée aux préconditions, postconditions et invariants. Elle emprunte beaucoup aux méthodes formelles, ce qui explique probablement un certain désintérêt de ma part. Hélas, l’exemple appuyant cette partie n’aide pas à rendre le propos plus clair.

La quatrième partie est dédiée à la gestion de la configuration, dont un chapitre est dédié au calcul du ROI, et un autre au « project portfolio management ». Si ce dernier chapitre ne m’a guère convaincu, par contre celui dédié au ROI est particulièrement concret et utilisable.

Cet ouvrage se démarque clairement des autres livres consacrés aux cas d’utilisation, car il est dédié à « ce que l’on peut faire avec les cas d’utilisation ». Bien que certaines parties s’appuient sur un formalisme très poussé, une grande partie est directement utilisable sur pratiquement beaucoup de type de projet.

succeeding-use-cases

Référence complète : Succeeding with Use Cases, Working smart to deliver quality – Richard Denney – Addison Wesley / O.T. series 2005 – ISBN: 0-321-31643-6

Succeeding with Use Cases: Working Smart to Deliver Quality


http://www.goodreads.com/book/add_to_books_widget_frame/0321316436?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Agile Product Management with Scrum, Creating products that customers love par Roman Pichler

Note : 3 ; Vraiment très léger, et pas si bien avisé que ça.

Plutôt qu’un livre, il s’agit d’un opuscule. D’abord par son nombre réduit de pages (118) et par son format à mi-chemin du livre de poche, ce qui est inhabituel. Tant mieux si le texte y gagne en pertinence et en efficacité. Hélas, ce n’est pas trop le cas, on frôle même parfois le hors sujet sans traiter en profondeur le sujet principal du livre ! Justement, effeuillons le texte. Celui-ci est découpé en 6 chapitres, donc avec une moyenne de 20 pages par chapitre.

Le premier chapitre rentre directement au cœur du sujet : qu’est-ce que le product owner ? On y énumère les qualités attendues de celui-ci et on évoque son rôle au sein de l’organisation, y compris celle d’un groupe de PO. Je dirais que globalement le propos est intéressant mais qu’on y apprends pas grand chose, le traitement me paraissant abstrait voir un peu théorique.

J’ai été intéressé de voir un chapitre consacré au développement de la vision, qui est l’un de mes thèmes favoris. Si on y reprends des bonnes idées largement connues par ailleurs (elevator statement, vision box ou modèle de Kano), je vois plutôt ce chapitre comme une introduction au sujet. Et je reste gentil.

Le troisième chapitre consacré au backlog est naturellement un des points majeurs du livre. Le principe de granularisation progressive des items de backlog est je pense un sujet connu d’un certain nombre de praticiens, il est bien de le voir évoqué là. Hélas une fois encore j’en trouve le traitement superficiel. Ce chapitre joue un double rôle en évoquant le volet recueil des besoins. Ce sujet aurait mérité son propre chapitre. Cet aspect est important et j’en trouve le traitement bien léger, voir bâclé. Un exemple du genre est l’évocation des exigences non fonctionnelles. La comparaison entre ce qui est dit ici et ce que l’on retrouve dans les meilleurs ouvrages traitant de l’ingénierie des exigences fait mal, très mal.

Les chapitres 4 et 5 sont consacrés au rôle du PO au sein des différentes pratiques de Scrum. Il s’agit à mon avis d’ajouts inutiles. Ces aspects sont déjà traités dans les ouvrages classiques traitant de Scrum. Et même si le propos est centré sur le product owner, je n’y trouve ni créativité ni apport de l’expérience de l’auteur.

Le sixième chapitre conclut sur les façons de monter en compétence sur le rôle de product owner. Dommage qu’il ne fasse que 7 pages, la prose y est forcément superficielle.

Clairement ce livre a été une grosse frustration pour moi. Il ne mérite pas la « signature series ». Peut-être mes attentes étaient-elles trop élevées, mais je pense qu’il y a plus et mieux à dire sur le rôle du product owner que ce qui est évoqué ici. Je n’estime pas la note trop sévère. Il reste que le texte satisfera peut-être de nouveaux venus à Scrum ?

agile-product-mgt-scrum

Référence complète : Agile Product Management with Scrum, Creating products that customers love – Roman Pichler – Addison Wesley / Signature series 2010 – ISBN : 978 0 321 60578 8

Agile Product Management with Scrum: Creating Products That Customers Love


http://www.goodreads.com/book/add_to_books_widget_frame/0321605780?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Managing Agile Projects, par Sanjiv Augustine

Note 6 ; Pour définir la « substance » de l’agile leadership…

Ecrire sur la gestion de projets agiles n’est pas chose facile, tant cette activité est difficile à définir en termes d’activités et de processus. Au lieu de cela, l’auteur a choisit d’évoquer le sujet sous l’angle des thèmes qui constituent le périmètre d’action de l’agile management.

Agile manager : Ce chapitre nous dévoile quelles sont les qualités que doit avoir l’agile manager, ainsi que les différences entre management et leadership.

Organic team : Deux chapitres traitent de la collaboration et de l’apprentissage (au sens de l’artisanat) eu sein des équipes agiles. On y évoque aussi l’émergence des communautés.

La Vision : L’un des rôles principaux du leader est de porter la vision du projet. Ce chapitre évoque la création et l’animation autour de cette Vision.

Les règles simples : Dans ce chapitre, on évoque les pratiques propres au management agile (backlog, release plan, etc.).

Information ouverte : L’une des valeurs essentielles de l’agilité est la communication. Ce chapitre traite des principes de communication applicables dans le cadre de l’agile management.

Touche légère : Le management agile passe par une ingérence la moins forte possible au sein des équipes, mais sans être totalement absent toutefois. Ce chapitre développe les actions possibles pour gérer une équipe en lui laissant l’initiative.

Le leadership adaptatif : Le feedback et l’adaptation sont un autre principe de l’agilité. Ce chapitre explique comment mettre en œuvre ces principes dans le management agile.

Effectuer la transition : Finalement, ce dernier chapitre traite du passage à l’agilité : quelles actions sont à mettre en œuvre, comment savoir si l’on est dans le bon chemin.

Au final, ce livre n’est pas grandiose, mais le sujet n’est pas facile. Je suis un peu resté sur ma faim, car le traitement du sujet manque de concret. La division en thèmes est une bonne idée, elle structure l’approche mieux que dans le livre de Jim Highsmith, et les liens vers d’autres références sont particulièrement pertinents. En bref, à l’époque le livre le plus utile sur le sujet. Aujourd’hui, je préfèrerais celui de Jurgen Appelo.

managing-agile-projects

Référence complète : Managing Agile Projects – Sanjiv Augustine – Prentice Hall 2005 – ISBN: 0-13-124071-4

Managing Agile Projects


http://www.goodreads.com/book/add_to_books_widget_frame/0131240714?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Release It ! Par Michael T. Nygard

Note : 9 ; Comprendre enfin les impératifs de production sur l’architecture. Book of the year 2007 !

Pour être tout à fait honnête, je dois avouer que j’ai d’abord acheté ce livre d’avantage par confiance envers l’éditeur (Pragmatic Programmers) que pour le titre, qui ne me disait pas grand-chose. Bien m’en a pris, le livre s’est avéré une mine de connaissances.

Ce livre traite de l’architecture des applications d’entreprise. Mais plutôt que de se focaliser sur les qualités classiquement attendues de telles applications, l’auteur s’intéresse aux comportements de applications d’entreprise en production. Et il connaît particulièrement bien son sujet, ayant participé aux mises en production de très gros sites de e-commerce. De fait, le texte regorge « d’histoires horrifiques » arrivés en production.

J’ai conscience que mon appréhension des besoins des équipes de productions par rapport aux systèmes que je développe est superficielle. Nous sommes dans deux mondes séparés. Cet ouvrage vient confirmer ce pressentiment. Jusqu’à présent, je pensais que la meilleure chose que j’avais à faire par rapport à la production était de produire un système solide et stable (de bonnes considérations), et que la seconde meilleure chose à faire était de produire un système très, très solide (ce qui commence à devenir stupide). L’auteur nous assène une vérité : tous les systèmes, d’une manière ou d’une autre peuvent et vont finir par faillir. Le design des applications doit êtres orientés par rapport à cette vérité, en termes de stabilité et en termes de capacité et surtout en terme de reprise sur crash !

Les 334 pages du livre sont découpées en 4 parties formant 18 chapitres. Il regorge littéralement de conseils d’architecture et de design formulés sous forme de patterns et d’antipatterns. Une vraie mine d’or !

Je recommande cet ouvrage sans aucune réserve. L’auteur prend des positions importantes et intéressantes, éclairées par une d’incontestables compétence et connaissances. Il nous fait découvrir un nouveau point de vue et de nouvelles idées à intégrer dans nos designs et nos architectures.

release-it-pragprog

Référence complète : Release It ! Design and deploy production-ready software – Michael T. Nygard – Pragmatic Bookshelf 2007 – ISBN : 0-9787392-1-3 ; EAN : 978 0 9787392 1 8

Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers)


http://www.goodreads.com/book/add_to_books_widget_frame/0978739213?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Management 3.0, Leading agile developers, developing agile leaders, par Jurgen Appelo

Note : 8 ; Du lourd, comme disent les jeunes…

Encore un livre sur le management ! OK, sur le management agile, mais quand même… Eh bien, celui-ci est différent ! Comme le signalait Robert Martin dans son avant-propos, celui-ci contient le mot « eucaryote ». Plus sérieusement, il s’agit d’un aspect important et remarquable du livre : la façon dont il s’appuie sur un très important corpus de connaissances scientifiques. Je serais bien en peine de nommer ici très nombreuses théories auxquelles l’auteur se réfère, il y en a une bonne demi-douzaine à chaque chapitre. Je vais par contre essayer d’en donner un éclairage synthétique.

L’axe majeur du livre de Jurgen Appelo est que la gestion d’une communauté de personnes est un système complexe et qu’il doit être appréhendé en tant que tel, contrairement à beaucoup d’approches de management qui ont une vision réductionniste. L’auteur s’appuie donc sur les théories ayant trait à la gestion des systèmes complexes : théorie des jeux, théorie des systèmes dynamiques, émergence, etc… Il articule aussi sont propos sur 6 vues, ou 6 tentacules devrais-je dire, car Jurgen représente son approche du management à l’aide d’une sorte de pieuvre munie de 6 tentacules au bout desquelles se trouve un œil. La bestiole se prénomme « Martie » ! Nous avons donc :

  • Energize people
  • Empower teams
  • Align constraints
  • Develop compétences
  • Grow structure
  • Improve everything

Je ne vais pas développer ces différents thèmes. Si vous êtes curieux, vous lirez le livre. Chaque thème fait l’objet de 2 chapitres, l’un théorique, l’autre pratique. La différence entre les deux ne m’est pas toujours apparu évidente. Le point commun est que chaque chapitre est vraiment lourd, fort d’une quantité impressionnante d’information. Souvent trop. Bref, ce n’est pas un livre que l’on lit en dilettante. Heureusement, l’auteur fait preuve d’un grand sens de l’humour, ce qui associé à une réelle qualité d’écriture fait de ce texte un réel plaisir !

L’ouvrage est dense, je l’ai déjà dit. Il est émaillé d’illustrations, de dessins en fait, réalisés par l’auteur lui-même. Ils accentuent la touche d’humour. Je ne suis pas convaincu que l’on puisse tout retenir. Il s’agit de ces livres sur lesquels il faut revenir lorsque l’on souhaite trouver le moyen d’améliorer un point particulier. Le modèle à 6 points de vues est lui facile à mémoriser et peut servir d’axe directeur.

J’ai mis du temps à sortir ce livre de son étagère. A tord. Il est réellement étonnant. Il faut une dose de courage pour se plonger dedans, mais ça vaut le coup !

management-30-Appello

Référence complète : Management 3.0, Leading agile developers, developing  agile leaders – Jurgen Appelo – Addison Wesley / Signature series 2010 – ISBN : 978-0-321-71247-9

Management 3.0: Leading Agile Developers, Developing Agile Leaders (Addison-Wesley Signature Series (Cohn))

http://www.goodreads.com/book/add_to_books_widget_frame/0321712471?atmb_widget%5Bbutton%5D=atmb_widget_1.png

Note de lecture : Adopting the rational Unified Process, par Stephan Bergström & Lotta Raberg

Note : 4 ; Une demarche qui a le mérite d’exister … mais la faiblesse de ne fonctionner que dans un environnement idéal !

Cet ouvrage complète la vision du RUP, non pas en abordant son utilisation, mais son déploiement au sein d’entreprises. A cette fin, les auteurs ont développé un processus d’adoption, dont les étapes servent de fil rouge à la structure de l’ouvrage. Si cette démarche est bien aboutie et forme un ensemble logique, il n’en reste pas moins que sa mise en œuvre semble se confiner aux grands groupes dont les moyens sont conséquents, capable de dédier un projet juste-comme-il-faut en tant que poisson pilote de l’organisation, et tout et tout…

Bref, il y a du bien et du moins bien dans ce livre, mais il est improbable que l’on ait souvent l’occasion de dérouler le processus tel qu’il est décrit. Il est plus probable que l’on ait la possibilité d’en exploiter des morceaux. Un autre point faible (et gênant) de l’ouvrage est qu’il est très abstrait quand au RUP lui-même ! J’aimerais d’avantage d’exemple plus concrets que des phrases telles que « sous ensemble de la discipline de tests ». En fait d’exemple, d’ailleurs, le style de l’ouvrage aurait été plus vivant si il avait été illustré tout au long par un exemple d’organisation fictive au sein de laquelle RUP doit être déployé.. Et ce, même si 2 références de déploiement sont décrites en annexes.

adopting-RUP

Référence complète : Adopting the rational Unified Process: Success with RUP – Stephan Bergström & Lotta Raberg – Addison Wesley / O.T. series 2004 – ISBN: 0-321-20294-5

Adopting the Rational Unified Process: Success with the Rup


http://www.goodreads.com/book/add_to_books_widget_frame/0321202945?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : The Pragmatic Programmer: From journeyman to master, par Andrew Hunt & David Thomas

Note : 9 ; Think! About your work; Book of the year (ex-æquo) 2002

Pensez! Mais pensez à la façon dont vous travaillez! Tel pourrait être le credo des auteurs de ce livre. Cet ouvrage ne traite pas de processus de développement logiciel à proprement parler, il expose plutôt une façon de se comporter et d’appréhender le développement logiciel au quotidien.

L’activité de développement logiciel est-elle un travail systématique décrit par des règles rigides? A cela les auteurs répondent: non! Ils abordent d’ailleurs le travail du développeur d’avantage comme l’activité d’un artisan que comme un travail d’ingénierie. Bien loin d’être un parallèle défavorable, il faut y voir une valorisation de notre travail, quand pour chaque problème il faut chercher une solution réfléchie, pragmatique et adaptée. Certains l’auront déjà compris, c’est d’agilité dont nous parlons ici ! Publié en 2000, il ne s’agit pas là d’une adhésion tardive à un effet de mode, mais au contraire le fruit de réflexions de « véritables croyants ». D’ailleurs Hunt et Thomas sont parmi les signataires originaux de l’agile alliance.

Le livre se découpe en 8 chapitres qui regroupent au total 70 « tips » (il y a un aide mémoire avec le livre).

Chap 1 : Pragmatic philosophy. On nous enseigne ici les lignes directrices de l’agilité : le « juste assez », l’entropie du logiciel, …

Chap. 2 : Pragmatic approach. Ce chapitre traite des tactiques de réalisation : la « balle traçante » ou le langage du domaine, par exemple.

Chap. 3 : Basic tools, traite de l’environnement, outils d’édition, de build ou de génération de code. Bref, c’est pour l’usine logicielle !

Chap. 4 : Pragmatic paranoia (là, c’est pour moi) nous enseigne l’anticipation des comportements erronés.

Chap. 5 :Bend or break, traite de conception (donc de patterns) et de sa bonne mise en œuvre.

Chap. 6 : While you are coding évoque tout ce qui gravite autour de l’implémentation : les tests, le refactoring, etc…

Chap. 7 : Before the project, car il ne faut pas confondre vitesse et précipitation ! On parle ici de spécifications, mais aussi des travers qui peuvent en découler.

Chap. 8 : Pragmatic projects, évoque la dimension stratégique du projet : la gestion des tests, le cycle itératif, etc…

Ne vous y trompez pas: ce livre ne vous expose pas comment programmer. Il existe pour cela d’autres ouvrages dédiés aux langages de programmation, par exemple. Une partie (importante) du texte est toutefois dédié à des aspects de conception générale: programmation défensive, méta programmation, architecture MVC.

Mais pour moi l’intérêt principal du livre n’est pas là. Son intérêt principal est de nous montrer que la responsabilité d’un ingénieur de développement ne se limite pas à écrire du code. Notre responsabilité est de livrer un développement dont nous pouvons être fiers, de qualité et répondant aux réels besoins utilisateur. Un travail que nous pourrions même signer: fruit d’une élaboration sérieuse, robuste, bien écrit et convenablement documenté. Un travail professionnel, réalisé par un vrai professionnel, un “pragmatic programmer”.

Ai-je oublié de vous dire que je recommande fort chaudement cet excellent ouvrage ? Mais notez au passage le vocabulaire plutôt riche employé dans le texte, qui peut en rendre la lecture légèrement difficile.

pragmatic-programmer

Référence complète : The Pragmatic Programmer: From journeyman to master – Andrew Hunt & David Thomas – Addison Wesley 2000 – ISBN: 0-201-61622-X

The Pragmatic Programmer: From Journeyman to Master

http://www.goodreads.com/book/add_to_books_widget_frame/020161622X?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Debug it ! Find, Repair & Prevent Bugs in Your Code, par Paul Butcher

Note : 3 ; Dommage qu’on y parle si peu de debug …

S’il est une facette du développement considérée comme peu noble, c’est bien le debug ! L’évolution des pratiques de développement tendent à réduire considérablement la part de debug nécessaire (entre autre via les tests unitaires) et c’est une bonne chose ! Toutefois la maîtrise de cet art reste une compétence nécessaire (où je n’ai pas la sensation d’exceller), c’est donc avec bonheur que j’ai accueilli ce nouvel ouvrage, cautionné par le sérieux des « pragmatic programmers » !

Je vais immédiatement casser le suspens en avouant de but en blanc que j’ai été fortement déçu.

La première partie est dédiée à la décomposition du processus de correction, avec un chapitre consacré à chaque phase du processus, soit 4 chapitre plus un chapitre de présentation, pour un total de 85 pages (sur 200). Le processus est simple et bien connu : reproduire, diagnostiquer, corriger, réfléchir (ou s’interroger plus exactement). Je ne suis pas un expert en correction de problèmes pourtant je connais (et pratique) cela depuis fort longtemps, aussi je pense que cette partie s’adresse au débutant. Too bad !

La seconde partie « biger picture », est longue de 25 pages découpée en 2 chapitres. Elle replace la correction de bugs dans un contexte plus large : les interactions avec les utilisateurs une équipe support, la remontée aux sources du mal (pourquoi avons-nous des bugs).

La troisième partie « debug fu » est la plus proche de ce que je considère comme le sujet du livre. Elle couvre 4 chapitres sur 85 pages. Les 20 pages du chapitre 8 « spécial cases » sont même au cœur du sujet. J’aurais espéré voir ce thème développé plus longuement, alors que le chapitre 9 consacré au « debuging environnement » parle de tout sauf d’environnement de debugging !

Au final, ce livre s’est fixé un but : décrire comment travailler (et avec quoi travailler) pour ne plus avoir besoin de debugger. En fait, je suis d’accord avec cet objectif. Mais je pense que les sujets attenants sont déjà traités par ailleurs et dans plus d’un livre ! Et mieux ! Et il arrive un moment où il faut bien sortir de sa boite à outil un savoir faire de debugage, car c’est ce dont on a un besoin. Et là ce livre ne réponds pas présent, alors que c’est là où je l’attendais, sur un domaine abandonné par tous les auteurs.

Mon conseil, et il est exceptionnel eut égard à la qualité du « pragmatic Bookshelf » : évitez ce livre !

debug-it-pragprog

Référence complète : Debug it ! Find, Repair & Prevent Bugs in Your Code – Paul Butcher – Pragmatic Bookshelf 2009 – ISBN : 978 1 93435 628 9

Debug It!: Find, Repair, and Prevent Bugs in Your Code

http://www.goodreads.com/book/add_to_books_widget_frame/193435628X?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Behind Closed Doors, secrets of great management, par Johanna Rothman & Esther Derby

Note : 6 ; Fortement concret, mais néanmoins décevant…

Evidemment, avec un titre, les attentes sont fortes ! Trop fortes, peut-être, car je dois m’avouer un peu déçu à la fin. Mais revenons au commencement : Behind closed doors est construit comme un recit, le recit d’un manager nommé Sam, arrivant dans une entreprise où il doit prendre en main une équipe formée d’une demi-douzaine de chefs de projets. Le corps du texte est formé de 7 chapitres, chacun représentant une semaine. Chaque semaine représente une étape majeure dans l’accomplissement de l’équipe et de Sam : apprendre à connaitre l’équipe, faire émerger l’ordre du chaos, construire l’équipe, gérer au jour le jour, découvrir les problèmes larvés, solidifier les capacités et s’arranger avec les réalités de la compagnie.

Finalement, les secrets dont il est question gravitent tous autour de la gestion des personnes. Il rapellent en cela l’ouvrage de Stephen Covey ou les outils promus lors des formations Krauthammer. Certes, ils ont de la valeur, mais de là à appeler cela des secrets…

La dernière partie (35 pages) est constituée de fiches pratiques autour des éléments mis en avant lors des 7 chapitres précédents. Il s’agit là d’une référence fort pratique, un véritable condensé d’expertise.

behind-closed-doors

Référence complète : Behind Closed Doors, secrets of great management – Johanna Rothman & Esther Derby – The Pragmatic Bookshelf 2005 – ISBN: 0-9766940-2-6

Behind Closed Doors: Secrets of Great Management


http://www.goodreads.com/book/add_to_books_widget_frame/0976694026?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Aspect-Oriented Software Development with Use Cases, par Ivar Jacobson & Pan-Wei Ng

Note : 3 ; Ou comment aller trop loin avec les cas d’utilisation.

Jacobson a décidé de surfer sur la vague des aspects, et d’offrir une nouvelle tenue « coloriée aspects » à ses cas d’utilisation à cette occasion. Pour cela, il s’est adjoint les services de Pan-ei Ng, qui a d’ailleurs en fait écrit la très grande partie du texte. Cela n’est pas un problème, car ce dernier tient fort bien la plume.

Le point de départ de ce livre est un article d’Ivar Jacobson écrit en 1986 sur une idée proche des « crosscutting concerns ». Ayant exhumé cet article et développant à partir de celui-ci, les auteurs ont fait évoluer l’approche des cas d’utilisation dans deux directions :

  • Structuration intensive des cas d’utilisation, utilisant intensivement la relation « extend » qui est la pierre angulaire du rapprochement avec l‘AOD. Cette structuration intensive s’accompagne de l’émergence de cas d’utilisation d’infrastructure. Bref, à mon avis cette approche s’éloigne d’un média de communication avec les utilisateurs car elle complexifie à outrance les cas d’utilisation. A cet égard, cette direction se rapproche des « use case patterns » de Gunnar Övergaard. Les spécifications de l’extension sont aussi beaucoup plus développé afin de ressembler aux « join points », le reste est à l’avenant : intéressant pour l’informaticien, moins pour celui qui ne l’est pas.
  • Les « use case slices » et « use case modules » : sont la structuration objet d’analyse. Plutôt que développer une architecture orthogonale au modèle des besoins, les auteurs soutiennent une bijection entre les cas d’utilisation et la structuration en « use case slices ». On aboutit ainsi à un système architecturé par les cas d’utilisation (même si les auteurs ne dénient pas la factorisation), ce qui me plonge dans un abîme de perplexité.

C’est vrai, il y a une corrélation forte entre les points de jonction de l’AOD et la relation « extend », et si le sujet mérite certains développements, je n’adhère pas franchement aux extrémités des auteurs qui nous éloignent par trop de la simplicité et des qualités de communication inhérente des cas d’utilisation. D’ailleurs l’ouvrage lui-même devient parfois un peu obscur. Limiter volontairement son volume à moins de 250page aurait certainement pu le rendre plus limpide.

Bref, une lecture tout ce qu’il y a de plus facultative.

aspect-or-soft-dev-use-cases

Référence complète : Aspect-Oriented Software Development with Use Cases – Ivar Jacobson & Pan-Wei Ng – Addison wesley / O.T. series 2005 – ISBN : 0-321-26888-1

Aspect-Oriented Software Development with Use Cases


http://www.goodreads.com/book/add_to_books_widget_frame/0321268881?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on