Formation Architecture Hexagonale & DDD Tactique
Objectifs
L'objectif de cette formation est d’acquérir les connaissances nécessaires pour concevoir et développer des applications évolutives et maintenables grâce aux patterns tactiques du Domain-Driven Design (DDD) et l'architecture hexagonale. Les participants apprendront à créer des applications qui répondent aux exigences métier mais qui sont également bien testées. Les participants apprendront à :
- Créer des logiciels centrés sur le métier :
- Concevoir des modèles de domaine riches en utilisant les patterns tactiques du DDD (aggregates, entities, value objects, etc.)
- Apprendre à modéliser des use cases grâce design pattern command handler
- Comprendre les concepts fondamentaux de l'architecture hexagonale :
- Identifier les composants de l'architecture hexagonale et leur rôle (domaine, ports & adapters primaires et secondaires)
- Concevoir le code métier indépendant du framework, librairies technique ou la plateforme utilisée
- Tester et valider le code : Apprendre à écrire des tests unitaires et des tests d'intégration pour garantir la qualité, la fiabilité des applications
La formation sera un mélange de sessions théoriques, d'exercices pratiques et de moments de partage pour apprendre les uns des autres.
- Théorie : 25%
- Pratique : 55%
- Échanges : 20%
Acquis à l'issue de la formation
À l'issue de cette formation, les participants auront acquis les compétences et connaissances suivantes :
- Concevoir du code métier grâce aux entités (Entities), aux objets de valeur (Value Objects), aux agrégats (Aggregates) et au design pattern Command Handler.
- Comprendre les mécanismes de validation de données
- Sauvegarder et récupérer l'état des objets du domaine grâce aux Repositories et aux Query Functions
- Comprendre et appliquer les mécanismes de l'architecture hexagonale (domaine, ports & adaptateurs primaires et secondaires)
- Comprendre comment tester le code qu’on produit : grâce aux tests unitaires et aux tests d'intégration
Public concerné et pré-requis
Cette formation vise les développeuses et développeurs familiarisé.e.s avec des frameworks, désireux d'approfondir leurs compétences en architecture logicielle grâce au DDD tactique et l'architecture hexagonale.
Les participants devront être équipés d’un PC (non fourni) avec Docker installé (seule la Partie 3 => faisable avec le formateur si vraiment impossible) et un environnement de développement prềt pour démarrer un nouveau projet (installation de son framework préféré et d’un framework de test).
Evaluation
En début de formation, une autoévaluation est effectuée pour évaluer le niveau, ainsi que les attentes de chaque participant. Ainsi nous pouvons organiser au mieux les différents groupes de travail.
Par la suite, le formateur effectue une évaluation continue à l'aide des nombreux exercices pratiques.
En fin de formation, la progression et les acquis sont autoévalués par chacun des participants. Le formateur fournit à chacun des participants une évaluation, ainsi que les axes d'amélioration.
En option, un accompagnement postformation peut être effectué. Cela fera l'objet d'un devis complémentaire.
Programme
-
1ère demi-journée : Modéliser les problématiques métier indépendamment du framework ou de n'importe quelle technologie
- Architecture hexagonale : le domaine
- Patterns tactiques du DDD : Entity, Value Object, Aggregate, Repository
- Patterns : Command / Command handler
- Test logiciel : Valider le code métier via des tests
-
2ème demi-journée : Isoler les entrées / sorties du code métier
- Architecture hexagonale : les ports et adapteurs secondaires
- Test logiciel : Dummy, Fake, Spy, Stub, Mock
-
3ème demi-journée : Persister et lire les données dans une base de données
- Persister un domain modèle : Repository, Domain model versus Persistence model et Transactional consistency (aggregate)
- Lire les données : Read model et Query fonctions
- Test logiciel : Valider un repository ou un query fonction via des tests d’intégration
-
4ème demi-journée : Ouvrir l'application vers l'extérieur, peu importe le moyen ou la technologie utilisée
- Architecture hexagonale : les ports et adapteurs primaires
- Valider les données fournies par les utilisateurs
- Patterns : Command bus / Event bus
- Test logiciel : Valider les adapteurs primaires via des tests
Formateur / Formatrices
Arnaud est développeur avec 15 ans d’expérience. Autodidacte, il a d'abord suivi une formation en télécoms et réseaux avant de se tourner vers le développement logiciel, un domaine qui le passionne et qu’il exerce depuis quinze ans. Il est devenu indépendant en 2022.
Arnaud a évolué dans divers environnements professionnels, allant de la petite entreprise (TPE) à la scale-up. Il aime comprendre les problématiques métier avant de coder. Passionné par l'architecture logicielle et les tests, il est fan de tout ce qui se termine par *DD.
Co-organisateur d'Agile Pays Basque, Arnaud donne des conférences et anime des BBL, partageant ainsi son expertise et sa passion pour l'ingénierie logicielle.
Clément a démarré son parcours professionnel en tant que développeur en 2004, après une formation d'ingénieur de Télécom Sud Paris (ex-Télécom INT). Il est développeur indépendant depuis 2013 en plus de son activité de formation HackYourJob.
Il a été également chef de projet, consultant qualité, architecte technique sur différents projets, tout en conservant un profil très technique proche du développement de logiciels. Toutes ces expériences l'ont amené à considérer la formation à de bonnes pratiques de développement au travers d'HackYourJob.
Il a donné des formations en entreprises par le biais d'autres organismes de formation et a été intervenant en Licence Pro à l'IUT Lyon 1 de 2015 à 2017.
Témoignages
Une formation de grande qualité qui m’a permis d’approfondir ma compréhension de l’architecture hexagonale et de mettre en pratique les tactiques du DDD.
PS F. (développeur)
Une formation de grande qualité qui m’a permis d’approfondir ma compréhension de l’architecture hexagonale et de mettre en pratique les tactiques du DDD.
PS F. (développeur)