Note de lecture : The C++ Programming Language 3rd edition, par Bjarne Stroustrup

Note : 4 ; En net progrès depuis la 2nd édition, mais encore fort confus.

Bien que très abondamment vendue, la seconde édition de cet ouvrage de référence ne pouvait se vanter d’être un livre incontournable. Le propos de l’auteur étant à la limite de la confusion, et les références multidirectionnelles (aussi bien vers l’avant que vers l’arrière) incessantes ainsi que les exemples incomplets en faisaient un ouvrage pratiquement inabordable pour les nouveaux venus au langage. Bref, il était loin d’offrir un pendant au célèbre ouvrage de Kernighan et Ritchie. Cette nouvelle mouture (qui ne l’et plus désormaisn, car il existe une 4ème édition) s’est grandement améliorée, même si elle est loin de faire taire les critiques énoncées ci avant : le propos de l’auteur est devenu plus clair, l’ouvrage s’est étoffé, et pas qu’un peu avec ses 900 pages, et il traite du C++ standard (avec toutes les nouveautés) y compris la librairie standard. En venir à bout relève du marathon, fort heureusement l’auteur a pensé aux étapes : le livre se découpe en 25 chapitres regroupés en 4 parties.

Avant même la première partie, 3 chapitres d’introduction dont un « tour du C++ » et un « tour des librairies » donnent (ou devraient donner) un bon aperçu du langage. Las, on passe très vite de sujet en sujet sans forcément comprendre comment on en est arrivé là : des templates aux containers en passant par les Stream, on a effectivement un aperçu, mais en accéléré ! On rembobine pour se remettre sur la ligne de départ !

La première partie « basic facilities » couvre 6 chapitres sur 150. Au programme : types et déclarations (chapitre 4), pointeurs, tableaux et structures (chapitre 5), expressions (chapitre 6), fonctions (chapitre 7), exceptions et namespaces (chapitre 8) et fichiers sources et programmes (chapitre 9). Déjà ça va mieux, la progression est moins décousue. La plupart des exemples de code sont assez courts et ils sont aussi très nombreux. Ils comptent pour environ la moitié du texte. Nonobstant, l’auteur ne peut s’empêcher d’utiliser des « petits trucs rigolos » dans ses exemples de code, qui ne font rire que lui : utilisation des iostreams, des références sur … eh bien on ne comprend pas trop quoi, des nommages façon vieil Unix sur une ou deux lettres qui rendent les exemples de code très hermétiques.

C’est aussi 6 chapitres pour la seconde partie « abstraction mechanisms », mais avec un tarif de 225 pages, cette fois. On a à l’affiche : classes (chapitre 10), surcharge d’opérateur (chapitre 11), classes dérivées (chapitre 12), templates (chapitre 13), gestion d’exception (chapitre 14) et hiérarchies de classes (chapitre 15). Ca recommence presqu’humainement au chapitre 10, n’était-ce l’incurable habitude du créateur du C++ de rentrer tout de suite dans les arcanes complexes du langage. Bien sûr le chapitre sur la surcharge d’opérateurs n’arrange rien, on côtoie rapidement le cas des opérateurs globaux friends, par exemple. L’héritage couvre non seulement les cas simples, mais aussi les classes abstraites (donc les méthodes virtuelles pures) et bien entendu l’héritage multiple. Les exemples me donnent surtout l’impression d’arriver à rendre ardu un sujet que je maitrise maintenant très bien. Tout cela me laisse craindre le pire quand au chapitre sur les templates. Mais si celui-ci ne fait pas de cadeau, il s’arrête à un niveau de complexité appréhendable par le commun des mortels. Les deux derniers chapitres de cette première partie sont une heureuse surprise. En fait, l’explication sur les hiérarchies de classes où l’on voit aussi l’héritage en diamant et l’héritage virtuel est même un exemple de pédagogie !

La 3ème partie aborde enfin la librairie standard : on en prends pour 7 chapitres et 260 pages. Des chapitres 16 à 19, on traite de la STL, puis viennent les String (chapitre 20), les Stream (chapitre 21) et les Numeric (chapitre 22). La STL est une librairie complexe et on ne peut reprocher à Bjarne Stroustrup de faire des impasses, mais s’y retrouver ici relève de la gageure. Heureusement j’ai en réserve d’autres références qui font mieux à cet égard ! Le chapitre sur les String nous permet de souffler… et même de comprendre ce que sont les traits ! Mais les Stream, sujet déjà difficile en soit nous assure la noyade. Avec les Numeric, c’est à peine mieux.

