Il refactoring svolge un ruolo fondamentale nella creazione e nella manutenzione di un codice di alta qualità. Questo processo di miglioramento graduale mira a eliminare i cosiddetti “code smells”, che sono indicatori di potenziali problemi nel design e nella struttura del codice. Analizziamo più da vicino alcuni dei code smells più comuni e le pratiche di refactoring associate.
Caratteristiche di un Clean Code:
1. Semplicità
La semplicità è alla base di un codice di qualità. Un codice semplice è più facile da leggere, comprendere e mantenere nel tempo, inoltre un design chiaro e diretto facilita la collaborazione tra membri del team e contribuisce alla manutenibilità complessiva del software.
2. Eliminazione delle duplicazioni
Le duplicazioni nel codice sono fonte di potenziali errori e complicano la manutenzione, è necessario identificare e rimuovere il codice duplicato attraverso l’uso di funzioni o classi riutilizzabili contribuisce a rendere il codice più pulito e snello.
3. Assenza di codice superfluo
Un codice efficiente evita elementi inutili o non necessari. L’eliminazione di codice superfluo non solo semplifica la comprensione ma migliora anche le prestazioni e la gestibilità del sistema.
4. Pressione da parte del business
Il codice dovrebbe rispecchiare chiaramente le esigenze del business. Comprendere appieno i requisiti del cliente e tradurli in codice intuitivo è essenziale per la riuscita del progetto ma la pressione che il business può fare al reparto tecnico o agli sviluppatori può essere la causa di un progetto con molti errori.
5. Gestione consapevole del debito tecnico
Essere consapevoli del debito tecnico è il primo passo per gestirlo. Il refactoring dovrebbe essere parte integrante dello sviluppo per affrontare gradualmente le aree problematiche e mantenere il codice in uno stato robusto nel tempo.
6. Test e documentazione
Il codice deve essere ampiamente testato per garantire stabilità e affidabilità inoltre la documentazione chiara fornisce un contesto essenziale per comprendere e mantenere il codice nel tempo.
Principali “Code Smells”:
1. Metodi lunghi
Metodi estesi possono essere difficili da leggere e comprendere tuttavia scomporre metodi lunghi in unità più piccole migliora la leggibilità e facilita la manutenzione.
double calculatePriceAndPayTaxes() {
double basePrice = quantity * itemPrice;
//Apply discount
if(user.equals(userWithPrivileges)) {
if (basePrice > 1000) {
basePrice = basePrice * 0.80;
}
else {
basePrice = basePrice * 0.90;
}
}
//Pay taxes
for(int i = 0; i < quantity; i++) {
//Call provider taxes
//send payment
//it could take several code lines
//finish send taxes
}
return basePrice;
}Code language: JavaScript (javascript)2. Classi enormi
Classi troppo grandi diventano complesse e difficili da gestire, al contrario la scomposizione in classi più piccole con responsabilità specifiche migliora la modularità del sistema.
package it.peduz.badcode.bloaters.largeclass.badcode;
public class LargeClass {
/*
* Class example for handling housework
*/
public void cookFirstPlate() {
//...
}
public void cookMainPlate() {
//...
}
public void cleanWithVacuum() {
//...
}
public void cleanWashingFloor() {
//...
}
public void gardening() {
//...
}
public void makeShopping() {
//...
}
}
Code language: PHP (php)3. Lunga lista di parametri
Limitare il numero di parametri di una funzione migliora la chiarezza e la manutenibilità del codice. L’uso di oggetti di trasporto o la riduzione delle dipendenze sono strategie comuni in questo contesto.
public class LongParameterList {
public void executeUpdate(String name, String secondName, String lastName, String dadName,
String motherName, String placeOfBirth, String gender, Date dateOfBirth) {
//...business logic
}
}Code language: JavaScript (javascript)4. Object Oriented Abusers
Evitare implementazioni errate di concetti orientati agli oggetti è fondamentale. Campi temporanei, eccessi di strutture di controllo, eccesso di ereditarietà e classi alternative con interfacce diverse sono “code smells” che richiedono attenzione.
public List<Object> elaborateData() {
data = new ArrayList<>();
if(hasValue1 && !hasValue2 || value1 > 1000) {
if(!hasValue2) {
//...
} else if(value1 > 1000) {
//....
}
} else if(thing1 == null && thing2 != null) {
if(hasValue1) {
//...
} else if(hasValue2) {
//...
} else if(value1 > 100) {
//...
} else if(value2 < value1) {
//...
} else {
//....
}
} else if(thing2 == null) {
if(hasValue1) {
//...
} else if(hasValue2) {
//...
} else if(value1 < 100) {
//...
} else if(value2 > value1) {
//...
} else {
//....
}
} else {
if(hasValue1) {
//...
} else if(hasValue2) {
//...
} else if(value1 < 100) {
//...
} else if(value2 > value1) {
//...
} else {
//....
}
}
return data;
}Code language: PHP (php)5. Cambiamento divergente
Strutturare il codice in modo da limitare l’impatto delle modifiche richieste in punti specifici migliora la flessibilità del sistema.
6. Dispensabilità
Eliminare il codice duplicato, il codice morto e le generalità speculative migliora l’efficienza del sistema e facilita la comprensione.
7. Accoppiamento
Risolvere “code smells” come feature envy, inappropriate intimacy e message chain riduce il forte accoppiamento tra le classi, semplificando la manutenzione e l’evoluzione del sistema.
In conclusione, il refactoring è una scelta necessaria nello sviluppo del software che contiene “code smells”; utilizzare buone pratiche di programmazione contribuisce a ottenere un codice robusto, flessibile e facilmente mantenibile nel tempo. Come artigiani del software, siamo chiamati a coltivare l’attenzione per la qualità e la dedizione al miglioramento continuo.
Ricordiamoci che un codice pulito è un investimento nel successo a lungo termine dei nostri progetti
Articolo consigliato: Angular Control Flow, la guida completa
