Clean Code

1. Scrivi codice pulito che sia leggibile e manutenibile

L'unica misura valida della qualità del codice: WTFs/minuto

La leggibilità è fondamentale. Il codice pulito deve essere facilmente comprensibile da altri sviluppatori. Deve essere semplice, elegante e privo di disordine. Sforzati di scrivere codice che esprima chiaramente la sua intenzione senza la necessità di commenti estesi. Usa nomi di variabili e funzioni significativi, mantieni le funzioni piccole e focalizzate, e organizza il codice in modo logico.

La manutenibilità consente l'evoluzione. Il codice difficile da modificare diventa una passività. Progetta il tuo codice per essere flessibile e modulare in modo che possa adattarsi ai requisiti in evoluzione. Segui principi come DRY (Don't Repeat Yourself) e SOLID per creare sistemi a basso accoppiamento e alta coesione. Refattorizza senza pietà per migliorare la struttura del codice senza cambiarne il comportamento.

Il codice pulito ripaga. Sebbene scrivere codice pulito richieda uno sforzo iniziale maggiore, risparmia tempo e mal di testa significativi a lungo termine. Il codice pulito è più facile da debug, estendere e mantenere. Consente agli sviluppatori di lavorare in modo più efficiente e riduce il rischio di introdurre bug durante le modifiche. Fai del codice pulito una parte fondamentale della tua pratica di sviluppo.

2. Segui convenzioni di denominazione significative

Il nome di una variabile, funzione o classe, dovrebbe rispondere a tutte le grandi domande. Dovrebbe dirti perché esiste, cosa fa e come viene utilizzata.

Usa nomi che rivelano l'intenzione. Scegli nomi che trasmettano chiaramente lo scopo e il comportamento di variabili, funzioni e classi. Evita nomi a singola lettera o abbreviazioni criptiche. Usa nomi pronunciabili che possano essere facilmente cercati. Ad esempio:

• Male: d (tempo trascorso in giorni)
• Bene: tempoTrascorsoInGiorni

Sii coerente e preciso. Usa convenzioni di denominazione coerenti in tutto il tuo codice. Sii preciso per evitare ambiguità - ad esempio, usa distinzioni significative come ottieniAccountAttivi() e ottieniInformazioniAccountAttivi(). Evita codifiche o prefissi che aggiungono rumore senza valore. I nomi delle classi dovrebbero essere sostantivi, i nomi dei metodi dovrebbero essere verbi.

La lunghezza del nome dovrebbe corrispondere all'ambito. Usa nomi più lunghi e descrittivi per variabili e funzioni con ambiti più ampi. I nomi brevi sono accettabili per ambiti piccoli e locali. La lunghezza di un nome dovrebbe essere proporzionale al suo ambito di utilizzo. Ottimizza per la leggibilità e la comprensione nel contesto in cui viene utilizzato il nome.

3. Mantieni le funzioni piccole e focalizzate

Le funzioni dovrebbero fare una cosa. Dovrebbero farla bene. Dovrebbero farla solo.

Piccolo è bello. Le funzioni dovrebbero essere piccole - tipicamente lunghe 5-10 righe. Dovrebbero stare su uno schermo e essere immediatamente comprensibili. Estrai il codice in funzioni di supporto ben nominate piuttosto che scrivere funzioni lunghe e complesse. Le funzioni piccole sono più facili da comprendere, testare e mantenere.

Fai una cosa bene. Ogni funzione dovrebbe avere uno scopo chiaro e unico. Se una funzione sta facendo più cose, estrai quelle in funzioni separate. Segnali che una funzione sta facendo troppo includono:

• Più livelli di astrazione
• Più sezioni o blocchi di codice
• Numerosi parametri

Mantieni un livello di astrazione. Le istruzioni all'interno di una funzione dovrebbero essere tutte allo stesso livello di astrazione. Non mescolare logica di alto livello con dettagli di basso livello. Estrai le operazioni di livello inferiore in funzioni separate. Questo migliora la leggibilità mantenendo le funzioni focalizzate e concettualmente semplici.

4. Pratica una formattazione e organizzazione adeguate

La formattazione del codice riguarda la comunicazione, e la comunicazione è la prima priorità di un sviluppatore professionista.