La dernière partie est dévolue à des considérations de conception. Elle se contente de 3 chapitres et 110 pages. Le chapitre 23 n’a même pas de code, et les deux suivant moins qu’il n’est de coutume. C’est le moment pour le père du C++ de dispenser un cours de programmation et de conception. Ce n’est pas sans intérêt, mais le Dr Stoustrup reste un pédagogue assez moyen…

Le grand mérite de cet ouvrage est d’avoir été le premier à paraître et à faire figurer ces éléments “up to date”. Depuis, est sorti la 3ème édition du “C++ primer” de Stan Lippmann (épaulé cette fois par Josée Lajoie), encore plus volumineux, et qui dépasse, sans coup férir, le livre de Bjarne Stroustrup par sa qualité. Bien sûr le « C++ 11 » est aussi arrivé depuis. L’occasion de publier 15 ans après une 4ème édition qui pèse le monumental volume de 1400 pages !

Difficile de recommander ce texte : il est difficile d’abord. Il nécessite souvent de relire 2 ou 3 fois un passage pour le comprendre. L’auteur n’a guère pitié de nous car les exemples, s’ils sont courts et nombreux surabondent en éléments connexes qui ne sont généralement pas connus et compliquent la compréhension. Il reste aussi un fervent de ce que j’appelle les « références en avant ». On ne pourra pas reprocher à l’auteur de faire l’impasse sur quoi que ce soit, mais que c’est dense. Chaque chapitre se termine par des conseils et des exercices. J’avoue ne pas avoir eu le courage de les faire. Par contre, les citations au début de chacun d’entre eux sont particulièrement pertinentes et savoureuses. Bref, une bonne lecture pour masochiste.

c++-prog-lang-stroustrup

Référence complète : The C++ Programming Language (3rd edition) – Bjarne Stroustrup – Addison Wesley 1997 – ISBN: 9780201700732

The C++ Programming Language


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

Publicité

ScrumBeer de rentrée : Une année French SUG à construire soi-même !

http://www.meetup.com/frenchsug/events/130351452/

L’appel est clair : cette fois, nous viendrons à la Scrum Beer avec un objectif concret en tête : proposer des thèmes et des formules originales pour cette année qui commence. Et pourquoi pas vous y impliquer également ?

ScrumBeer de rentrée : Une année French SUG à construire soi-même !

Note de lecture : The Ingres Papers, Michael Stonebraker edt.

Note 4 :Les principes fondamentaux d’architecture d’une base de données… d’il y a 30 ans !

Il fut un temps où la course entre les bases de données relationnelles se jouait entre Oracle et Ingres ! Ce temps est passé, Oracle a gagné. Ecrit par le père de Ingres (INteractive Graphics and REtrieval System), ce livre rassemble des articles détaillant l’architecture les problématiques et choix techniques d’Ingres. Comme on peut s’y attendre (Michael Stonebraker est professeur à Berkeley), les articles ont une coloration très académique. L’ensemble des 22 articles couvrant 425 pages sont regroupés en 6 sections :

  • Section 1 : Design of relational systems : Cette section relate les choix fondamentaux d’Ingres, la rétrospective sur les choix et erreurs faits durant la conception d’Ingres.
  • Section 2 : Supporting studies on relational systems : Cette section aborde des problématiques spécifiques sur les bases de données telles que le verrouillage, les performances, le système de gestion des requêtes et l’interface avec l’operating system. De nombreux point de recherches d’optimum sont abordés (granularité de verrouillage, taille de cache), d’optimisation de compilation, etc..
  • Section 3 : Distributed database systems : Cette section rassemble des articles sur des aspects avancées d’Ingres : répartition physique des données, gestion des requêtes distribuées redondance et commit sur plusieurs bases.
  • Section 4 : User interface for database systems : Cette section relate le développement d’un language de requête interactif (EQUEL) sur Ingres et d’un portail, sorte de buffer de requêtes prêtes à être utilisées. Les principes de construction de Schémas de base et de constructions d’applications à l’aide de formulaires (FADS) terminent cette section.
  • Section 5 : Extended semantics for the relational model : Cette section explore de nouvelles sémantiques au-dessus de la sémantique relationnelle, telles que la conception assistée par ordinateur ou la gestion de relations hypothétiques qui sont des sortes de « vues » sur les relations. Un autre sujet d’intérêt est la gestion des documents, permettant non seulement la gestion d’information de grande taille, mais également leur manipulation (recherche, division ou concaténation).
  • Section 6 : Database design : Cette section aborde quelques questions avancées tels que la conversion d’un modèle logique en modèle physique ou la recherche de chemins d’accès sur la base.

