I MIL-STD-2167A har termerna "modul" och "enhet" specifika betydelser, även om de ofta används omväxlande i allmän programmering. Här är uppdelningen:
* Modul: En modul är en logiskt distinkt del av ett program, utformat för att utföra en specifik funktion eller uppsättning relaterade funktioner. Det består vanligtvis av en uppsättning rutiner (funktioner, underprogram). Moduler är utformade för att främja modularitet, vilket gör koden lättare att förstå, underhålla och återanvända. Tänk på det som en relativt hög nivå byggsten i mjukvarusystemet. Den viktigaste aspekten av en modul är dess funktionella sammanhållning . Alla delar inuti arbetar tillsammans för att utföra en definierad uppgift.
* Enhet: En enhet är en enda, testbar komponent i ett program. Det är vanligtvis en rutin (funktion, underprogram) eller en liten uppsättning tätt kopplade rutiner. Fokus ligger på Individuell testbarhet . Enhetstest verifierar att varje enhet fungerar korrekt isolerat. Om en modul är som ett rum, är en enhet en enskild apparat eller möbler i det rummet.
Nyckelskillnader sammanfattade:
| Funktion | Modul | Enhet |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syfte | Uppnå modularitet, kapsla in relaterad funktionalitet, förbättra kodorganisationen och underhållbarhet. Fokusera på större funktion eller uppsättning relaterade funktioner. | Underlätta enhetstestning, verifiera att enskilda komponenter fungerar korrekt isolerat. Fokusera på en enda funktion eller ett litet antal tätt kopplade funktioner. |
| räckvidd | Bredare, omfattar flera enheter. | Smalare, vanligtvis en enda rutin eller mycket liten uppsättning relaterade rutiner. |
| Testabilitet | Kan testas som en helhet, men testning är ofta inriktad på integrationstest för att säkerställa att moduler fungerar korrekt. | Designad för oberoende enhetstestning. Varje enhet ska vara testbar utan att bero på andra delar av systemet (med hjälp av stubbar eller håna vid behov). |
| storlek | Större, bestående av flera rutiner och datastrukturer. | Mindre, vanligtvis en enda rutin eller några nära besläktade rutiner. |
| fokus | Funktionell nedbrytning, sammanhållning och design på hög nivå. | Implementeringsdetaljer på låg nivå, individuell rutinmässig korrekthet och isolering. |
| relation | En modul innehåller en eller flera enheter. Enheter är byggstenarna för moduler. | En enhet är en komponent * av * en modul. |
Exempel:
Föreställ dig ett mjukvarusystem för att kontrollera en robotarm:
* Modul: En "rörelsekontrollmodul" kan vara ansvarig för att kontrollera robotarmens rörelser. Denna modul kan innehålla rutiner för att beräkna ledvinklar, styra motorhastigheter och hantera armens bana.
* Enhet: En "calculate_inverse_kinematics ()" rutin inom "rörelsekontrollmodulen" skulle vara en enhet. Det skulle ta den önskade sluteffektorpositionen som inmatning och beräkna de nödvändiga fogvinklarna. Denna rutin skulle testas enhet för att säkerställa att den korrekt beräknar vinklarna för olika positioner. En annan enhet kan vara en funktion som kallas `set_motor_speed ()`.
Vikt i MIL-STD-2167A:
Skillnaden mellan moduler och enheter är viktig i MIL-STD-2167A eftersom standarden betonar en strukturerad utvecklingsprocess, inklusive:
* Modulär design: Standarden främjar designprogramvara på ett modulärt sätt, där funktionalitet är uppdelad i väl definierade moduler med tydliga gränssnitt. Detta underlättar utveckling, testning och underhåll.
* Enhetstestning: Standarden kräver rigorös enhetstest för att verifiera att enskilda komponenter i programvaran fungerar korrekt.
* Integrationstestning: Efter enhetstestning integreras och testas moduler för att säkerställa att de fungerar korrekt.
Genom att förstå skillnaden mellan moduler och enheter kan utvecklare bättre följa principerna för MIL-STD-2167A och producera högkvalitativ, tillförlitlig programvara. Medan MIL-STD-2167A är en äldre standard, förblir dess principer för modularitet och enhetstest relevant i moderna mjukvaruutvecklingspraxis.
