Tu en as marre :
❌ de devoir passer du temps à débugger plutôt qu'à créer de nouvelles fonctionnalités ?
❌ de faire une modification en apparence toute simple, mais voir que tu as cassé une partie du code qui n'a rien à voir ?
❌ de devoir maintenir des tests qui cassent dès que tu bouges le petit doigt ?
❌ d'attendre des semaines entières avant de pouvoir mettre en production tes changements
❌ d'être déprimé.e d'aller au travail tous les matins à cause de ces problèmes ?
En cherchant des solutions, tu as très probablement déjà entendu parler du Software Craftsmanship :
👉 Dans des posts LinkedIn
👉 Dans des annonces de recruteurs
👉 Dans des vidéos YouTube ou des articles de blog
Tu as donc probablement déjà vu passer les termes :
🤷♂️ Tests automatisés
🤷♂️ Clean Architecture
🤷♂️ Architectures Hexagonale
🤷♂️ Test-Driven Development
🤷♂️ Domain-Driven Design
🤷♂️ Continuous Delivery
🤷♂️ Story Mapping
🤷♂️ Event Storming
🤷♂️ Example Mapping
🤷♂️ CQRS
😩 ...
Évidemment, et c'est tout à ton honneur, tu as tenté de t'y mettre toi aussi !
Mais il y a plusieurs gros problèmes !
❌ Tu ne sais pas par où commencer dans cette jungle de concepts et de connaissances à avoir
❌ Tu n'arrives pas à vraiment comprendre comment relier toutes ces notions
❌ Tu vois tellement d'exemples différents qui semblent dire tout et leur contraire que tu es découragé.e
❌ Tu t'es rendu.e compte que ces incompréhensions te font finalement perdre du temps dans ton travail au quotidien
❌ Tu es frustré.e de ne pas réussir à livrer aussi rapidement que tes collègues qui eux ne s'occupent pas de ces pratiques alors que c'est pourtant toute la promesse
❌ Tu t'es cassé.e les dents quand tu as essayé d'appliquer ces pratiques dans le frontend car tous les exemples concernent le backend majoritairement
❌ Tu as peur qu'on te reproche de faire de la "surqualité" ou de "l'overengineering"
Je suis passé par là ! Et j'ai mis des années avant d'arriver à relier toutes ces notions.
🤓 Spoiler alert : j'apprends encore tous les jours !
Et ce qui m'a le plus manqué à l'époque : une roadmap pour aborder ces notions dans le bon ordre.
L'objectif de ce cours est donc de te faire gagner des années d'étude de ces concepts dans ton coin en te proposant une formation précise étape par étape d'apprentissage par la pratique, backend et frontend !
Grâce à ce cours, tu pourras :
✅ Appliquer concrètement, en pratique, les concepts du Software Craftsmanship
✅ Être vraiment agile, du recueil des besoins jusqu'à la mise en production
✅ Construire une application web fullstack rapidement et sereinement grâce au filet de sécurité apporté par les tests
✅ Être à l'aise avec une pratique cohérente du Test-Driven Development pour bénéficier du maximum de ses avantages, sans les inconvénients d'une mauvaise pratique
✅ Déployer beaucoup plus souvent pour obtenir un feedback le plus fréquent possible de tes utilisateurs
✅ Appliquer les patterns stratégiques du Domain-Driven Design pour atteindre une architecture découplée et un maximum de vélocité
✅ Appliquer les patterns tactiques du Domain-Driven Design pour soutenir l'implémentation de ton application de manière efficace et maintenable
✅ Devenir un "vrai" pragmatique, c'est-à-dire que tu sauras quand il est judicieux d'appliquer telle ou telle problématique, sans forcément tout le temps faire "by the books"
Certains modules sont déjà disponibles !
- Présentation du cursus (4:56)
- Qu'est-ce que le Software Craftsmanship ? (3:51)
- L'ingénierie logicielle (5:09)
- Qu'est-ce qu'un logiciel de qualité ? (3:28)
- L'importance de travailler de façon itérative (3:28)
- L'importance de travailler de façon incrémentale (4:18)
- L'importance du feedback (3:59)
- La pipeline de déploiement (4:45)
- Introduction (2:09)
- Le problème avec les tests manuels (5:05)
- Les différents types de use case au sein d'une application (8:27)
- Anatomie d'une architecture testable (6:28)
- Structure d'un test unitaire (7:11)
- Qu'est-ce qu'un bon test unitaire ? (7:05)
- L'importance de l'inversion de dépendances (6:35)
- Les test doubles (4:28)
- Tester un vrai use case (7:00)
- L'importance d'écrire des tests concis et lisibles (4:25)
- Écrire des tests maintenables : Le pattern Object Mother (3:17)
- Écrire des tests maintenables : Le pattern Builder (2:56)
- Écrire des tests concis et lisibles : Principe D.A.M.P et fixture (3:52)
- Sociable unit tests, solitary unit tests, et quiproquos sur les tests unitaires (12:38)
- Les différents types de tests (7:54)
- L'architecture hexagonale (5:00)
- À lire avant de commencer
- Introduction (8:55)
- Example Mapping (13:32)
- Initialisation du projet (4:36)
- Structure d'un test : raconter l'histoire dans le code (10:16)
- Structure d'un test : connecter les étapes (7:07)
- Création d'un use case simple et inversion de dépendances (13:53)
- Implémentation de la première règle métier : le message trop long (8:09)
- Création d'une test fixture et implémentation des messages avec que des espaces (7:06)
- Création de la commande post avec commander (10:32)
- Création d'un adapter FileSystemMessageRepository (5:14)
- Implémentation du use case ViewTimelineUseCase (32:00)
- Shift Gear Down : S'aider de tests unitaires plus fins (22:31)
- Implémentation de la commande console "view" (13:28)
- Factorisation de fixture et builders (23:01)
- Création d'un use case EditMessage (25:24)
- Création d'un value object MessageText (8:35)
- Test d'intégration du FileSystemMessageRepository (23:02)
- Création d'une classe Message avec encapsulation de la serialization et deserialization (12:55)
- Screaming Architecture (11:06)
- Exercice : Implémente le use case FollowUser (6:15)
- Première implémentation du FollowUserUseCase (13:36)
- Implémentation du ViewWallUseCase (31:34)
- TDD sur un test d'intégration ! (23:32)
- Base de données - Des repositories avec Prisma (21:50)
- Test d'intégration avec TestContainers (31:16)
- Implémentation d'une API fastify simple (14:11)
- Dissocier outpout de CLI et d'API grâce à un Presenter (19:37)
- Gérer les erreurs différemment avec un objet Result (10:06)
- Passage sous NestJS (54:08)
- Implémenter les tests end-to-end (26:49)
"Il n'y a pas de compromis entre la vitesse et la qualité"
Les équipes qui mettent en place les pratiques que l'on verra dans ce cours ont des résultats qui parlent d'eux-mêmes :
source : livre Accelerate
À qui s'adresse ce cours ?
Ce cours est pour toi si tu souhaites développer des applications robustes et maintenables de A à Z grâce à un niveau avancé dans les pratiques liées au Software Craftsmanship.
Si tu es développeur.se junior ne t'inquiète pas, ce cours est prévu pour être suivi étape par étape. La difficulté est croissante, il faudra s'accrocher, mais tu ne seras jamais seul.e !
Si tu es un.e développeur.se plus confirmé.e qui connait déjà un peu le software craftmanship, tu passeras plus rapidement les premiers modules, mais les suivants te donneront probablement du fil à retordre !
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.
Qui suis-je ?
Je suis Pierre Criulanscy, développeur fullstack freelance depuis 2010.
Je suis passionné par l'architecture logicielle et par toutes les pratiques qui permettent de rendre un code plus maintenable et évolutif.
C'est donc tout naturellement que je me suis intéressé aux pratiques liées au Software Craftsmanship que j'étudie et met en pratique depuis 2016 au sein de grands groupes comme Le Figaro ou Eurosport.
J'ai aussi travaillé pour des startups pour lesquelles aller vite et bien est primordial.
Je suis surtout présent sur LinkedIn où je partage régulièrement mes connaissances sur le sujet auprès de mes plus de 17000 abonnés.
F.A.Q
🔷 Quels-sont les technologies / langages utilisés pour le cours ?
Pour l'instant le cours est uniquement proposé pour TypeScript, React, NextJS, NestJS
🔷 Je n'utilise pas la même stack technique, est-ce que ce cours est adapté quand même ?
Tous les apprentissages de ce cours peuvent être adaptés à d'autres langages / framework. C'est tout l'intérêt du Software Craftsmanship : avoir des connaissances profondes, qui peuvent ensuite être appliquées peu importe la situation
🔷 Est-ce que la formation peut être financée ?
Non :( Pour l'instant, il n'existe aucune possibilité de financement via CPF ou OCPO, mais j'y travaille !
🔷 Est-ce que je peux être remboursé.e si je ne suis pas satisfait.e du cours ?
Tout à fait ! Une fois que tu as acheté le cours, tu as 30 jours pour demander le remboursement. J'y procèderai sans poser de question.
🔷 J'ai terminé la formation, je l'ai mise en pratique pendant plusieurs semaines, mais je ne vois aucune amélioration. Je peux avoir mes 1200€ ?
Je suis désolé que la formation ne t'ait pas convenu.e ! Mais oui bien sûr :) La seule contrepartie est que tu me dises ce qui t'a manqué dans la formation, et je procéderai au paiement immédiatement :) Évidemment il faudra que tu me montres que tu as essayé d'appliquer toute la formation, sans quoi je ne pourrais pas te rembourser. Et ce remboursement est limité à un par personne, évidemment :)
🔷 Combien de temps va me prendre la formation complète ?
Tout dépend de toi ! L'objectif est de vraiment prendre son temps tout en pratiquant en même temps. Fais-le à ton rythme, c'est le plus important, ce n'est pas une course !
🔷 Est-ce que je serai livré.e à moi-même pendant la formation ?
Bien sûr que non ! Tu as la possibilité de laisser des commentaires sur chaque cours, auxquels je réponds le plus rapidement possible. Tu seras aussi invitée à rejoindre notre Slack où tu pourras discuter avec les autres stagiaires et partager tes interrogations, mais aussi tes réussites ! Je suis évidemment très disponible sur le Slack si tu as la moindre question.
🔷 Est-ce que je vais apprendre en profondeur React / NextJS / NestJS ?
Pas du tout ! Ce n'est pas un cours axé sur des technologies. J'utilise cette stack en support du cours, car c'est ma stack privilégiée, mais ce cours n'est pas un tutoriel sur ces technos.
*Garantie 1 : Tu devras me prouver que tu as bien suivi la formation en m'expliquant clairement comment tu l'as appliquée dans ton travail.
*Garantie 2 : Je vérifierai simplement que tu n'as regardé qu'une trois vidéos, peu importe le module. Si c'est bien le cas, je te rembourse immédiatement sans poser plus de questions :)