Note de lecture : Eclipse, par Steve Holzner

Note: 4 ; Un livre de commande, ni bon ni mauvais, mais qui date un peu!

Je profite de la période de noël pour vous asséner l’une de mes petites notes de lecture archéologiques ! Celle-ci date d’une bonne douzaine d’années, ne vous plaignez pas j’en ai de bien plus anciennes. Et que diable, il faut bien que je refourgue mes fonds de tiroir !

Il n’y a pas à dire : depuis quelques années, O’Reilly a perdu de sa superbe. Autrefois incontournables sur leurs sujets, nombre des titres de l’éditeur sont là pour occuper le terrain. C’est le cas de ce titre. De toute évidence, ce titre comble un trou dans le catalogue de l’éditeur. Mais voyons de quoi nous parlons.

Le livre est globalement divisé en 2 parties. La première présente l’IDE Java, tandis que la seconde expose le développement d’applications Java classiques, Web et plugins. La première partie est sans surprise, et l’on effectue le « tour du propriétaire » classique : fonctions de l’éditeur, debogage et profiling, réfactoring, gestion de projets avec Ant, gestion de versions avec CVS, etc… Le tout plus qu’abondamment illustrés de copies d’écran dont, si j’étais mauvaise langue, je dirais qu’elles sont là pour faire du volume. Au moins l’approche est didactique et ne requiert pas vraiment d’effort de la part du lecteur. On regrettera que l’auteur ne prenne aucun parti pris sur l’organisation du travail, des workspaces, etc.. Il se contente d’exposer (bien que clairement) les fonctions disponibles. Pas très inventif, tout ça.

La seconde partie expose en grande partie des éléments que l’on trouve ailleurs : développement d’applets ( !) et d’IHM avec Swing, ainsi que le développement d’applications Web « classiques » en JSP/Servlet, mais sans plugins avancés. La seconde moitié de cette seconde partie est plus spécifique à Eclipse avec SWT et les plugins. J’en conclus que cet assemblage un peu large a pour objet de mettre entre les mains du lecteur un ouvrage « tout en un » où l’on trouvera de quoi démarrer sur la plupart des sujets courants en Java.

Lire la suite

Note de lecture : Serial Communications, A C++ Developer’s guide, par Mark Nelson

Note : 7 ; Bien que désormais obsolète (car concerne surtout Windows 16 bits), reste intéressant sur les principes de gestion des ports série.

Tant que je suis dans les antiquités…en voici une tout à fait honorable ! Certes ce livre a perdu une grande partie de son intérêt, d’abord avec l’arrivée du Windows 32 bit et de TAPI puis des infrastructures et librairies qui rendent aujourd’hui transparente les vicissitudes des protocoles de communication.

Cet ouvrage nous permet, aujourd’hui encore, de nous ressourcer sur la mise en œuvre des communications à bas niveau, là où les caractéristiques du matériel ne peuvent être ignorées ! Mais la bête est imposante : ce sont 600 pages qui se présentent à nous sur ce seul sujet, le tout en 11 chapitres ! Le premier d’entre-eux rappellera des souvenirs aux plus anciens d’entre nous, il aborde l’interface RS 232 C sur 64 pages. Tout y passe, depuis la norme du connecteur, la signification des signaux et les protocoles de transmission modem. L’électronique sous-jacente, les fameux UART sont évoqués, mais leur gestion fera l’objet d’un chapitre à part. Finalement les protocoles d’échange de fichier (Kermit, ZModem, etc.) clôturent le chapitre. C’était en quelque sorte le tour du propriétaire.

Le chapitre 2 s’articule autour de la définition de la classe C++ RS232 ; il s’agit d’un wrapper abstrait sur lequel peu de méthodes concrètes « intelligentes » sont implémentées. Essentiellement les fonctions de lecture et écriture. C’est un bel exemple de mise sous forme de classe d’un protocole, car tous les signaux de la norme apparaissent sous forme de méthodes virtuelles. A part cela le chapitre est peu passionnant, essentiellement constitué de listings.

Ce sont près d’une centaine de pages qui sont dédiées au chapitre 3, dévolu à l’implémentation de RS232C sur l’UART 8250. Toute la première partie expliquant le fonctionnement de l’UART est réellement très intéressante même si je regrette le peu qui est consacré au 16550, certes nettement moins rependu à l’époque, mais nettement plus intéressant. Hélas la seconde moitié du chapitre est de nouveau consacré à de fastidieux listings bien peu expliqués…

Le chapitre 4, shared interrupt device rompt la monotonie avec seulement 25 pages. Il est consacré à l’accès aux ports COM dans l’architecture PC via les 2 interruptions qui leurs sont dédiées (pour 4 ports en principe accessibles). Le code du handler et les principes de gestion sont clairement appréhendés. Des informations par ailleurs rares dans la littérature, pour ne pas dire plus.

C’est à un périphérique plus exotique qu’est consacré le chapitre 5 : le Digiboard ! C’est donc une nouvelle sous-classe de RS232 qui nous attend. Un chapitre dont je soupçonne qu’il tenait à cœur à l’auteur, mais qui n’a pas retenu mon attention.

