Valutare la Complessità del Codice: Ciclomato vs. Cognitivo

Capire il Codice è fondamentale per i programmatori. Quando i dev modificano o sistemano il codice, devono capirlo bene. Se il codice non è facile da leggere, possono sorgere errori e ci vuole più sforzo per scriverlo e mantenerlo. Idealmente, i dev dovrebbero scrivere codice chiaro che sia facile da capire senza faticare troppo.

#Obiettivo

Questo pezzo esplora se due misure di complessità, la Complessità Ciclomatica e la Complessità Cognitiva, possano aiutare a prevedere quanto i programmatori trovino comprensibile il codice. L'obiettivo è capire quale delle due sia migliore per valutare la chiarezza del codice.

#Metodo

Per scoprirlo, abbiamo condotto uno studio coinvolgendo 216 programmatori junior. Questi dev avevano da uno a quattro anni di esperienza nel coding. Hanno esaminato 12 classi Java che variavano nella loro complessità, utilizzando sia misure di Complessità Ciclomatica che Cognitiva.

#Risultati

La Complessità Cognitiva si è rivelata leggermente migliore della Complessità Ciclomatica nel prevedere quanto i programmatori trovassero comprensibile il codice.

#Conclusione

Questa indagine mostra che trovare una misura solida per la complessità del codice è ancora una sfida. Né la tradizionale Complessità Ciclomatica né la più recente Complessità Cognitiva funzionano come predittori affidabili della Comprensibilità del codice, almeno per i programmatori junior.

#Comprensibilità del Codice

La comprensibilità del codice si riferisce a quanto bene i programmatori possono leggere e lavorare con il codice. Questo include sia il codice che hanno scritto sia quello scritto da altri. Più il codice è facile da leggere, più è facile trovare e risolvere problemi, fare modifiche e aggiungere nuove funzionalità. Dall'altra parte, un codice difficile da leggere può creare confusione, causare errori e portare a lunghi problemi di troubleshooting.

Vari fattori contribuiscono alla Leggibilità del codice. Questo include:

• Sintassi chiara e semplice
• Formattazione coerente
• Convenzioni di denominazione
• Struttura del codice ben organizzata
• Buona documentazione e commenti

Quando il codice è difficile da capire, può aumentare lo sforzo necessario per lavorarci di oltre il 50%. Anche le male interpretazioni possono interrompere l'intero processo di sviluppo. Quindi, i dev dovrebbero puntare a scrivere codice che sia facile da comprendere.

Sono state proposte diverse metriche per valutare la complessità del codice, tra cui la Complessità Ciclomatica e Cognitiva. Oggi, molti strumenti consentono ai programmatori di monitorare queste metriche in tempo reale.

La Complessità Cognitiva è stata aggiunta da SonarQube come modo per comprendere meglio la leggibilità del codice. Studi precedenti hanno evidenziato che la Complessità Cognitiva potrebbe indicare comprensibilità, con valori più alti che suggeriscono minore comprensibilità. Tuttavia, non hanno considerato come i programmatori percepiscono la complessità, che riteniamo sia essenziale.

Le ricerche precedenti hanno anche sottolineato che le metriche di complessità e comprensibilità non sono state ben studiate e validate. Le metriche esatte che prevedono la comprensibilità del codice non sono ancora chiare.

#Misure di Complessità

In questa sezione, delineeremo brevemente le due misure di complessità che abbiamo studiato.

#Complessità Ciclomatica

La Complessità Ciclomatica è una metrica creata nel 1976. Misura quanti percorsi indipendenti esistono nel codice di un programma. L'idea è che più percorsi indipendenti indicano maggiore complessità. Questa misura si basa su un grafo di flusso di controllo, che rappresenta i percorsi di esecuzione nel codice. Ogni percorso si pensa aggiunga complessità.

Pur essendo ampiamente utilizzata, la Complessità Ciclomatica non affronta tutti i problemi di codice, specialmente in scenari complessi. Ha difficoltà con le condizioni nidificate e i cicli. Anche se è una misura comune per valutare la propensione agli errori di un codice, non è molto efficace per capire la chiarezza del codice.

In strumenti come SonarQube, la Complessità Ciclomatica aumenta con ogni punto decisionale in un pezzo di codice, ma il modo in cui viene calcolata può variare leggermente tra i linguaggi di programmazione.

#Complessità Cognitiva

La Complessità Cognitiva guarda all'aspetto umano della comprensione del codice. Non tutti i punti decisionali in un programma sono uguali; alcuni sono più facili da capire di altri. Questa misura assegna pesi ai punti decisionali in base alla loro difficoltà. Decisioni più complesse ricevono pesi più alti.

La Complessità Cognitiva è stata creata per affrontare alcuni problemi con la Complessità Ciclomatica. Mira a fornire una migliore comprensione di quanto sia davvero complesso un pezzo di codice considerando lo sforzo mentale necessario per capirlo.

Le regole per calcolare la Complessità Cognitiva includono:

