Cursus Artisan Développeur v1.0 by Benoit Gantaume
L'inscription est fermée

Cursus Artisan Développeur v1.0

Le cursus complet pour apprendre à écrire du code durable.
L'inscription est fermée

Développer, c’est plus qu’un langage ou un framework.

C’est comme dire qu'il suffit de connaître la grammaire françaisee pour écrire un livre. Non, il faut plus que ça.

Je sais que ce sont les technos qui sont mises en avant dans un CV : les langages et frameworks. Quand on cherche un job ou quand un client cherche un développeur, c’est le premier critère. Quand tu t’inscris dans une école, on t’explique que tu vas maîtriser un langage, et donc que tu vas trouver un job.
Ces dernières années, javascript fait une belle percée avec tous les frameworks front. Ok. De la même manière qu’ils sont venus détrôner d’autres langages ou frameworks, d’autres viendront derrière.

Le souci, c’est que ce n’est pas parce que tu connais un framework ou un langage que tu sais développer. C’est nécessaire mais insuffisant. Les langages sont souvent orientés objet, et, comme ils reflètent une certaine réalité physique, tu pourrais penser que c’est naturel de les manipuler. Que c’est facile de les concevoir. 
Et bien non en fait.
Cela demande de la technique. 
Une technique qui va bien au-delà d’un langage. 
Ce type de compétence est une compétence profonde, au sens de Carl Newport.
“La capacité au travail profond devient de plus en plus rare au moment précis où il a de plus en plus de valeur dans notre économie. En conséquence de quoi, ceux qui cultiveront cette compétence et en feront le cœur de leur habitude de travail, prospéreront”

En travaillant ce type de compétence, tu travailles directement ton employabilité, et donc ta carrière. Ta carrière, c’est l’évolution de ton salaire, et l’intérêt des missions qui te sont confiées. 

Une journée trop banale

Tu démarres ta session de développement. Tu as les idées claires sur ce que tu veux faire, mais pas forcément sur comment tu vas le faire. Ça touche une partie du code que tu ne connais pas, et tu as peur de casser quelque chose. Tu sais déjà que la journée va être longue. Tu te lances. Tu cherches à comprendre où tu pourrais te brancher. C’est laborieux. Enfin, tu trouves. Fatigué, tu fais une pause café. Tu t’y remets, et tu codes la nouvelle fonction.  Comme tu es un peu coincé dans ce code legacy que tu n’oses pas trop toucher, tu fais au mieux pour coder ce que tu avais en tête. Tu livres sur develop, et tu montres ça à ton PO. Il y a pas mal de trucs à revoir. Cela va t’obliger à reprendre les morceaux que tu n’avais pas envie de toucher. Tu joues la montre et retournes faire une pause. Bon, faut y aller : tu t’attaques au gros morceau. C’est une bataille épique et stressante, mais tu finis par y arriver. C’était épuisant, mais tu pourrais presque être satisfait.
Le seul hic, c’est que tu viens d’ajouter trois bugs dont un critique dans l’application.
Tu rentres chez toi frustré de ton travail.

Tu es concerné si...

  • Tu as la trouille de changer quelque chose.
  • Quand tu corriges un bug, deux autres apparaissent. 
  • Ton boss te demande d’en faire plus, mais c’est de plus en plus difficile. 
  • Tu as récupéré un code legacy.
  • Tu en arrives à perdre le plaisir de coder.
Et pourtant, nous avons la chance de faire un job qui peut être tellement épanouissant !

Une nouvelle journée

Imagine maintenant : tu commences ta session de développement. Tu as clarifié ta user story, et tu es prêt à y aller. Tu te sens complètement serein, parce que tu sais déjà que ça va bien se passer. Tu démarres ta nouvelle fonction, et tu te plonges à fond. Le travail est fluide. Tu es tellement concentré que tu ne vois pas l’heure passer ! Tu es dans le flux, totalement absorbé par ce que tu fais. Tes neurones carburent à fond, et c’est bon ! À la fin d’une longue session de travail, tu livres ça sur develop. Tu fais une démo à ton PO qui y apporte quelques ajustements. Tu corriges, et pouf, c’est prêt à passer en validation. C’est facile & direct.
Tu finis ta journée avec la satisfaction du devoir accompli : tu es fier de ton travail.