Plus intéressant pour moi, mais hélas plus légèrement traité, le chapitre 6 nous propose une nouvelle sous-classe de RS232, mais cette fois en s’appuyant sur les primitives disponibles dans le BIOS. Seul 30 pages y sont consacrées et l’auteur aurait pu faire plus d’effort pour développer plus clairement les interruptions du BIOS et leur exploitation.

Au chapitre 7, le FOSSIL driver se voit lui aussi consacrer une trentaine de pages. La profondeur de traitement est à peu près la même que pour l’implémentation BIOS. Mais j’avoue encore une fois que l’aspect exotique de cette norme fait que le chapitre n’a pas retenu mon attention.

Nouvelle alternative au chapitre 8 : une implémentation sur les API Windows. Près de 50 pages sont noircies sur le sujet. Cela paraît mieux, mais à l’époque où ces informations étaient vitales pour moi, la profondeur des informations restait bien insuffisante. Mais au moins le livre fournit des informations d’exploitations de ces APIs, choses pratiquement indisponibles par ailleurs en 1993 !

Le chapitre 9 est long de 40 pages. C’est un changement, car on quitte la couche RS232 pour s’attaquer à la gestion des modems, avec les fameuses normes V24, V32 et autres et bien sûr le protocole Hayes. La question est bien traitée et fort clairement. C’est probablement la meilleure source d’information que j’ai pu croiser sur la question.

Au chapitre 10, on s’attaque aux transferts de fichier, avec les protocoles XModem, YModem et ZModem. La question ne m’intéresse guère et j’ai du mal à avoir un avis sur le chapitre. Le sujet semble bien traité et le listing de fichier une fois encore un peu longuet.

Le dernier chapitre du volume va s’intéresser à l’émulation de terminal. Le thème remplit 60 pages et ne semble guère passionnant tel qu’il est traité ici. On est beaucoup dans l’explication de texte du listing, fort peu sur la déconstruction du problème.

L’auteur a développé une petite librairie de classes multiplateformes, multi-modems et multi contrôleurs qui, ma foi, m’a bien fait de l’usage à son époque. Le livre gravite entièrement autour de cela ce qui rend parfois le propos un peu rébarbatif et les listings ennuyeux. Mais le volet technique est très affuté et ce fut très clairement la meilleure source d’information sur bon nombre de sujets qui y sont traités. Difficile de faire valoir une pertinence après presque 25 ans, pourtant le volume mérite d’être conservé à titre d’archive !

image

Référence complète : Serial Communications : A C++ Developer’s guide – Mark Nelson – Prentice Hall / M&T Books 1992 – ISBN : 0-13-011776-1

Serial Communications: A C ++ Developer's Guide : A Comprehensive Guide to Writing Serial Communications Applications Using Object-Oriented Techniqu

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

Note de lecture : Conception orientée objet, par Peter Coad & Edward Yourdon

Note 3 ; Les principes embryonnaires de la conception objet

Il y a « l’avant » Design Patterns, et « l’après ». Cet ouvrage est dans la catégorie « avant ». Il fait aussi suit à « l’Analyse orientée objet » des mêmes auteurs. Et son âge respectable le classe parmi les livres qui ont servi de fondation à l’orienté objet. Bien sûr, depuis on a construit pas mal d’étages, et seul les férus d’histoire informatique auront à cœur de se replonger dans ces textes !

Le problème avec « l’avant » Design Patterns, c’est que l’on parle bien d’analyse et de conception (ici séparés en 2 livres) et que l’on prétend faire la différence clairement, mais en fait ce n’est pas le cas ! Au long des 160 pages du texte principal, les auteurs peinent à exposer des aspects clairement différents entre l’analyse et la conception. Voyons cela.

En plus du texte principal découpé en 10 chapitres, l’ouvrage  compte 24 pages d’annexes, elles-mêmes séparées en 3. Passé la quinzaine de pages d’avant-propos, ce sont les 10 pages du premier chapitre « améliorer la conception » qui ouvrent le bal. Bien que cela ne soit pas avoué ouvertement, la conception y est présenté comme quelque chose d’ajoutée « après coup » pour améliorer la qualité et la maintenance ! On y évoque aussi les principes d’encapsulation et l’organisation fonctionnelle.

Le chapitre 2 traite du passage au modèle en couche. Un modèle en couche bien rigide qui en possède nécessairement 5 ! Les auteurs posent aussi leur position sur le passage de l’analyse à la conception : c’est un continuum. J’aime tout particulièrement le passage où l’on explique que le modèle passe d’analyste aux concepteurs qui reviennent avec une matrice de traçabilité pour prouver qu’ils ont effectivement fait quelque chose !

Après voir tenté de nous faire admettre aux forceps qu’il y a une différence entre analyse et conception, le chapitre 3 en rajoute une couche. Oui, la COO est différente : on ajoute des abstractions, on optimise pour la vitesse, on ajoute des composants bas-niveau. Si vous n’avez pas été convaincus par le chapitre 2 (comme moi), il y a peu de chances que vous le soyez par les 20 pages de ce chapitre ci.