Les sujets abordés dans ce livre accusent clairement le poids des ans ! Il n’en reste pas moins que lorsque l’on a un peu la fibre du chercheur, ces sujets font envie et donnent envie d’aller regarder comment ces problèmes sont abordés dans les bases de données modernes ! Le niveau du propos reste souvent obscur au béotien, hélas, dû au fait qu’il s’agit d’articles de recherche. Aussi décroche-t-on souvent du texte et c’est dommage ! C’est aussi ce qui justifie ma note un peu sévère. J’aurais préféré un texte reformulé afin de le rendre plus abordable, ceci sans dégrader sa teneur technique. Les texte universitaires se font trop souvent un point d’honneur à être hermétiques !

Ingres-papers

Référence complète : The Ingres Papers, Anatomy of a relational database system – Michael Stonebraker edt. – Addison Wesley 1986 – ISBN : 0-201-07185-1

The Ingres Papers: Anatomy of a Relational Database System

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

Note de lecture : Stratégies & tactiques C++, par Robert B. Murray

Note : 7 ; Des conseils d’expert sur l’utilisation avancée du C++, pour le développeur émérite. N’est toutefois pas à la hauteur des ouvrages de Scott Meyers.

Ce livre fait également partie de la série à laquelle appartiennent les ouvrages de Tom Cargill et Scott Meyers. Il s’agissait à l’époque de produire une série d’ouvrage donnant des avis d’experts. Si « effective C++ » donna non seulement naissance à une série de texte mais aussi inspira d’autres auteurs, celui-ci reste plus qu’honorable. Ecrit par le créateur de C++ Report et chroniqueur de “C++ obfuscated” dans cette même revue, ce livre s’attaque à des préoccupations très techniques : effet de bord des initialisations, de l’héritage virtuel, etc… Chaque chapitre se termine par un paragraphe “En bref” qui résume celui-ci, et par un paragraphe “Questions” qui permet au lecteur de faire le point sur ses connaissances acquises.

C’est la traduction Française que j’ai acquise. Dans cette version, le livre compte quand même 280 pages réparties en 11 chapitres.

Plus que de langage, c’est de conception dont nous parle le chapitre 1 et plus particulièrement d’abstraction (et aussi d’héritage, donc). Mais point de code C++ ou à peine, mais un bref aperçu des cartes CRC.

Long de plus de 40 pages, le chapitre 2 évoque les classes et de nombreux aspects de conception et de comportements qui tournent autour : constructeurs par défaut ou de copie (et donc forcément opérateur d’affectation), on y traite précisément la différence entre initialisation et affectation. Bien d’autres subtilités (constance, membres de type référence, etc…) sont couvertes. Je trouve un peu dommage que l’auteur, s’il présente avec brio le comportement du langage ne prenne pas plus position.

Le titre du chapitre 3 est un peu abscons car il parle de « descripteurs », en fait il s’agit de stratégies de pointeurs intelligents tels que le « copy on write » ou le comptage de références. L’utilité pratique de ces techniques a baissé avec le temps, du fait de la baisse des coûts d’allocation, de l’augmentation des tailles mémoire, mais surtout de l’avènement du multi-threading et des architectures multi-cœurs. Mais la compréhension de ces mécanismes reste un excellent exercice, lui-même excellemment expliqué.

Le chapitre 4 traite en profondeur le cas de l’héritage simple, qu’il soit public, privé… ou protégé. C’est l’un des rares ouvrages de ma connaissance traitant de ce dernier cas il est vrai pas très utile. L’auteur n’oublie pas de parler des méthodes virtuelles et virtuelles pure et explique précisément le fonctionnement des constructeurs et destructeurs dans ces situations. Rien à redire.

C’est à l’héritage virtuel qu’est consacré le chapitre 5 et seulement à cela. Bob Murray utilise abondamment les diagrammes de Venn pour expliquer les principes sous-jacents. Bien sûr on n’échappe pas à l’héritage en diamant et à son corolaire : l’héritage virtuel. Si le cas de classes de bases héritées différemment (public, protégé, privé) est mentionné, l’auteur ne rentre pas dedans plus avant, par contre il évoque la dominance d’héritage ce qui est rare. Ici aussi, l’auteur excelle à expliquer les choses en détail, mais moins à prendre position.

C’est toujours d’héritage dont il est question au chapitre 6. Ici l’auteur rentre dans des questions de conception : quand et comment concevoir pour l’héritage ? L’héritage peut-il induire des comportements erronés ? Et plus précisément comment se comportent constructeurs et destructeurs. J’ai été surpris de ne pas voir évoqué l’héritage privé dans le cas de classes fournissant des services non virtuels aux classes dérivées, et de ne pas voir trace de l’usage du « template method ».

Le chapitre 7 est le premier à évoquer les templates. On reste en zone de sécurité avec la démonstration de template sur des smart pointeurs ou sur des fonctions. Les exemples de code deviennent aussi non triviaux. A l’époque où le texte fut écrit, le comportement des templates était peu spécifié, on n’est donc pas étonné de ne pas voir l’auteur y entrer en profondeur. L’impact sur l’instanciation de code est toutefois débattue.