La formattazione coerente è importante. Usa indentazione, interruzioni di linea e spaziatura coerenti in tutto il tuo codice. Questo migliora la leggibilità e riduce il carico cognitivo. Concorda sugli standard di formattazione con il tuo team e usa strumenti automatici per farli rispettare. Linee guida chiave per la formattazione includono:

• Indentazione corretta
• Posizionamento coerente delle parentesi
• Interruzioni di linea logiche
• Spaziatura appropriata

Organizza il codice in modo logico. Raggruppa il codice correlato e separa il codice non correlato. Usa righe vuote per creare "paragrafi" tra sezioni logiche. Posiziona le funzioni correlate vicine tra loro. Mantieni i file focalizzati su un singolo concetto o componente. Dividi i file grandi in file più piccoli e focalizzati quando appropriato.

Segui le convenzioni standard. Attieniti alle convenzioni standard per il tuo linguaggio e la tua comunità. Questo rende il tuo codice più familiare e accessibile ad altri sviluppatori. Ad esempio, in Java:

• I nomi delle classi usano PascalCase
• I nomi dei metodi usano camelCase
• Le costanti usano TUTTO_MAIUSCOLO

5. Gestisci le dipendenze ed evita la duplicazione

La duplicazione può essere la radice di tutti i mali nel software.

Elimina la duplicazione. Il codice duplicato è un'opportunità mancata per l'astrazione. Quando vedi duplicazione, estrai il codice comune in una funzione o classe riutilizzabile. Questo migliora la manutenibilità centralizzando la logica e riducendo il rischio di modifiche incoerenti. Tipi di duplicazione da tenere d'occhio:

• Blocchi di codice identici
• Algoritmi simili con lievi variazioni
• Catene ripetute di switch/case o if/else

Gestisci le dipendenze con attenzione. Minimizza le dipendenze tra i moduli per ridurre l'accoppiamento. Usa l'iniezione delle dipendenze e l'inversione del controllo per rendere il codice più modulare e testabile. Segui il Principio di Inversione delle Dipendenze - dipendi dalle astrazioni, non dalle concretizzazioni. Questo rende il tuo codice più flessibile e facile da modificare.

Usa il principio della minima conoscenza. Un modulo non dovrebbe conoscere i dettagli interni degli oggetti che manipola. Questo riduce l'accoppiamento tra i moduli. Ad esempio, usa la Legge di Demetra - un metodo dovrebbe chiamare solo metodi su:

• Il proprio oggetto
• Oggetti passati come parametri
• Oggetti che crea
• I suoi oggetti componenti diretti

6. Gestisci gli errori con grazia

La gestione degli errori è importante, ma se oscura la logica, è sbagliata.

Usa eccezioni piuttosto che codici di errore. Le eccezioni sono più pulite e non ingombrano la logica principale del tuo codice. Consentono di separare la gestione degli errori dal percorso felice. Quando usi le eccezioni:

• Crea messaggi di errore informativi
• Fornisci contesto con le eccezioni
• Definisci classi di eccezioni basate sulle esigenze del chiamante

Non restituire null. Restituire null porta a eccezioni di puntatore null e ingombra il codice con controlli null. Invece:

• Restituisci collezioni vuote invece di null per le liste
• Usa il pattern Null Object
• Usa Optional in Java o Maybe nei linguaggi funzionali

Scrivi prima le istruzioni try-catch-finally. Inizia con il try-catch-finally quando scrivi codice che potrebbe lanciare eccezioni. Questo aiuta a definire l'ambito e le aspettative per il codice chiamante. Garantisce che le risorse siano gestite e rilasciate correttamente, anche in scenari di errore.

7. Scrivi test unitari approfonditi

Il codice di test è importante quanto il codice di produzione.

Segui le tre leggi del TDD. Il Test-Driven Development (TDD) migliora la qualità e il design del codice:

1. Scrivi un test fallito prima di scrivere qualsiasi codice di produzione
2. Scrivi solo quanto basta del test per dimostrare un fallimento
3. Scrivi solo quanto basta del codice di produzione per far passare il test

Mantieni i test puliti e manutenibili. Applica gli stessi standard di qualità del codice ai tuoi test come al codice di produzione. Refattorizza e migliora regolarmente il codice di test. I test ben strutturati fungono da documentazione e consentono una refattorizzazione senza paura del codice di produzione.

