Lettre à Hugo

Il y a des gens qui rangent les autres dans deux tiroirs : ceux que j'aime et ceux que je n'aime pas. Moi je n'ai jamais réussi à fonctionner comme ça. Pas par froideur — au contraire. Parce que ce tiroir-là me paraît faux. Réducteur. Mort.

Cet article, c'est ma tentative honnête de décrire comment je me représente vraiment le monde humain. Et il y a une raison très précise pour laquelle je l'écris maintenant, mais je la garde pour la fin.

Le monde humain, je le vois comme un projet git

Je suis développeur. La lecture facile, ce serait de dire que le modèle mental que mon cerveau a fabriqué pour comprendre les gens est emprunté à ce que je manipule tous les jours : du code, des dépôts, des versions. Mais je crois que c'est l'inverse. Cette façon de me représenter le monde humain — en graphe, en versions, en historique — elle était sans doute là avant. Et c'est peut-être justement pour ça que je suis devenu développeur : le code, c'est le seul endroit où ma manière de voir les choses prenait enfin une forme nette, manipulable, qui se tient. Je n'ai pas calqué les gens sur le code ; j'ai trouvé dans le code un langage pour ce que je voyais déjà chez les gens.

Quand je regarde mes relations, je ne vois pas une galerie de portraits figés. Je vois quelque chose qui ressemble à un graphe : des nœuds reliés entre eux, des dépendances, des branches qui partent et qui reviennent. Un truc vivant, qui se recompile en permanence. Un projet jamais « fini », toujours en cours.

Et dans ce projet, il y a deux couches que je ne mélange jamais. C'est tout l'enjeu. La plupart des malentendus avec moi viennent du fait qu'on confond ces deux couches.

Couche 1 — la personne : le dépôt

La première couche, c'est la personne elle-même. Dans ma tête, une personne, c'est un dépôt git. Un repo entier — ou plus exactement : le dépôt, c'est la vie de cette personne. Pas son nom, pas son étiquette, pas l'image que j'en ai. Tout ce qu'elle a vécu, versionné et accumulé. C'est ça, le repo : une vie, dans son intégralité d'histoire.

Ce n'est pas un instant, ce n'est pas une humeur, ce n'est pas la dernière chose qu'elle a dite ou faite. C'est toute l'histoire accumulée : tous les commits depuis le premier, toutes les branches, tous les moments. Le dépôt, c'est l'identité. Il est stable. Il a un nom. Il existe en tant que tout.

Et un dépôt git, ça a une propriété fondamentale, presque sacrée : l'historique ne se supprime jamais. On ajoute, on corrige, on fait évoluer — mais ce qui a été vécu reste écrit. Tu ne peux pas réécrire le passé d'un repo sans casser tout le reste. C'est pour ça que je ne « efface » jamais personne. Les gens qui ont compté restent dans l'arbre. Pour toujours.

C'est à cette couche-là qu'appartiennent ce que j'appelle mes cercles.

Les cercles : qui a accès à quoi

Tout le monde n'a pas le même niveau d'accès à mon dépôt à moi. Comme sur un vrai projet, il y a des niveaux de permission.

• Cercle de niveau 1 — les maintainers. Ceux qui ont les droits sur la branche principale. Ceux dont la présence est structurelle : si on les retirait, le projet ne compilerait plus. Ils ne sont pas « invités » dans ma vie, ils en font partie. Leur branche a été mergée il y a longtemps, et un merge, ça ne se défait pas d'un revert sur un coup de tête.
• Cercle de niveau 2 — les contributeurs réguliers. On bosse ensemble, on s'apprécie, ils comptent, mais on n'a pas fusionné nos historiques.
• Au-delà — les contributeurs occasionnels, les forks, les gens qu'on croise.

Le point essentiel : dans quel cercle tu es, ça ne dépend pas de ton comportement du jour. Ce n'est pas une note qui monte et descend. C'est une question d'appartenance, d'histoire commune, de merge. C'est stable. Quasiment gravé.