C’est de composants d’interaction humaine qu’il s’agit au chapitre 4. Les 15 pages de ce chapitre sont assez perturbantes, car il commence par une note résolument fonctionnelle (mais sans l’avouer) : identification des utilisateurs et les cas d’usage ! La partie résolument conception est un exposé de l’utilisation de l’outil OOATool ! Un chapitre à oublier.

Le chapitre 5 ne fait que 6 pages. C’est bien suffisant pour traiter le « composant de coordination des tâches ». Il s’agit du pattern Command (en moins bien).

C’est la gestion de données qu’est sensé traiter le chapitre 6 sur 15 pages. On connaît la complexité du sujet. Et les auteurs font leur possible pour l’esquiver. On aurait pu économiser du papier.

Plus de 30 pages sont consacrées au passage en revue des langages OO de l’époque et de la façon dont ils abordent les concepts OO : C++, Pascal Objet, Objective C (si, si), Eiffel et même Ada. Sans être un modèle du genre, cela reste mon chapitre préféré !

Au chapitre 8, on parle des critères de la conception OO. Disons que c’est mon deuxième chapitre préféré : couplage faible, forte cohésion, simplicité. Les prémisses de ce qui fera le succès des livres de Robert Martin est bien là !

L’avant-dernier chapitre est consacré aux outils. Donc un chapitre à peu près inutile. Heureusement il ne pèse que 5 pages. C’est à peu près la taille du dernier chapitre qui sert essentiellement à nous donner la bénédiction des auteurs pour partir sur la conception en objet !

Nous sommes ici encore dans le schéma des méthodologies rigides et de styles architecturaux qui sont de mêmes ! Ne perdez pas votre temps sur cet ouvrage si votre intérêt est autre qu’historique. Le texte ne recèle pas de pépites le gardant pertinent 25 ans plus tard…

image

Référence complète : Conception orientée objet – Peter Coad & Edward Yourdon – Masson 1993 (V.O.: Object Oriented Design – Prentice Hall 1991) – ISBN: 2-225-84212-4

Conception orientée objet

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

Note de lecture : Unix, utilisation administration système et réseau, par Christian Pélissier

Note : 5 ; Unix pour les bénédictins, mais néanmoins très utile !

Je n’ai encore jamais croisé un bouquin sur Unix qui soit une franche tranche de rigolade. Celui-ci ne fait pas exception. En fait son style est franchement monacal. Je ne vais pas passer en revue les 37 chapitres composant les 750 pages de ce pavé. Et rester au niveau des 3 parties serait trop succinct.

Si l’aspect premier est rébarbatif, en y regardant de plus près, l’ouvrage est plutôt bien fait, à mi-chemin entre le manuel de référence et le guide de l’utilisateur, avec une prédominance pour ce dernier aspect. Tout d’abord le texte a le bon goût d’être finement découpé : 37 chapitres, c’est en moyenne une vingtaine de pages par chapitres. Le style est très sibyllin, mais il se débarrasse ainsi des circonvolutions qui rendraient l’ouvrage moins efficace. Il y a au moins 3 choses que j’apprécient :

  • Les exemples clairs de la ligne de commande. Cela ne se limite pas à la syntaxe, mais à l’usage réel que l’on peut en faire dans une séquence type.
  • Les variantes BSD et Système V sont présentées. Ce choix paraitra évidemment aujourd’hui un peu désuet.
  • Les commandes connexes sont évoquées : ainsi sur la création de répertoire, on parle de la façon de les supprimer, etc…

Bref, ce n’est pas un livre que l’on va lire avant de se coucher, ni même d’une traite d’une couverture à l’autre. Il est plutôt fait pour être lu de manière discontinu chapitre par chapitre, car ceux-ci sont courts. Il sera également utile comme référence. Mais il trouvera aussi ces limites ici, car le texte ne traite pas en profondeur des subtilités des options des différentes commandes. Ce n’est définitivement pas un manuel de référence. Il cible plutôt les nouveaux venus à Unix.

image

Référence complète : Unix, utilisation administration système et réseau – Christian Pélissier – Hermes 1995 – ISBN : 9782866014490

Unix, utilisation administration système et réseau

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

Note de lecture : Cross-Platform GUI Programming with wxWidgets, par Julian Smart et Kevin Hock avec Stefan Csomor

Note : 4 ; Pas un truc qu’on lit pour le fun !

Les frameworks IHM en C++ ne sont pas mort ! Et ce volume de 540 pages (hors annexes) compte bien nous en faire la preuve avec wxWidgets. Le bestiaux compte 20 chapitres, il faudrait aussi y ajouter presque 100 pages d’annexes.

Les deux premiers chapitres (assez courts) sont là d’une pour nous présenter très brièvement l’historique de wxWidgets, puis un « hello world » qui nous montre déjà une certaine ressemblance avec MFC…

Dès le chapitre 3 on rentre dans le dur avec la gestion des évènements. Je trouve la prose et les explications assez sèches. D’un autre côté, la petite taille des chapitres aide…