Un chemin long et parfois difficile

J’aimerais pouvoir te vendre une carte SD qui t’apprenne à écrire du code durable. Tu aurais juste à la brancher à ton cerveau, et tu téléchargerais tout…

Mais ça ne marche pas comme ça.

C’est long à apprendre.
C’est pas tant la théorie qui prend du temps. C’est surtout la pratique. Et c’est lent, comme toute compétence profonde.

C’est parfois difficile aussi.
Il faut accepter de remettre en question tes croyances, et redevenir débutant. Pas facile, et même douloureux parfois. Sans compter les vrais maux de tête quand ton cerveau sature.

Si tu n’es pas prêt à faire ces efforts, tu peux arrêter de lire là.

Mais si tu es prêt à te dépasser pour rendre ta carrière de développeur épanouissante, à augmenter ta confiance en ton code, et  à prendre du plaisir à faire un job qui te rende fier, alors tu es au bon endroit.

Car tu n’es pas obligé d’être seul pour traverser tout ça.
Je suis passé par là, et je peux t’accompagner à faire ce chemin toi aussi.

Pour ça, j’ai créé le cursus Artisan Développeur, et il a déjà aidé ne nombreux développeurs à progresser.

Quelques extraits de feedbacks

Le kata est une bonne façon d’échanger sur le module.
Colas
Je n’ai plus peur de travailler dans le Legacy.
Michael
 Les exemples sont pertinents et pédagogiques.

Alessandro
J'ai apprécié les explications claires, sujet intéressant, et exemple concret dans la vidéo permettant de bien comprendre les notions.
Julia
J’ai apprécié la qualité du contenu dans l’ensemble. Les nouvelles compétences acquises.
Nicolas
Les exercices pratiques mis en place ont bien aidé à mettre en pratique directement les points du module et à commencer à se poser des questions.
Mélanie
J’ai apprécié la formalisation de nombreux aspects de notre travail. Le vocabulaire et l’approche que tu transmets nous permettront de mieux véhiculer nos messages à l’avenir auprès de nos collaborateurs.
Vincent
J’ai beaucoup apprécié de recentrer notre métier autour du réel savoir-faire (méthodologie, culture… ), plus que sur la connaissance du technique. Riche en enseignements, en remise en cause, travailler les fondations.
Gérald
La mise en pratique concrète et l’impression de réellement débuter les travaux dans notre code. Nous avons trouvé des exemples concrets, et avons débuté une phase de refacto en accord avec les conseils prodigués dans ce module -> on commence à apercevoir l’intérêt d’Artisan Développeur au quotidien.
Tommy
J’ai apprécié la découverte de nombreuses choses que je ne connaissais pas. Étant novice dans l’agilité… j’ai beaucoup appris auprès de toi.
Sébastien
J’ai apprécié l’apprentissage et la mise en pratique des principes de l’agilité et du TDD via des cas concrets de la vie de tous les jours. Les exercices à la fin des modules.
Floran
TDD : J’ai une meilleure compréhension (moins académique) du principe, et de comment mettre en place la pratique au niveau de l’équipe.
Stanislas

Le cursus Artisan Développeur

Le cursus complet se découpe en 8 modules :
  1. Les trois clefs d’un code durable
  2. Ranger chaque objet à sa juste place
  3. Dompter les dépendances
  4. Le cœur du réacteur 
  5. Reprendre le contrôle du legacy  
  6. Communiquer avec le métier 
  7. Piloter aux instruments 
  8. Les pratiques d'équipe

Cette formation te donne accès aux 8 modules, ainsi qu'aux mises à jour à venir.

Ce cursus est le fruit de dizaines d’heures de travail, de centaines d’heures de lecture, de milliers d’heures d’expérience accumulées pendant 20 ans de carrière.
Alors, tu as le choix entre lire des tonnes de livres et tâtonner pendant des années, ce qui est une bonne option, ou alors tu n’as pas ce temps, et tu veux un condensé structuré que tu vas directement pouvoir mettre en œuvre.

Cette formation contient plus de 8h de cours en ligne condensés.
Avec les exercices et les quizz, il faut prévoir l'équivalent d'au moins une semaine pleine de formation. 
Après, tu vas à ton rythme !

Module 1 : Les 3 principes clefs d'un code durable

