* Módulo: Un módulo es una parte lógicamente distinta de un programa, diseñada para realizar una función específica o un conjunto de funciones relacionadas. Por lo general, se compone de un conjunto de rutinas (funciones, subprogramas). Los módulos están diseñados para promover la modularidad, lo que hace que el código sea más fácil de entender, mantener y reutilizar. Piense en ello como un bloque de construcción de nivel relativamente alto en el sistema de software. El aspecto clave de un módulo es su Cohesión funcional . Todas las piezas en el interior están trabajando juntas para realizar una tarea definida.
* Unidad: Una unidad es un componente único y comprobable de un programa. Por lo general, es una rutina (función, subprograma) o un pequeño conjunto de rutinas estrechamente acopladas. El enfoque está en Testability individual . Las pruebas unitarias verifican que cada unidad funciona correctamente de forma aislada. Si un módulo es como una habitación, entonces una unidad es un aparato individual o mueble en esa habitación.
Diferencias clave resumidas:
| Característica | Módulo | Unidad |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------
| Propósito | Lograr la modularidad, encapsular la funcionalidad relacionada, mejorar la organización del código y la mantenibilidad. Centrarse en la función de mayor escala o el conjunto de funciones relacionadas. | Facilitar las pruebas unitarias, verificar que los componentes individuales funcionen correctamente de forma aislada. Concéntrese en una sola función o en un pequeño número de funciones estrechamente acopladas. |
| Alcance | Más amplio, que abarca múltiples unidades. | Más estrecho, típicamente una rutina única o un conjunto muy pequeño de rutinas relacionadas. |
| Testability | Puede probarse en su conjunto, pero las pruebas a menudo se centran en las pruebas de integración para garantizar que los módulos funcionen juntos correctamente. | Diseñado para pruebas unitarias independientes. Cada unidad debe ser probable sin depender de otras partes del sistema (usando trozos o simulacros si es necesario). |
| tamaño | Más grande, compuesto por múltiples rutinas y estructuras de datos. | Más pequeño, generalmente una sola rutina o algunas rutinas estrechamente relacionadas. |
| Focus | Descomposición funcional, cohesión y diseño de alto nivel. | Detalles de implementación de bajo nivel, corrección individual y aislamiento. |
| Relación | Un módulo contiene una o más unidades. Las unidades son los bloques de construcción de los módulos. | Una unidad es un componente * de * un módulo. |
Ejemplo:
Imagine un sistema de software para controlar un brazo de robot:
* Módulo: Un "módulo de control de movimiento" podría ser responsable de controlar los movimientos del brazo del robot. Este módulo puede incluir rutinas para calcular los ángulos de las juntas, el control de las velocidades del motor y la administración de la trayectoria del brazo.
* Unidad: Una rutina `calculado_inverse_kinematics ()` rutina dentro del "módulo de control de movimiento" sería una unidad. Tomaría la posición deseada del efector final como entrada y calcularía los ángulos de unión requeridos. Esta rutina se probará unitaria para asegurarse de que calcule correctamente los ángulos para varias posiciones. Otra unidad podría ser una función llamada `set_motor_speed ()`.
Importancia en MIL-STD-2167A:
La distinción entre módulos y unidades es importante en MIL-STD-2167A porque el estándar enfatiza un proceso de desarrollo estructurado, que incluye:
* Diseño modular: El estándar promueve el diseño del software de manera modular, donde la funcionalidad se divide en módulos bien definidos con interfaces claras. Esto facilita el desarrollo, las pruebas y el mantenimiento.
* Prueba unitaria: El estándar requiere pruebas unitarias rigurosas para verificar que los componentes individuales del software funcionen correctamente.
* Prueba de integración: Después de la prueba unitaria, los módulos se integran y se prueban para garantizar que funcionen juntos correctamente.
Al comprender la diferencia entre módulos y unidades, los desarrolladores pueden adherirse mejor a los principios de MIL-STD-2167A y producir un software confiable de alta calidad. Si bien MIL-STD-2167A es un estándar más antiguo, sus principios de modularidad y pruebas unitarias siguen siendo relevantes en las prácticas modernas de desarrollo de software.