En comparaison, le chapitre 4 « Windows basics » fait plutôt mouse costaud avec ses presque 100 pages ! La prose me semble assez décousue et si la présence de nombreux tableaux de référence semble rassurante, elle fait ressembler ce chapitre d’avantage à un manuel de référence qu’à un tutorial.

La partie sur l’écriture sur les devices ressemble plutôt à une introduction sur le sujet. Fort heureusement on a quitté le mode « manuel de référence ». Si les contextes graphiques, arrières plans, etc… semblent décemment traités, j’ai quelques soupçons sur l’affichage de bitmaps, la gestion des imprimantes me paraît un peu légère et la partie 3D est carrément un gag !

Passons sur le chapitres 6 dédié à la gestion des inputs pour arriver aux chapitres 7 et 8 consacrés aux layouts puis aux dialogues standards. Ces deux chapitres sont justes introductifs avec de petits fragments de code pour illustrer les cas courants. En gros, ce que propose le manuel en ligne de wxWidgets. Ce n’est pas le cas du chapitre 9 qui traite les « custom dialogs » et s’appuiera sur un exemple plus conséquent.

Si le traitement des images au chapitre 5 m’avait déçu, le chapitre 10 rattrape le coup en traitant exclusivement de cet aspect.

Le drag and drop est toujours une fonctionnalité complexe, difficile à exposer clairement. C’est le cas ici, avec une approche confuse. Un exemple global appréhendé par morceau aurait aidé, ainsi qu’une explication de la cinématique globale. Suite des aspects avancés avec le chapitre 12 qui traite des différentes classes de fenêtres.

Les chapitres 13 et 14 nous ramènent à l’époque où l’on réinventait l’eau chaude en C++ à chaque librairie ! Voilà donc des objets de base pour gérer chaine de caractères, collections, fichiers, etc… Malheureusement toutes ces choses sont prises en paramètre par les API du framework…

Je passe sur le chapitre 15 qui décrit les facilités de debuggage et de gestion d’erreur et sur le chapitre 16 qui traite l’internationalisation très classiquement par le biais de ressources. Ces deux chapitres sont de toute façon assez courts. Plus intéressant, les chapitres 17 et 18 se focalisent sur des aspects systèmes : les threads et les sockets, prenant en charge ce que ACE fait en cross plateforme par exemple. On aime ou pas, mais wxWidgets permet de traiter ces aspects évènements de ces deux sous-systèmes dans sa boucle d’événement. Personnellement, j’aime pas !

Il est curieux qu’il faille attendre le chapitre 19 pour voir décrit le modèle « document – vue » de wxWidgets ! Il aurait dû être présenté bien avant. Quoi qu’il en soit, les auteurs proposent ici une approche par étape qui tranche un peu sur ce qui est fait par ailleurs dans le livre, et c’est une bonne nouvelle.

L’ouvrage se conclut par un chapitre 20 « perfecting your application » qui est un melting pot de différents sujets sans rapports les uns avec les autres.

Il faut voir les choses en face : il n’y a pas le choix de livres sur wxWidgets. C’est le seul. En terme de ciblage il se cherche un peu. Il voudrait être l’introduction à la programmation avec wxWidgets comme l’était le Petzold pour Windows mais tombe souvent dans le travers du manuel de référence sans en avoir la qualité. Ce n’est pas le Petzold non plus, c’est certain. Bref ce n’est pas un livre que je pourrais conseiller les yeux fermés, mais il n’est pas écrit avec les pieds non plus.

Plutôt vide, avec beaucoup de déclarations d’intention mais peu de concret.

Bref, un livre qui est loin d’être indispensable.

image

Référence complète : Cross-Platform GUI Programming with wxWidgets – Julian Smart and Kevin Hock with Stefan Csomor – Prentice Hall 2006 – ISBN : 9780131473812

Cross-Platform GUI Programming with Wxwidgets

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

Note de lecture : Programmer sous Windows 95 (4ème édition), par Charles Petzold et Paul Yao

Note : 9 ; Plus qu’un livre : une institution

10 ans après la 1ère édition, cette 4ème (qui ne fut pas la dernière) a encore pris de l’embonpoint pour atteindre 1200 pages. Malgré l’entrée dans le monde 32 bits, cette institution qu’est « le Petzold » reste fidèle à la programmation via les API héritées de Win16. Donc la part belle est faite aux applications fenêtrées : fenêtres, menus, tracés graphiques, impression, boites de dialogue, presse-papiers, etc… Il traite plus succinctement des aspects systèmes et des aspects spécifiques à Win32. Il est temps d’entrée dans le cœur du sujet. On parle de 20 chapitres regroupés en 5 parties.

La première partie comporte 4 chapitres totalisant 270 pages. Le livre ne commence réellement qu’au chapitre 2, qui s’articule autour du redoutable HelloWin.c ! Il faut tout le talent pédagogique de Charles Petzold pour démystifier les arcanes de la boucle d’événement et des handles de fenêtre, afin de donner une logique à l’ensemble. Utiliser le Canvas de fenêtre, l’événement WM_PAINT et autres invalidation de surfaces (sans parler des scroll barres) n’est pas non plus une sinécure, mais le chapitre 3 y vient à bout de manière méthodique. Une bonne base pour aborder la terrible complexité de la GDI au chapitre 4 ! Toutefois, le sujet mérite un livre (au moins) à lui tout seul et celui-ci ne saurait couvrir complètement le sujet…