Dans ce module, tu apprendras les principes de base d’un code vraiment évolutif. 
On t’a fait croire qu’il fallait tout anticiper à l’avance ?
Tu verras que c’est tout le contraire.

Dans ce module de formation, on voit :
  • La grande loi immuable qui explique pourquoi rien ne se passe jamais comme prévu.
  • Comment préparer l'avenir en se concentrant sur aujourd'hui.
  • Comment le plus grand mensonge de notre industrie continue de nous pourrir la vie.
  • Pourquoi le SCRUM seul est insuffisant pour gérer un projet logiciel.

On n'entre pas encore dans le code, mais on pose le référentiel de travail.

Module 2 : Ranger chaque classe à sa juste place

Quand tu utilises un langage objet, tu peux avoir l’impression que les objets sont naturels, qu’ils sont faciles à créer.
C’est comme dire que, par-ce qu’un téléphone ou un ordinateur est facile à utiliser, c’est facile de le fabriquer.
En fait non, c’est tout le contraire. C’est difficile de créer des objets qui sont faciles à utiliser.

Dans ce second module, on entre en plein dans le code et on voit : 
  • Comment mettre en œuvre concrètement le principe de responsabilité unique.
  • Comment partir d’un pot de code confus pour l’améliorer en faisant émerger les concepts.
  • Comment utiliser le principe DRY et ton instestinomètre.
  • Quand prendre une décision ou ne pas la prendre.
  • Mes trois patterns de refactoring favoris pour transformer n’importe quel bout de code, aussi moche soit-il, en un code propre de première classe.

Après s'être occupé d'une classe, on pourra voir les interactions entre classes dans le prochain module.

Module 3 : Dompter les dépendances

Dès lors que tu as plus qu’une classe Main dans ton projet, tes classes sont en interdépendance. 
Et c’est là que les choses se compliquent. 🤯
Car, si tu ne gères pas les dépendances correctement, tu te retrouves avec du code difficile à faire bouger, et le monstre spaghetti te dévore tout cru !

Alors, pour dompter les dépendances, on voit dans ce module:
  • Pourquoi il vaut mieux dépendre d’une interface que d’une classe concrète avec la métaphore du bouton vert
  • Les 3 design patterns que j’emporte partout avec moi (et non, Singleton n’en fait pas partie…)
  • Mes 4 techniques pour gérer les dépendances
  • Comment utiliser la loi de Déméter pour débusquer les dépendances à problème

À ce stade du cursus, tu es prêt à passer au plat de résistance : le TDD ! 🤘

Module 4 : Le cœur du réacteur

Les tests unitaires, c’est important.
Et pourtant, tu n’en écris pas.
Ça fait peut-être même partie de ta "définition de terminé", la règle dans le SCRUM qui dit quand tu as fini une story. Mais, en réalité, personne n'en écrit vraiment.

Alors, soyons clairs : les tests unitaires, c’est pas un truc important.
C’est LE truc fondamental. C’est la base de ta stratégie de tests.

Avec des tests, tu éradiques les bugs, t’es ultra zen, tu peux refactorer ton code à volonté et en continu.

Les tests unitaires, c’est le premier pas vers un monde épanouissant. Et oui, le monde des Bisounours existe.

Les tests, c’est la vie du code !

Dans ce module : 
  • Je t’apprends à écrire tes premiers tests unitaires. 
  • Je t’explique pourquoi tester c’est douter (je veux dire vraiment)
  • Quels sont les différents types de tests
  • Comment structurer un test 
  • Quels sont les critères d’un bon test
  • On aborde aussi la dimension psychologique qui joue un rôle essentiel dans l'adoption de cette pratique. 

On y parlera bien sûr TDD qui est pour moi la seule manière d’écrire des tests valables.

Mon objectif est que tu sois en capacité d’écrire tes premiers tests d’ici la fin du module. 

Module 5 : Reprendre le contrôle du legacy

