Clean Code: verifica di un codice di programmazione pulito

Il Clean Code risale a Robert Cecil Martin, un consulente informatico, che nel suo libro “Clean Code: guida per diventare bravi artigiani nello sviluppo agile di software” (disponibile in inglese con il titolo di “Clean Code: A Handbook of Agile Software Craftsmanship”) lo ha utilizzato come termine per definire un codice pulito. I principi del Clean Code però hanno una storia ancora più lunga e le sue origini non sono a dire il vero legate allo sviluppo di software. Di seguito vi spiegheremo cosa rende i codici puliti, quali sono i vantaggi e come fare per scriverli in autonomia.

Cos’è il Clean Code?

Il Clean Code non è un rigido insieme di regole, definisce invece una serie di principi che consentono di realizzare un codice comprensibile in modo intuitivo e facile da modificare. Comprensibile significa in questo caso che il codice è chiaro fin da subito per uno sviluppatore. Le seguenti proprietà semplificano la leggibilità del Clean Code:

  • Il thread di esecuzione dell’intera applicazione è strutturato in maniera semplice e ordinata.
  • La correlazione tra le diverse parti del codice è evidente.
  • Il compito o ruolo di ciascuna classe, funzione, metodo e variabile è comprensibile immediatamente.

Inoltre, il codice è facilmente modificabile quando deve solamente essere adattato o ampliato, in questo modo è anche più semplice eliminare un errore all’interno del codice. Per questo motivo il Clean Code è veramente di facile manutenzione. Un codice semplice da modificare ha le seguenti caratteristiche:

  • Le classi e i metodi sono ridotti e possibilmente hanno un solo compito ben preciso.
  • Le classi e i metodi sono prevedibili, funzionano come ci si aspetterebbe e sono accessibili pubblicamente tramite API (interfacce) ben documentate.
  • Il codice dispone di unit test.

I vantaggi di questo tipo di programmazione sono evidenti: il Clean Code è indipendente dallo sviluppatore originario. Quindi, in linea di principio, ogni programmatore può lavorare con il codice, in questo modo vengono evitati i problemi che potrebbero, ad esempio, sorgere utilizzando un Legacy Code. Anche la manutenzione del software risulta semplificata, perché in questo modo i bug vengono identificati e rimossi più facilmente.

Spiegazione sintetica dei principi del Clean Code

Ma come si fa a scrivere un codice pulito? Nel Clean Code vanno tenuti presenti determinati principi guida della programmazione. Non si tratta tanto di concrete istruzioni su cosa e come programmare in una determinata situazione, ma piuttosto di dare uno sguardo che rimanda alla propria esperienza di lavoro sul campo come sviluppatore. Proprio per questo nella comunità degli sviluppatori la definizione del significato concreto di Clean Code è dibattuta: quello che per alcuni programmatori è “pulito”, per altri è ancora “poco lineare”. La percezione di quanto un codice risulti pulito è quindi in parte sempre anche soggettiva. Di seguito vi proponiamo alcuni principi consolidati del Clean Code, che vengono considerati ragionevoli dalla maggior parte degli sviluppatori.

Un codice il più semplice possibile: KISS

Il KISS (Keep it simple, stupid)è uno dei primi principi del Clean Code in ordine di tempo, è stato infatti applicato dalle forze armate statunitensi negli anni ‘60. Il KISS ricorda ai programmatori di realizzare un codice che sia il più semplice possibile; qualsiasi complessità inutile andrebbe evitata. Nella programmazione non c’è mai una sola via per risolvere un problema, un compito può essere espresso in linguaggi diversi e formulato con comandi differenti. Un programmatore che segue il principio KISS deve quindi sempre chiedersi se un determinato problema potrebbe essere risolto anche in maniera più semplice.

Evitare ripetizioni inutili: DRY

DRY(Don’t repeat yourself) è in un certo senso una concretizzazione del KISS. Un Clean Code conforme al principio DRY fa in modo che una funzione abbia una sola e univoca rappresentazione all’interno dell’intero sistema.

N.B.

Il contrario di DRYè WET(We enjoy typing). Un codice viene chiamato WET quando dei doppioni inutili compaiono nel codice.

Il seguente esempio dovrebbe chiarire il principio del Clean Code: il nome utente e la password vengono richiamati due volte nel codice, per essere utilizzati per azioni diverse. Invece di programmare i due processi separatamente, questi possono essere uniti in una sola funzione. Da un codice WET con ridondanze si ottiene così un conciso codice DRY.

Codice WET:

//Variante A
let username = getUserName();
let password= getPassword();
let user = { username, password};
client.post(user).then(/*Variante A*/);

//Variante B
let username = getUserName();
let password= getPassword();
let user = { username, password};
client.get(user).then(/*Variante B*/);

Codice DRY:

function getUser(){
  return {
    user:getUserName();
    password:getPassword();
  }
}

//Variante A
client.post(getUser()).then(/*Variante A*/ );

//Variante B
client.get(getUser()).then(/*Variante B*/);

Togliere quello che non serve: YAGNI

Dietro al principio YAGNI(You aren’t gonna need it) del Clean Code si cela la seguente idea: uno sviluppatore dovrebbe inserire in un codice funzionalità aggiuntive solamente quando queste diventano necessarie. YAGNIè strettamente connesso ai metodi dello sviluppo agile dei software. Invece di partire dallo sviluppo di un progetto completo, quando si programma secondo il principio YAGNI si crea l’architettura del software a piccoli step, per poter rispondere ai problemi in maniera dinamica e mirata. Si crea quindi un Clean Code ogniqualvolta il problema di base è stato risolto nel modo più efficiente.

Leggibilità e concisione

Il codice deve funzionare ed essere comprensibile per la macchina che esegue l’operazione. Ma soprattutto nei casi in cui lavorate a un progetto con più persone, anche altri sviluppatori devono poter comprendere il codice. Per questo motivo la leggibilità nello sviluppo del codice è sempre più importante rispetto alla concisione dello stesso. Non ha senso scrivere un codice che sia molto breve, se poi gli altri sviluppatori non lo capiscono. Un buon esempio di Clean Code per quanto riguarda la leggibilità è la denominazione delle variabili.

Il nome di una variabile dovrebbe essere sempre comprensibile. La seguente variabile non è chiara senza conoscenze pregresse e una spiegazione:

int d;

Se viene invece viene rinominata come di seguito, la variabile si spiega da sé:

int elapsedTimeinDays;