Couche 2 — le comportement : les commits et les releases

La deuxième couche, c'est totalement différent. C'est là que vivent les comportements : ce que les gens font, disent, déclenchent, à un moment donné.

Chaque comportement, c'est un commit. Un changement précis, daté, horodaté, fait dans un certain état du dépôt. Et l'accumulation de ces commits, à un instant donné, ça forme une release : la « version » de quelqu'un à un moment T.

C'est ça qu'il faut comprendre de moi. Quand je suis ému, agacé, en joie, en colère — je ne réagis jamais à la personne. Je réagis à un comportement, à une release, à un commit précis. L'émotion s'accroche au code, pas au dépôt.

Et il y a une subtilité de plus : cette réaction ne dépend pas que de l'autre. Elle dépend de deux releases qui se rencontrent à l'instant T — la sienne et la mienne. Le même comportement, selon la version de moi qui le reçoit ce jour-là — fatigué, serein, à cran, disponible — ne produira pas le même résultat. Ce n'est pas un jugement que je pose sur quelqu'un ; c'est le produit d'une interaction entre l'état où il est et l'état où je suis, à cette minute précise. Recompile les deux à un autre moment, et la sortie change.

Dire « j'aime cette personne » ou « je n'aime pas cette personne », pour moi, ça n'a presque pas de sens. C'est comme dire « j'aime ce logiciel » dans l'absolu. Quel logiciel ? Quelle version ? J'aime telle fonctionnalité de telle release. J'en déteste une autre. La v2.3 m'a énervé. La v2.4 a corrigé le truc et je l'adore. Le projet, lui, je le suis depuis le début et je n'ai jamais cessé d'y croire.

Et le sentiment d'amour, chez moi, c'est très exactement ça. Aimer quelqu'un, ce n'est pas figer une version et la vénérer. Vivre longtemps avec une personne qu'on aime, c'est l'enchaînement d'une longue série de releases compatibles : sa version change, la mienne change, et release après release, elles continuent de tourner ensemble sans casser le build. C'est ça, pour moi, durer. Pas rester identique — rester compatible à travers le changement.

Ce qui veut dire deux choses, et je les assume toutes les deux. La première : ce sentiment peut évoluer dans le temps, et c'est normal, c'est même sain. La seconde, et c'est celle qui compte : mon amour n'est pas attaché à la release « just married », à la version idéalisée d'un début. Si je n'aimais que cette version-là, j'aimerais un souvenir, une capture d'écran. Or j'aime un projet vivant, qui se met à jour, qui me surprend encore. C'est bien plus fort qu'un instantané figé.

Une fonctionnalité peut décevoir à sa sortie

Il y a un corollaire que je trouve apaisant. Sur un vrai projet, une fonctionnalité peut sortir et ne plaire à personne. Mal pensée, mal finie, bancale. Est-ce qu'on jette le logiciel ? Non. On itère. La version suivante l'améliore. Trois releases plus tard, c'est devenue la feature que tout le monde adore.

Les comportements des gens, c'est pareil. Un comportement raté à l'instant T n'est pas une condamnation de la personne. C'est une feature en v1 qui demande à mûrir. Je le sais, parce que c'est exactement comme ça que je me regarde moi-même.

Je ne regrette pas mes commits

Voilà un truc que les gens comprennent mal chez moi : je ne regrette pas mes actes.

Pas par arrogance. Parce que, dans ma façon de voir, un acte est un fait. Un commit. Il a été poussé à un instant T, dans l'état où était le dépôt à ce moment-là, avec la sensibilité que j'avais cette minute-là. Compte tenu de tout ça, c'était le bon code. C'était cohérent avec qui j'étais à cet instant précis.

