La dénomination interne (classes, méthodes, tables de base de données, etc.) des entités doit-elle être modifiée si la dénomination marketing et d'interface utilisateur change?

Nous avons un produit à longue durée de vie depuis environ 8 ans maintenant. Au fil du temps, les noms des concepts et des entités changent. Devrions-nous mettre le travail pour renommer toutes les tables et colonnes de base de code et de base de données pour correspondre à ces nouveaux noms?

Existe-t-il une étude sur ce sujet ou sur certaines des meilleures pratiques publiées?

Merci

Le décalage entre les noms internes et externes sent définitivement. Comme le souligne Rinzwind, les homophones et les synonymes sentent le pire.

La vraie question à laquelle vous devez répondre est la suivante: quel est le compromis coût / bénéfice pour effectuer le changement?

Le coût de ne pas changer est une courbe d'apprentissage plus abrupte pour les nouveaux membres de l'équipe et une probabilité accrue de bugs futurs. Le coût du changement est le temps évident impliqué, une nouvelle courbe d'apprentissage pour les anciens sur le projet et la possibilité de nouveaux bugs.

Si vous vous attendez à avoir un nombre relativement important de nouveaux membres de l'équipe, il est plus probable de faire le changement. Si vous ne vous attendez à aucun chiffre d'affaires, l'équipe actuelle n'a pas tendance à se confondre et l'équipe est satisfaite du statu quo, alors cela n'a pas vraiment de sens de renommer les choses.

Si le code devrait durer longtemps et que de nouveaux développeurs y travailleront, je ferais les changements.

Il peut être très déroutant et long pour un nouveau développeur d'entrer dans un projet et de trouver que les noms d'entités sont trompeurs.

Il y a aussi l'argument valable de ... Si ce n'est pas cassé, ne le répare pas.

En ce qui concerne votre deuxième question, je n'ai connaissance d'aucune étude ou meilleure pratique publiée. En ce qui concerne la première question, je peux offrir quelques observations de l'expérience personnelle avec un produit similaire à longue durée de vie où les noms «internes» et «externes» sont parfois différents.

Les noms que je voudrais vraiment fixer sont les «homophones», où un nom est utilisé à la fois en interne et en externe pour différentes choses. Cela peut être vraiment déroutant, surtout si les deux choses ne sont pas complètement différentes (de sorte que le contexte aide à lever l'ambiguïté). Un exemple (abstrait) de cela dans mon expérience personnelle est où en interne vous avez quelque chose comme un Fooqui est une collection de multiples FooEntity; extérieurement, seul ce dernier est visible et est appelé «Foo». Il m'a fallu un certain temps pour comprendre que lorsque le manuel du client parlait de plusieurs «Foo», cela signifiait en fait plusieurs FooEntity(en un seul Foo), si cela vous semble toujours logique.

Deuxièmement, je voudrais corriger tous les «synonymes» où un nom externe a été utilisé en interne. Comme dans les noms de variables, des parties de noms de méthodes / fonctions, etc. Cela se produit souvent lorsque les développeurs implémentent quelque chose directement à partir d'une description des exigences du client et oublient de «traduire» les noms. Une fois que cela se produit, le «mauvais» nom a également tendance à se répandre, car d'autres développeurs copient / collent une partie de ce code pour l'utiliser comme modèle pour le nouveau code par exemple. Ces synonymes ne sont pas si déroutants, mais ils peuvent être gênants car si vous recherchez des références dans le code, Barvous devrez peut-être garder à l'esprit que certaines parties peuvent y faire référence commeQux, vous devez donc effectuer deux recherches. (Cela peut être pire dans les langages typés dynamiquement que dans les langages statiques, car vous devez rechercher sur des parties du nom des variables / fonctions / ... plutôt que sur le nom de leur type.) Comme pour le cas inverse des «synonymes », Où un nom interne a été utilisé en externe: cela a tendance à ne pas se produire aussi souvent, car les employés du service client, etc. sont généralement moins conscients des noms internes, bien que je suppose que cela prête à confusion pour les clients quand cela se produit.

Si vous pouvez éviter ou corriger au moins les deux situations ci-dessus, je ne sais pas si vous devriez aller jusqu'à faire en sorte que tous les noms internes soient les mêmes que les noms externes. Il y a probablement une bonne raison pour laquelle les noms internes n'ont pas été également modifiés lorsque le nom externe a été différent de celui interne en premier lieu. D'après mon expérience personnelle, cette bonne raison est la nécessité de prendre en charge les anciennes versions du produit; il peut devenir difficile de fusionner un correctif de bogue d'une version avant le nettoyage des noms à la version la plus récente si beaucoup de code doit être modifié.

C'est un problème assez courant. Un certain nombre de projets sur lesquels j'ai travaillé utilisent des noms de code au lieu de noms de produits (qui n'ont peut-être pas été décidés à ce stade), et utilisent une terminologie très différente dans le code que celle affichée pour l'utilisateur. Je laisserais probablement les choses telles quelles, à moins que vous ne subissiez une refonte massive du code ou s'il y a quelque chose de spécifique qui cause des problèmes. Inutile de bouleverser le chariot à pommes. De plus, qui dira que dans 5 ans, il n'y aura plus de changements? Et ensuite, vous devrez recommencer le changement de nom. Et n'oubliez pas, cela affecte également toute documentation de code distincte que vous pourriez avoir (API publiées), ce qui pourrait être un problème particulièrement coûteux s'il est imprimé (copie papier).

Je dis le réparer dans tous les cas où le code est destiné à être maintenu pendant une durée indéterminée. Vous économiserez probablement de la confusion et du temps à l'avenir.

Je trouve que souvent les entités "marketing" ne correspondent pas exactement aux entités internes. Dans de tels cas, il est plus logique d'introduire une entité à un niveau d'abstraction différent, ce qui fait des différences terminologiques un point discutable.

Par exemple, nous avons un modèle qui représente une hiérarchie. Chaque niveau de la hiérarchie est associé à un terme basé sur la façon dont la hiérarchie est utilisée pour modéliser les relations réelles, mais en interne, il n'y a pas de différence de comportement d'un niveau de la hiérarchie au suivant. La terminologie est essentiellement juste un nom pour ce niveau dans la hiérarchie, donc pour un nœud particulier dans l'arborescence, le nom décrit simplement ce qu'est le nœud; il ne prescrit aucun comportement particulier.

De plus, l'arborescence est à plusieurs racines, il y a donc plusieurs nœuds sans parent. Même si conceptuellement une racine existe (elle représenterait essentiellement l'univers), et l'inclure dans le modèle faciliterait de nombreuses opérations, il n'y a pas de "terme marketing" pour cela.

Bien sûr, différents composants de notre système utilisent une terminologie différente. Ils ont été développés à différents moments par différentes équipes, et nous n'avons aucun contrôle sur chacun d'eux. En fait, à un moment donné, quelqu'un a ajouté ou supprimé un niveau dans un composant, et les autres niveaux sont donc décalés les uns par rapport aux autres. Les trois mêmes niveaux sont représentés par A, B et C dans un composant, mais comme B, C et D dans un autre.

Faire un pas dans l'abstraction et simplement modéliser tout comme un «nœud» ou quelque chose de tout aussi générique rend ces types de modèles beaucoup plus faciles à raisonner. Chaque nœud sait quel est son «terme marketing» et le type qui représente un terme marketing particulier peut savoir ce que ce terme signifie dans chaque contexte.