* Module: Een module is een logisch afzonderlijk onderdeel van een programma, ontworpen om een ​​specifieke functie of een reeks gerelateerde functies uit te voeren. Het bestaat doorgaans uit een reeks routines (functies, subprogramma's). Modules zijn ontworpen om de modulariteit te bevorderen, waardoor de code gemakkelijker te begrijpen, te onderhouden en opnieuw te gebruiken is. Zie het als een bouwsteen op relatief hoog niveau in het softwaresysteem. Het belangrijkste aspect van een module is de functionele samenhang . Alle onderdelen binnenin werken samen om een ​​gedefinieerde taak uit te voeren.

* Eenheid: Een eenheid is een enkel, testbaar onderdeel van een programma. Het is meestal een routine (functie, subprogramma) of een kleine set nauw gekoppelde routines. De focus ligt op individuele testbaarheid . Bij het testen van eenheden wordt gecontroleerd of elke eenheid afzonderlijk correct functioneert. Als een module op een kamer lijkt, dan is een unit een afzonderlijk apparaat of meubelstuk in die kamer.

Belangrijkste verschillen samengevat:

| Kenmerk | module | Eenheid |

| ------------- | -------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------ |

| Doel | Bereik modulariteit, kapsel gerelateerde functionaliteit in, verbeter de code-organisatie en onderhoudbaarheid. Focus op een functie op grotere schaal of een reeks gerelateerde functies. | Vergemakkelijk het testen van eenheden, controleer of individuele componenten afzonderlijk correct werken. Focus op een enkele functie of een klein aantal nauw gekoppelde functies. |

| Reikwijdte | Breder en omvat meerdere eenheden. | Smaller, meestal een enkele routine of een zeer kleine reeks gerelateerde routines. |

| Testbaarheid | Kan in zijn geheel worden getest, maar testen is vaak gericht op integratietesten om ervoor te zorgen dat modules correct samenwerken. | Ontworpen voor onafhankelijke unit-tests. Elke eenheid moet testbaar zijn zonder afhankelijk te zijn van andere delen van het systeem (indien nodig met behulp van stubs of mocks). |

| Grootte | Groter, bestaande uit meerdere routines en datastructuren. | Kleiner, meestal een enkele routine of een paar nauw verwante routines. |

| Focus | Functionele ontbinding, samenhang en ontwerp op hoog niveau. | Implementatiedetails op laag niveau, individuele routinecorrectheid en isolatie. |

| Relatie | Een module bevat één of meerdere eenheden. Eenheden zijn de bouwstenen van modules. | Een eenheid is een onderdeel *van* een module. |

Voorbeeld:

Stel je een softwaresysteem voor voor het besturen van een robotarm:

* Module: Een "Motion Control Module" kan verantwoordelijk zijn voor het besturen van de bewegingen van de robotarm. Deze module kan routines bevatten voor het berekenen van gewrichtshoeken, het regelen van motorsnelheden en het beheren van het traject van de arm.

* Eenheid: Een `calculate_inverse_kinematics()` routine binnen de "Motion Control Module" zou een eenheid zijn. Het zou de gewenste eindeffectorpositie als invoer nemen en de vereiste gewrichtshoeken berekenen. Deze routine wordt per eenheid getest om er zeker van te zijn dat de hoeken voor verschillende posities correct worden berekend. Een andere eenheid kan een functie zijn genaamd `set_motor_speed()`.

Belang in MIL-STD-2167A:

Het onderscheid tussen modules en eenheden is belangrijk in MIL-STD-2167A omdat de standaard de nadruk legt op een gestructureerd ontwikkelingsproces, waaronder:

* Modulair ontwerp: De standaard promoot het modulair ontwerpen van software, waarbij functionaliteit is opgedeeld in goed gedefinieerde modules met duidelijke interfaces. Dit vergemakkelijkt de ontwikkeling, het testen en het onderhoud.

* Eenheidstesten: De standaard vereist rigoureuze unit-tests om te verifiëren dat individuele componenten van de software correct functioneren.

* Integratietesten: Na het testen van de units worden de modules geïntegreerd en getest om er zeker van te zijn dat ze correct samenwerken.

Door het verschil tussen modules en eenheden te begrijpen, kunnen ontwikkelaars zich beter houden aan de principes van MIL-STD-2167A en hoogwaardige, betrouwbare software produceren. Hoewel MIL-STD-2167A een oudere standaard is, blijven de principes van modulariteit en unit-testen relevant in moderne softwareontwikkelingspraktijken.