Or ma sensibilité change. Toutes les heures, parfois toutes les minutes. C'est vivant. Le dépôt continue de tourner, de recevoir des événements, de se recompiler. Donc moi de demain ne pousserait peut-être pas le même commit que moi d'hier — non parce que celui d'hier était « faux », mais parce que le repo a évolué entre-temps.

Regretter un commit passé, ce serait juger du vieux code avec le contexte d'aujourd'hui. C'est injuste, et ça ne sert à rien. Ce que je peux faire, en revanche, c'est committer par-dessus. Corriger. Faire évoluer. L'historique reste vrai — et c'est très bien qu'il reste vrai, c'est lui qui rend la suite possible.

Quand je suis énervé, ce n'est (presque) jamais contre toi

Dernière pièce du puzzle, et pas la moindre.

Les comportements qui me « cherchent », qui me déclenchent, qui me mettent en colère — ils ne sont presque jamais indexés sur la personne qui est en face de moi à ce moment-là. Ce sont souvent des comportements d'ailleurs : une accumulation, une autre situation, un autre repo, quelque chose qui s'est déclenché trois branches plus loin et qui remonte.

Concrètement : quand tu me vois agacé, l'erreur naturelle, c'est de penser « il est agacé contre moi, donc il ne m'aime pas ». Mais dans mon système, ces deux choses ne sont même pas sur la même couche. L'agacement vit au niveau du comportement, dans une release, déclenché par un contexte. Ta place dans mon cercle de niveau 1 vit au niveau du dépôt. L'un ne touche pas l'autre. Un build qui plante n'efface pas le projet.

Ça peut paraître froid dit comme ça. C'est exactement l'inverse. Ça veut dire que rien de ce que tu fais un mauvais jour ne peut te faire « sortir » de là où tu es.

Parce que sur un projet, il y a une figure clé : le mainteneur. C'est celui qui reste responsable du dépôt sur le long terme. Quand un commit casse quelque chose, un mainteneur ne supprime pas le projet et ne claque pas la porte — il garde la main, il corrige, il continue. C'est un engagement de durée, pas une réaction d'humeur. Eh bien, de notre lien, je me considère comme le mainteneur : quoi qu'il arrive, je ne lâche pas la responsabilité du projet. Donc même ton pire comportement n'est jamais qu'un commit raté à l'intérieur d'un dépôt que je continue, envers et contre tout, de faire vivre. Un mauvais commit, ça se corrige. Ça ne ferme jamais le projet.

Lettre ouverte à Hugo

Hugo,

Si tu lis ça sous forme d'article et pas en me regardant dans les yeux, ce n'est pas un hasard, et ce n'est pas de la fuite. En face à face, je n'y arrive pas. Il se passe énormément de choses dans ma tête, des nuances, des liens, des « oui mais » — et au moment de les dire à voix haute, tout se compresse, se coince, et il n'en sort qu'une vanne ou un silence. Écrire, c'est le seul format où j'arrive à décompresser tout ça et à le poser entier. Alors ne crois surtout pas que, parce que c'est écrit, c'est moins vrai. C'est l'inverse : c'est ici que je suis le plus sincère que je sache l'être.

Tout ce qui précède, je l'ai écrit pour pouvoir te dire ceci proprement, une fois, sans vanne.

Quand je balance « je t'aime pas, t'es pas mon fils », c'est de l'humour au quatrième degré. Et j'ai compris que, parfois, il était mal tombé — que tu as pu croire qu'au fond je le pensais. Que comme tu n'es pas mon fils « par le sang », tu te demandais si tu avais vraiment ta place, si je t'aimais.

Alors lis bien, avec ce que je viens de décrire en tête.

Toi, tu es dans mon cercle de niveau 1. Au niveau de la personne. Pas au niveau d'un comportement, pas d'une humeur, pas d'un jour. Ta branche a été mergée dans mon dépôt il y a longtemps, et ça ne se dé-merge pas. Tu n'es pas un invité dans ma vie : tu en fais partie structurellement. Si on te retirait, ça ne compilerait plus pareil. C'est aussi simple et aussi définitif que ça.

