Comment savoir si un logiciel est fortement couplé?

Je connais le terme «hautement couplé», mais je suis curieux de savoir s'il existe des signes (odeurs de code) qui peuvent indiquer que le code est fortement couplé. Je travaille actuellement avec Java EE mais cela peut s'appliquer à n'importe quel langage.

Éditer:

Si quelqu'un est intéressé, cet article semble utile: à la recherche de la qualité du code: méfiez-vous du couple serré! (IBM)

À mon avis, l'indicateur numéro un des modules mal couplés est la dépendance bilatérale. Par exemple, Module1 appelle une fonction dans Module2 et Module2 appelle une fonction dans Module1.

La plupart des interfaces doivent être unidirectionnelles. Si le module qui a été appelé doit transmettre au module appelant des informations qui ne sont pas renvoyées dans le cadre de l'appel, il doit utiliser une sorte de mécanisme de transmission de messages ou de déclenchement d'événements, comme une file d'attente de messages. Idéalement, le descripteur de l'interface de transmission des messages doit être transmis au cours d'un processus d'initialisation ou d'enregistrement. Cela résume complètement l'interface de telle manière que le module ne se soucie pas vraiment de qui est l'événement ... donc il est découplé.

Une autre indication est lorsqu'un module appelle constamment un autre module pour un ensemble de données spécifique. Cela devrait vous amener à vous demander à qui devrait appartenir l'ensemble de données. Pourquoi ce module en question a-t-il toujours besoin de voir les données qui appartiennent à un autre module?

Un troisième outil pour ainsi dire est de vous demander: «Puis-je retirer ce module et le remplacer sans nécessiter de modification des autres modules.

Ce n'est en aucun cas une liste exhaustive, mais ce sont les trois principales choses que je me pose lors de la conception de logiciels.

Le vieil adage dit: "Vous pouvez toucher vos amis et vous pouvez toucher vos soldats. Mais vous ne pouvez pas toucher vos amis." C'est le couplage en bref.

Les signes de code fortement couplé incluent de très grandes interfaces qui permettent aux gens de connaître les détails privés de l'implémentation et les objets qui semblent "se connaître beaucoup les uns les autres". Il existe des outils d'analyse automatique qui signaleront le code qui vous semble étroitement couplé. Voir http://www.scitools.com/features/metricsintro.php pour un aléatoire. (Je ne sais pas à quel point cela fonctionne. Il s'est avéré assez élevé dans une recherche Google.)

Essayez d'écrire des tests unitaires pour les classes. Si vous ne pouvez pas facilement tester des classes sans avoir besoin de créer / simuler des charges de classes de support ou un db / ui, c'est un signe certain de mauvais couplage / dépendances.

C'est aussi l'un des meilleurs remèdes, mais vous devez le faire pendant le codage (comme TDD) pour rester honnête.

Le signe évident pour moi est que tout est public.

L'autre signe est la violation de la loi de Demeter - références excessives à this.SomeObj.SomeProp.SomeProp sur les interfaces non fluentes.

J'ai vu une fois ce que j'ai depuis surnommé une "classe de marionnettiste" qui a créé un formulaire de saisie de données à la volée. Il avait plusieurs autres violations de conception de logiciels, donc un couplage excessif était le moindre de ses soucis.

Quand il a récupéré des données des contrôles qu'il a créés, il l'a fait comme ceci:

var control = activeDataEntryControl as CustomTextBox;
if (control != null)
   result = control.NestedTextBox.Text;

/* several other controls */

L' effet d'entraînement .

Chaque changement a un effet d'entraînement sur tous les modules étroitement couplés.

Le principe "Open-Closed" a été violé en ce qu'il n'est pas correctement fermé et change les fuites.

Vérifiez le nombre de # include / imports etc. entre les classes / packages / dlls / jars / whatnots. Essayez de dessiner un graphique de cela, mentalement, manuellement ou en utilisant une sorte d'outil.

• Si ce graphique est dense (c'est-à-dire de nombreuses connexions partout), votre système est monolithique et fortement couplé.
• S'il est clairement divisé en couches, sans connexion à travers / en couches et que les connexions sont peu nombreuses, vous avez un système modulaire et découplé.

Si vous trouvez impossible d'implémenter une fonctionnalité parce que vous ne savez pas où va une responsabilité spécifique, alors votre système est trop étroitement couplé.

Pour des signes très basiques, vous pouvez envisager de regarder le nombre d'interfaces et leur utilisation entre les classes de différents packages (généralement le code à couplage lâche contient des interfaces et il y a une interaction directe limitée entre les classes individuelles dans différents packages), le nombre de noms de classe qui peuvent être utilisé pour regrouper d'autres classes (dans le code à couplage lâche, l'interaction réelle entre les classes qui ont des tâches différentes est effectuée par des fonctions d'interface ou par des fonctions de classes plus communes / de regroupement) ou pour numéroter des variables publiques à l'intérieur des classes (plus librement beaucoup moins / même aucune variable publique ).

Presque toutes les odeurs de code indiquent un couplage superflu d'une certaine manière. Je suppose que l'odeur qui indiquerait le plus le couplage pourrait être "l'intimité inappropriée" (mon odeur préférée).

Je suppose qu'une autre méthode raisonnable pour mesurer serait de compter les lignes de votre diagramme UML. Si vous avez N objets et N ^ N (ou plusieurs) lignes entre eux, alors votre code est à peu près couplé au maximum. N lignes seraient probablement aussi minimes que possible.