La seconde partie est consacrée à la saisie. On parle de saisie au sens large : comptez 4 chapitres et 200 pages pour des sujets couvrant bien sûr le clavier et la souris, mais aussi l’horloge et les fenêtres enfant ! On ne se douterai pas au premier abord que la gestion du clavier puisse être si complexe, impliquant des messages clavier, mais aussi de focus de fenêtre, sans compter la prise en compte de paramètres OEM ! Un sujet parfaitement traité en profondeur ici. Heureusement, la gestion de la souris traitée au chapitre 6 génère moins de tracas, même quand on essaie de pousser le sujet dans ses retranchements : souris gérée au clavier, capture de la souris (si, si), etc.. La gestion de l’horloge abordée au chapitre 7 est pour une fois réellement simple sous Windows, peut-être est-ce pour cela que l’auteur a choisi un exemple complexifiant inutilement le sujet en y mettant de la GDI ? Par fenêtre enfants, il faut entendre les contrôles, essentiellement les boutons et la façon dont ils communiquent avec la fenêtre encadrante. Ce chapitre conclue cette partie.

C’est à la gestion des ressources qu’est consacrée la 3ème partie. 4 chapitres et pas loin de 450 pages sont nécessaires pour couvrir ce sujet hélas beaucoup plus compliqué qu’il ne devrait ! Icônes, curseurs et bitmaps que l’on fait figurer dans le fichier .res sont vite balayés au chapitre 9. La gestion des menus est menée de façon plus poussée au chapitre 10, avec quelque cas d’usage non orthodoxes ! Les boites de dialogues sont un sujet très large, allant des boites de messages et des CommonDlg aux boites de dialogues non modales. 90 pages pour couvrir cela de manière progressive et pédagogique ne sont pas de trop. Un sujet qui s’entend sur les 110 pages du chapitre suivant pour couvrir des aspects avancés qui sont une spécificité de cette édition « Windows 95 ». Hélas le sujet est traité avec beaucoup moins de pédagogie, c’est même un peu confus.

La 4ème partie pèse 150 pages et 3 chapitre et est entièrement dévolue aux fonction système. Le chapitre 13, très court donne une impression de bâclé pour traiter la gestion mémoire et des entrées sortie. Le chapitre consacré au multitâche l’est moins, mais on ne peut toutefois le considérer que comme une introduction au sujet. Il ne saurait faire concurrence au texte de Jeffrey Richter. On finit avec la gestion de l’imprimante, un sujet ridiculement compliqué, mais que la prose de l’auteur, encore perfectionnée depuis l’édition précédente, rend abordable.

La dernière partie de l’ouvrage est consacrée aux différents modes d’échange de données. 250 pages sur 5 chapitres leur sont consacrés. 2 chapitres sont consacrés respectivement au presse-papier et au très malcommode DDE. Je m’étonne de le trouver encore là, car son remplaçant (OLE) point le bout de son nez un peu plus loin… L’interface MDI, dont c’était le chant du cygne a encore doit à son chapitre également. Pas de changement non plus pour le chapitre consacré aux DLL, je continue à trouver que la gestion « sans import » n’est pas sérieusement traitée, alors que c’est la seule réellement utile ! Enfin le chapitre 20 nous fait découvrir OLE, nouveauté de cette version. Disons que c’est un chapitre introductif à la question, mais il est plutôt bien fait, eut égard au sujet dont la courbe d’apprentissage est plutôt raide ! Notons aussi que c’est le seul chapitre dont les exemples sont en C++. Bien sûr la couverture du sujet est très loin d’être à la hauteur du Brockschmidt, mais celui-ci n’est pas non plus extraordinairement pédagogique…

Bien sûr, cela semble dépassé de s’intéresser à la programmation Windows aujourd’hui, surtout à aussi bas niveau. Néanmoins, comprendre le fonctionnement d’une interface fenêtrée au niveau de ses fondamentaux n’est pas ridicule. A l’époque où le développement Windows battait son plein, je considère que la connaissance du développement au niveau des API était un savoir fondamental, même à une époque où l’on développe confortablement avec les MFC et des assistants (beurk !). Le Petzold est un modèle de pédagogie, c’est pourquoi j’avais élu l’édition précédente (celle de 1992) « book of the year ».

image

Référence complète : Programmer sous Windows 95, 4ème édition – Charles Petzold & Paul Yao – Microsoft Press 1996 – ISBN : 2-84082-195-8 (VO : ISBN 1-55615-676-6)

Programmer sous Windows 95

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

Note de lecture : Analyse orientée objets, par Peter Coad et Edward Yourdon

Note : 4 ; Typique de l’approche objet des années 80

