Un usage réfléchi du mot-clé public
Chez VisionPM, nous tenons à un usage réfléchi du mot-clé public. Nous savons qu'il crée un contrat immédiat et souvent irréversible.
Écrire le mot-clé ne demande aucun effort. Le retirer plus tard oblige chaque appelant à changer. Cette asymétrie est la raison de traiter public comme une décision de design, et pas comme un choix par défaut.
Pourquoi un membre public est-il un contrat ?
Le langage laisse tout code qui voit un membre public s'en servir. Dans un petit programme, vous connaissez tous les appelants. Dans une grosse codebase, ou dans un système avec plusieurs équipes, non. Certains appelants, vous ne les verrez jamais.
Chaque appelant qui dépend d'un nom public détient une promesse : le nom, sa signature et son comportement. Pour changer cette promesse, vous devez trouver chaque appelant et le changer avec vous. Sinon, vous la cassez. C'est pour cela que le contrat est immédiat : le premier appelant commence à en dépendre le jour même. Et souvent irréversible : les appelants que vous ne voyez pas gardent l'ancienne promesse en vie.
Imaginez une méthode qui retourne les clients dans un ordre fixe, et un appelant qui affiche la première page sans trier. Vous changez la méthode pour qu'elle les retourne sans ordre particulier. Son nom et sa signature restent les mêmes. L'appelant casse, et personne dans votre équipe ne peut voir la dépendance. La promesse n'a jamais été écrite, et pourtant elle tenait l'appelant en place.
Le mot-clé est une décision : qui a le droit de dépendre de vous ? Prenez cette décision une fois, exprès.
Quelle est la gravité de chaque type d'exposition publique ?
Tous les public ne coûtent pas le même prix. Voici comment le risque grandit, de la plus petite exposition à la plus grande :
- Les variables
public: un risque de gravité moyenne, qui peut fragiliser l'encapsulation. Une classe n'impose ses règles que sur l'état qu'elle contrôle. Quand un autre code écrit dans un champ public, il contourne ces règles, et la classe ne peut plus garantir ses propres invariants. - Les méthodes
public: vues comme un risque de gravité haute, elles peuvent mettre à mal le Single Responsibility Principle (SRP) et l'Interface Segregation Principle (ISP) des principes SOLID. Le SRP dit qu'une classe doit avoir une seule raison de changer. L'ISP dit qu'un client ne doit pas dépendre de méthodes qu'il n'utilise pas. Chaque méthode publique donne aux autres une nouvelle raison de dépendre de la classe. - Les classes ou packages exportés en
public: classés en gravité critique, ils menacent l'intégrité de la modularité du monolithe. Les classes exportées d'un module sont son interface avec le reste du système. Dès que d'autres modules importent une classe interne, la frontière entre les modules a disparu, et le monolithe redevient un seul programme emmêlé. - Les événements
publicpubliés sur les brokers d'entreprise : c'est considéré comme un problème de gravité fatale, car cela peut créer un bazar monolithique distribué. Des consommateurs d'autres équipes s'abonnent à l'événement. Son schéma devient un contrat avec des parties que vous ne voyez pas. Vous ne pouvez plus changer l'émetteur sans vous coordonner avec chaque abonné.
Le schéma est le même à chaque niveau. Plus l'audience est large, plus le changement coûte cher, et plus il est difficile de revenir en arrière.
Que veut dire la règle du refactoring ?
Voici la règle en une ligne : la vitesse à laquelle vous pouvez refactorer est inversement proportionnelle au nombre de contrats publics que vous gérez.
Inversement proportionnelle, cela veut dire que plus le nombre de contrats publics grandit, plus votre vitesse baisse. Chaque contrat ajouté, c'est un groupe d'appelants de plus qui doit être d'accord avant que vous changiez quoi que ce soit. Refactorer sans peur demande peu de contrats. Et peu de contrats, cela vient d'une surface publique petite et voulue.
Commencez par une question pour chaque membre : qui en a besoin ? Si la réponse est la classe elle-même, ou un test, le membre reste privé. Si la réponse est une équipe que vous n'avez jamais rencontrée, le membre mérite une version, un schéma et une revue.
David L. Parnas a introduit le masquage d'information en 1972, comme critère pour décomposer un système en modules. Chaque module cache ses décisions de design derrière une petite interface. Chaque membre que vous exposez au-delà de cette interface est une décision que vous aviez cachée, puis révélée.
Comment garder une surface publique petite ?
Suivez ces étapes pour chaque nouveau module :
- Rendez chaque champ privé par défaut.
- N'exposez que les méthodes dont les appelants ont besoin aujourd'hui.
- Gardez les classes internes hors du package exporté.
- Versionnez chaque événement publié, et traitez son schéma comme un contrat.
- Relisez chaque nouveau membre public en code review, comme une décision de contrat.
✅ Testez le comportement public que sert un helper, et gardez le helper privé dans son module.
❌ Passez le helper en public pour qu'un test puisse l'atteindre.
La seconde option est la plus courante, et c'est celle qui coûte le plus cher plus tard. Le test devient un deuxième appelant, et le helper devient un contrat.
Quand un membre public est-il le bon choix ?
Public n'est pas l'ennemi. Une librairie existe pour être utilisée, et son API publique, c'est le produit. Un événement dont d'autres équipes ont besoin doit être public. C'est exactement pour cela qu'il lui faut une version et un schéma clair.
Le problème, c'est le public involontaire : un membre rendu visible par commodité, pour faciliter un test, ou pour éviter une question de design. Nommez chaque membre public, connaissez ses consommateurs, et acceptez son coût. Un membre public que vous avez choisi est une promesse que vous pouvez tenir. Un membre public que vous avez oublié est un risque que vous portez sans le savoir. Une API publique est plus facile à ajouter qu'à retirer. Commencez donc étroit, et élargissez la surface quand un vrai appelant le demande.
💡Chaque mot-clé public est une promesse faite à des gens que vous ne rencontrerez peut-être jamais. Faites cette promesse exprès !
Ressources et bibliographie
- Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship (Prentice Hall, 2008). https://www.oreilly.com/library/view/clean-code-a/9780136083238/
- David L. Parnas, On the Criteria To Be Used in Decomposing Systems into Modules (Communications of the ACM, 1972). https://dl.acm.org/doi/10.1145/361598.361623
- John Ousterhout, A Philosophy of Software Design (Yaknyam Press, 2018). https://web.stanford.edu/~ouster/cgi-bin/aposd.php
- Sam Newman, Building Microservices, 2nd edition (O'Reilly, 2021). https://www.oreilly.com/library/view/building-microservices-2nd/9781492034018/
Publié d'abord sur LinkedIn : le post d'origine
