Clean code: ottimizzare il codice per un software migliore

Quando si scrive codice per un software, un’applicazione web, mobile, videogames, ecc. è importante, in una prima fase, assicurarsi che il codice svolga bene il lavoro per cui è stato scritto.

Questo molto spesso richiede svariati ritocchi in corso d’opera, man mano che si avanza con lo sviluppo.

È però di vitale importanza ottimizzare il codice e renderlo ordinato e leggibile.

Infatti, con il procedere dello sviluppo del prodotto e con il passare del tempo si perde familiarità con il codice già scritto e dopo qualche mese, se è necessario ritoccare una funzione scritta molto tempo prima, non sempre è facile capire il codice scritto in precedenza, il perché all’ora sono state fatte determinate scelte piuttosto che altre e il funzionamento profondo del metodo, della funzione o dell’algoritmo in questione.

“Quando ho iniziato a scrivere questo codice solo io e Dio sapevamo cosa fosse. Ora lo sa solo Dio.”

Questo problema genera non pochi grattacapi nelle aziende con più collaboratori che lavorano sugli stessi progetti.

Il modo per ovviare a questo problema è spesso molto semplice e la pratica standard dovrebbe essere questa:

una volta scritto codice funzionante (testato e funzionante al 100%) è il momento, prima di andare avanti, di soffermarsi su quel codice, consolidarlo, ottimizzarlo e soprattutto riorganizzarlo in moda da renderlo ordinato e leggibile.

Questa pratica migliora non solo i tempi di sviluppo e manutenzione dei prodotti software ma anche le performance del prodotto che con un codice ottimizzato saranno decisamente migliori.

Un esempio di ottimizzazione del codice potrebbe essere quella di spostare tutto il possibile all’interno di cicli if in modo da non eseguire più operazioni del necessario, come nell’esempio che segue:

/**
 * Codice non ottimizzato
 */
$hasPermission = false;

$data = Database::getData();
if ($hasPermission) {
    return $data;
} else {
    return false;
}

/**
 * Codice ottimizzato
 */
$hasPermission = false;

if ($hasPermission) 
    return Database::getData();
return false;

In questo caso, dopo l’ottimizzazione, la funzione che prende i dati verrà eseguita solo se l’utente avrà il permesso, mentre prima dell’ottimizzazione la variabile $data veniva popolata anche nel caso l’utente non disponesse dei permessi per ottenere i dati, consumando di conseguenza molte più risorse.

Un altro esempio di miglioramento della leggibilità è dato dal corretto utilizzo dei costrutti di programmazione come, ad esempio, lo switch che potrebbe migliorare di molto la leggibilità rispetto ad una serie di if:

/**
 * Codice non leggibile
 */
$permission = 'admin';
$authorized = false;

if ($permission == 'admin') {
    $authorized = true;
} else if ($permission == 'user') {
    $authorized = false;
} else if ($permission == 'system') {
    $authorized = true;
} else {
    $authorized = false;
}

/**
 * Codice leggibile
 */
$permission = 'admin';
$authorized = false;

switch ($permission) {
    case 'admin':
        $authorized = true;
        break;
    case 'system':
        $authorized = true;
        break;
    
    default:
        $authorized = false;
        break;
}

Un’altra buona abitudine è quella di creare i cosiddetti nomi di variabile, funzioni, metodi e classi “parlanti”, ovvero che siano esplicativi del contenuto o della loro funzione, come l’esempio seguente dimostra è molto più facile comprendere il codice del secondo blocco:

/**
 * Codice scritto senza cura nei nomi
 */
class Crp {
    public int $number = 16;

    public function Ga () {
        return $this->number;
    }
    public function Ra (int $reg) {
        $this->number = $this->number - $reg;
    }
    public function Ia (int $reg) {
        $this->number = $this->number + $reg;
    }
}

/**
 * Codice scritto con variabili, metodi e classi parlanti
 */
class Human {
    public int $age = 16;

    public function GetCurrentAge () {
        return $this->age;
    }
    public function ReduceAge (int $year) {
        $this->age = $this->age - $year;
    }
    public function IncrementAge (int $year) {
        $this->age = $this->age + $year;
    }
}

La stessa cura andrebbe posta ovviamente anche nei nomi di file e cartelle del progetto, adottando una solida naming convention condivisa da tutti gli sviluppatori che vi lavorano.

Gli esempi riportati in questo articolo sono in PHP ma quanto detto vale per ogni linguaggio e ogni tipo di programmazione (desktop, web, mobile ,ecc.).

In sostanza, potremo dire che una volta scritto il codice queste sono le domande che un bravo sviluppatore dovrebbe porsi:

• Posso ottimizzare il codice a livello di performance?
• Posso migliorare i nomi di files, classi, metodi funzioni e variabili per renderli più esplicativi anche ad un collega che non conosce il contesto?
• Posso utilizzare costrutti linguistici più leggibili e/o moderni?
• Ho uniformato le spaziature?
• Ho indentato correttamente il codice per la sua interezza?
• Ho scritto commenti esplicativi per funzioni, classi e metodi che ne descrivano le funzionalità?
• Mi sono assicurato di eliminare codice vecchio, commentato, variabili e metodi/funzioni non più utilizzate?

Anche se queste prassi possono sembrare noiose e ridondanti ti assicuro che faranno davvero la differenza tra un lavoro ben fatto e un lavoro frustrante e confusionario, soprattutto nel lungo periodo.

Hai trovato questo articolo interessante?

Condividilo con i tuoi amici e colleghi programmatori!

Leggi tutti gli articoli: vai al blog.