Il s’agit ici de l’approche objet typique des années 80. L’emphase est mise sur l’identification “à priori” des objets, ainsi que des attributs et des services attenants, en ne prenant que faiblement en compte le contexte de leur utilisation. Avec 180 pages pour 10 chapitres, ce n’est pas un gros volume. Un second tome, dédié à la conception le complète.

Le premier chapitre est un très classique argumentaire de l’intérêt de l’objet par rapport à la décomposition fonctionnelle en rappelant les grands traits de l’objet : héritage et encapsulation principalement.

Les chapitres 2 et 3 s’articulent autour de l’identification des objets. On notera aussi passage l’évocation de Smalltalk par les auteurs. Les méthodes suggérées sont plutôt empiriques, et surtout on reste sur l’idée d’identifier les objets « à priori », symptomatique du courant de pensée de cette époque.

Le chapitre 4 consacré à l’identification des structures est en fait consacré à l’héritage. Il répond à la question : qu’est-ce qui est et qu’est-ce qui n’est pas un héritage. Question dont la réponse est : ce qui obéit à la relation « est un ». On n’avait pas besoin de 30 pages pour cela ! La notion de « sujet » qui est l’objet du chapitre 5 correspond plus ou moins à celle de package. Elle est curieusement mêlée avec l’idée d’une classe parent qui porterai le même nom… On est décidément dans la mouvance « montrez-moi votre arbre d’héritage !

Attributs et relations sont abordés au chapitre 6. J’ai trouvé que c’était le plus intéressant arrivé à ce point de la lecture, car il répond au moins à des questions de structuration concrètes.

La notion de « service » abordée au chapitre 7 correspond au volet dynamique de la modélisation. Son focus n’est pas très clair car assemble plusieurs concepts, y compris des notions d’architecture et de diagramme d’état. Bref, je n’ai pas accroché.

Le chapitre 8 consacre quelques pages futiles aux outils de modélisation. De même le chapitre 9 est succinct et prétend traiter le passage à la conception orientée objet. Si l’auteur disent bien qu’il s’agit d’un continuum, on ne voit rien de tangible. Le livre se conclut sur un chapitre 10 qui traite de considérations générales sur la mise en œuvre de l’analyse orientée objets.

Ce livre est symptomatique de l’approche objet de la fin des années 80 : une emphase sur les aspects objet liés à l’héritage, plus encore qu’à l’encapsulation (évoquée, mais pas vraiment mise en œuvre). On y voit beaucoup de formalisme et une grande rigidité dans la démarche, ce qui rend cette démarche (comme les autres) bien peu opérationnelle.

L’ouvrage, aujourd’hui ne présente plus qu’un intérêt historique, mais sa lecture ne présente plus d’intérêt pour lui-même. Qui plus est, la prose, du moins dans sa traduction est plutôt aride.

image

Référence complète : Analyse orientée objets – Peter Coad & Edward Yourdon – Masson 1993 (V.O.: Object Oriented Analysis, 2nd edition – Prentice Hall 1991) – ISBN: 2-225-82562-9

Analyse orientée objets

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

Note de lecture : The C++ Answer Book, par Tony L. Hansen

Note : 6 ; Un compagnon de route au Stroustrup.

Il s’agit, comme son titre l’annonce d’un livre d’exercices corrigés. Aujourd’hui c’est un texte fort ancien. Ancien peut-être, mais volumineux, certainement. On en prend pour 520 pages sur 8 chapitres seulement, sans compter les annexes ! Voyons ce qu’il a dans le ventre.
On passera rapidement sur le 1er chapitre qui est introductif (5 pages) pour nous tourner vers le 2nd qui traite des déclarations et des constantes. Les exercices sont tous très simples, c’est aussi l’occasion d’évoquer des éléments connexes à la questions en plus de répondre à celle-ci.

Si le chapitre 2 ne comptait qu’une trentaine de pages, c’est près de cinquante que nous offre le chapitre 3 dédié aux expressions. On y a droit inévitablement aux ordres d’évaluation de expressions, mais aussi aux comportements « limite » du langage, y compris à ceux causant des problèmes de portabilité. Une partie significative du chapitre est dédié à la manipulation de chaine de caractères, à l’ancienne façon « C ». Le niveau de difficulté augmente significativement, il était au maximum à 1.5 au chapitre 1, il monte ici à 2.5 selon l’échelle exponentielle de l’auteur ! La dimension algorithmique des exercices n’est pas triviale. De quoi se rafraichir les neurones !

Au chapitre 4, on évoque les fonctions et les fichiers. Du moins c’est ce que dit le titre. 60 pages sont consacrées à cette partie qui, en fait a surtout trait à la manipulation de structures : listes, graphes ou tableaux bi-dimensionnels avec les inévitables tris et manipulation. On parle en fait assez peu de fichiers et si on évoque les différences entre C et C++, cela reste du code à affinité C. Bien sûr, le niveau de difficulté augmente sensiblement et culmine à 3.

