Punti chiave
Mantieni pulito il codice: la scorciatoia di oggi presenta il conto a ogni modifica
La scorciatoia apparente si accumula nel tempo. Martin sostiene che il codice scritto in fretta e aggrovigliato rallenta ogni modifica successiva. Ricorda un prodotto software un tempo popolare, le cui versioni uscivano sempre più lentamente, i bug restavano irrisolti e gli arresti anomali aumentavano. Un ex dipendente ricondusse il declino a una base di codice difficile da estendere. Man mano che il caos cresce, le modifiche diventano più rischiose, i team rallentano e aggiungere personale può aggravare il problema, perché i nuovi arrivati devono lavorare con un’architettura che non capiscono.
Riscrivere tutto non è una soluzione miracolosa. Nello scenario di riprogettazione descritto nel libro, un nuovo team realizza un sostituto mentre il vecchio sistema continua a cambiare. La corsa può durare anni e il sistema sostitutivo può ereditare lo stesso disordine. L’alternativa pratica è continuare a migliorare il codice man mano che cambia, invece di trattare la pulizia come un progetto da rimandare.
Colpisce l’argomento economico che si cela dietro il discorso sulla cura artigianale: ogni decisione poco chiara crea lavoro per chi leggerà il codice in futuro, e quel costo si distribuisce lungo l’intero ciclo di vita del prodotto. È simile alla manutenzione preventiva in ingegneria, dove piccole verifiche riducono il rischio di guasti costosi. L’argomento è più convincente quando il codice sarà mantenuto nel tempo da un team. Un prototipo destinato a essere scartato comporta costi diversi: la pulizia dovrebbe quindi rispondere all’uso previsto, senza trasformarsi in un rito fine a se stesso.
Scrivi per chi leggerà il codice, non solo per il compilatore, e rendi ricercabile l’intento
La maggior parte del lavoro consiste nel leggere. Martin stima che i programmatori passino a leggere il codice più di dieci volte il tempo che impiegano a scriverlo. La modifica successiva dipende dalla comprensione di ciò che è già presente, perciò la leggibilità non è un ornamento. I nomi dovrebbero dire ai lettori che cosa rappresenta un valore, che cosa fa una funzione e come viene usato un risultato. Per esempio, una variabile temporale dovrebbe indicare sia l’intervallo sia l’unità di misura, invece di lasciare a un commento il compito di chiarire questi aspetti.
Rendi facile trovare il significato. Preferisci nomi pronunciabili e distintivi ad abbreviazioni criptiche, serie numeriche arbitrarie o nomi che soddisfano soltanto il compilatore. Un contatore di ciclo può avere un nome breve se il suo ambito è minuscolo; un valore usato in molti punti ha bisogno di un nome ricercabile. Una formattazione coerente e le convenzioni del team aiutano i lettori a riconoscere la struttura senza dover reimparare ogni file.
Il codice leggibile riduce la quantità di informazioni che una persona deve tenere a mente mentre segue una modifica. Dare un nome è quindi una forma di progettazione dell’interfaccia: spesso l’identificatore è la prima spiegazione che vede un collaboratore. Il libro collega inoltre lo stile locale alla fiducia nel team, perché un’impaginazione coerente consente ai lettori di prevedere dove si trovano i vari concetti. C’è però un limite: i nomi più lunghi non sono automaticamente più chiari e un eccesso di dettagli può nascondere un’operazione locale semplice. La chiarezza dipende dal concetto e dal suo ambito.
Mantieni le funzioni abbastanza piccole da esprimere un passaggio chiaro alla volta
Una funzione, un livello di dettaglio. Una funzione dovrebbe descrivere una singola operazione, articolando i passaggi interni al livello di dettaglio successivo. Martin lo mostra trasformando una routine aggrovigliata per la generazione di HTML in una breve sequenza che individua le pagine di test, include il materiale di preparazione e pulizia e restituisce il risultato renderizzato. Le funzioni più piccole rendono visibile lo scopo senza costringere i lettori a decifrare prima la gestione delle stringhe a basso livello.
Riduci il carico interpretativo. Usa pochi argomenti, evita i flag booleani che fanno comportare una funzione in due modi diversi e tieni separati i comandi che modificano lo stato dalle query che restituiscono informazioni. Gli effetti collaterali nascosti sono particolarmente costosi: una funzione chiamata «verifica password» non dovrebbe reimpostare di nascosto la sessione di un utente. Anche le eccezioni possono separare la gestione degli errori dall’algoritmo ordinario.
La struttura narrativa è più di una preferenza stilistica. Una sequenza ben ordinata permette al lettore di passare dai principi ai meccanismi, proprio come una buona spiegazione presenta un’affermazione prima delle prove. Le funzioni piccole facilitano anche i test e il riuso. Tuttavia, si può esagerare con l’estrazione: un programma diviso in innumerevoli involucri banali può costringere i lettori a saltare da una definizione all’altra. Il criterio utile non è un limite universale di righe, ma chiedersi se ogni unità abbia uno scopo coerente, descrivibile con un nome che non si limiti a ripetere l’implementazione.
Assegna a ogni classe un solo motivo per cambiare, poi scegline deliberatamente la forma
Conta le responsabilità, non i metodi. Il principio di responsabilità unica afferma che una classe dovrebbe avere un solo motivo per cambiare. Anche una dashboard con pochi metodi può combinare attività non correlate, come gestire una finestra e comunicare i numeri di versione del software. Separando la gestione delle versioni si crea un’unità più piccola e con uno scopo più chiaro. Un’elevata coesione significa che i dati e i metodi di una classe sono pertinenti tra loro; gruppi non correlati indicano che al suo interno si nasconde probabilmente un’altra classe.
Scegli tra oggetti e strutture dati in base ai cambiamenti previsti. Gli oggetti nascondono i dati ed espongono il comportamento, rendendo più facile aggiungere nuovi tipi. Le strutture dati espongono i propri campi e consentono di aggiungere nuove operazioni senza modificare ogni tipo. Nessuno dei due stili è sempre preferibile. Mescolarli produce ibridi che non nascondono né i dati né le responsabilità e rendono più difficili entrambi i tipi di modifica.
È un utile antidoto all’idea che la progettazione orientata agli oggetti consista nel trasformare ogni sostantivo in un oggetto. La questione fondamentale è dove è probabile che avvengano i cambiamenti. Se si aggiungono spesso nuovi tipi di comportamento, i dati esposti con operazioni separate possono essere più semplici; se invece si aggiungono spesso nuovi tipi di dati, gli oggetti polimorfici possono circoscrivere le modifiche. Anche il criterio della responsabilità è pratico, ma può essere soggettivo. Il confine di una classe è un’ipotesi sui cambiamenti futuri, non una legge che garantisce l’architettura giusta.
Mantieni i test puliti per proteggere le modifiche, senza creare un altro sistema legacy
I test preservano la libertà di migliorare. Lo sviluppo guidato dai test, o TDD, consiste nello scrivere un test che fallisce prima di implementare il comportamento in produzione, aggiungere solo il codice necessario per superarlo e poi perfezionare il risultato mantenendo i test verdi. Martin descrive un ciclo rapido di test e implementazione. I test non sono impalcature da eliminare. Un team lasciò che il codice dei test diventasse aggrovigliato; alla fine gli sviluppatori abbandonarono la suite, persero fiducia nelle modifiche e smisero di migliorare il codice di produzione.
Rendi i test leggibili e affidabili. Il libro raccomanda test rapidi, indipendenti, ripetibili e autocontrollati, scritti vicino al codice che specificano. La struttura prepara-esegui-verifica aiuta i lettori a distinguere la configurazione, l’azione e il risultato atteso. Verifica un concetto principale alla volta e mantieni le asserzioni abbastanza mirate da indicare chiaramente il comportamento quando falliscono.
I test funzionano come una memoria eseguibile. Conservano ciò che il team ritiene debba fare il software, anche quando gli sviluppatori originali se ne sono andati. Il loro valore è in parte tecnico e in parte sociale: un test comprensibile offre a chi revisiona una prova su cui basarsi per accettare una modifica. Attenzione, però: il superamento dei test non dimostra la correttezza assoluta. Una suite riflette i casi previsti da chi l’ha scritta, perciò restano importanti anche i controlli sui casi limite, gli schemi di errore e la revisione umana.
Rifattorizza con piccoli passi verificati, non con riscritture eroiche
Il codice funzionante è solo una prima stesura. Nel caso di studio sul parser da riga di comando, la prima versione gestiva correttamente le opzioni booleane. L’aggiunta di opzioni stringa e intere moltiplicò i casi speciali, finché l’implementazione divenne difficile da gestire. Invece di aggiungere altre funzionalità, Martin si fermò ed estrasse un’astrazione comune per la gestione degli argomenti. Dopo ogni piccola modifica venivano eseguiti i test, mantenendo stabile il comportamento mentre le responsabilità venivano spostate e la logica duplicata eliminata.
Lascia che siano le prove a guidare la pulizia. In una revisione separata di una classe per le date, i test originali coprivano circa metà delle istruzioni eseguibili. I test aggiuntivi portarono alla luce errori nei casi limite, tra cui un calcolo del giorno della settimana che restituiva la data corrente invece di individuare la ricorrenza successiva. Le priorità di progettazione semplice indicate nel libro sono: mantenere verdi i test, eliminare le duplicazioni, rendere chiaro l’intento ed evitare classi o metodi non necessari. I casi di studio mostrano che il perfezionamento spesso consiste nel provare una modifica, verificarla e poi rivederla.
La rifattorizzazione incrementale somiglia a un esperimento controllato: si modifica una variabile, si osserva il risultato e si conserva una base di partenza funzionante. Così il lavoro dipende meno dalla memoria e dalla fiducia nelle proprie capacità. Emerge anche una distinzione fondamentale tra riscrittura e trasformazione: il comportamento viene protetto mentre cambia la struttura. Tuttavia, i test verdi sono informativi solo quanto la loro copertura e le loro asserzioni. Il caso delle date è significativo proprio perché test più ampi hanno rivelato difetti che la suite originale non aveva messo in luce.
Usa i commenti per spiegare le ragioni, mai per mascherare codice confuso
Il codice dovrebbe spiegarsi da sé. Un commento che ripete un’istruzione ovvia aggiunge solo disordine, mentre uno non aggiornato può fuorviare più del silenzio. Se un commento spiega che una condizione verifica il diritto a un sussidio, la condizione potrebbe essere più chiara se trasformata in una funzione con un nome appropriato. Nomi, funzioni piccole e valori intermedi espliciti spesso comunicano l’intento con più affidabilità della prosa accanto a codice denso.
Conserva i commenti che aggiungono il contesto mancante. Gli avvisi legali, la documentazione delle API pubbliche, gli avvertimenti su conseguenze non ovvie e le spiegazioni di decisioni sorprendenti possono essere utili. Elimina i registri delle modifiche obsoleti, il codice commentato, le intestazioni ridondanti e le note TODO che nessuno rivede. Il controllo delle versioni può conservare il codice eliminato: il file sorgente non deve diventare il proprio archivio storico.
La distinzione più importante è quella tra descrivere che cosa fa il codice e spiegare perché è stata presa una decisione. La prima cosa spesso duplica l’implementazione; la seconda può conservare un contesto che l’implementazione non riesce a rivelare. Questo si accorda con le pratiche di documentazione nei lavori critici per la sicurezza, dove le motivazioni sono importanti perché chi manterrà il codice in futuro potrebbe trovarsi di fronte a vincoli non più visibili. Tuttavia, si può esagerare con l’avversione ai commenti. Il codice chiaro non riesce sempre a comunicare politiche, presupposti di dominio o soluzioni alternative deliberate: quando rimane accurata, una spiegazione concisa merita spazio.
Rendi espliciti gli errori e mantieni snello il percorso normale
Separa la gestione degli errori dall’algoritmo. I codici di ritorno costringono chi chiama a verificare ogni operazione, spesso annidando condizioni di successo intorno al lavoro principale. Le eccezioni possono spostare la gestione degli errori su un percorso distinto, mentre un contesto utile identifica l’operazione fallita e il motivo. Racchiudere un’API di terze parti in un involucro può tradurre diverse eccezioni specifiche del fornitore in un unico tipo che l’applicazione può gestire in modo coerente.
Non rendere ambigua l’assenza. Restituire null impone a ogni chiamante un obbligo nascosto e favorisce i controlli mancanti. Se, per esempio, non ci sono dipendenti, una lista vuota consente a chi la riceve di iterare in sicurezza senza diramazioni. Quando si verifica una situazione speciale legittima, un oggetto dedicato può fornire il comportamento normale: per esempio, un risultato relativo alle spese dei pasti che indica una diaria quando non è stata presentata alcuna richiesta di rimborso. Evita di accettare valori null in ingresso, a meno che l’interfaccia non lo richieda esplicitamente.
Questo approccio considera gli errori parte dell’interfaccia, anziché scarti implementativi scomodi. È particolarmente efficace quando chi chiama può reagire in modo utile a un errore e quando le eccezioni contengono informazioni sufficienti per diagnosticarlo. Anche il ricorso ai casi speciali riduce le diramazioni, rappresentando un’assenza legittima con un valore utilizzabile. I sistemi di tipi moderni possono rendere più esplicite queste scelte, ma nessuna rappresentazione elimina la necessità di decidere se un evento sia eccezionale, previsto o recuperabile.
Crea punti di separazione intorno alle librerie e all’avvio, così le modifiche restano circoscritte
Tieni ai margini le assunzioni esterne. Una collezione di uso generale, come una mappa, può consentire operazioni o valori che l’applicazione non desidera. Un piccolo involucro specifico dell’applicazione può esporre solo il comportamento necessario e concentrare in un unico luogo le conversioni di tipo, le regole sui tipi e i dettagli della libreria. I test di apprendimento sono piccoli esperimenti che verificano il comportamento di un’API sconosciuta prima che il codice di produzione dipenda da essa. Per esempio, i test per log4j hanno rivelato dettagli di configurazione non evidenti dalla sola documentazione.
Separa la creazione dall’uso. Costruisci e collega gli oggetti principali in un’area di avvio, in una factory o in un contenitore per l’iniezione delle dipendenze. L’applicazione può così usare semplici oggetti di dominio senza sapere come viene assemblata ogni dipendenza. Se un’API non esiste ancora, definisci l’interfaccia di cui ha bisogno l’applicazione e crea un adattatore che la colleghi al fornitore futuro.
Un confine è al tempo stesso un punto di separazione tecnico e un luogo in cui gestire l’incertezza. Gli involucri riducono il numero di punti coinvolti da una modifica del fornitore, mentre i test di apprendimento trasformano comportamenti non documentati in prove ripetibili. Separare la fase di avvio dall’esecuzione rende inoltre più facile testare la logica dell’applicazione senza dover costruire l’intero sistema. Il compromesso è il costo dell’astrazione: racchiudere ogni tipo di libreria o adottare prematuramente un framework di grandi dimensioni può creare più complicazioni che protezione. Incapsula un confine quando limita gli usi impropri o riduce in modo significativo il costo dei cambiamenti.
Considera la concorrenza un problema di progettazione a sé, non un interruttore per aumentare la velocità
Lo stato condiviso crea percorsi di esecuzione nascosti. Due thread che incrementano lo stesso identificatore possono leggere entrambi il vecchio valore prima che uno dei due lo scriva, producendo un duplicato e perdendo un aggiornamento. Il libro calcola 12.870 possibili interleaving di bytecode per un semplice incremento eseguito da due thread, mostrando perché un’istruzione che sembra indivisibile potrebbe non essere atomica. La concorrenza è utile quando il lavoro può procedere mentre si attende, per esempio durante l’accesso alla rete; non rende automaticamente più veloci le operazioni limitate dalla potenza di calcolo.
Riduci le occasioni di interferenza. Tieni separato il codice che deve gestire i thread, limita i dati condivisi, usa copie o dati indipendenti per ciascun compito quando possibile e mantieni brevi le sezioni sincronizzate. Impara il modello di esecuzione e gli strumenti di libreria pertinenti. Esegui test con numeri diversi di thread, piattaforme e carichi e considera i guasti rari come prove concrete, senza liquidarli come episodi isolati.
L’intuizione centrale del capitolo è che la concorrenza amplia l’insieme delle possibili sequenze di esecuzione che il programma deve riuscire a gestire. Per questo l’isolamento e le interfacce controllate sono più preziosi di blocchi intelligenti sparsi nel codice dell’applicazione. I vantaggi in termini di prestazioni dipendono dalle circostanze: il lavoro parallelo può mascherare i tempi di attesa, ma i thread aggiuntivi comportano anche costi di coordinamento e contesa. Una progettazione responsabile comincia dall’individuazione del collo di bottiglia e dello stato condiviso, poi usa i test per mettere alla prova le ipotesi sulla pianificazione, invece di dare per scontato che un’esecuzione riuscita dimostri la sicurezza.
Analisi
Clean Code. Guida per scrivere codice pulito ai tempi dell'AI si comprende al meglio come un libro dedicato a contenere il costo dei cambiamenti. Le sue tecniche specifiche, dai nomi precisi alle interfacce ristrette, riducono tutte la quantità di contesto nascosto che chi svilupperà in futuro dovrà ricostruire. La narrazione rafforza questa tesi attraverso prodotti deteriorati, funzioni tentacolari, un parser da riga di comando salvato con la rifattorizzazione e una logica per le date i cui difetti sono emersi solo grazie a test più ampi. I casi contano perché i consigli vengono presentati come il risultato di una pratica artigianale, non come una lista di controllo capace di produrre qualità per magia.
La sintesi più duratura è un ciclo di feedback: esprimere chiaramente l’intento, verificare il comportamento, apportare una piccola miglioria strutturale e controllare che il comportamento sia rimasto intatto. La leggibilità facilita l’esame dei difetti e delle responsabilità. I test rendono meno rischiosa la pulizia. Confini ben definiti impediscono che le modifiche esterne si propaghino. Queste pratiche si rafforzano a vicenda: ecco perché considerare i test o la formattazione una rifinitura facoltativa indebolisce il sistema nel suo insieme.
Il libro esprime deliberatamente opinioni nette e alcune delle sue regole andrebbero considerate impostazioni predefinite, non principi assoluti. Funzioni molto piccole possono frammentare il flusso di controllo. Le astrazioni possono moltiplicarsi senza aggiungere flessibilità utile. I commenti possono conservare motivazioni di dominio che i nomi non sono in grado di esprimere. Persino l’architettura migliore dipende dai cambiamenti che il sistema deve davvero affrontare. I casi di studio del libro propongono un criterio più sano della conformità rigida: esaminare il codice, verificare le ipotesi, apportare una modifica locale e valutarne il risultato.
La tesi più ampia, di natura professionale, è che velocità e cura non siano in contrasto quando il software deve evolversi. La misura pertinente non è la rapidità con cui si digita il codice, ma quanto facilmente un team riesce a comprenderlo, modificarlo in sicurezza e verificarlo. La pulizia non è quindi una perfezione estetica: è un investimento continuo per fare in modo che la prossima modifica resti comprensibile e sostenibile.
Sintesi delle recensioni
Clean Code. Guida per scrivere codice pulito ai tempi dell'AI riceve recensioni perlopiù positive per i suoi principi sulla scrittura di codice leggibile e manutenibile. I lettori apprezzano i consigli pratici su nomi, funzioni e test. Le critiche più comuni riguardano l'attenzione al linguaggio Java e alcune linee guida ritenute troppo rigide. Molti lo considerano una lettura essenziale per gli sviluppatori, anche se alcuni lo trovano meno utile per i programmatori esperti. Alcuni lodano i casi di studio e gli esempi di refactoring, altri li giudicano eccessivi. Nel complesso, i recensori concordano sul fatto che il libro offra spunti preziosi sulla qualità del codice, anche se non tutti i suggerimenti sono applicabili universalmente.
Altri hanno letto anche
Glossario
sensibilità per il codice (code-sense)
capacità di giudicare il refactoringLa capacità, acquisita con la pratica, di riconoscere codice poco chiaro o aggrovigliato, immaginare alternative migliori e scegliere una sequenza di modifiche che ne migliori la struttura preservandone il comportamento. Il libro la considera un'abilità che si sviluppa esercitandosi ripetutamente, non un istinto che si acquisisce memorizzando regole.
regola del boy scout
lasciare il codice miglioratoUn principio di manutenzione che invita gli sviluppatori ad apportare un piccolo miglioramento ogni volta che lavorano su una parte del codice. La modifica non deve essere ampia: un nome più chiaro, una funzione più breve o la rimozione di una duplicazione possono prevenire il graduale deterioramento del codice, se la pratica viene ripetuta.
regola della progressione graduale (step-down rule)
ordinare per livello di astrazioneUn modo di organizzare le funzioni che consente al lettore di passare da un'operazione di alto livello ai passaggi di livello inferiore che la realizzano. Ogni funzione richiama o introduce il livello successivo di dettaglio, così che un file sorgente si legga come una spiegazione progressivamente più specifica.
principio di responsabilità unica
un solo motivo per cambiareUn principio di progettazione secondo cui una classe o un modulo dovrebbe avere una sola responsabilità, intesa come un unico motivo principale per cui potrebbe essere necessario modificarlo. Guida la definizione dei confini tra classi: i comportamenti che cambiano per ragioni non correlate possono essere separati in unità distinte.
legge di Demetra
limitare la navigazione tra oggettiUn'euristica di progettazione che sconsiglia a un metodo di attraversare diversi oggetti per raggiungere un dettaglio interno. Un modulo dovrebbe comunicare principalmente con i propri metodi, gli oggetti che crea, gli argomenti che riceve e gli oggetti che detiene direttamente, anziché dipendere dal grafo di oggetti di un collaboratore.
F.I.R.S.T.
cinque qualità dei testAcronimo che descrive le qualità dei test unitari puliti: veloci, indipendenti, ripetibili, autoverificanti e tempestivi. Nel loro insieme, queste qualità rendono i test pratici da eseguire spesso, facili da diagnosticare e strettamente collegati al codice di cui specificano il comportamento.
test di apprendimento
esplorare le API esternePiccoli test scritti per esplorare e verificare il comportamento di una libreria di terze parti quando viene usata nel modo previsto dall'applicazione. Rendono eseguibili le ipotesi su un'interfaccia sconosciuta, aiutano a distinguere il comportamento della libreria dagli errori dell'applicazione e possono rilevare modifiche incompatibili dopo l'aggiornamento di una libreria.
iniezione delle dipendenze
fornire le dipendenze dall'esternoUn approccio alla gestione delle dipendenze in cui un oggetto non crea né individua i propri collaboratori. Una routine di avvio o un contenitore crea gli oggetti necessari e li fornisce tramite costruttori o setter, separando la costruzione degli oggetti dal comportamento dell'applicazione durante l'esecuzione.
pattern del caso speciale
incapsulare le eccezioni previsteUna tecnica per rappresentare una situazione eccezionale ma legittima tramite un oggetto che fornisce il comportamento appropriato, così che chi lo usa non debba aggiungere un ramo separato. Per esempio, una richiesta relativa alle spese può restituire un oggetto di spesa per i pasti che fornisce l'importo della diaria quando non è stata registrata alcuna spesa per i pasti.
separazione tra comando e query
separare la modifica dalla consultazioneUn principio di progettazione secondo cui una funzione svolge un solo ruolo: modificare lo stato di un oggetto oppure restituire informazioni su di esso. Combinare entrambi i ruoli può rendere ambigua una chiamata, soprattutto quando un'operazione che modifica lo stato viene usata come condizione. Separarli rende più chiari sia il codice sia il suo intento.
FAQ
Di cosa parla «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Attenzione al codice pulito: «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI» di Robert C. Martin sottolinea l'importanza di scrivere codice facile da leggere, comprendere e mantenere.
- Professionalità nella programmazione: sostiene che il codice pulito sia un segno distintivo della professionalità nello sviluppo software.
- Consigli pratici: il libro offre linee guida, esempi e casi di studio per aiutare gli sviluppatori a scrivere codice pulito ed efficiente.
Perché dovrei leggere «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Migliorare le proprie capacità di programmazione: insegna a scrivere codice pulito, efficiente e manutenibile.
- Imparare dagli esperti: fa parte della serie di Robert C. Martin, nota per l'approccio tecnico e pragmatico.
- Vantaggi a lungo termine: scrivere codice pulito riduce i costi di manutenzione e rende gli sviluppatori più preziosi.
Quali sono i punti chiave di «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Leggibilità del codice: sottolinea che il codice dovrebbe essere facile da leggere e comprendere.
- Principio di responsabilità unica: sostiene che ogni classe o funzione dovrebbe avere un solo motivo per cambiare.
- Miglioramento continuo: incoraggia gli sviluppatori a migliorare continuamente il codice, seguendo la regola del boy scout.
Come definisce il codice pulito «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Eleganza ed efficienza: il codice pulito è descritto come elegante ed efficiente, con dipendenze ridotte al minimo.
- Leggibile e manutenibile: dovrebbe leggersi come un testo ben scritto, rendendo chiaro l'intento di chi lo ha progettato.
- Mirato e focalizzato: ogni funzione, classe e modulo dovrebbe avere uno scopo unico e chiaro.
Che cos'è il principio di responsabilità unica in «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Un solo motivo per cambiare: una classe o un modulo dovrebbe avere uno, e un solo, motivo per cambiare.
- Migliora la coesione: fa sì che le classi siano coese, con metodi e variabili strettamente correlati.
- Facilita la manutenzione: rende il codice più facile da mantenere ed estendere, riducendo l'impatto delle modifiche.
Che cos'è la «regola del boy scout» menzionata in «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Miglioramento continuo: suggerisce di lasciare la base di codice più pulita di come la si è trovata.
- Piccole modifiche incrementali: incoraggia piccoli miglioramenti, come rinominare variabili o suddividere funzioni.
- Responsabilità professionale: è presentata come una responsabilità professionale volta a garantire la manutenibilità.
Come affronta lo sviluppo guidato dai test (TDD) «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Disciplina fondamentale: il TDD è essenziale per scrivere codice pulito e affidabile.
- Le tre leggi del TDD: scrivere prima un test che fallisce, scrivere il codice necessario a superarlo, quindi eseguire il refactoring.
- Vantaggi: aiuta a individuare gli errori in anticipo e migliora la progettazione del codice.
Che cosa sono i «code smell» secondo «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Definizione: segnali di possibili problemi che ostacolano la leggibilità o la manutenibilità.
- Esempi: metodi lunghi, classi grandi e codice duplicato.
- Come affrontarli: il libro offre euristiche e tecniche di refactoring per migliorare la qualità del codice.
Come suggerisce di gestire le eccezioni «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Preferire le eccezioni: usare le eccezioni invece dei codici di errore per avere più contesto e semplificarne la gestione.
- Fornire contesto: includere messaggi significativi e informazioni contestuali quando si sollevano eccezioni.
- Evitare le eccezioni controllate: suggerisce di usare eccezioni non controllate per ottenere codice più pulito.
Che ruolo hanno i test unitari in «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Garantire la qualità del codice: i test unitari assicurano che il codice funzioni come previsto e resti manutenibile.
- Sviluppo guidato dai test: il libro sostiene che i test vadano scritti prima del codice di produzione.
- Test puliti e leggibili: i test dovrebbero essere puliti e leggibili quanto il codice di produzione.
Qual è il ruolo del refactoring in «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI»?
- Miglioramento continuo: il refactoring migliora la struttura e la leggibilità del codice senza modificarne le funzionalità.
- Tecniche: il libro presenta tecniche come l'estrazione di un metodo e la rinomina di una variabile per migliorare la qualità del codice.
- Refactoring senza timori: con test completi, gli sviluppatori possono eseguire il refactoring con fiducia.
Quali sono le citazioni migliori di «Clean Code. Guida per scrivere codice pulito ai tempi dell'AI» e che cosa significano?
- «Il codice pulito fa bene una sola cosa.» Sottolinea l'importanza di concentrarsi e di essere chiari nel codice.
- «Lascia il campeggio più pulito di come l'hai trovato.» Incoraggia a migliorare continuamente la base di codice.
- «Sai di lavorare su codice pulito quando ogni routine che leggi si rivela più o meno esattamente ciò che ti aspettavi.» Evidenzia l'importanza della leggibilità e della prevedibilità.
Scarica PDF
Scarica EPUB
.epub è ideale per leggere ebook su telefoni, tablet ed e-reader.