Comment recruter le bon développeur pour votre équipe ? Vous pouvez regarder le CV, les diplômes, la liste des frameworks. Vous pouvez aussi regarder quelque chose de moins cher et de plus honnête : sa façon de nommer les choses.

Le nom est la seule décision qu'un développeur prend à chaque ligne. Personne ne le relit dans un contrat, personne ne le mesure dans un test. Pourtant, un nom vous dit ce que l'auteur a compris, et ce qu'il a décidé de ne pas comprendre. Selon leur façon de nommer, les développeurs se rangent en 4 catégories.

Qu'est-ce qu'un bon nom ?

La vieille blague de Phil Karlton dit qu'il n'y a que deux choses difficiles en informatique : l'invalidation de cache et le nommage. La blague dure parce que sa deuxième moitié est vraie. Un nom est une décision de design. Un mauvais nom est payé par tous ceux qui lisent le code après vous.

Eric Evans a donné un nom à cette pratique dans Domain-Driven Design : l'ubiquitous language. L'équipe, les gens du produit et le code utilisent les mêmes mots pour les mêmes concepts. Quand un mot change entre la salle de réunion et le code, une couche de traduction apparaît, et elle n'appartient à personne.

Pour comparer les quatre styles, je prends un seul exemple. Imaginons une feature qui permet aux utilisateurs de stocker de façon sécurisée des fichiers de contrat dans une archive.

1. Le développeur tmp-driven 🚴🏽

Ce style consiste à donner tout de suite un nom temporaire au composant en cours de développement (classe, fonction, variable…), en attendant d'avoir une meilleure idée… ou pas. La meilleure idée vient rarement. Quand on sous-estime l'influence des noms, on retrouve souvent le code de production dans cet état :

const somestring = body.login;
const foo = body.pwd;
Service.save(Toto, somestring, foo);

Chaque développeur qui arrive ensuite doit fournir un gros effort, à lire et à débugger dans tous les sens, avant de comprendre les responsabilités de ce composant. Ce n'est pas l'auteur qui paie. Ce sont les dix lecteurs suivants.

Ce type de développeur ne pense qu'à faire avancer son ticket et à l'exécuter, peu importe comment. Le ticket avance. Le produit paie.

2. Le mind-mapper 🪄

Regardons d'abord un extrait de code :

loginService.check(login, password);
ftp.save(document);

Le développeur a changé le mot « contract » en « document », et le concept d'« archive » en concept de « ftp ». Il a aussi décidé que la sécurité ne devait pas être la responsabilité de l'archive, mais celle d'une autre couche de service applicatif, qui peut atteindre l'archive de façon non sécurisée.

Prise seule, chaque décision peut sembler raisonnable. Ensemble, elles créent de l'indirection et obligent l'équipe à entretenir une mind map qui traduit le vocabulaire du produit en code. Le product owner demande « l'archive », et le développeur doit penser « ftp ». Chaque conversation paie une taxe de traduction.

Cela limite aussi les choix de l'équipe produit. Elle devient vite esclave des choix des développeurs. Des choix en général non communiqués et pris seuls, parce qu'on les considère comme « techniques ». Ils ne le sont pas. Ce sont des décisions sur le vocabulaire du métier.

3. Le geek technique 🤓

Celui-ci nomme tout d'après comment les choses sont faites, et dit rarement ce qui est fait. Le code devient trop détaillé, bruyant, et difficile à lire pour n'importe quel lecteur expérimenté. Le code donnerait :

const contractFromDb = contractService.loadFromDatabase(id);
archiveService.tryLoginWithHashedMd5OrThrow(command.login, command.pwd);
archiveService.throwIfNoFile(contractFromDb);
archiveService.persistSync(contractFromDb);

Chaque nom laisse fuiter un détail d'implémentation : la base de données, l'algorithme de hash, l'écriture synchrone. Changez l'algorithme, et vous devez changer le nom. Sinon le nom ment. Un nom qui décrit le mécanisme vieillit aussi vite que le mécanisme.

C'est le développeur qui sait beaucoup de choses et qui les dit toutes en même temps. Le lecteur cherche la règle métier et ne la trouve pas sous la plomberie.

4. Le développeur architecture-driven 📐

Ce développeur aide l'organisation par des choix simples, qui facilitent l'intégration des nouveaux et donnent au produit une capacité d'adaptation rapide. Il écoute attentivement le langage du domaine. Il met assez d'abstraction, et les bons noms, pour épouser les choix fonctionnels. Il parle le même langage que le métier, cache les détails techniques, et fait quand même crier la structure et l'architecture. Le code donnerait :

const contract = contractRepository.byId(id);
archivingGateway
  .accessFor(User.from(login, password))
  .save(contract.file);

Lisez-le à voix haute à un product owner. Il comprendra. C'est ça, le test. Les mots sont ceux du métier : contract, archive, access. Les choix techniques, la base de données et la vérification des identifiants, sont derrière la gateway. Là, ils peuvent changer sans changer la phrase.

« Screaming architecture » est l'expression de Robert C. Martin : la structure d'un système doit crier à quoi sert le système. C'est pareil pour une simple ligne de code.

Comment s'en servir quand vous recrutez ?

Recruter sur les noms n'est pas une astuce. C'est une façon de lire les intentions. Voici comment je m'en servirais :

  1. Lisez du vrai code du candidat : une pull request, un kata, un dépôt. Lisez les noms avant la logique.
  2. Donnez une phrase métier et demandez-lui d'écrire la signature du code. Reprend-il vos mots, ou en invente-t-il d'autres ?
  3. Demandez-lui de renommer un extrait bruyant, et écoutez ses questions. « Comment appelez-vous ça dans votre métier ? » est une très bonne question.
  4. Surveillez le commentaire. Si vous avez besoin d'un commentaire, vous n'avez pas mis assez d'effort dans le nom.

Votre code parle peut-être plus fort que votre CV !

Bien sûr, c'est une heuristique, pas un verdict. Un candidat stressé par l'entretien peut écrire un foo. Et les gens changent : le nommage est une compétence, et une équipe qui relit les noms ensemble fait progresser tout le monde. J'en ai parlé dans Nommage #1 et Nommage #2. Le signal reste fort, parce que les profils ci-dessus correspondent à des attitudes : se soucier du prochain lecteur, ou se soucier du prochain ticket.

💡 Tous les développeurs n'ont pas le même impact ! Choisissez avec soin, recrutez avec discernement, et lisez leurs noms avant leurs diplômes.

Continuez à apprendre ! Continuez à lire ! Bon code !

Ressources et bibliographie

Publié d'abord sur LinkedIn : l'article d'origine