Le code legacy, c'est pas toujours le pied. 
Il est peut-être pas merveilleux, mais il a le mérite d'exister.
Attendre la grande ré-écriture n'est pas LA solution à tous les problèmes du code legacy.
En effet, les projets neufs ont trois inconvénients majeurs : 
- Rien ne te garantit que tu vas pas refaire les mêmes erreurs qui aboutiront aux mêmes résultats. Dans 6 mois, 1 an, 3 ans, tu te retrouveras dans la même situation qu’aujourd’hui si tu ne changes rien.
- Ensuite, ils sont rares ! C’est pas tous les jours qu’une boîte décide de lancer un chantier de refonte. Alors que chaque jour est l’occasion de s’améliorer…
- Enfin, ils sont longs à sortir : en général le projet de refonte doit atteindre un certain niveau fonctionnel avant de remplacer le système legacy. Et, pendant ce temps, il faudra bien continuer à faire avec…

Dans ce module, on aborde :
  • Les raisons cachées qui rendent le monstre spaghetti si puissant
  • La règle d’or à suivre tel un fil d’Ariane dans une tempête de sable
  • Les techniques de Ninja pour t’en sortir dans n’importe quel code

Module 6 : Communiquer avec le métier avec le BDD

As-tu déjà remarqué comme la spec était un sujet courant d’embrouille dans un projet ?

Si en plus c’est ce qui définit le cadre commercial, les choses peuvent devenir vite rigides… 

Pour moi, une bonne spec remplit les critères suivants :
  • Elle capte le besoin business
  • Elle sert de pivot avec le développement
  • Elle est vivante (ie : transformable en tests)
  • Elle sert de documentation de référence

Dans ce module, je te montre comment utiliser le BDD, et le transformer en un véritable levier de communication avec ton client.
Je te montre aussi comment je l’utilise concrètement au quotidien depuis des années pour mener à bien mes projets.

Module 7 : Piloter aux instruments

Les outils de mesure, c'est un peu comme les instruments du pilote de ligne : ils lui permettent de naviguer sans voir ce qui se passe dehors.

Grâce à ces outils, on prend du recul sur le code pour mieux l'analyser et l'améliorer.

Dans ce module, je t’explique à quoi servent les linters et comment les utiliser efficacement. 
On passe en revue quelques métriques les plus répandues, comme la complexité cyclomatique et la couverture de code. 
Ensuite, on dégomme quelques mutants à la machette.
Et, pour finir, on voit comment intégrer tout ça dans ton workflow quotidien, avec les conseils issus de mon expérience.

Module 8 : Les pratiques d'équipe

Il est fini le temps où un développeur seul pouvait révolutionner une industrie.
Aujourd’hui, pour conquérir un marché, il faut bien souvent plusieurs développeurs, et toute une équipe avec des compétences variées, ce qu’on appelle aujourd’hui une feature team.

C’est là que l’équipe peut faire une grosse différence : va-t-elle être capable de jouer en équipe, ou va-t-elle être en mode cowboy solitaire ?

Ce module est centré sur les pratiques d’équipes qui viennent non seulement renforcer, mais aussi amplifier les pratiques techniques que l’on a vues jusqu’à maintenant. On y voit notamment les 4 pratiques essentielles du tueur de bugs. On en profitera pour pourfendre les mythes et les idées fausses autour du binômage
On y parlera auto-organisation, amélioration continue, responsabilité collective, rythme durable, conception émergente, ou encore du principe de petites livraisons.

On revoit aussi les questions de règles de codage, TDD et intégration continue, cette fois sous l’angle non plus technique, mais de la pratique d’équipe.

On fera aussi un passage du côté du dark agile pour apprendre à débusquer les pièges de l’agilité.

Enfin, on visitera la dimension psychologique du code : car oui, coder propre rend heureux !

La pédagogie en escalator

Le cursus est construit avec une arche pédagogique précise : la pédagogie en escalator.

La pédagogie en escalator, c'est quand il y a un double effet : 
  • Adopter ces pratiques, c'est difficile, on va pas se le cacher. La courbe d'apprentissage est raide. Donc j'ai découpé la progression en étapes pour rendre ça accessible. D'où les différents modules en escalier.
  • Les premiers progrès te donnent confiance, et te gonflent à bloc en motivation pour attaquer des problèmes de plus en plus difficiles. C'est le moteur de l'escalator.

Je crois tellement en cette pédagogie que j'offre une garantie satisfait ou remboursé pendant 30j : si tu n'y trouves pas ton compte, il te suffit de m'expliquer pourquoi et je te rembourse sans aucune autre condition.

Vous allez recevoir :

Video Icon 66 vidéos File Icon 23 des dossiers

Contenu