Le chapitre 5 marque notre véritable entrée dans le C++ car il y est question de classes ! Transition en douceur, car les premiers exercices font suite au chapitre précédent et l’on commence par faire des classes avec des struct ! D’un point de vue utilisation du langage, les 80 pages de ce chapitre restent dans la simplicité. Finalement on travaille surtout à encapsuler la complexité algorithmique dans des classes, ce qui n’est pas si mal. D’un point de vue conception, l’exercice le plus complexe est l’implémentation d’un interpréteur d’expressions à l’aide d’un pattern composite (l’un de mes exercices préféré).

Il me semble assez curieux que le chapitre suivant soit consacrée à la surcharge d’opérateur, car il ne m’a jamais semblé que ce soit une fonctionnalité fondamentale. On trouve quand même 125 pages à lui consacrer ! On commence à rentrer dans le dur du comportement du langage. Il est d’ailleurs troublant de constater que la notion de référence est abordée ici chemin faisant… La classe LINT (large int) nous occupe pas mal de temps, notamment pour comprendre les comportements au limite du langage. Après avoir plafonné à 3 au chapitre précédent, le niveau de difficulté culmine à 4.

Ce sont 90 pages qui sont dédiés à la question des classes dérivées dans cet avant-dernier chapitre. L’exercice sur la classe process nous vaut le niveau de difficulté maximum, mais le chapitre me semble globalement simple. Si on y trouve de l’héritage privé (une fonctionnalité dont l’usage est rare), ainsi que des enum et des classes « friend », nulle trace d’héritage multiple et d’héritage virtuel ! Mais je ne dois pas oublier que le livre date de 1990…

Le dernier chapitre est consacré aux streams. Un sujet souvent bien mal traité. Ici ce sont 90 pages qui lui sont consacrées. Après un démarrage en douceur on aborde vite des exercices compliqués comme l’implémentation de la librairie IO C en C++ et vice-versa !

Les exercices traitant des parties cœur du langage sont toujours valables, ils mériteraient une réactualisation par rapport à la librairie standard, bien sûr. C’est donc un bon bouquin pour solidifier les bases.

Les exercices sont souvent courts et les explications précises. Les plus complexes nécessitent qu’on leur consacre beaucoup, beaucoup de temps ! Par bien des côtés, je retrouve là l’approche du Kernighan & Ritchie. Avec 550 pages il est quand même moins digeste que son aîné. De fait, c’est plutôt un texte dans lequel aller picorer des exercices, plus qu’à être lu de bout en bout ! Le texte fait référence au Stroustrup orignal (1er édition) que je ne possède pas, ayant débuté avec la seconde édition en français.

image

Référence complète : The C++ Answer Book – Tony L. Hansen – Addison Wesley 1990 – ISBN : 0-201-11497-6

The C++ Answer Book

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

Note de lecture : High-Speed Windows Applications, par Bruce E. Krell

Note : 2 ; Beaucoup de lourdeurs et de formalisme, mais peu d’idées intéressantes.

Ce livre traite de la gestion multitâche sous Windows 3.1, donc en s’appuyant sur les messages Windows. On en prend pour plutôt cher : un peu plus de 330 pages hors annexes. Celles-ci sont elle-même volumineuses : 130 pages ! L’approche pédagogique est pour le moins sujette à caution, le formalisme est lourd et guindé. Le titre de section de la page 7 est assez symptomatique : « Turn off your PC ! ». Mais voyons ce que ce volume a dans le ventre. En l’occurrence, ses entrailles sont divisées en 10 chapitres.

Le premier chapitre se compose d’une douzaine de pages pour décrire l’approche générale de la méthode (car en fait, c’est une méthode). On a vite compris que l’on va s’appuyer sur les message Windows centré sur la logique utilisateur.

Le chapitre 2 est aussi une introduction, mais cette fois au SDK. C’est très descriptif et donc assez abstrait. Je ne pense pas que j’aurais pu aborder la programmation Windows avec ça (merci Charles Petzold !). Les exemples de code des fameux « WinMain » et « WndProc » n’aident guère.

Ca y est, au chapitre 3, l’auteur peut commencer à développer sa notation et son approche complètement démente. J’ai l’impression de me retrouver en plein SADT : l’horreur !

Les chapitres 4 et 5 sont dévolus à l’application au « Windows High Speed Application ». On a toujours cette emphase méthodologique qui obscurcit terriblement le propos. J’ai l’impression qu’il y a une idée d’architecture derrière. Mais le fil est ténu et masqué par la prose idéologique. Pardon, méthodologique. On parle bien de « master control task » et « master scheduler task », mais impossible de comprendre à quoi ils ressemblent.

Au chapitre 6, on est déjà (enfin ?) arrivé page 100 et l’auteur souhaite nous parler « toolbox ». Nous devrions enfin avoir les pieds qui touchent le sol. A la place on nage en pleine confusion. Je ne saurais dire plus.

Les 50 pages du chapitre 7 sont entièrement méthodologiques, avec des templates de documents partant des tâches utilisateur et le mapping des activités sur les tâches. Au moins, c’est vaguement rigolo, si l’on a le goût pour ça !

Le chapitre 8 est court, mais en fait je n’ai pas compris ce que l’auteur cherche à faire. Passons au chapitre 9. Il fait 80 pages et enfin, on y voit le développement du master controler. Curieusement la façon dont l’auteur conçoit les choses a du sens. Mais la gangue méthodologique rend tout cela bien pénible. Le chapitre 10 rajoute une petite couche méthodologique bien futile.

