Note : 4 ; Le “seriously” est à prendre très au sérieux !

Ce texte n’est pas très facile à classer entre Java et Craftsmanship. S’il est résolument orienté sur la plateforme Java, c’est tout de même sur les principes d’implémentation (et un peu de conception) que l’auteur met l’accent. L’auteur, parlons-en, est professeur d’informatique à l’université de Naples. De fait, sans en avoir l’austérité, le texte a quelques ressemblances avec un support de cours.

Voyons un peu ce qu’il en est. L’ouvrage compte 9 chapitres répartis sur 2 parties très inégales, pour un total de 280 pages. On le voit, ce sont des chapitres relativement conséquents, en moyenne supérieur aux 20 pages par chapitre qui m’a toujours semblé un bon compromis. La première partie compte deux chapitres, couvrant 45 pages. Le chapitre introductif traite de la qualité ou plus exactement des qualités attendues d’un logiciel. Ce seront les points successivement développés dans les chapitres suivant, puis l’étude de cas qui nous suivra tout au long de l’ouvrage est introduite.

Le second chapitre introduit l’implémentation de référence. Une implémentation qui ne cherche à optimiser ni la performance ni l’emprunte mémoire. Toutefois l’approche adoptée pour analyser l’un et l’autre est présentée ici, grâce à cette version facilement appréhendable. Bien sûr c’est la notation O popularisée par la STL qui est utilisée pour les performances. On sent déjà le côté « support de cours » dans ce chapitre par ailleurs pas désagréable à lire.

La seconde partie couvre les 7 chapitres restant. Le chapitre 3 qui ouvre cette partie s’intéresse à l’optimisation de performances et va requérir 33 pages pour cela. L’auteur nous propose 3 versions successives de l’étude de cas, optimisant l’un ou l’autre des cas d’utilisation afin de montrer que ces optimisations sont souvent antinomiques. Bien que convenablement illustré, ce chapitre n’est pas très simple et respire quelque peu le « support de cours » que j’ai évoqué plus haut. Impression renforcée par les quizz en cours de chapitre et les exercices en fin de celui-ci. Enfin la section « and now for something completely different » avec un ou plusieurs cas d’utilisation différents ne me semble pas un ajout utile. Nous retrouverons ces constructions dans tous les chapitres de cette seconde partie.

Au chapitre 4, c’est au tour de l’espace mémoire. Avec un volume de la même eau que pour les performances et une construction semblable (mais cette fois avec 4 versions de l’étude de cas), il est toutefois un peu moins rugueux. Les explications et autres tableaux montrant les compromis des différentes solutions se montrent à cet égard particulièrement clair. Le chapitre 5 adresse le monitoring et y consacre 34 pages. Toutefois, ce n’est pas ce que vous pensez. Par monitoring, l’auteur évoque le « design by contrat » auquel il accorde une importance inhabituelle. Ainsi, préconditions, post-conditions et invariants tels que définis par Bertrand Meyer sont présentés ici dans le cadre d’un design Java. C’est une philosophie qui, au moins en partie, rentre en concurrence avec l’approche par les tests et elle met en relief l’aspect académique de l’ouvrage. Néanmoins, l’auteur aborde le sujet avec une profondeur que je n’ai trouvé nulle part ailleurs. Un point fort de l’ouvrage.

Le chapitre 6, justement, est consacré aux tests. Avec 33 pages, c’est le tarif habituel. La couverture du sujet n’est pas exceptionnelle, mais elle a attiré mon attention sur deux points. Tout d’abord sur l’articulation avec le contract-based design, sujet du chapitre précédent. Sur ce point, je n’ai guère été surpris. Ensuite sur le « input coverage », parfois abordé dans d’autres ouvrages, mais rarement aussi bien traité qu’ici. C’est de lisibilité dont il est question, au long des 28 pages du chapitre 7. Qui trop étreint mal embrasse dit le proverbe. C’est le cas ici, où le propos se disperse entre la lisibilité des structures à grande échelle, le flux de contrôle, le nommage et les commentaires (beurk). Tout cela sans rentrer en profondeur (impossible vu la taille du chapitre) et donc sans substance réellement intéressante. Bref, un chapitre à oublier.

Le chapitre 8 est gourmand aussi, car il tente de traiter en 29 pages la question du thread-safety ! Certes, l’auteur maîtrise son sujet, mais le propos échoue à être exposé clairement, tout comme l’est la juxtaposition des classes immutables dans ce paysage. Le chapitre 9 dédié à la réutilisabilité clos l’ouvrage. Je m’avoue surpris de la résurgence de ce sujet qui avait disparu des radars depuis les années 90. En fait ici, il s’agit de mettre un gros focus sur les génériques dans un contexte de généralisation. Le propos est assez complexe et ne convainc guère.

Le livre est assez décevant, bien que la compétence et souvent la teneur même de l’ouvrage soient solides. Le côté « support de cours » du texte le rend assez peu fun à lire, mais on est prévenus : c’est « sérieux » et ce qualificatif est à prendre au premier degré. C’est dommage, quand le texte s’adresse à un public assez peu expérimenté…

Référence complète : Seriously Good Software – Marco Faella – Manning 2020 – ISBN : 978 1 61729 629 1