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

Cursus Artisan Développeur v1.1

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é des dizaines de développeurs à progresser.

Jean-Maxime Bouloc - Développeur

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

Emmanuel Riche - Développeur

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

Chaque module est construit avec 3 outils : 
  • Les vidéos
  • Les quizz
  • Les exercices

Les vidéos sont soit théoriques soit pratiques : je commence par de donner les éléments théoriques, puis je les illustre par un cas concret.
Tu peux voir comment j'applique la théorie et je te donne les clefs pour l'adapter à ton contexte. Libre à toi de faire comme moi ou trouver ton propre style.
C'est vraiment un élément important du cursus et ça fait partie intégrante de la pédagogie. Si d'ailleurs un point n'est pas assez clair, dis le moi et soit je rajoute ce qui manque, soit je précise mon propos.
Par exemple la v1.0 contenait trop peu de katas d'illustrations du TDD. Ce sera corrigé dans la v1.2.

Les quizz sont là pour ancrer les connaissances et les exercices pour te permettre d'aller plus loin à ton rythme.

A tout moment, je reste avec toi par email : si tu as un doute, une question ou simplement que tu as envie de partager ton travail, tu m'envoies un email et je te réponds.

Cette formation te donne accès aux 8 modules, ainsi qu'aux mises à jour à venir. Comme tu pourras le constater dans le release notes en dessous, je travaille sur ce cursus depuis un moment et je continues de le faire évoluer au fur et à mesure des retours.

Ce cursus est le fruit de plusieurs années à le construire et l'affiner, 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 environ 8h de cours en ligne condensés. Attention, une heure de cours en ligne structurée est beaucoup plus dense qu'une heure en formation classique : avec les exercices et les quizz, il faut prévoir l'équivalent d'environ une semaine pleine de formation. 

Après, tu vas à ton rythme et tu le consommes que tu veux. Si tu te contentes d'écouter les vidéos en x2, tu n'en n'auras pas le même bénéfice que si tu travailles chaque exercice que je te donne.

Deux dojos bonus

Cette fois j'améliore le cursus avec 2 dojos bonus :
- Le 3 Décembre de 13h00 à 14h30.
- Le 14 Décembre de 13h00 à 14h30.
Je fais en sorte que cela te laisse le temps d'absorber le cours au moins jusqu'au module 4.

Ces dojos seront ouverts à tous les clients du cursus. Si ça plaît, je pourrai les re-conduire et pourquoi pas en faire régulièrement ?

On travaillera à priori sur un kata ou sur du code réel partagé par un des participants.
Mon expérience me montre que ces dojos apportent beaucoup de valeur dans les échanges qu'ils génèrent.
Et puis ça sera l'occasion de rencontrer d'autre apprenants du cursus et pourquoi pas continuer entre vous !

Ç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

Qu'est-ce que ce cursus ne t'apportera pas

Ce cursus n'est pas une liste de choses à suivre à la lettre. 
C'est un cadre de réflexion à t'approprier.

Si tu cherches quelqu'un qui te dises exactement étape par étape ce qu'il faut faire ou ne pas faire, tu peux passer ton chemin.
Si par contre tu cherches quelqu'un qui t'apprenne à réfléchir par toi même pour t'adapter à chaque situation, tu es au bon endroit.

De la même façon, tu ne trouveras pas d'exemples dans tous les langages de la terre. Donc à priori, pas dans ton langage préféré, sauf le kata greetings qui a été traduit dans de nombreux langages par la communauté.
Et c'est pas grave : j'utilise des langages de manière extrêmement basique. Pas de fioriture. 
Je choisis des langages simples qui parlent à tous le monde. Java et Dart pour le moment. Je n'utilise aucun framework.
Encore une fois, le langage employé n'a pas d'importance ici : les exemples ne sont là que pour illustrer les concepts que l'on voit dans les vidéos. Ils sont pédagogiques car ils traduisent concrètement ce que l'on aborde, mais le langage employé est secondaire dans cette formation.

Arthur Magne - CTO

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.
  • Les principes pour développer du code et un logiciel de qualité qui va durer dans le temps.
  • Comment préparer l'avenir en se concentrant sur aujourd'hui.
  • Comment amener son manager à investir dans un bon design.
  • Comment le plus grand mensonge de notre industrie continue de nous pourrir la vie.
  • L'état d'esprit pour développer du code propre et professionnel.
  • 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 détecter qu'une classe fait trop de choses et comment la décomposer.
  • Comment appliquer concrètement les design pattern dans du code de production.
  • 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.
  • Comment démêler des dépendances intriquées.
  • 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 dans ma méthode. C’est la base de la 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
  • Je te montre ma manière de résoudre plusieurs katas pour illustrer concrètement la démarche.
  • 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. 

C'est clairement la partie la plus difficile du cursus. En théorie, c'est simple. Mais la mise en pratique est vraiment très difficile.
C'est là que la plupart des gens calent.
Mais ça serait dommage de s'arrêter là : tu es à deux doigts de transformer ton quotidien.

C'est pour t'aider à franchir ce cap que j'intègre dans le cursus 2 sessions de coding dojo : ensemble, on lève les derniers freins qui t'empêchent de sauter le pas.