Ce livre ne constitue pas une œuvre. Quand on décode le message, on comprend que l’auteur emploie des messages pour compléter les traitements (l’équivalent du pattern “complétion token”). Il formalise son approche à l’aide de diagrammes plus ou moins standard. Franchement, ce n’est pas fantastique.

Bien sûr, tout ceci est aujourd’hui complètement dépassé. La conception qu’emploie l’auteur est tout à fait intéressante. Il aurait pu la condenser dans un opuscule d’une centaine de pages (avec les blocs de code) qui du coup aurait été intéressant !

image

Référence complète : High-Speed Windows Applications, Multitasking design method – Bruce E. Krell – Bantan Professional Book 1993 – ISBN: 0-553-08992-7

High-Speed Windows Applications: Multitasking Design Methods


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

Note de lecture : Le génie logiciel orienté objet, par Ivar Jacobson, Magnus Christerson, Patrik Jonsson & Gunnar Övergaard

Note : 3 ; Trop théorique et trop volumineux

Voici un livre qui traite vraiment de méthodologie. Jacobson est le créateur des use cases, il était donc logique que son livre se focalise sur l’analyse. Au delà de ceci, il traite bien entendu des aspects processus et conception, cependant son propos reste souvent de très haut niveau. Mais voyons plus précisément ce que recèle l’ouvrage. Tout d’abord, il est volumineux, avec plus de 500 pages sur 16 chapitres regroupés en 3 parties.

La première partie traite des concepts objet. On en prend pour 5 chapitres sur 110 pages. Le premier chapitre est représentatif du livre : de bons vieux concepts « industriels », avec un processus en phase et une grande croyance dans la réutilisation sortie des cartons… Le second chapitre est une variation de celui-ci et ne nous apprend pas grand chose. C’est avec le chapitre 3 que l’on aborde l’orientation objet. Une vue très conceptuelle et analyse de l’objet, qui fait écho à ce qui est développé dans OMT (mais sans être aussi bien formalisé). Le chapitre 4 est le prolongement « conception » de ce chapitre. J’avoue avoir du mal à distinguer en quoi il apporte quelque chose au propos. En toute logique, le 5ème chapitre traite de l’implémentation orientée objet. C’est une nouvelle illustration de l’incapacité des ouvrages méthodologiques de cette époque de traiter décemment d’implémentation !

La seconde partie parle des « concepts », c’est à dire en fait des grands domaines d’ingénierie. Ce sont 7 chapitres qui constituent cette partie, la plus longue du livre avec près de 240 pages. Et l’on commence par évoquer l’architecture. En fait d’architecture, les auteurs développent plutôt une représentation en vues du système, ce qui permet d’introduire chemin faisant les cas d’utilisation. Mais tout ceci est bien abstrait. C’est de modèle d’analyse qu’il est ensuite question, en quelque sorte une reprise des chapitres 3 et 4. Puis c’est au tour de la « construction ». Pas plus que le chapitre 5, celui-ci n’est convainquant. Mais c’est l’occasion de présenter quelques diagrammes : diagramme d’interaction, d’activité et d’état-transition. Les auteurs tentent aussi de décliner quelques spécialisations , comme le temps réel avec un focus particulier sur les stimuli et la communication entre objets. On s’occupe également des bases de données, sujet mal traité qui semblait plutôt facile à aborder pourtant. On parle aussi de composants, on en parle toujours. Et c’est toujours aussi peu convainquant. Viennent finalement les tests, dont on se dit que le chapitre ne sert qu’à occuper le terrain…

La dernière partie est consacrée aux études de cas. Elle s’étend sur 150 pages et 4 chapitres. Le premier d’entre eux est une étude de cas sur la gestion d’entrepôts. On y développe un peu de cas d’utilisation, un peu de modèle d’analyse et une structuration en bloc. Pas de quoi bien comprendre la démarche de Jacobson. Une seconde étude de cas dans le domaine des télécommunications n’apporte pas grand chose. Les deux derniers chapitres traitent d’une part de la transition vers Objectory (vague et abstrait) et de la comparaison avec les autres méthodes, ce qui étonnamment s’avère intéressant.

Si le propos des auteurs est souvent assez vague, il est peu efficace, et la substance utile de ce livre (indéniable) ne justifie pas son volume. Je trouve aussi que l’aspect processus est trop idéalisé : il est rare qu’un développement se situe dans un cadre aussi idéal que celui décrit.

Aujourd’hui, ce livre présente certainement un intérêt “historique”, car le livre écrit par ce même Jacobson avec Rumbaugh et Booch, The Unified Software Development Process, traite le même sujet tout en étant plus d’actualité.

image

Référence complète : Le génie logiciel orienté objet – Ivar Jacobson, Magnus Christerson, Patrik Jonsson & Gunnar Övergaard – Addison Wesley 1993 – ISBN : 2-87908-042-8 (VO : 0-201-54435-0)

Le génie logiciel orienté objet

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