• Ignorare le strutture che semplificano il codice, consentendo una lettura più facile.
• Aggiungere complessità quando il flusso del codice è interrotto.
• Tenere conto di quanto siano profondamente nidificate le strutture di controllo.

#Lo Studio Empirico

Il nostro studio mirava a confrontare la Complessità Ciclomatica e Cognitiva per vedere quale riflette meglio come i programmatori percepiscono la complessità del codice Java. Ecco i passaggi coinvolti:

#Selezione del Codice

Abbiamo scelto classi Java che contenevano vari problemi che influenzavano la comprensibilità. Un gruppo di valutatori ha identificato le classi con problemi su cui tutti concordavano.

#Misurazione della Complessità

Abbiamo calcolato la Complessità Ciclomatica e Cognitiva di queste classi utilizzando SonarQube.

#Selezione dei Programmatori

I programmatori junior sono stati selezionati come partecipanti perché sono spesso quelli che devono affrontare codice sconosciuto. Abbiamo coinvolto 216 programmatori junior familiari con Java, tutti con almeno un anno di esperienza nel coding.

#Ispezione del Codice

I partecipanti hanno ispezionato manualmente le classi per valutare quanto fosse comprensibile il codice. Hanno compilato un questionario diviso in quattro sezioni:

• Background del rispondente, incluso il loro livello di esperienza.
• Ispezione del codice dove hanno valutato la comprensibilità su una scala da 1 a 5 (1 molto facile e 5 molto difficile).
• Identificazione dei problemi nel codice e la loro gravità percepita, anche valutata su una scala da 1 a 5.

#Analisi dei Dati

I dati raccolti sono stati analizzati osservando come i programmatori hanno valutato la comprensibilità del codice. Le correlazioni tra la comprensibilità percepita e le due misure di complessità sono state esaminate utilizzando metodi statistici.

#Risultati

Abbiamo raccolto dati da 216 partecipanti. La maggior parte di loro ha valutato la maggior parte delle classi come né facili né difficili da capire.

La Complessità Cognitiva sembrava essere un indicatore migliore della comprensibilità del codice. I programmatori concordavano perlopiù sulla sua utilità rispetto alla Complessità Ciclomatica. Quando le classi erano meno complesse, venivano considerate più facili da capire, sostenendo l'idea che una bassa complessità porti a una migliore leggibilità. Tuttavia, alti livelli di complessità portavano a opinioni variegate sulla comprensibilità.

L'analisi statistica ha rivelato risultati significativi, indicando che la Complessità Cognitiva si correla meglio con le percezioni dei programmatori rispetto alla Complessità Ciclomatica.

#Identificazione dei Problemi e Severità

Lo studio ha anche riguardato se i programmatori potessero identificare i problemi di coding nelle classi. La maggior parte dei partecipanti ha identificato correttamente almeno un problema, suggerendo che i programmatori notano problemi di design quando guardano il codice.

Per quanto riguarda la severità percepita dei problemi identificati, i programmatori li hanno valutati come almeno di gravità media in media. Questo significa che i programmatori prendevano sul serio i problemi che trovavano.

#Minacce alla Validità

Sono state considerate diverse minacce alla validità dello studio:

#Validità Costruttiva

Abbiamo selezionato con cura i compiti per garantire che le classi analizzate provenissero dallo stesso strumento, prevenendo malintesi su come venivano percepite le complessità.

#Validità Interna

La selezione di programmatori junior mirava a mantenere lo studio focalizzato. Tuttavia, questo potrebbe introdurre bias, poiché quei programmatori potrebbero avere livelli di formazione variabili.

#Validità Esterna

La generalizzabilità dei risultati può essere una preoccupazione poiché lo studio ha utilizzato un set specifico di classi. Potrebbero servire ulteriori studi con contesti di coding diversi per conclusioni più ampie.

#Validità della Conclusione

Il design dello studio mirava a garantire che i compiti fossero strettamente correlati agli esiti osservati, e sono state condotte valutazioni esperte per confermare la validità dei sondaggi.

#Lavoro Futuro

Studi futuri potrebbero coinvolgere un gruppo più ampio di programmatori e chiedere loro di suggerire azioni di refactoring per affrontare i problemi. Inoltre, confrontare le percezioni della comprensibilità del codice tra programmatori junior e senior potrebbe fornire ulteriori spunti. Potrebbero anche essere esplorati altri linguaggi di programmazione per vedere se queste tendenze si confermano in diversi ambienti di coding.

#Considerazioni Finali

Capire come i programmatori percepiscono la complessità del codice è essenziale. Anche se né la Complessità Ciclomatica né quella Cognitiva hanno fornito indicatori perfetti della comprensibilità del codice, la Complessità Cognitiva ha mostrato delle potenzialità. Man mano che le pratiche di sviluppo evolvono, ulteriori ricerche continueranno a raffinare la nostra comprensione di cosa renda il codice chiaro e facile da lavorare.