Les 3 principes clefs d'une conception durable
Module 1 - Mind Map.pdf
67,4 ko
Introduction
2 min
#1 Tout change tout le temps
17 min
#2 Repousser les décisions
13 min
#3 La grande oubliée du SCRUM
15 min
La suite du cursus
2 min
Module 1 - Quizz & Exercice.pdf
27,5 ko
Ranger chaque classe à sa juste place
Module 2 - Mind Map.pdf
71,3 ko
0 - Introduction
4 min
1 - Une question de réponsabilité
26 min
Dojo d'entraînement
2 - Mes 3 patterns de refactoring préférés
22 min
3 - Quand prendre une décision, ou pas
16 min
4 - Conclusion
2 min
Module 2 - Quizz & Exercice.pdf
34,1 ko
Dompter les dépendances
Module 3 - Mind Map.pdf
71,1 ko
1. Une question de dépendances
10 min
2. 3 patrons de conception essentiels
8 min
3. Comment casser les dépendances
4 min
4. Application concrète
16 min
5. La loi de Déméter
4 min
6. Bref...
4 min
Module 3 - Quizz & Exercice.pdf
28,5 ko
Le cœur du réacteur
Module 4 - Mind Map.pdf
66,2 ko
1. Introduction
2 min
2. Tester, c'est douter
8 min
3. Les différents types de tests
5 min
4. La famille xUnit
6 min
5. La structure d'un test
10 min
6. Des tests FIRST
7 min
7. Quelques conseils pour commencer
15 min
8. Le cycle TDD
11 min
9. Kata chiffres romains
25 min
A. La clef - le feedback
8 min
B. Utiliser des bouchons
9 min
C. Screencast Utilisation d'un bouchon
10 min
D. Conclusion
1 min
Module 4 - Quizz & Exercice
50,4 ko
Bonjour.pdf
22,6 ko
Jeu du bowling.pdf
27,9 ko
Chiffres romains.pdf
27 ko
Kata Potter.pdf
23,5 ko
Pile d'entier.pdf
20,2 ko
Automatiser ses tests avec JUnit - Chapitre 5.pdf
544 ko
Reprendre le contrôle du legacy
Module 5 - Mind Map.pdf
58,1 ko
1 - Introduction
3 min
2 - Pourquoi c'est si dur ?
9 min
3 - LA règle d'or
2 min
5 - Mettre sous tests #1
2 min
5 - Mettre sous tests #2 - Instancier
7 min
4 - Refactoring : où commencer ? Quand s'arrêter ?
7 min
5 - Mettre sous tests #3 - Exécuter
6 min
5 - Mettre sous tests #4 - Singleton
8 min
5 - Mettre sous tests #5 - Méthode privée
7 min
5 - Mettre sous tests #6 - Bref
2 min
6 - Les techniques de Ninja
5 min
7 - Screencast Ninja #1 Héritage
3 min
7 - Screencast Ninja #2 Décoration
4 min
7 - Screencast Ninja #3 Wrap method
5 min
7 - Screencast Ninja #4 Sprout
8 min
8 - Bref.final.mp4
2 min
Module 5 - Quizz & Exercice.pdf
83,5 ko
Communiquer avec le métier
Module 6 - Mind Map
56,6 ko
0 - Introduction
2 min
1 - C'est quoi le BDD ?
7 min
2 - Comment ça marche
10 min
3 - Dans la vraie vie
9 min
4 - Une question de spec
9 min
5 - Bref
3 min
Quizz & Exercices module 6
29,8 ko
Piloter aux instruments
Module 7 - Mind Map.pdf
57,9 ko
0 - Introduction
3 min
1 - Le linter est ton ami
11 min
2 - La complexité cyclomatique
5 min
3 - Couverture de code
12 min
4 - Les mutants attaquent
13 min
5 - Métriques et workflow
5 min
6 - Quelques conseils
9 min
7 - Bref.mp4
2 min
Exercices module 7.pdf
20,7 ko
Les pratiques d'équipe
MindMap Module 8.pdf
57,4 ko
0 - Introduction
3 min
1 - Les 4 pratiques de tueur de bug
11 min
2 - Principes fondamentaux
15 min
3 - Dark Agile
8 min
4 - La dimension psychologique
6 min
5 - S'affranchir des règles
5 min
6 - Bref
2 min
Exercices du module 8.pdf
18,8 ko

