Livre : "Les design patterns en Ruby"

Préambule

Russ Olsen nous offre ici un excellent livre. Pour avoir lu d'autres ouvrages du genre, j'ai adoré. Ce livre est admirablement écrit et Russ amène très bien la problématique des design patterns de façon très didactique avec une méthode toute incrémentale dans la description du modèle décrit, et le tout avec une pointe d'humour que j'ai apprécié.

En plus d'une révision d'un panel de patterns des plus connus (en C# on pourra se référer au site Do Factory), ce livre apporte sa touche Ruby : comment transposer les DP à la Ruby en utilisant les spécificités et avantages du langage, souvent en version plus concise. A chaque pattern, l'auteur rappelle une utilisation dans le monde réel, notamment une application dans les librairies Ruby.

Une revue des 18 chapitres

Partie I : Patterns et Ruby

• Chapitre 1 : introduction et rappel des principes objets,
• Chapitre 2 : rappel des bases de Ruby, le fameux Duck Typing ("si un objet ressemble a un canard et qu'il couine comme un canard, alors, ce doit être un canard", autrement dit, plus besoin d'interfaces par exemple), Proc et blocs, modules mixin

Partie II : les Patterns en Ruby

• Chapitre 3 : nous démarrons avec le pattern Template Method, qui utilise le principe Hollywood "ne nous appelez pas, nous vous appellerons". Vous apprendrez à afficher un rendu en HTML, en texte, voire plus selon le contexte d'utilisation. Une autre utilisation de ce pattern réside dans les hooks, ou méthodes d'accrochages, bien utiles lorsqu'un objet externe souhaite intervenir sur le contexte courant. Pour un débat d'idées sur les langages à typage statique vs. typage dynamique (en gros, compilés vs. interprétés), lire les pages 61 à 64 pour un intéressant point de vue Ruby, pour lequel j'adhère au moins pour les tests unitaires,
• Chapitre 4 : basé sur le même principe que le Template Method, le pattern Strategy apportera une moindre adhérence au client par l'utilisation de la composition et l'injection d'objet afin d'obtenir une meilleure délégation. Une version supplémentaire est proposée, adaptée a Ruby : suppression des interfaces, remplacées par le typage à la canard (il n'existe pas d'interfaces en Ruby, elle est juste simulée par l'héritage de méthodes vides, et en y ajoutant des exceptions si non implémentées), utilisation des Proc et blocs,
• Chapitre 5 : bien qu'il soit disponible en natif dans Ruby, dans ce chapitre, le pattern Observer est à l'honneur. On y découvrira les modules mixin afin de partager du code vers plusieurs classes sans être bloqué par l'héritage le cas échéant,
• Chapitre 6 : on apprendra à utiliser le pattern Composite pour cuisiner, afin de découper en tâches toutes les manipulations nécessaires pour réaliser un bon repas,
• Chapitre 7 : le pattern Iterateur nous fera découvrir la richesse de Ruby avec le mixin Enumerable ou d'autres méthodes très utiles à l'aide des blocs : any?, all?, scan(regexp), et bien sur each et ses variations each_key, each_value, each_entry, ...
• Chapitre 8 : cela sera l'occasion de parcourir le pattern Command, qui se base sur le pattern Composite vu précédemment. On y parlera des migrations d'ActiveRecord, qui gèrent les actions à faire (up) ou à défaire (down) au niveau de la base, ou encore de Madeleine, une librairie de sérialisation binaire d'objets (Marshalling dans le jargon),
• Chapitre 9 : découverte de l'Adapter au travers du StringIOAdapter ou de sa mise en application dans ActiveRecord. On y apprendra qu'en Ruby, on peut modifier à la volée toute classe ou instance pour y ajouter ou modifier les méthodes, ce qui dans un contexte approprié, pourra remplacer l'Adapter,
• Chapitre 10 : vous redemanderez bien un proxy ? on y découvrira bien sûr les proxy services Web (avec un appel SOAP à un WS .NET sur http://www.webservicex.net), mais aussi le proxy de contrôle d'accès, ou encore le proxy pour le lazy loading, courant dans les ORM. Le tout sera bien évidemment réécrit à la Ruby, en utilisant method_missing ou la méthode send pour l'envoi de messages explicites à des méthodes, on retrouve ici la concision de Ruby,
• Chapitre 11 : décorez-moi cette classe que je ne saurais voir. Dans ce chapitre, on apprendra à ajouter des fonctionnalités à un objet, ou à empiler des responsabilités (sous forme de chaîne), on retrouvera la délégation propre au DP. La version Ruby apportera le module Forwardable, alternative à la technique method_missing, ou encore à la technique d'alias d'une méthode ou encore l'utilisation d'extend afin d'étendre un objet avec des modules et donc de fonctionnalités. L'application du motif dans le monde réel se réalisera au travers d'ActiveRecord et la méthode alias_method_chain,
• Chapitre 12 : le fameux et si décrié (difficulté de tester, effets de bord) pattern Singleton sera à l'honneur, avec l'utilisation du module Singleton.
• Chapitre 13 : avec le Factory method et l'Abstract Factory pour la fabrication d'objets de même catégorie, il sera temps de revoir comment marche un canard, et de réviser le Template method, car fabriquer des objets n'a jamais été aussi simple qu'en Ruby. On y apprendra également, qu'en Ruby, TOUT est objet, les classes comprises, ce qui nous donnera la possibilité d'optimiser la création de nos objets,
• Chapitre 14 : tous les geeks sont passionnés par leur machine, mais en monter une peut s'avérer compliqué. Le pattern Builder nous aidera à simplifier cette tâche pour ne pas se tromper dans les composants. Un retour sur les méthodes magiques, à l'aide de method_missing, nous seront d'un grand secours.
• Chapitre 15 : Interpreter. Parler AST (Abstract Syntax Tree) plaira aux aficionados des entrailles d'un langage, ou comment concevoir son propre interpréteur pour son langage nouvellement créé : un langage de recherche de fichiers, sous forme d'un ensemble d'expressions représentant notre arbre, qui nous serviront à filtrer les fichiers. On nous parlera de Racc, le petit frère du fameux Yacc, ou encore de la librairie Runt pour exprimer des dates et des intervalles de temps.

Partie III : les Patterns Ruby

• Chapitre 16 : après l'interpréteur, il est temps de titiller les DSL (Domain Specific Language). On y apprendra à développer le DSL (interne) Packrat pour sauvegarder des fichiers. La fonction eval() interprétera notre nouveau langage. Le DSL le plus connu en Ruby est l'utilitaire Rake, qui remplace Ant et Make dans le monde Ruby.
• Chapitre 17 : méta-programmation : l'auteur reprend l'exemple du chapitre 13 afin de l'adapter à la méta-programmation. Nous verrons comment injecter du code (nouvelles méthodes d'une classe) dynamiquement dans un programme, notamment grâce à %Q{ #code } et à la fonction class_eval(). Un exemple de l'implémentation de ce type de programmation reste attr_accessor, attr_reader, attr_writer de Ruby, qui n'appartiennent pas aux mots clés du langage.
• Chapitre 18 : ce dernier chapitre est consacré au paradigme très utilisé sous Rails, moins technique et plus proche d'une bonne pratique : convention plutôt que configuration. Dans ce dernier chapitre Russ nous propose de faciliter la fabrication d'adaptateur pour envoyer des messages sous différentes formes : FTP, SMTP, HTTP, ... où tout développeur pourra facilement rajouter un adaptateur suivant une convention déterminée par une arborescence de répertoires / fichiers. Rails est l'exemple le plus frappant de ce type de modèle développement.

Conclusion

Je ne peux que conseiller ce livre, où la traduction française a été bien réalisée. Russ Olsen nous guide vers les design patterns classiques mais aussi vers les plus spécifiques du langage avec une méthode très didactique et un sens non dénué d'humour.

Pour les néophytes de Ruby, cela sera l'occasion d'en découvrir toutes les facettes et la puissance qu'apporte Ruby.

Un bouquin que l'on peut sans hésiter conseiller à tout développeur en mal de curiosité.