Le lien entre le nommage et le principe de responsabilité unique (SRP) est fort.

On cite souvent Phil Karlton : « There are only two hard things in computer science: cache invalidation and naming things. » La phrase est en général racontée comme une blague. Je pense que sa deuxième moitié mérite d'être prise au sérieux. Un nom est l'une des décisions de design les moins chères que vous prendrez, et l'une des plus faciles à rater.

Que demande le principe de responsabilité unique à un composant ?

Le SRP dit que chaque composant d'un système, qu'il s'agisse d'un module, d'une classe, d'une fonction ou d'un état, doit avoir une seule responsabilité et rester séparé des autres responsabilités. Robert C. Martin exprime la même idée en termes de changement : une classe doit avoir une seule raison de changer.

Le principe est pratique, pas académique. Un composant qui a deux responsabilités change pour deux raisons. Un changement fait pour l'une peut casser l'autre. Chaque lecteur doit comprendre les deux rôles avant de toucher à l'un des deux, et le coût grandit à chaque rôle ajouté.

Comment savoir qu'un composant en fait trop ?

« Mais comment savoir si un composant a plus d'une responsabilité ? » C'est la question qui compte dans chaque revue de code. Lire chaque ligne, ça marche, mais c'est lent, et on rate facilement le deuxième rôle.

Depuis quelques années, j'utilise le nommage pour traiter ce problème, et la solution s'est montrée efficace. Le nommage est un excellent moyen de refléter et de faire respecter le SRP, parce qu'un nom peut énoncer les responsabilités d'un composant avec des mots simples.

Le mécanisme est simple. Un nom est une courte affirmation sur ce que fait un composant. Quand l'affirmation tient en une expression, le composant a probablement un seul rôle. Quand le nom honnête a besoin d'un « and », d'un « or » ou d'un mot vague comme « Manager », le composant a plus d'un rôle, et le nom le montre.

Lisez le nom comme une phrase. « Cette classe gère l'authentification des utilisateurs » a un sujet et un but. « Cette classe gère les utilisateurs, leurs commandes et leurs factures » est un avertissement.

Pourquoi un nom révèle-t-il une deuxième responsabilité ?

Un nom vague accepte tout. Une classe appelée « UserManager » peut contenir le login, la modification du profil, la facturation et les notifications, et le nom convient toujours. Rien dans le nom n'arrête la croissance. Le développeur suivant ajoute la feature suivante dans la classe qui a le nom le plus large, et la classe continue de grossir. On appelle souvent ce pattern une God class : un objet qui en sait trop et qui en fait trop.

Un nom précis pose une limite. « UserAuthenticator » a un bord. Un lecteur qui y trouve un parcours de réinitialisation de mot de passe demandera ce qu'il fait là. Et cette question, c'est tout l'intérêt. Avec ce nom, le code qui n'est pas à sa place se voit.

Voici les contrastes que j'utilise :

✅ Une classe nommée « UserAuthenticator » indique clairement qu'elle est responsable de l'authentification des utilisateurs.

❌ Une classe nommée « UserManager » peut indiquer que son périmètre est trop large, ce qui est le signe d'un mauvais design. God class ?

✅ Une fonction nommée « loginOrSignup » assume plusieurs responsabilités. Clairement. Le nom est honnête sur les deux rôles : la fonction est donc bien identifiée et facile à retravailler.

❌ Une signature de fonction « login(Boolean emailExists) » est l'indice d'un code smell : c'est le flag qui décide entre le login et l'inscription. L'appelant doit connaître l'intérieur pour choisir la bonne branche.

Un argument booléen, c'est une deuxième fonction cachée dans la première. Remplacez le flag par des noms honnêtes, et chaque nom porte une seule responsabilité :

// Le flag cache une deuxième fonction dans la première.
function accessAccount(emailExists: boolean, email: string): void {
  /* ... */
}

// Deux noms honnêtes, deux responsabilités, deux endroits à modifier.
function logIn(email: string, password: string): Session {
  /* ... */
}

function signUp(email: string, password: string): Session {
  /* ... */
}

Comment utiliser les noms pour trouver et corriger les violations ?

Voici la méthode, étape par étape :

  1. Écrivez d'abord le nom, en une expression, avant d'écrire le corps.
  2. Lisez le nom comme une phrase. S'il a besoin d'un « and » ou d'un « or », notez le deuxième rôle.
  3. Remplacez les mots vagues comme Manager, Helper, Util et Handler par le travail que fait le code.
  4. Regardez les paramètres. Traitez chaque flag booléen comme un candidat à une deuxième fonction.
  5. Renommez le composant avec le nom honnête, même quand ce nom met mal à l'aise.
  6. Découpez le composant en suivant ses noms. Chaque nouveau morceau a ses propres tests et sa propre raison de changer.
  7. Relisez les nouveaux noms, et vérifiez que chacun se lit comme une seule phrase.

Les techniques de nommage rendent tout cela plus facile. Celle dont j'ai parlé brièvement dans le post précédent de cette série, c'est le nommage de l'extérieur. Vous partez de l'appelant : écrivez l'appel que vous aimeriez avoir, puis implémentez ce que le nom promet. Freeman et Pryce décrivent cette approche de l'extérieur vers l'intérieur dans Growing Object-Oriented Software, Guided by Tests. Nommer depuis l'appelant garde le nom centré sur l'utilisateur du composant, pas sur ses entrailles. Les détails internes donnent en général des noms internes, et c'est par les noms internes que le bazar commence.

Quand un nom ne règle-t-il pas le problème de design ?

Un nom montre une responsabilité. Il ne choisit pas la bonne frontière. Ce choix est une décision de design, et aucun renommage ne la prendra à votre place.

Renommer une violation sans la découper ne fait que la cacher derrière un meilleur mot. La classe a toujours deux rôles, et maintenant elle porte un nom plus poli.

Un nom long n'est pas toujours un smell. Si le domaine est complexe, le nom honnête est long. Le raccourcir en « Manager » pour taper moins de lettres, c'est échanger un problème contre un pire. Regardez le domaine avant de raccourcir quoi que ce soit.

Choisir les frontières est un vieux problème. En 1972, David Parnas expliquait qu'un système doit être découpé selon les décisions de design que chaque module cache, pas selon l'ordre des étapes de traitement. Un module nommé d'après une décision cachée est en général sur la bonne frontière. Un module nommé d'après une étape d'un organigramme est souvent sur la mauvaise. Le catalogue de patterns Smalltalk de Kent Beck dit la même chose, côté nommage : les noms doivent révéler l'intention.

💡 Un nom qui a besoin d'un « and », c'est une question de design qui attend sa réponse. Répondez-y avant que la prochaine feature n'atterrisse dans la même classe.

Continuez à apprendre ! Continuez à lire ! Bon code !

Ressources et bibliographie

Publié d'abord sur LinkedIn : le post d'origine