Introduction

Depuis les années 60, de nombreux logiciels en finance sont développés pour satisfaire les différents besoins dans les marchés financiers sur les plateformes électroniques. Au fur et à mesure de l’évolution des technologies informatiques et massives données à traiter qui passent à l’échelle, beaucoup de codes derrière ces fonctionnalités devront être réexaminés, ce qui parfois est très délicat et compliqué à cause de leurs conceptions architecturales très élémentaires ou itératives avant ou pendant les développements.

Dans cet article, on parle de l’art du Clean Code où les principes SOLID sont évoqués, qui propose un ensemble de règlements généraux à respecter pour développer les codes et les modules. Néanmoins, on cherche parfois une solution de réalisation plus concrète en face à une demande architecturale plus précise.

L’introduction des patrons de conception (Design Patterns) [1] devient nécessaire pour répondre à ce défi plus raffiné. Dans les articles suivants, on va présenter pourquoi et comment pratiquer ses conceptions dans le code en Python 3 qui est très populairement pratiqué en application financière de nos jours [2], en résolvant les demandes que l’on rencontre en question.

Afin de mieux mettre en évidence les patrons de conception, on les classifie en trois familles [3] créatrices, structurales et comportementales en fonction des contextes d’utilisation.

1. La famille créatrice offre la possibilité de créer des objets en fonction d'un critère requis et de manière contrôlée.

2. La famille structurale consiste à organiser différentes classes et objets pour former des structures plus grandes et fournir de nouvelles fonctionnalités.

3. La famille comportementale cherche à identifier des modèles de communication en commun entre les objets et à réaliser ces modèles.

Si on comprend bien comment profiter des avantages des patrons de conception dans chaque famille aux contextes correspondants, on pourrait non seulement réduire le cycle et le coût du développement de logiciel, mais aussi favoriser la réutilisation dont le code devient plus robuste et hautement maintenable, ce qui rend notre code facile à étudier et à déboguer.

Voici une liste des patrons de conception [3] des trois familles mis en valeur dans mes articles à la suite pour nos développements en Python 3.

1. La Famille Créatrice

a) Le singleton (Singleton Pattern en anglais) est une classe dont une seule instance peut exister.
b) Le prototype ( Prototype Pattern en anglais) est une instance entièrement initialisée à copier ou cloner.
c) La fabrique (Factory Method Pattern en anglais) est une interface pour créer des objets, mais laisse les sous-classes décider quelles classes à instancier.
d) La fabrique abstraite (Abstract Factory Pattern en anglais) crée une instance de plusieurs familles de classes.
e) Le moteur (Builder Pattern en anglais) sépare la construction de l'objet de sa représentation.

2. La Famille Structurale

a) L’adaptateur (Adapter Pattern en anglais) fait correspondre les interfaces de différentes classes.
b) Le pont (Bridge Pattern en anglais) sépare l'interface d'un objet de son implémentation.
c) Le composite (Composite Pattern en anglais) est une arborescence d'objets simples et composites.
d) Le décorateur (Decorator Pattern en anglais) ajoute des responsabilités aux objets de manière dynamique.
e) Le proxy (Proxy Pattern en anglais) est un objet représentant un autre objet.
f) La façade (Facade Pattern en anglais) est une classe unique qui représente un sous-système entier.
g) Le poids mouche (Flyweight Pattern en anglais) est une instance fine utilisée pour un partage efficace.

3. La famille comportementale

a) Le patron de méthode (Template Method Pattern en anglais) définit le squelette d'un algorithme dans une opération, en reportant certains détails aux sous-classes.
b) Le médiateur (Mediator Pattern en anglais) définit un objet qui encapsule la façon dont un ensemble d'objets interagit.
c) La chaîne de responsabilité (Chain of Responsibility Pattern en anglais) reçoit des objets et transmettre la requête le long de la chaîne jusqu'à ce qu'un objet la traite.
d) L’observateur (Observer Pattern en anglais) définit une dépendance un-à-plusieurs entre les objets où un changement d'état dans un objet entraîne la notification et la mise à jour automatique de toutes ses dépendances.
e) La stratégie (Strategy Pattern en anglais) définit une famille d'algorithmes, encapsule chacun et les rend interchangeables.
f) La commande (Command Pattern en anglais) encapsule une requête en tant qu'objet, permettant ainsi le paramétrage de clients avec de différentes requêtes.
g) L’état (State Pattern en anglais) autorise un objet à modifier son comportement lorsque son état interne change.
h) Le visiteur (Visitor Pattern en anglais) représente une opération à effectuer sur les éléments d'une structure d'objet.
i) L’interprète (Interpreter Pattern en anglais) définit une représentation pour la grammaire d’une langue avec un interprète qui utilise la représentation pour interpréter des phrases dans la langue.
j) L’itérateur (Iterator Pattern en anglais) fournit un moyen d'accéder aux éléments d'un objet agrégé de manière séquentielle sans exposer sa représentation sous-jacente.
k) Le mémento (Memento Pattern en anglais) capture et externalise l'état interne d'un objet permettant à l'objet d'être restauré à cet état plus tard sans violer l'encapsulation.

Dans cet article nous avons accordé l’importance de l’introduction des patrons de conception (Design Patterns) pendant nos solutions informatiques aux applications financières. Les patrons de conception basiques et populairement utilisés pour nos développements se sont catégorisés en trois familles créatrices, structurales et comportementales, ce qui facilitera les présentations à la suite. A la chaîne des articles suivants on va aborder leurs avantages initiaux et implémentations détaillées en Python 3.

Références

[1] Freeman, Eric T.; Robson, Elisabeth; Bates, Bert; Sierra, Kathy (2004). Head First Design Patterns. O'Reilly Media. ISBN 978-0-596-00712-6.

[2] Yves J. Hilpisch (2019). Python for Finance. O'Reilly Media. ISBN 978-1-492-02433-0.

[3] Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1995). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. ISBN 978-0-201-63361-0.