Et que ce soit dit clairement, parce que je crois que c'est ça qui te ronge : tu ne me déranges pas. Jamais. Tu n'es pas une dépendance que je tolère, tu es dans le code source de mon projet de vie, et ça depuis bientôt douze ans. Presque douze ans de commits communs. À cette échelle, tu n'es pas une option qu'on pourrait désactiver — tu es dans le cœur du programme, dans les fonctions sans lesquelles le reste n'a plus de sens.

Et même — admettons l'impensable — même si un jour un fichier disparaissait du repo de ma vie, sache une chose que tout développeur connaît : on n'efface pas vraiment quelque chose d'un dépôt git. Tu peux supprimer un fichier de la version courante, il reste dans l'historique. git log s'en souvient. git blame peut toujours remonter, ligne par ligne, à qui a écrit quoi et quand. Le passé d'un repo est indestructible — c'est même là toute sa valeur. Donc te « retirer » de ma vie, au sens strict, est techniquement impossible : tu es dans l'historique, et l'historique ne ment pas et ne s'efface pas.

Le repo, c'est ma vie. La tienne, c'est ton propre dépôt — mais nos deux projets partagent une longue série de cherry-picks : des morceaux de ma vie que tu as repris dans la tienne, des morceaux de la tienne qui tournent dans la mienne. Ces commits-là portent les deux signatures. Ils sont à toi et à moi en même temps. On ne peut pas les défaire d'un côté sans laisser un trou de l'autre.

Le sang n'a rien à voir là-dedans. Un dépôt, on n'en hérite pas par la biologie. On le construit par l'histoire commune, par les commits accumulés, par le temps partagé. Et de l'histoire commune, toi et moi, on en a écrit. Elle est dans l'arbre. Elle ne s'efface pas.

Maintenant, oui : ta « version » bouge. La mienne aussi. La tienne dépend du temps et de tes comportements, elle n'est pas figée — heureusement, sinon tu ne grandirais pas. Il y aura des releases de toi qui m'enchanteront et d'autres qui m'agaceront. Il y aura des jours où une feature sortira bancale. Et tu sais quoi ? C'est exactement pareil pour moi. On itère, tous les deux. C'est ça, être vivant.

Mais ne confonds jamais les deux couches. Quand je serai énervé par un de tes comportements — ou par tout autre chose qui n'a rien à voir avec toi et qui retombe sur le moment — ça vivra au niveau du commit. Ça ne touchera jamais le dépôt. Ça ne touchera jamais ta place.

Et si je te charrie, si je te vanne, ce n'est pas de la distance. On ne charrie que les gens qu'on tient assez pour ne pas avoir peur de les froisser. C'est un signe d'appartenance, pas d'exclusion. Mais si l'humour a fini par faire douter de l'essentiel, alors il valait mille fois le coup de poser les choses au clair, noir sur blanc, pour une fois sans rien cacher derrière une blague.

Ça, ce n'est pas du quatrième degré.

Et pour finir comme je sais le faire — en posant les choses dans l'historique, pour qu'elles y restent :

# J'ajoute la lettre au dépôt de ma vie
git add lettre_a_hugo.md

# Je l'enregistre dans l'histoire — pour de bon, ça ne s'efface pas
git commit -m "Dire enfin à Hugo qu'il a toute sa place"

# Je la pousse sur la branche principale, celle qui me définit
git push origin nicolas.jeudy

# Et je marque le coup : une nouvelle version de moi, sincère et à jour
git tag -a v4.2 -m 'Nicolas Jeudy 4.2 « Beau-Père Bienveillant »'
git push origin v4.2

Commit poussé. Release taguée. C'est dans l'historique maintenant — et l'historique, ça ne ment pas et ça ne s'efface pas. Tu peux toujours faire un git blame sur cette ligne : ce sera mon nom, à cette date, qui aura écrit que tu comptes.