Ce que tu vas apprendre dans ce cours

Module 1

Comprendre d'un point de vue général l'importance des pratiques crafts et d'ingénierie logiciel dans notre industrie :

• L'aspect scientifique de l'ingénierie logiciel
• L'importance de travailler de façon itérative
• L'importance de travailler de façon incrémentale
• L'intérêt de travailler par petites étapes
• L'importance du feedback
• L'importance du Continuous Delivery et de la pipeline de déploiement

Objectif de ce module : être au clair sur les différentes notions qui seront abordées dans la formation, et donner des arguments pour convaincre son équipe

Module 2

Comprendre la théorie sur les tests automatisés et l'architecture hexagonale et comment ces pratiques s'inscrivent dans les objectifs définis dans le premier module :

• comprendre le problème avec la façon dont tout le monde teste son code aujourd'hui
• l'importance des tests automatisés
• les différents types de tests automatisés
• qu'est-ce qu'une bonne stratégie de tests ?
• qu'est-ce qu'un bon test unitaire ?
• les tests double (mock, spy, stub, etc.)
• comment écrire des tests unitaires maintenables
• l'architecture hexagonale
• les adapters secondaires de l'architecture hexagonale pour comprendre comment intéragir avec l'extérieur
• les adapters primaires de l'architecture hexagonale pour comprendre comment piloter notre application

Objectif de ce module : comprendre les différents types de tests, les nomenclatures existantes, et l'intérêt de chaque type de tests

Module 3 : Création d'une Clean Architecture de A à Z

On passe à la pratique ! Ce module est un mini projet TypeScript en full console pour commencer et finissant par une API, avec une approche pilotée par les tests, afin de s'habituer aux notions de use cases et de testabilité du code. Tu y découvriras notamment :

• Comment utiliser les tests pour piloter le développement de notre application
• Construire une architecture évolutive, en partant de simples fichiers sans structure, jusqu'à une application complète gérée par NestJS
• comment utiliser l'Example Mapping pour aider à trouver des exemples et des critères d'acceptation pour les différents use cases
• comprendre ce que l'on veut tester
• terminer une implémentation basique mais fonctionnelle
• comment gérer les erreurs
• comment valider les données
• comment encapsuler certaines règles dans des Value Objects
• comment faire des tests d'intégration avec TestContainers
• comment faire des tests end-to-end

Objectif de cette partie : apprendre à créer une architecture évolutive de A à Z, pilotée par les tests.

Module 4

On continue dans la pratique, ce module est un module focalisé sur le frontend avec React. On y reprendra le projet précédent pour y greffer une interface React plutôt que la console. Tu apprendras notamment :

• comment mettre en place un projet React TypeScript rapidement avec NextJS
• comment créer une pipeline de déploiement minimale avec GitHub Actions et Vercel, et semantic release
• comment rendre ses composants React le plus simple possible grâce aux ViewModels
• la création d'une persistance avec Firebase (ou autre)
• comment tester l'intégration avec Firebase grâce aux TestContainers
• comment mettre en place des outils de monitoring dédiés au frontend

Objectif de cette partie : comprendre comment implémenter une architecture hexagonale simple côté frontend et tester l'intégration avec l'I/O et la mise en place d'une pipeline CI/CD

Module 5

Présentation d'un nouveau projet plus complexe, avec problématique de concurrence. Tu y découvriras :

• les patterns stratégique du Domain-Driven Design
• la définition d'un bounded context
• les différentes relations entre bounded context
• l'importance de se focaliser sur le core domain
• les patterns tactiques du Domain-Driven Design (Aggregate, Value Object, Domain Event, ...)
• L'EventStorming pour aider à déterminer les bounded contexts et les aggregates

Objectif : comprendre les principes généraux du DDD, avoir une vision claire des étapes de l'implémentation.

Module 6

Tu mettras en pratique tout ce que tu as appris dans les précédents modules. Tu implémenteras l'application de façon itérative par petits incréments, en livrant régulièrement en production avec une implémentation d'abord full in-memory, avec React. En parallèle, tu développeras le backend associé grâce aux différents concepts vus précédemment, tout en livrant continuellement aussi.

Objectif : pouvoir développer une application fullstack grâce aux principes crafts

Le cours étant en construction, ce plan n'est pas exhaustif et donne juste une idée assez fidèle du cours. Le plan peu changer d'ici à la sortie du cours en fonction des retours.