Le cursus Artisan Développeur by Benoit Gantaume
L'inscription est fermée

Le cursus Artisan Développeur

Disponible jusqu'au 22 Mai - 14h00
L'inscription est fermée

Le monstre spaghetti

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. Et c’est bien le souci. En début de projet, on découvre le métier et comment l’application va être utilisée. Alors on créé un objet, puis deux. Ils démarrent leur vie et puis le projet s’enrichit progressivement.

Si tu n'y prends pas garde, tu as vite fait de te retrouver avec une grosse boule de boue qui engendre le monstre spaghetti.

Le monstre spaghetti est ton ennemi.

Petit à petit tu glisses sur une pente dangereuse et tu perds la maîtrise de ton code. A chaque fois que tu veux utiliser un morceau, tu es obligé d'emporter la moitié de l'application. 
Tu te rends bien compte que tu t'enfonces progressivement, c'est étouffant. 
Alors tu prends ton courage à deux mains, plein d'espoir, et tu te promets de faire les choses proprement : d'écrire des tests, nettoyer tout ce code mal rangé, tout ça, tout ça...

Mais la réalité te rattrape vite : tous ces concepts sont comme de beaux objets en vitrine. Ils te font envie, mais tu n’arrives pas à traverser la vitre : apprendre de nouvelles choses tout en ayant à gérer un existant, c'est juste super difficile. 

Une journée trop banale

Aujourd’hui, 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. Ca 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 code 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 montre ç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 retourne 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.

Essayer de pourfendre le monstre

Pourtant tu étais plein.e d’envie : tu avais peut-être même décidé de nettoyer ton code, casser ces dépendances lourdes qui verrouillent le code et commencer à écrire des tests. 

Tu as essayé, mais rapidement tu as dû abandonner. Rassure toi, c'est normal : écrire des tests unitaires sur un code qui n’a pas été conçu pour, c’est difficile.
Et quand je dis difficile, je suis gentil. C’est par-ce que je pense que cela a bien dû arriver à quelqu’un dans le monde. C’est juste que je ne l’ai encore jamais rencontré…

Tu as fini par te résigner.
Alors chaque jour tu nourris la bête monstrueuse qui grossit à chaque petit renoncement.

Tester c’est douter

Peut-être même que tu te dis des trucs comme : 
« Au fond à quoi bon tester ? »
« Est-ce vraiment utile ? »
« Est-ce fait pour moi ? Je suis pas convaincu »
« Après tout, je m’en sors très bien sans jusqu’à maintenant »
Ah oui ? Vraiment ? 

Si ton code ne contient pas de bug, que tu es zen comme Bouddha à la fin de sa méditation quand tu mets en production, que tu gardes une vitesse de développement véloce, si t’as tout ça sans avoir besoin d’écrire de tests unitaires, tu peux fermer cette page et retourner dans la matrice.

Mais si comme beaucoup de développeurs que je connais tu n’écris pas vraiment de tests et :
  • Tu as des bugs dans ton application. Et oui je sais, en 2019 ça existe encore les bugs...
  • Tu fêtes une mise en production à grand renfort de sucre et d’alcool car tu viens d’accomplir un exploit.
  • Tu gaspilles du temps à comprendre pourquoi ce que tu viens d’écrire ne marche pas.
  • Tu utilises un debugger au quotidien. 
  • Tu as des sueurs froides en écoutant ton client te parler de sa prochaine idée qui va déchirer rien qu’en pensant à l’implémentation
  • T’as la boule au ventre le matin en venant bosser alors que tu aimes ton travail
  • Tu passes un temps de dingue à faire du support et régler les problèmes en urgence.
  • T’as peur de refactorer ton code car tu sais pas si tu vas pas casser un truc.

Alors j’ai un quelque chose pour toi.

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 ! A 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.

La pédagogie de l’escalator

Depuis 8 ans que je transmets les pratiques artisanales, j’ai mis au point une nouvelle approche : la pédagogie de l’escalator. 
Les marches viennent diviser la difficulté et rendre le cursus accessible.
La motivation des premiers résultats te donnent l’énergie de continuer ta progression.
Cette pédagogie s’appuie sur 2 outils inclus dans ce pack :
  • Le cursus en ligne Artisan Développeur
  • Les groupes de travail avec mentoring

Le cursus Artisan Développeur

Le cursus complet se découpe en 8 modules :
  • Les trois clefs d’une conception durable
  • Ranger chaque objet à sa juste place
  • Dompter les dépendances 
  • Le coeur du réacteur 
  • Reprendre le pouvoir
  • La fin des bugs
  • Quality gate
  • Communiquer avec le métier

Pour l'instant seuls les modules 1, 2, 3 et 4 sont disponibles et sont inclus dans ce pack.
Je m'appuierai sur vos retour lors des ateliers pour créer le module 5 que je t'offrirai dès sa sortie.