Punta a una copertura di test completa. Scrivi test che coprano casi limite, condizioni di confine e scenari di errore - non solo il percorso felice. Usa strumenti di copertura del codice per identificare le lacune nella copertura dei test. Ricorda che una copertura del 100% non garantisce un codice privo di bug, ma fornisce fiducia nella refattorizzazione e nelle modifiche.

8. Refattorizza il codice continuamente

Lascia il campeggio più pulito di come l'hai trovato.

Refattorizza opportunisticamente. Migliora la struttura del codice ogni volta che lavori su un pezzo di codice. Segui la Regola del Boy Scout: lascia il codice meglio di come l'hai trovato. Piccoli miglioramenti incrementali si sommano nel tempo e prevengono il degrado del codice. Tecniche comuni di refattorizzazione includono:

• Estrazione di metodi o classi
• Ridenominazione per chiarezza
• Semplificazione di condizionali complessi
• Rimozione della duplicazione

Refattorizza in sicurezza con i test. Avere sempre una solida suite di test prima di refattorizzare. Fai piccoli cambiamenti incrementali e esegui i test frequentemente. Questo ti dà fiducia che le tue modifiche non stiano rompendo la funzionalità esistente. Usa strumenti di refattorizzazione automatizzati quando disponibili per ridurre il rischio di introdurre errori.

Bilancia la refattorizzazione con la consegna del valore. Sebbene la refattorizzazione continua sia importante, non lasciare che paralizzi i progressi. Mira a "abbastanza buono" piuttosto che alla perfezione. Concentrati sugli sforzi di refattorizzazione nelle aree di codice più problematiche o frequentemente modificate. Comunica il valore della refattorizzazione agli stakeholder per garantire il supporto per il miglioramento continuo del codice.

9. Applica principi di programmazione orientata agli oggetti e funzionale

Gli oggetti nascondono i loro dati dietro astrazioni ed espongono funzioni che operano su quei dati. Le strutture dati espongono i loro dati e non hanno funzioni significative.

Usa saggiamente i principi orientati agli oggetti. Applica principi come incapsulamento, ereditarietà e polimorfismo per creare design flessibili e modulari. Segui i principi SOLID:

• Principio di Responsabilità Singola
• Principio Aperto-Chiuso
• Principio di Sostituzione di Liskov
• Principio di Segregazione delle Interfacce
• Principio di Inversione delle Dipendenze

Sfrutta i concetti di programmazione funzionale. Anche nei linguaggi orientati agli oggetti, le tecniche di programmazione funzionale possono portare a un codice più pulito:

• Funzioni pure senza effetti collaterali
• Dati immutabili
• Funzioni di ordine superiore
• Composizione di funzioni

Scegli l'approccio giusto per il problema. I paradigmi orientati agli oggetti e funzionali hanno ciascuno punti di forza e debolezza. Usa il design orientato agli oggetti quando hai bisogno di modellare domini complessi con comportamento. Usa approcci funzionali per la trasformazione e l'elaborazione dei dati. Molti linguaggi moderni supportano un approccio ibrido, permettendoti di usare lo strumento migliore per ogni parte del tuo sistema.

10. Considera attentamente la concorrenza

La concorrenza è una strategia di disaccoppiamento. Ci aiuta a disaccoppiare cosa viene fatto da quando viene fatto.

Comprendi le sfide della concorrenza. La programmazione concorrente introduce complessità e potenziale per bug sottili. Problemi comuni includono:

• Condizioni di gara
• Deadlock
• Segnali mancati
• Problemi di visibilità della memoria

Separa le preoccupazioni di concorrenza. Mantieni il codice relativo alla concorrenza separato dal resto del codice. Questo lo rende più facile da ragionare e testare. Usa astrazioni come Executors, Futures e Actors per gestire la concorrenza piuttosto che lavorare con thread grezzi.

Preferisci l'immutabilità e le funzioni pure. Gli oggetti immutabili e le funzioni pure sono intrinsecamente thread-safe. Eliminano molti problemi di concorrenza evitando lo stato mutabile condiviso. Quando lo stato mutabile è necessario, usa tecniche di sincronizzazione adeguate e considera l'uso di variabili atomiche o collezioni concorrenti.

Ultimo aggiornamento: July 25, 2024