* Modulo: Un modulo è una parte logicamente distinta di un programma, progettata per eseguire una funzione specifica o un insieme di funzioni correlate. È in genere composto da un insieme di routine (funzioni, sottoprogrammi). I moduli sono progettati per promuovere la modularità, rendendo il codice più facile da comprendere, mantenere e riutilizzare. Pensalo come un elemento di costruzione di livello relativamente alto nel sistema software. L'aspetto chiave di un modulo è la sua coesione funzionale . Tutte le parti all'interno stanno lavorando insieme per eseguire un'attività definita.
* unità: Un'unità è un singolo componente verificabile di un programma. Di solito è una routine (funzione, sottoprogramma) o un piccolo insieme di routine strettamente accoppiate. L'attenzione è focalizzata su testimonianza individuale . Il test unitario verifica che ciascuna unità funziona correttamente in isolamento. Se un modulo è come una stanza, allora un'unità è un singolo elettrodomestico o mobili in quella stanza.
Differenze chiave riassunte:
| Caratteristica | Modulo | Unità |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| scopo | Raggiungere la modularità, incapsulare funzionalità correlate, migliorare l'organizzazione del codice e la manutenibilità. Concentrati su funzionalità su scala più ampia o insieme di funzioni correlate. | Facilitare i test unitari, verificare che i singoli componenti funzionino correttamente in isolamento. Concentrati su una singola funzione o un piccolo numero di funzioni strettamente accoppiate. |
| Ambito | Più ampio, che comprende più unità. | Più stretto, in genere una singola routine o una serie molto piccola di routine correlate. |
| Testabilità | Può essere testato nel suo insieme, ma i test sono spesso focalizzati sui test di integrazione per garantire che i moduli lavorino insieme correttamente. | Progettato per test unitari indipendenti. Ogni unità dovrebbe essere verificabile senza dipendere da altre parti del sistema (usando mozziconi o derche se necessario). |
| dimensione | Più grande, composto da più routine e strutture di dati. | Più piccolo, di solito una singola routine o alcune routine strettamente correlate. |
| Focus | Decomposizione funzionale, coesione e design di alto livello. | Dettagli di implementazione di basso livello, correttezza di routine individuale e isolamento. |
| relazione | Un modulo contiene una o più unità. Le unità sono i mattoni dei moduli. | Un'unità è un componente * di * un modulo. |
Esempio:
Immagina un sistema software per il controllo di un braccio robot:
* Modulo: Un "modulo di controllo del movimento" potrebbe essere responsabile del controllo dei movimenti del braccio del robot. Questo modulo potrebbe includere routine per il calcolo degli angoli articolari, il controllo delle velocità del motore e la gestione della traiettoria del braccio.
* unità: Una routine `Calculat_Inverse_KineMatics () all'interno del" modulo di controllo del movimento "sarebbe un'unità. Assumerebbe la posizione di fine effettore desiderata come input e calcolare gli angoli articolari richiesti. Questa routine verrebbe testata con unità per assicurarsi che calcola correttamente gli angoli per varie posizioni. Un'altra unità potrebbe essere una funzione chiamata `set_motor_peed ()`.
Importanza in MIL-STD-2167A:
La distinzione tra moduli e unità è importante in MIL-STD-2167A perché lo standard enfatizza un processo di sviluppo strutturato, incluso:
* Design modulare: Lo standard promuove la progettazione di software in modo modulare, in cui la funzionalità è divisa in moduli ben definiti con interfacce chiare. Ciò facilita lo sviluppo, i test e la manutenzione.
* Test unitario: Lo standard richiede rigorosi test unitari per verificare correttamente i singoli componenti della funzione del software.
* Test di integrazione: Dopo il test unitario, i moduli vengono integrati e testati per assicurarsi che lavorino correttamente.
Comprendendo la differenza tra moduli e unità, gli sviluppatori possono aderire meglio ai principi di MIL-STD-2167A e produrre software di alta qualità e affidabile. Mentre MIL-STD-2167a è uno standard più vecchio, i suoi principi di modularità e test unitari rimangono rilevanti nelle moderne pratiche di sviluppo del software.
sistemi © www.354353.com