Note de lecture : Refactoring to Patterns, par Joshua Kerievsky

Note : 6 ; Un grand sujet, traité avec acuité, mais parfois présenté de façon un peu fastidieuse !

Joshua Kerievsky est donc le premier à avoir franchi le fossé entre le refactoring et les patterns ! Nous devons lui en être reconnaissants. L’intérêt et l’expérience de l’auteur (notamment en tant que créateur du « new York patterns group ») l’ont conduit à aborder les patterns non pas comme des éléments initiaux de conception, mais comme des solutions à des problèmes, donc des éléments de conception émergentes, ce qui nous amène au refactoring ! La conception émergente via les patterns est le thème et l’intérêt central du livre et en font sa valeur.

Le sujet va nous occuper au long des 350 pages découpés en 11 chapitres que forme cet ouvrage. Au chapitre 1, l’auteur nous livre la démarche que l’a conduit à ce texte. En partant tout d’abord des patterns pour obliquer vers le refactoring et le cycle TDD, pour revenir enfin vers les patterns, pour améliorer la conception sans tomber dans l’over engineering. Le second chapitre est consacré au refactoring. Il ne s’agit pas là, en une douzaine de pages, de reprendre le propos de Martin Fowler, mais simplement de se focaliser sur l’intention et l’essence de cette démarche.

L’introduction aux patterns du chapitre 3 n’est ni vraiment utile, ni spécialement éclairante. Le chapitre est court mais assez vague sur la nature des patterns, le propos se concentrant plutôt sur l’histoire personnelle de l’auteur… Les Code Smells du chapitre 4 souffrent moins de ce défaut, Joshua Kerievsky nous gratifie ici des odeurs les plus rependues. Il s’agit plus d’un mini-catalogue que d’une introduction.

Au chapitre 5, on attaque les choses sérieuses avec le catalogue de « refactorings to patterns ». Ce chapitre 5 n’est que le préambule, expliquant la méthodologie employée. Les « gros » chapitres du catalogue commencent au chapitre 6, avec les patterns associés à la création d’éléments. Chaque pattern suit le même schéma : d’abord la description des points de départ et d’arrivée, avec les bénéfices et inconvénients attendus. Ensuite l’auteur déroule les étapes de refactoring (en Java) permettant d’arriver au résultat. Il faut l’avouer, le style est dynamique et engageant. La démarche et les petites étapes rappellent l’ouvrage de Kent Beck sur le TDD. On retrouve ici, et à ce format, les classiques du GOF : Factory, Factory method, Builder…

Le chapitre 7 « simplification » parait de prime abord plus mystérieux sur ses intentions. En fait, il s’agit des patterns structuraux du GOF (cette fois encore), à l’exception du « compose method » qui n’y figure pas. J’ai été un peu déçu du traitement du décorateur, même si l’auteur s’y attarde pas mal, il a aussi un peu de mal à donner une ligne de partage claire entre stratégie et décorateur. Peut mieux faire… Le titre du chapitre 8 « Generalization » est plus direct sur ses intentions. Il n’est guère surprenant d’y trouver des patterns tels que le Template Method et le Composite (bien adressé dans ces pages), par exemple. L’observer est un des rares patterns qui pour moi s’implémentent intentionnellement plutôt que de manière émergente. De fait je trouve le refactoring (remplacement de notifications directes) un peu tiré par les cheveux.

Tout comme pour le chapitre 7, le titre du chapitre 9 « Protection », ne laisse guère en dévoiler le contenu. Il ne s’agit d’ailleurs pas majoritairement de patterns du GOF. « replace type by class » est bien symptomatique de ce que l’on veut illustrer ici. Le Singleton apparait lui, pour la seconde fois. J’aurais préféré un concept plus généralisé de limitation du nombre d’instances au-delà du « single ». Le chapitre 10 semble plus spécialisé, en étant intitulé « Accumulation ». Il n’y a d’ailleurs que deux patterns, le « Collecting Parameters » et le Visiteur, qui a fait déjà couler tellement d’encre. Le chapitre fait un peu parent pauvre. Enfin, le chapitre 1, « Utilities », nous propose des patterns qui sont plutôt des refactorings, tel le « Extract Parameters ».

Construire un pont rejoignant les patterns avec le refactoring était un exercice méritant d’être tenté, car le lien entre les deux, s’il semble évident, n’était abordé que du bout des lèvres. La description pratique des refactorings est quant à elle un peu fastidieuse, c’est dommage ! J’avoue qu’il m’est difficile de cerner la valeur originale de ce livre par rapport aux deux piliers que sont le « Design Pattern » et le « Refactoring », mais la barre était vraiment haute.

Référence complète : Refactoring to Patterns – Joshua Kerievsky – Addison Wesley / Signature series 2004 – ISBN: 0-321-21335-1

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur la façon dont les données de vos commentaires sont traitées.