|
Dans MIL-STD-2167A, les termes « module » et « unité » ont des significations spécifiques, bien qu'ils soient souvent utilisés de manière interchangeable dans la programmation générale. Voici la répartition :
* Module : Un module est une partie logiquement distincte d'un programme, conçue pour exécuter une fonction spécifique ou un ensemble de fonctions connexes. Il est généralement composé d'un ensemble de routines (fonctions, sous-programmes). Les modules sont conçus pour promouvoir la modularité, rendant le code plus facile à comprendre, à maintenir et à réutiliser. Considérez-le comme un élément constitutif de niveau relativement élevé dans le système logiciel. L'aspect clé d'un module est sa cohésion fonctionnelle . Toutes les pièces à l’intérieur travaillent ensemble pour effectuer une tâche définie.
* Unité : Une unité est un composant unique et testable d’un programme. Il s'agit généralement d'une routine (fonction, sous-programme) ou d'un petit ensemble de routines étroitement couplées. L'accent est mis sur la testabilité individuelle. . Les tests unitaires vérifient que chaque unité fonctionne correctement de manière isolée. Si un module ressemble à une pièce, alors une unité est un appareil individuel ou un meuble dans cette pièce.
Résumé des principales différences :
| Fonctionnalité | Module | Unité |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Objectif | Obtenez la modularité, encapsulez les fonctionnalités associées, améliorez l’organisation et la maintenabilité du code. Concentrez-vous sur une fonction à plus grande échelle ou sur un ensemble de fonctions connexes. | Facilitez les tests unitaires et vérifiez que les composants individuels fonctionnent correctement de manière isolée. Concentrez-vous sur une seule fonction ou sur un petit nombre de fonctions étroitement couplées. |
| Portée | Plus large, englobant plusieurs unités. | Plus étroit, généralement une seule routine ou un très petit ensemble de routines associées. |
| Testabilité | Peut être testé dans son ensemble, mais les tests sont souvent axés sur les tests d'intégration pour garantir que les modules fonctionnent correctement ensemble. | Conçu pour les tests unitaires indépendants. Chaque unité doit être testable sans dépendre d'autres parties du système (en utilisant des stubs ou des simulations si nécessaire). |
| Taille | Plus grand, composé de plusieurs routines et structures de données. | Plus petit, généralement une seule routine ou quelques routines étroitement liées. |
| Concentration | Décomposition fonctionnelle, cohésion et conception de haut niveau. | Détails de mise en œuvre de bas niveau, exactitude des routines individuelles et isolement. |
| Relation | Un module contient une ou plusieurs unités. Les unités sont les éléments constitutifs des modules. | Une unité est un composant *d'* un module. |
Exemple :
Imaginez un système logiciel pour contrôler un bras robotique :
* Module : Un « module de contrôle de mouvement » pourrait être chargé de contrôler les mouvements du bras du robot. Ce module peut inclure des routines pour calculer les angles des articulations, contrôler la vitesse des moteurs et gérer la trajectoire du bras.
* Unité : Une routine `calculate_inverse_kinematics()` au sein du "Motion Control Module" serait une unité. Il prendrait la position souhaitée de l'effecteur final comme entrée et calculerait les angles d'articulation requis. Cette routine serait testée unitairement pour garantir qu'elle calcule correctement les angles pour différentes positions. Une autre unité pourrait être une fonction appelée `set_motor_speed()`.
Importance dans MIL-STD-2167A :
La distinction entre modules et unités est importante dans MIL-STD-2167A car la norme met l'accent sur un processus de développement structuré, comprenant :
* Conception modulaire : La norme favorise la conception de logiciels de manière modulaire, où les fonctionnalités sont divisées en modules bien définis avec des interfaces claires. Cela facilite le développement, les tests et la maintenance.
* Tests unitaires : La norme exige des tests unitaires rigoureux pour vérifier que les composants individuels du logiciel fonctionnent correctement.
* Tests d'intégration : Après les tests unitaires, les modules sont intégrés et testés pour garantir qu'ils fonctionnent correctement ensemble.
En comprenant la différence entre les modules et les unités, les développeurs peuvent mieux adhérer aux principes de MIL-STD-2167A et produire des logiciels fiables et de haute qualité. Bien que MIL-STD-2167A soit une norme plus ancienne, ses principes de modularité et de tests unitaires restent pertinents dans les pratiques modernes de développement de logiciels.
|
