Note : 6 ; Du (très) bon, mais hélas aussi du moins bon
Comme l’indique son nom, ce livre concerne l’écriture de beau code. Il rejoint en cela « implementation patterns » de Kent Beck ou « Refactoring » de Martin Fowler.
J’ai beaucoup apprécié les 10 premiers chapitres. L’auteur (ou les auteurs, devrais-je dire) y évoque en détail différents aspects d’écriture et de présentation du code.
Au chapitre 1 qui évoque le « pourquoi » de l’ouvrage, le chapitre 2 traites du nommage, ou comment le rendre pertinent et distinguable. Des aspects que l’on a trop souvent tendance à oublier.
Le chapitre 3 traite des fonctions, sujet important s’il en est. Bien sûr on y parle de la taille des fonctions et de leur lisibilité, mais aussi de la nécessité de concevoir les fonctions selon un seul niveau d’abstraction. Par contre l’idée de séparer l’interception d’exception ne tient tout simplement pas la route. Désolé.
Au chapitre 4 on aborde les commentaires. La règle est simple, le code doit principalement être lui-même le commentaire et ceux-ci doivent donc être réduits à la portion congrue. Le chapitre 5 concernant le formatage est plus surprenant, pourtant les conseils y sont bons, par exemple concernant l’espacement vertical.
On monte en niveau d’abstraction avec le chapitre 6 traitant des structures de données et le chapitre 7 évoquant les exceptions. Rappeler d’anciens principes tels que la loi de Déméter me semble aujourd’hui plus nécessaire encore qu’hier !
Les chapitres 8 et 10 traitent d’avantage de considérations de design. Si le contenu reste valable, le traitement du « 3rd party code » est quand même un peu simpliste. On ne saurait couvrir ce genre de problématiques en 15 pages et 2 conseils donnés à l’emporte-pièce. Les directives données sur la conception des classes rappellent celles issues du précédant livre de l’auteur : « agile software development ». Donc rien de nouveau.
Rien de nouveau non plus sur les tests unitaires évoqués au chapitre 9, bien que la lecture en soit plaisante.
En montant en niveau d’abstraction, les chapitres 11 à 13 qui traitent plutôt de problématiques d’architecture, voient un peu gros pour un traitement qui se révèle un peu court. Le chapitre 11 aborde l’intérêt de l’AOP par rapport à la conception de systèmes, mais il s’agit à peine d’une introduction même si l’on tente d’évoquer les mérites comparés d’Aspect J et de Spring AOP. Je n’ose même pas retenir le chapitre 12 traitant de l’émergence en 5 pages ou du chapitre 13 sur la concurrence qui ne saurait soutenir la comparaison avec l’ouvrage de Doug Lea. Même avec son chapitre complémentaire en annexe.
Les chapitres 14 à 16 sont des tutoriaux guidés de refactoring. Hélas, le format livre se prête mal à cet exercice qui se révèle rapidement rébarbatif. Un support interactif online serait bien mieux adapté.
Bref, j’ai bien apprécié 150 des 400 pages de ce livre. C’est insuffisant pour classer celui-ci dans les bons ouvrages, mais il vaut quand même un petit détour.
Référence complète : Clean Code, a handbook of agile software craftsmanship – Robert C. Martin – Prentice hall / Robert C. martin series 2008 – ISBN: 0-13-235088-2 ; EAN: 978 0 13 235088 4
Software Freethinker 