Feedback

Artisan Développeur est venu confirmer et ajouter du poids à la compréhension de l’agilité et du craftsman que j’ai découverte depuis maintenant quelques années. Cette graine que tu plantes dans les esprits ne pourra prendre forme que si un travail de fond est effectué pour l’entretenir. Bien que je sois un peu pessimiste initialement (vis-à-vis du contexte tout particulièrement), tu m’as donné envie d’être acteur du changement.
Anonyme

Ça va changer quoi dans ta vie ?

Grâce à ce cursus, tu pourras :
  • Éradiquer les bugs dans ton application
  • Mettre en prod comme tu mettrais une chemise propre
  • Passer plus de temps à créer de la valeur qu'à jouer à l’archéologue
  • Supprimer le debugger de ton quotidien
  • Innover en permanence, et prendre 3 longueurs d’avance sur la concurrence
  • Venir le matin au boulot avec un sourire insolent
  • Bâtir sereinement une application durable
  • Refactorer ton code en continu pour l’améliorer

Ton formateur

Benoit Gantaume est tombé dans la marmite de la startup depuis l’école d’ingénieur. Les startups sont des environnements particulièrement exigeants sur la vélocité et la capacité d’adaptation. Cela se traduit par des changements de direction fréquents, qu’il faut savoir gérer pour garder une base de code saine. C’est avant tout son expérience qu’il partage dans ses écrits sur artisandeveloppeur.fr, son livre sur "JUnit et l’écriture de tests automatiques" ou le podcast quotidien qu’il anime.
Développeur, auteur, formateur, vacataire, consultant sont autant de manières différentes d’exprimer une même passion pour le code.

FAQs

Quelle différence avec les modules d’avant ?

Ces derniers mois, j’ai mis en vente les modules du cursus les uns après les autres. Cette édition regroupe tous les modules en un cursus.
Donc, pour l’instant, il n’y a aucune différence. Si tu as acheté les anciens modules, ce seront les mêmes.
J’ai dit “pour l’instant”, car, à partir de maintenant, je mettrai à jour ce cursus. Aujourd’hui, c’est la v1.0.
Elle n’est pas parfaite, loin de là, et j’ai déjà plusieurs idées d’amélioration, que ce soit sur le fond ou sur la forme.
Je prévois par exemple de reprendre certains katas, d’en ajouter, voire même parfois de réenregistrer certains modules.
Si tu entres dans le cursus aujourd’hui, tu auras accès gratuitement à toutes ces évolutions à venir. 

Est-il possible de déduire du prix les modules déjà achetés ?

Absolument. Si tu as déjà acheté certains modules du cursus, envoie-moi un email, et je te donnerai un coupon qui déduira les montants déjà versés.
Je le générerais bien automatiquement pour tout le monde, mais la plateforme que j’utilise ne permet pas de l’automatiser, et il y a trop de monde pour que je le fasse à la main… Donc, si tu es intéressé, fais-moi signe.

Ça marche si je suis débutant ?

Si tu es tout débutant, et que tu n’as pas encore écrit ton premier programme, je te conseille plutôt de te concentrer là-dessus.
En revanche, si tu sais déjà utiliser un langage, alors ça peut être intéressant, même si tu es en cours de formation, du moment que tu as du temps à y consacrer.
Ça peut même te permettre de partir sur de bons rails, plutôt que de prendre de mauvaises habitudes qu’il faudra ensuite effacer.

Est-ce que le résultat est garanti ?

Oui.
Si tu n’es pas satisfait, je te rembourse sous 30 jours si tu m’expliques pourquoi tu n’es pas content.
Mais, si tu bosses sérieusement, cela n’arrivera pas.

Il faut prévoir combien de temps pour finir le cursus ?

Il faut compter l’équivalent d’une semaine pleine pour étudier le cursus.
Ce temps est à étaler, à raison de quelques heures par semaine.
J’en vois qui avalent et digèrent le cursus en 4 semaines. D’autres en 12. Cela dépendra beaucoup de ton engagement, ta motivation et tes disponibilités.

Est-ce que je peux payer en plusieurs fois ?

Oui. Il y a une option pour un paiement en 4x.

Si j'ai d'autres questions

Il te suffit de m'envoyer un email à benoit arobase artisandeveloppeur.fr