Ce cursus est le fruit de dizaines d’heures de travail, de centaines d’heures de lectures, de milliers d’heures d’expérience accumulées pendant 18 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 oeuvre.

Les groupes de travail à 4

Le contenu pédagogique en ligne est complété par des groupes de travail à 4 pour t’accompagner dans la mise en oeuvre concrète des concepts vus dans les différents modules.
Pendant 6 semaines, on travaille en petits groupes de 4 personnes maximum.
On se rencontre par Skype toutes les semaines pendant 90 minutes et on avance ensemble.

Seul on va plus vite. A plusieurs on va plus loin.

Le format est le suivant :
  • Pendant 10 à 15 minutes, chacun partage sur ses progrès de la semaines et les difficultés qu’il rencontre. Le groupe lui apporte son regard bienveillant et lui donne des pistes pour avancer.
  • Pendant 30 minutes on réfléchit ensemble ou on code en mob programming sur la problématique d’un membre du groupe ou sur un kata.

J'animerai ces groupes de travail et entre deux séances je te donnerai du grain à moudre pour faire évoluer ton état d’esprit.
On pourra également continuer la discussion via notre groupe privé sur slack.

Mon objectif est qu'à la fin du parcours tu aies dépassé tes blocages pour écrire tes premiers tests & refactorer ton code legacy. Après je vais être honnête : le résultat dépendra beaucoup de ton engagement.
Si tu as des attentes plus spécifiques, on pourra en discuter lors de notre première réunion.
 
Ces groupes sont un espace d'échange et de partage. Le but est de sortir de l'isolement et progresser avec des pairs qui ont envie d'avancer eux aussi.
La bienveillance est quelque chose qui me tient particulièrement à coeur. Mais attention à ne pas confondre bienveillance et guimauve dégoulinante. Si tu rejoins le groupe, nous serons exigeants avec toi à la hauteur de tes objectifs.
C'est aussi un espace d'humilité : chacun peut apprendre de l'autre. Il n'y a aucun enjeux d'ego ou de pouvoir. Le seul point est de progresser. C'est pour ça qu'on se donne du temps : pour créer l'espace de confiance nécessaire à un échange fructueux.

Rejoins nous si tu as envie de :

  • Ressentir le plaisir du travail bien fait en rentrant le soir
  • Challenger ta pratique pour devenir meilleur
  • Voir dans chaque ligne de legacy un défi technique stimulant
  • Rendre ton quotidien de développeur épanouïssant
  • Supprimer le débugger de ton quotidien (😱que vas-tu faire de tout ce temps libre ?)

Les pré-requis

Le premier pré-requis est que tu aies vraiment envie de te dépasser. Notre travail va te faire sortir de ta zone de confort, t'obliger à t'exposer et accepter le regard des autres.  Je sais à quel point cela peut être troublant et enrichissant. 

Tu  n'as pas besoin d'avoir beaucoup d'expérience. Les juniors ont aussi leur place du moment qu'ils sont à l'aise avec leur langage. 

A part ça, l’autre pré-requis est de travailler sur un projet d’application, histoire qu'on ait de la matière pour échanger. Même sur un petit projet. Mais un truc concret.

Autre point important : tout ce qui est échangé reste strictement confidentiel. Que ce soit les échanges entre membres ou le code exposé, chaque participant s'engage à garder pour lui ce qu'il aura vu ou entendu.

Vous allez recevoir :

Groupe de travail à 4

On passe à la pratique ensemble dans la vraie vie.
Voir la formation L'inscription est fermée

Module 1 - Les 3 principes clefs d'une conception durable

Niveau 1 : Viens apprendre ou revoir les principes fondateurs pour garder une base de code saine

Module 2 - Ranger chaque classe à sa juste place

Niveau 2 : Viens apprendre ou revoir comment créer des objets faciles à utiliser

Module 3 - Dompter les dépendances

Niveau 3 : Comment briser les chaines du couplage

Module 4 - Le coeur du réacteur

Niveau 4 : Ecrire ses premiers tests unitaires en TDD. 

Testimonials

Le point de vue et les mises en perspective diffèrent de ce que j'ai déjà pu lire ou entendre sur le sujet. Ce fut une belle découverte.
Jean-Luc
Sa vision très pragmatique et concrète peut te permettre de voir comment faire un beau design aujourd'hui
Nicolas Bouteiller
Un programme accessible avec un accompagnement qui s’adapte et qui est à l’écoute. Une formation qui demande à l’équipe de s’investir et qui en vaut la peine
Olivier Massol

On commence quand ?

Les inscriptions ferment le 22 Mai à 14h.

Le programme se déroule du 27 Mai au 5 Juillet.
Une fois les groupes constitués, on définit ensemble le meilleur créneau pour chaque groupe et on planifie les 6 semaines.

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 directions 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.

Photo by Jingda Chen on Unsplash