C’est encore de templates dont parle le chapitre 8. Faisant suite au chapitre précédent, celui-ci est entièrement dévolu aux problématiques d’implémentation de conteneurs avec des éléments homogènes ou non et aux sémantiques de conteneurs par valeur ou par référence. Une lecture franchement difficile à suivre.

On passe aux questions de réutilisabilité au chapitre 9. Ici on se situe plus au niveau des pratiques permettant la réutilisation au niveau d’une classe : celle-ci est-elle bien documentée, avec de bons nommages ? Qu’en est-il de sa robustesse, celle-ci est-elle éprouvée avec des assertions (on ne parlait pas de tests unitaires à cette époque) ? Une grande partie du chapitre est dédiée aux questions de débogage et comment rendre son code monitorable dans ces conditions. La partie consacrée aux allocateurs et à la façon de les rendre parlant est particulièrement intéressante, y compris aujourd’hui.

On ne pouvait échapper à un chapitre consacré aux exceptions. C’est le chapitre 10. La prose n’est pas exceptionnelle, si je puis dire, même si c’est la première fois qu’on y évoque le « les exceptions doivent être exceptionnelles ».

Le livre se termine avec un chapitre sur la migration d’applications vers C++. Il s’agit en fait de considérations et d’un ensemble de conseils (de bons conseils) pour ceux passant du C au C++.

Cette ouvrage est d’une lecture aisée, du moins pour le développeur déjà expérimenté en C++, et se consomme rapidement en une semaine ou deux, ce qui n’est pas la moindre de ses qualités. La petite surprise est que le texte ne se focalise pas uniquement sur le langage mais aussi sur son usage et sur une bonne compréhension de la conception : qu’est-ce qu’une bonne classe, une bonne abstraction, etc… Le texte mériterait un bon rafraichissement car il accuse maintenant 2 décennies, mais il reste de très bonne tenue.

cpp-strategies-tactics

Référence complète : Stratégies & tactiques C++ – Robert B. Murray – Addison Wesley 1994 (V.O. : C++, Strategies & Tactics ; Addison Wesley 1993 ; ISBN : 9780201563825) – ISBN : 2-87908-066-5

C++ Strategies and Tactics

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

Note de lecture : Conception orientée objet, pratique de la méthode HOOD par Michel Lai

Note : 3 ; Dense et pas très engageant

Bien sûr, aller regarder aujourd’hui un texte aussi ancien n’a pas forcément beaucoup de valeur (quoique certains textes vieillissent fort peu). Non, ici la motivation est historique, car ce livre est l’un des seuls traitant de la méthode Hood, spécifiquement développée pour le langage Ada.

L’ouvrage débute par une introduction à la conception objet et aux objets, assez formelle je dois dire, mais illustrée de code Ada. Vient ensuite la présentation de la méthode Hood proprement dite. Celle-ci n’est pas didactique à mon goût, car les éléments sont présentés sous l’angle de leur définition, c’est difficile à digérer, même si je dois admettre que ce n’est certainement pas une approche superficielle. Curieusement, si des exemples de syntaxe Hood sont fréquemment fournis, ce n’est pas le cas de la notation graphique ! Petite curiosité : en plein milieu de l’ouvrage, un chapitre est consacré à un outil : HyperHood ! Généralement, ce genre de chapitre est mis en fin d’ouvrage, voir en annexe, mais comme on dit : on va survivre à ça. La lecture reprend avec un chapitre complémentaire sur la méthode, que j’aurai vu personnellement en tête d’ouvrage, car elle illustre (enfin) la méthode avec un cas d’utilisation : le poste de conduite d’une voiture. Hood+ et H+ complètent le tour d’horizon de la méthode avec ce faisant un retour au style rébarbatif, accompagnés de chapitres sur des métriques et des retours d’expérience.

On ne saurait prétendre que ce livre est creux : au contraire, il y a pas mal de matière, c’est même un peu dense à la matière d’un porridge. Et tout aussi indigeste, d’ailleurs. Si vous souhaitez vous cultiver, et avoir juste une idée de Hood, vous trouverez ce livre peu engageant : il n’y a pas de doute, pour rentrer dans ce livre, il faut de la volonté. Je soupçonne que celui-ci ait été conçu comme complément à un cours magistral, ce qui expliquerai bien des choses… Bref : pas très engageant, mail il y a pire…

hood

Référence complète : Conception orientée objet, pratique de la méthode HOOD – Michel Lai – Dunod 1991 – ISBN : 2-10-000250-3

Conception orientée objet, pratique de la méthode HOOD


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