En effet, une fois que tu as atteint ce niveau, tu peux participer aux différents dojos programmés.

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.
  • Les différentes techniques pour reprendre la main sur du code legacy impropre aux tests et le rendre progressivement testable.

On va pas se le cacher, c'est la partie la plus dense. Mais c'est aussi celle qui te sauveras la mise quand tu devras attaquer un projet legacy.

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.

Après ça, c'est sera fini des "à mais voyons, c'était évident" qui pourrissent l'ambiance : on maximise les chances de se comprendre et faire circuler la connaissance dans l'équipe.

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.

Grâce à ce module, tu apprendra à mettre sous contrôle ton pot de code en suivant les quelques métrique qui te sont utiles au quotidien tout en apprenant à utiliser les autres qui te seront utiles de temps en temps.
Tu pourras prendre du recul et piloter un niveau au dessus. C'est particulièrement utile dès lors que tu bosses en équipe.

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 les individus feront une grosse différence : vont-t-ils être capables de jouer en équipe, ou se la jouer solo en mode cowboy ?

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
  • Les principes d'aut-organisation, d'amélioration continue, de responsabilité collective, de rythme durable, de conception émergente, ou encore du principe de petites livraisons.
  • 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.
  • Quelques aspects 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 !

Damien Palagi - Développeur

Rémi Privet - Développeur

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 72 vidéos File Icon 23 des dossiers

Contenu

Les 3 principes clefs d'une conception durable v2
Module 1 - Mind Map.pdf
57,5 ko
Introduction
1 min
C'est quoi le design ?
4 min
Pourquoi s'intéresser au design ?
4 min
Premier principe : tout change tout le temps
5 min
Second principe : repousser les décisions
3 min
L'héritage de la cascade
3 min
L'héritage du monde réel
5 min
Troisième principe : affûter sa technique
3 min
Une multitude de manières de faire
5 min
Qualité de code et dette technique
4 min
Bref...
1 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

Thierry Desmorest - Coach Agile

Release notes

Le cursus est un produit que j'améliore au fur et à mesure des retours.
En achetant le cursus aujourd'hui, tu bénéficies des mises à jour à venir.

v1.3 - Début 2021 
Refactoring du module 2
Améliorations suggérées par la communauté

v1.2 - Fin 2020 - Améliorations du module 4.
Refonte du kata romain
Ajout des plusieurs vidéos notion
Ajout de nouveaux katas


v1.1 - 6 Octobre 2020 - refactoring du module 1- Les 3 principes clefs d’une conception durable
v2 du module 1. Plus dense, plus court, plus structuré.
Nouveau studio et processus de production.

v1.0 - 27 Mai 2020 - Mise en ligne du cursus complet
Regroupement de tous les modules en une formation complète

v0.8 - 1 Avril 2020 - Module 8 - Les pratiques d’équipe
v1 du module 8
Nouveau micro

v0.7 - 19 Mars 2020 - Module 7 - Piloter aux instruments
v1 du module 7

v0.6 - 12 Février 2020 - Module 6 - Communiquer avec le métier via le BDD
v1 du module 6

v0.5 - 5 Janvier 2020 - Module 5 - Reprendre le contrôle du legacy
v1 du module 5

v0.4 - 22 Avril 2019 - Module 4 - Le coeur du réacteur
v1 du module 4
Nouveau format de vidéo

V0.3 - 9 Décembre 2018 - Module 3 - Dompter les dépendances
v1 du module 3
Nouvelle caméra

v0.2 - 5 Octobre 2018 - Module 2 - Ranger chaque classe à sa juste place
v1 du module 2

v0.1 - 24 Septembre 2018 - Module 1 - Les 3 principes clefs d’une conception durable
v1 du module 1
Premier module du cursus

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

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 2 dernières années, j’ai mis en vente les modules du cursus les uns après les autres. Cette édition regroupe tous les modules en un cursus ainsi que les mises à jour publiées depuis. 
Tu en trouveras le détail dans la partie 'Release notes'.

Je prévois de continuer à améliorer les supports et la pédagogie au fur et à mesure des échanges et de tes retours.

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.

Quels langages sont utilisés dans les exemples ?

J'utilise pour le moment Java et Dart.
Ils me semblent faciles à comprendre et pédagogique. 
Je n'utilise aucune spécificité du langage ni framework. Le but est uniquement d'illustrer les concepts vus ensemble dans un cas concret.

Si vraiment tu n'arrives pas à faire le lien avec ton langage, tu me l'expliques dans les 30j qui suivent ton achat et je te rembourse.

Je suis déjà bien formé sur tous ces sujets, est-ce que je pourrai en tirer quelque chose ?

De l'expérience que j'ai du cursus en entreprise, je constate que tout le monde y trouve son compte : ceux qui découvrent ces notions apprennent à les mettre en oeuvre, ceux qui sont déjà familiés vont plus loin, et ceux qui maîtrisent ces sujets y trouvent une manière différente de les transmettre en s'inspirant de ma pédagogie.
A toi de voir la valeur que tu y cherches. Dans le doute, envoie moi un email à benoit arobase artisandeveloppeur point fr. 

Si j'ai d'autres questions

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