Devops for Growth

Learn about the Event Aggregator pattern for organizing event communication in a microservices architecture with an example.

Comprendre les différents design patterns de construction

Est-ce que quelqu'un peut m'expliquer dans quel cas il faut utiliser le Design Pattern Strategy et pourquoi ? Je ne vois vraiment pas l'intérêt… Merci

Tutoriel pour apprendre les bonnes pratiques pour coder le patron de conception Singleton Thread-Safe et Lazy avec le langage Java

Après avoir étudié quatre approches permettant de faire du multitâche sans threads, nous allons voir la dernière, probablement la plus sympathique pour le développeur. C’est une évolution syntaxique des langages permettant de porter le principe d’un pool de hard-threads unique à tout un programme, et donc de porter dans la syntaxe de quoi programmer facilement avec le modèle réactif.

Describing the way architectures for UIs have evolved over the years, in particular the many and often misunderstood definitions for Model-View-Controller.

Pour résumer :

• Job (Batch) = ensemble de Step (étape) : lire, transformer, écrire.
• JobInstance = Job + identifiant (peut être une date, l’heure, tout ce qui permet d’identifier de façon unique un Job) : Job du 15 Septembre, du 12 Octobre, etc.
• L’identifiant d’un Job peut être construit à partir des informations fournies comme paramètre lors de son lancement. Ces paramètres sont appelés JobParameters.
• L’instance d’exécution d’un Job est appelée JobExecution.

Parmi les design patterns que l'on trouve en programmation, il en est un que l'on oublie un peu trop à mon avis : c'est la notion de façade. Pour bien comprendre de quoi il s'agit, un petit exemple sera plus parlant. Imaginez travailler dans un centre de conception automobile. Votre boulot consiste à concevoir toute la partie commande de la voiture. Vous allez collaborer avec les designers qui conçoivent l'habitacle et le tableau de bord (la vue) et avec les ingénieurs qui conçoivent la partie mécanique (le modèle ou métier). À vous de relier le tout (faire le contrôleur). Si les mécanos commencent à vous parler de boulon de six ou de durite d'injection, vous allez droit à la crise de nerfs. Ce dont vous avez besoin, c'est de savoir comment on fait marcher le tout. Par exemple : comment accélérer. Que la commande d'accélération actionne un régulateur électrique, ouvre un carburateur ou actionne un injecteur de gasoil, vous importe peu.

Vous avez besoin de définir une API pour votre partie mécanique. Cette définition peut se présenter simplement par une documentation. Mais aussi par un point d'entrée unique qui vous cache la complexité du métier. Cela s'appelle une façade.

Vous ne vous êtes jamais penché sur le problème de savoir comment votre banquier traitait vos chèques ? Vous fournissez au guichet le bordereau dûment rempli comme le prévoit la façade et ce qu'il se passe après vos importe peu, du moment que votre argent va sur votre compte.

C'est donc une pratique courante qui, étrangement, se perd lorsqu'on développe des logiciels. Bien souvent, on fait ce qu'il y a à faire sans trop se demander s'il ne serait pas opportun d'isoler un sous-ensemble derrière une API. En programmation objet on encapsule ainsi des éléments. Mais on pense rarement que tout un ensemble pourrait être caché par une seule classe. La littérature sur ce sujet est pourtant vaste. Et utiliser une façade à bon escient est un gage pour l'avenir.

L'évolution des besoins (réductions des coûts et du time to market, concept d'ATAWAD (AnyTime, AnyWhere, AnyDevice)…) a mis en avant certaines architectures (architecture applicative cloud ready, architecture microservices, architecture distribuée…).

Cela a engendré de nouvelles problématiques, en particulier l'augmentation du nombre de dépendances et donc potentiellement soumises à la latence du réseau.

C'est à ce moment qu'apparaissent à nouveau les Illusions de l'informatique distribuée :

Le réseau est fiable.
Le temps de latence est nul.
La bande passante est infinie.
Le réseau est sûr.
La topologie du réseau ne change pas.
Il y a un et un seul administrateur réseau.
Le coût de transport est nul.
Le réseau est homogène.

Et ces illusions ne prennent pas en compte la partie dépendance et son lot de problèmes (crash, temps de réponse lent, réponse non conforme…).

Pour répondre à ces défis, la philosophie de design for failure (les traitements applicatifs doivent, dès leur conception, prévoir le cas où les composants qu'ils appellent pourraient tomber en erreur) a pris encore plus d'importance.

Et donc nous sommes passés de : « prévenir toutes les défaillances » à : « les défaillances font partie du jeu ».

Parmi toutes les solutions composant le design for failure, nous allons nous pencher sur le patron de conception (design pattern) « Circuit Breaker » popularisé par Michael Nygard dans le livre « Release It! ».

Mais avant cela, faisons un tour rapide sur d'autres solutions permettant de gérer des problèmes de dépendances.

Il est donc très important de prendre le temps de réfléchir à la signification de la relation que vous rédigez chaque fois que vous héritez une classe. La composition est une solution parfaite dans la plupart des situations. En utilisant la composition, vous définissez une relation que possède un objet. Cette technique, qui est aussi une des notions de base de la programmation orientée objet, est souvent associée aux interfaces. La composition se retrouve en outre dans plusieurs design patterns comme le composite, le delegate ou le decorator

By the way non-embedded engineers, you essentially write firmware too whenever you bury SQL in your code or when you spread platform dependencies throughout your code. Android and iPhone app developers do it when they don’t separate everything they should from dependency on those platforms.

I’ve been involved in a lot of efforts where the line between the product code (the software) and the code that interacts with the product’s hardware (the firmware) is pretty fuzzy at best, fuzzy to the point of non-existence

Microservice Architecture, Database per Microservice, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalize Configuration, Consumer-Driven Contract Testing

Learn about the design patterns of microservice software architecture to overcome challenges like loosely coupled services, defining databases, and more.

One of the most useful design principles that I've found and followed is that of keeping a good separation between the presentation aspects of a program (the user interface) and the rest of the functionality. Over the years where I've seen this done, I've seen plenty of benefits:

• Presentation logic and domain logic are easier to understand when separate.
• You can support multiple presentations on the same base program without duplicating code.
• User interfaces are hard to test, separation keeps more logic in more testable places.
• You can easily add a programmatic API for scripting or exposed as services (I actually see these as alternative presentations).
• Presentation code requires different skills and knowledge to domain code.

There are several ways to split up the logic of the presentation.

La manipulation des données stockées par une application utilisant un architecture-pattern de type MVC entraine souvent l'utilisation d'un ORM pour réaliser cette tâche. Par exemple j'utilise personnellement Doctrine que ce soit avec Zend Framework 2 ou Symfony 2. Il en existe d'autres, comme Propel ou Eloquent.

Il existe néanmoins une différence de paradigme parmi les ORM. Et celle-ci "déchire" parfois les utilisateurs d'ORM... Il s'agit de deux patrons (patterns) :

Le Active Record pattern
Le Data Mapper pattern (parfois aussi appelé Repository Pattern)