Come posso definire e misurare la semplicità nel codice?

Ci sono molte risposte nella mia precedente domanda sulla semplicità relative alla leggibilità che mi hanno aiutato a vedere la mia definizione e comprensione della semplicità nel codice era, molto probabilmente, errata.

Come posso definire la semplicità nel codice? Quali misure e metriche software sono disponibili per misurare la semplicità del codice?

Le metriche più comuni per misurare la complessità (o semplicità, se si considera la semplicità l'opposto della complessità) sono la complessità ciclomatica di McCabe e le metriche della complessità di Halstead .

La complessità ciclomatica misura il numero di percorsi distinti attraverso una data unità, generalmente un metodo o una funzione, sebbene possa anche essere calcolata su una classe. Con l'aumentare del numero di percorsi, diventa più difficile ricordare il flusso di dati attraverso un determinato modulo, che è correlato al concetto di memoria di lavoro . Un'elevata complessità ciclomatica tende a indicare difficoltà nella capacità di testare un modulo: sono necessari più casi di test per coprire i vari percorsi attraverso il sistema. Ci sono stati anche studi che hanno collegato un'elevata complessità ciclomatica a tassi di difetti elevati. Tipicamente, una complessità ciclomatica di 10 indica che un'unità deve essere rivista e possibilmente refactored.

Le misure di complessità di Halstead utilizzano gli input di operatori e operandi totali e distinti per calcolare il volume, la difficoltà e lo sforzo di un pezzo di codice. La difficoltà, che è il (numero di operatori unici / 2) * (numero totale di operandi / numero di operandi unici), è legata alla capacità di leggere e comprendere il codice per attività come l'apprendimento del sistema o l'esecuzione di una revisione del codice. Ancora una volta, puoi contare questo a livello di sistema, a livello di classe o a livello di metodo / funzione. Ci sono alcuni post sul calcolo di queste misurazioni qui e qui .

Il semplice conteggio delle righe di codice può anche darti un'idea di complessità. Più righe di codice significano che c'è più da leggere e comprendere in un modulo. Sarei titubante nell'usarlo come misura autonoma. Invece, lo userei con altre misurazioni, come il numero di difetti in un dato modulo per ottenere la densità dei difetti. Un'alta densità di difetti potrebbe indicare problemi nella scrittura dei test e nell'esecuzione delle revisioni del codice, che possono essere o meno causati da codice complesso.

Fan-in e fan-out sono altre due metriche, correlate al flusso di dati. Come definito qui , fan in è la somma delle procedure chiamate, i parametri letti e le variabili globali lette e fan out è la somma delle procedure che chiamano una determinata procedura, parametri scritti in (esposti agli utenti esterni, passati per riferimento), e variabili globali scritte. Ancora una volta, un alto fan-in e fan-out potrebbero essere indicativi di un modulo che potrebbe essere difficile da capire.

In paradigmi specifici, potrebbero esserci anche altre misure o metriche utili. Ad esempio, nel mondo orientato agli oggetti, il monitoraggio dell'accoppiamento (desiderio basso), della coesione (desiderio alto) e della profondità dell'eredità (desiderio basso) può essere utilizzato per valutare quanto sia semplice o complicato un sistema.

Naturalmente, è importante rendersi conto che molte misure e metriche sono semplicemente indicatori. Devi usare il tuo giudizio per determinare se è necessario refactoring per aumentare la semplicità o se non vale la pena farlo. È possibile effettuare le misurazioni, calcolare le metriche e conoscere il codice, ma non si desidera progettare il sistema in base ai numeri. Alla fine, fai ciò che ha senso.

Invece di guardare un modo formale per definire la semplicità, preferirei definire la semplicità come un attributo della qualità della scrittura del codice.

Non sto mettendo un po 'di semplicità ma quando chiami qualcosa di semplice o no.

1. Code Traversal:
quanto è facile navigare nel codice? È facile individuare dove sono scritte le funzioni API? È facile capire i flussi di chiamate, ad esempio quali metodi chiamano gli altri (e perché) - ci sono macchine a stato buono implementate o algoritmi ben identificati?

Quando l'attraversamento del codice è semplice, il codice è semplice da seguire.

2. Denominazione
Mentre altri standard di codifica aiutano a rendere il codice più pulito, la cosa più importante è la denominazione di classi / istanze di oggetto / variabili / metodi. L' uso di nomi chiari e inequivocabili ha chiaramente un grande impatto sulla semplicità del codice. Quando è difficile identificare un nome semplice, è un segno che potresti voler ripensare l'idea che sia quella variabile / metodo.

3. Interpretazione e riferimenti
Ognuno dei tuoi metodi ha un ruolo chiaro da svolgere. Ogni variabile / attributo è facile da determinare il ruolo che stanno giocando? Quando un pezzo di codice fa qualcosa che implica presupposti o influisce su un insieme di variabili non correlate, può diventare un incubo per la manutenzione.

4. Dipendenza o accoppiamento
Questo è difficile da giudicare solo guardando il codice, ma diventa molto evidente se qualcuno cerca di correggere i tuoi bug. Quando alcune altre cose cambiano in qualche altro oggetto, l'operazione qui cambia? Questi cambiamenti sono evidenti? Hai bisogno di cambiare l'API così spesso per ospitare cose. Questi suggeriscono che le relazioni intermodule non sono semplici

5. Input Utente o Applicazioni
Finalmente quanto sono semplici gli input o l'applicazione dell'utente accettati nell'API / UI? Quando più utenti / applicazioni possibili (per scopi diversi) devono darti: sono ovvi? Ci sono stati / dettagli che non sono correlati all'astrazione più alta ma continuano comunque a passare all'interfaccia?

Una semplice domanda che generalmente vorrei porre è la seguente: se invece di un programma, se avessi chiesto la stessa funzione che un essere umano avrebbe svolto, avrei riempito queste informazioni su un modulo cartaceo ? In caso contrario, non sono abbastanza semplice qui.

Non dirò che questo elenco è esaustivo, ma credo che i criteri siano quanto sia facile o difficile usare e modificare il software. È semplice.

Non sono a conoscenza di buone metriche esistenti per la semplicità del codice (ciò non significa che non esistano - solo che non li conosco). Potrei proporne alcuni, forse alcuni aiuteranno:

• Semplicità delle funzioni linguistiche utilizzate: se la lingua ha caratteristiche che potrebbero essere considerate "avanzate" e "semplici", è possibile contare il numero di occorrenze delle funzioni avanzate. Il modo in cui definisci "avanzato" potrebbe essere un po 'più soggettivo. Suppongo che qualcuno potrebbe dire che è anche come misurare la "intelligenza" di un programma. Un esempio comune: alcuni potrebbero dire che l' ?:operatore dovrebbe essere una funzionalità "avanzata", altri potrebbero non essere d'accordo. Non so quanto sia facile scrivere uno strumento in grado di verificare questo.

• Semplicità dei costrutti all'interno del programma: è possibile misurare il numero di parametri accettati da una funzione. Se hai> n % di tutte le funzioni con> m parametri, puoi scegliere di contarlo come non semplice, a seconda di come definisci n e m (forse n = 3 e m = 6?). Penso che ci siano alcuni strumenti di analisi statica che possono misurare questo - penso che JTest abbia semplicemente misurato le funzioni con parametri > m .

• Potresti provare a contare il numero di loop nidificati o strutture di controllo. Questo penso che in realtà non sia una cattiva metrica e penso che ci sia un nome per questo (non ricordo la parte superiore della mia testa). Ancora una volta, penso che ci siano strumenti (di nuovo, come JTest) che possono misurare questo, fino a un certo punto.

• Potresti provare a misurare la "rifattabilità". Se il tuo codice contiene molti pezzi di codice che potrebbero essere refactored ma non lo sono , forse potrebbe non essere semplice. Ricordo anche da quando ho lavorato con JTest che ha provato a misurare anche questo, ma ricordo che in questo caso non ero spesso d'accordo, quindi YMMV.

• Potresti provare a misurare il numero di strati tra diverse parti del tuo sistema. Ad esempio: quante diverse parti di codice toccheranno i dati che provengono da un modulo Web prima che vengano archiviati nel database? Questo potrebbe essere difficile da misurare correttamente ...