Bienvenue sur le podcast Artisan Developer,
l'émission dédiée au programmeur qui parle de techniques, bien sûr,
de codes durables, mais aussi du métier en lui-même,
de recrutement, de développement personnel,
ou encore d'entrepreneuriat pour t'accompagner dans une vie de développeur épanouissante.
Alors, est-tu prêt à passer au niveau supérieur ?
C'est parti !
Aujourd'hui, je suis avec Xavier Knopp, Xavier bonjour.
Bonjour Benoît.
Dans le précédent épisode, on parlait de ton expérience
où tu avais en quelques heures implémenté quelque chose,
une nouvelle fonctionnalité, dans un langage infraignement
que tu connaissais finalement assez mal, à savoir ruste.
Et on n'avait pas pu aller jusqu'au bout de l'épisode sur
comment est-ce que ton expérience en tant que vieux développeur
t'avait aidé à bien tirer parti de ce qui existait, d'aller vite.
Il nous a bien parlé des tests de comment tu les as utilisés comme doc,
mais est-ce que tu avais envie d'approfondir sur la question ?
Oui, effectivement, je trouvais ta question intéressante
et c'est un peu la réflexion que je m'étais faite.
Donc, on s'est retrouvé lundi matin et que ce challenge du product honneur
a proposé d'essayer d'implementer une fonctionnalité qui nous fallait
dans une librairie qu'on utilise, mais que je connaissais pas plus que ça.
Et surtout dans un langage, toutes les basse-couches sont en ruste,
un langage que je ne connais pas du tout, que j'ai un peu aperçu ces derniers temps.
Donc, j'ai parlé de l'autre fois des tests.
Donc, effectivement, quand même, point très positif,
il y a toute cette batterie d'eau test.
Et donc, j'ai commencé par écrire moi un test assez haut niveau dans cette librairie
en ruste. Alors, ce qui était cool, c'est qu'il y avait des tests déjà existants.
Donc, j'ai repris le test qui était écrit au-dessus chez Récrile Mien.
Donc, je me suis bien inspiré.
Je n'ai pas fait du copier-coller, mais c'était pas loin.
Donc, ça, c'est quand même cool de pouvoir déjà écrire un test,
de voir qui ne marche pas et, entre guillemets, il n'y a plus qu'à le faire marcher.
Et puis ensuite, de suivre les différentes courses,
de voir les réflexes de recherche.
Et là, effectivement, j'étais surpris parce que je pensais mettre la semaine à faire ça.
Et déjà, à la fin de la première journée,
j'avais déjà, à premier test qui passait,
j'avais implémenté vraiment la fonction de crypto,
alors que je ne suis pas un spécialiste de crypto.
Donc, ça, c'était intéressant.
Et du coup, la deuxième journée, c'est-à-dire hier,
j'ai réussi à remonter dans les couches et à implémenter
dans d'autres couches une couche native,
puis la couche remontée jusqu'à Node.js,
puisqu'on utilise, nous, le wrapeur Node.js.
Et là encore, de pouvoir écrire un test unitaire dans le wrapeur.
Donc, le wrapeur, lui aussi, avait des tests unitaires.
Donc là aussi, c'était bien.
J'ai trouvé un test qui faisait des tests de crypto proches de ce que je voulais.
Donc, j'ai pu en écrire un autre.
Et là encore, une fois que le test passait,
j'ai pu bon dire de joie sur ma chaise,
puisque je savais que c'était bon.
Donc, c'est vrai que les tests unitaires te permettent quand même
de valider quand même quelque chose que tu vas faire.
On le dit souvent, fonctionnellement,
mais aussi techniquement sur des langages que tu connais pas ou peu.
Et c'est vrai que pour ça, Rust est quand même assez particulier.
Mais comme tu disais, mine de rien,
je me suis rendu compte que pour y arriver à faire ça en deux jours,
j'ai puiser dans mes vieilles,
mes vieux souvenirs de CEC++ qui datent de, il y a pas mal de temps,
un peu des notions de compilation native qui datent aussi.
Et puis, je suis tombé sur des gestions de monade type les futurs
que j'avais vus qui sont équivalents des promesses nods.
Et j'avais vu les futurs dans ce cas-là.
Les options qu'on retrouve, que j'avais découvert dans ce cas-là,
qu'on était rajoutés dans Java,
qu'on retrouve éventuellement avec des artifices,
on peut faire des optionnels en JS en rajoutant ce qu'il faut.
Ce n'est pas un tutif, c'est pas un trincerc au langage.
Et puis, un peu d'aspect fonctionnel,
de programmation fonctionnelle que j'avais vu là aussi un peu en JS
et surtout en ce cas-là.
Donc, ce qui est intéressant, c'est qu'en puissant dans ces expériences
passées, tu as retrouvé des concepts qui t'ont permis de facilement
prendre en main ce nouveau frère mort, ce nouveau langage en fait.
Oui, complètement, complètement.
Et d'ailleurs, c'est marrant parce que c'est lié aussi,
enfin, je veux dire, les gens qui ont la fondation Mozilla
qui a lancé Rust pour réécrire Two Firefox,
tu vois que les gens qui ressortent des nouveaux langages
puissent dans les bonnes idées des uns et des autres.
Et ça, c'est quand même cool.
Je trouve qu'on est dans une période où il y a des choses sympas
qui émergent dans différents langages.
Et quand un langage va appuiser dans les autres ou un nouveau langage sort
en essayant de prendre le meilleur ou les bonnes idées ici et là,
c'est quand même chouette.
Et c'est vrai que le fait d'avoir touché différents langages,
après, te permet de monter plus vite en compétences.
J'avais évoqué que j'avais regardé Rust entre midi et deux avec un collègue à moi.
Et c'est un collègue qui a quelques années d'expérience,
qui a fait essentiellement du Node.js.
Et quand on a regardé un peu Rust,
j'ai vu que moi, je lisais un peu les explications qu'on avait sous les yeux.
OK, ça me parlait, j'arrivais à comprendre, etc.
Et à un moment, j'ai vu que lui, il y avait plus de peine,
parce qu'en fait, ne serait-ce que le typage, par exemple,
c'est quelque chose qui ne connaissait pas.
Donc, le typage, il ne connaissait pas.
À un moment, on a vu que ça parlait de tuples.
La notion de tuples, il ne connaissait pas.
Donc, c'était cool.
C'était l'occasion de lui expliquer la notion de tuples.
Moi, les tuples, je les ai découvert quand j'ai fait du Scala,
j'ai fait une mission où il y avait du Scala.
Et j'ai vu, par rapport à ce développeur,
qu'à quelques années d'expérience,
et donc, il y a vu moins de langage, moins de concept,
que du coup, c'était tout en plus dur pour lui,
parce qu'il y a des concepts qui découvraient là.
D'ailleurs, comme moi, le jour où j'ai eu cette mission en Scala,
j'ai été un peu à la peine,
parce qu'il y avait les nouveaux tradits en langage
et des nouveautés aussi de concepts que j'avais pas encore vu.
Mais effectivement, tu les engranges au fil des années d'expérience.
Donc, c'est là où je te rejoins sur ce que tu disais précédemment,
l'intérêt aussi d'un développeur d'élargir son champ de vision,
non seulement pour être compétent sur différents langages.
Je ne suis pas forcément expert, mais avoir des notions.
Et ces notions permettent d'appréhender plus facilement d'autres langages
ou de mieux coder même dans son langage de prédilection.
Oui, moi, je vois ça avec plusieurs regards.
D'abord, un regard sur l'industrie,
et notamment les process de recrutement,
où il n'y a pas longtemps, j'ai remis un doigt dans le circuit,
parce que je m'intéressais au Canada et j'étais curieux de voir
ce qui était possible de faire.
Et dès que je parlais en recruteur,
la première question, c'était, OK, quels sont vos technos ?
Et je trouvais tellement la question déplacée, en fait.
J'avais envie de lui dire, mais tu sais, j'ai 20 ans d'expérience.
J'avais envie de lui dire quel technos tu veux.
J'avais pas l'impression que c'était un enjeu.
Je ne dis pas que je suis expert tout de suite de n'importe quel technos.
Lors de là, il y a encore des concepts qui,
tu vois, par exemple, le notion fonctionnelle,
si jamais un truc m'a trop attiré,
j'étais un peu traumatisé à l'école dingée par le lispe.
Mais c'est des choses dont je suis curieux.
J'ai eu une grosse première partie de vie,
les dix premières années où j'étais dans du compilé,
tout petit peu de Java, mais surtout beaucoup de C++,
donc des trucs vraiment hardcore, bas niveau,
où tu gères ta mémoire et compagnie.
Faites dix ans que je fais du Rails,
donc je suis parti dans un opposé total.
Et aujourd'hui, tu vois, c'est très drôle.
J'ai envie de revenir à du compilé.
J'ai envie de revenir à du compilé et des trucs un petit peu plus bas niveau.
En ce moment, je l'aurent beaucoup du côté d'IOS
et de... Parce que c'est mon téléphone,
mon écosystème est très bon chez Apple,
donc si j'étais sous Android, je reviendrais sous Android.
Et tu vois, il y a des phases comme ça.
Je ne sais pas si ça te le fait, mais il y a des phases.
En ce moment, j'ai envie de compilé.
Je ne sais pas.
J'ai envie de refaire du compilé, j'ai envie de retrouver...
Ouais, voilà.
Ça te parle, ce truc ou pas ?
Alors, moi, ce n'est pas vraiment des envies que j'ai particulièrement.
Par contre, ce que j'apprécie,
c'est deux choses.
Tu vois, j'arrive dans cette startup.
On a une blockchain et quelque part, on n'a pas le choix.
Les bases-couches sont en rust.
Donc soit tu es capable de rentrer dedans,
de puger les idées, voir comme je l'ai fait,
de rajouter une fonctionnalité qui te manque.
Soit tu trouves autre chose et du coup,
tu dois trouver d'autres blockchains,
alors que c'est peut-être celle qui te correspond à ton besoin.
Donc ça, je trouve ça intéressant de cette capacité
de pouvoir s'adapter à un environnement.
Et puis, ce que je vois aussi,
c'est aussi d'un moment de pouvoir choisir le meilleur langage
par rapport à un besoin.
Et c'est ça, je trouve qu'on est dans un écosystème
où il faut vraiment cultiver ça.
Je ne sais pas si vraiment le cultive,
vraiment j'ai l'impression qu'il y a un peu des espèces de trucs universels.
Tu vois, le truc très tendance en ce moment,
c'est GES et React et tous ces cousins.
Et j'ai l'impression qu'il y a un peu ce côté,
les seniors des anneaux, un langage et un framework
pour les gouverner tous.
Ce n'est pas ce que t'en penses.
Ah oui, oui, complètement.
Complètement, on a 3 frameworks pour le front qui se tire la bourre,
mais qui en gros, permettent de faire les mêmes choses.
Et on oublie complètement que,
des fois pour certains besoins,
tu n'as pas besoin de tout ça, tu n'as pas besoin.
Tu peux faire du statique et ça fait bien le boulot.
C'est-à-dire qu'on sort la râtiérie lourde pour faire des choses simples.
Et tu vois, là, par exemple, je m'intéresse aussi à Go,
parce que j'entends dire, et je l'ai un peu vu et ça semble assez vrai,
que par exemple, faire des microservices en Go
pour des choses assez simples, c'est super adapté.
Parce que ça se compile en natif,
que tu fais du multi-stage avec Docker,
un stage pour bulle des ton Go et le résultat,
tu mets dans une image,
avec basé sur Alpine et t'as une image Docker hyper light.
Donc, c'est des usages qui sont, c'est des choix techniques.
Pour moi, les choix techniques doivent s'adapter au mieux, au besoin.
Et plus ton éventail de langage et d'outils est large,
et plus tu pourras t'adapter aux différents besoins.
C'est ça que je trouve intéressant.
Écoute, je suis complètement d'accord
et je te propose que ce soit le mot de la fin.
Si les auditeurs veulent en savoir plus,
ils peuvent venir où pour voir ce que tu publie ?
Ils peuvent venir me voir sur mon lieu de travail
pour discuter, partager une bière
et coder un bout de quelque chose ensemble.
Toi, tu es ou toi ? Tu es à Grenoble, c'est ça ?
Oui, je suis à Grenoble.
Sinon, taper mon nom sur un moteur de recherche
et puis on trouve mon blog qui est plus trop actif
et Twitter et autres.
Merci d'être venu, Xavier.
Merci à toi, Benoît.
Quant à toi, cher auditeur, j'espère que t'as aimé ce podcast
et que si c'est le cas, je t'encourage fortement
à mettre une bonne note dans l'outil de podcast que tu utilises.
Je ne sais pas si c'est iTunes podcast,
si c'est Google podcast, Spotify, whatever.
S'il te plaît, ça peut être vraiment super
parce que ça va donner de la visibilité au podcast
et donc aider encore plus de gens à progresser.
Je te remercie, je te dis à demain.