“Clean Code” di Robert C. Martin

Clean Code, il fulcro della teoria del codice pulito e agile

Un libro da leggere e conoscere, ma anche analizzare con spirito critico

“Clean Code: A Handbook of Agile Software Craftsmanship” fa parte di quei libri storici che vanno letti almeno per due motivi:

• Per conoscere la storia degli eventi, trattati e spunti teorici che hanno portato lo sviluppo del software al livello attuale.
• Per capire le ragioni, a supporto ma anche critiche, che sono maturate nel tempo e vengono sostenute da fazioni diverse.

Potremmo dire che, così come per capire la letteratura moderna occorre prima aver maturato una discreta conoscenza dei classici, per comprendere la teoria moderna dello sviluppo del software occorre conoscerne le radici e la storia.

Ancora una volta oltretutto fa la comparsa il caro Uncle Bob, il nomignolo con cui è universalmente noto Robert C. Martin, ormai una presenza fissa in questo blog.

“To write clean code, you must first write dirty code and then clean it.”

Clean Code: la genesi

Clean Code è stato pubblicato per la prima volta nel  2008.

Indubbiamente molte cose sono cambiate dalla sua prima pubblicazione, tra cui anche lo stile di divulgazione e di pubblicazione di testi scientifici, nel novero dei quali certamente ricade anche Clean Code.

Il testo è stato uno spartiacque nella carriera di scrittore di Robert C. Martin.

Dopo il suo innegabile successo, sia in termini di notorietà che commerciale, Uncle Bob ha declinato l’opera in diversi sotto-argomenti.

Il prefisso “Clean” è diventato il marchio di fabbrica dei suoi scritti successivi.

• Clean Code (2008)
• Clean Coder (2011)
• Clean Architecture (2017)
• Clean Agile (2019)
• Clean Craftmanship (2021)

Clean Code: di cosa parla?

Clean Code è suddiviso in 17 capitoli più tre appendici:

1. Clean Code
2. Meaningful Names
3. Functions
4. Comments
5. Formatting
6. Objects and Data Structures
7. Error Handling
8. Boundaries
9. Unit Tests
10. Classes
11. Systems
12. Emergence
13. Concurrency
14. Successive Refinement
15. JUnit Internals
16. Refactoring SerialDate
17. Smells and Heuristics
18. Appendix A: Concurrency II
19. Appendix B: org.jfree.date.SerialDate
20. Appendix C: Cross References of Heuristics

Ho trovato preziosi e veramente da analizzare i primi 10 capitoli, che valgono l’acquisto del libro.

Anche l’appendice C sulle euristiche è molto valida, quasi da sola riassume un po’ tutto il senso del libro.

Dal capitolo 11 in avanti invece gli esempi di codice diventano molto prolissi e alcuni spunti di discussione piuttosto filosofici. Inoltre alcune parti mancano a mio modesto avviso di cura narrativa, si tratta di leggere pagine di codice commentato. Farlo su un IDE è un conto, farlo su un libro di testo è un’altro tipo di esperienza.

I passaggi chiave di Clean Code

• Per scrivere codice pulito, occorre partire dallo scrivere codice sporco, e poi ripulirlo.
• Il buon software è testabile, oppure non è buon software.
• Non avere mai paura di segmentare funzioni e classi in elementi atomici, seguendo i principi SOLID.
• Mai procrastinare una sessione di refactoring.
• Il codice non è mai “troppo efficiente”. Nel momento in cui un prodotto si considera “finito”, esso inizia a diventare obsoleto.

Agile ma non troppo

Già, perché a dispetto delle premesse, Clean Code non è proprio così “clean” e tantomeno “agile”, per lo meno se letto pedissequamente in tutte le sue 450 e oltre pagine di esempi.

La prima parte è molto scorrevole e piacevole. Si introducono le basi della progettazione del software e si esplorano i suoi elementi cardine, sempre avendo di fondo una logica ad oggetti.

Uncle Bob è un portavoce se non uno tra gli artefici di questo paradigma di programmazione.

Tuttavia la seconda parte del testo diventa molto più impegnativa, non tanto per la difficoltà tecnica, ma per la struttura stessa del libro. Quasi in antitesi all’approccio “Clean” che l’autore suggerisce.

Occorre infatti affrontare lunghi e prolissi esempi di codice, tra loro disgiunti (una app per una palestra, uno script per un termostato, un convertitore di temperatura e date, etc.), intervallati da illustrazioni caricaturali piuttosto decontestualizzate con l’opera. Affrontare tali sezioni è stato faticoso.

Inoltre Clean Code è interamente basato su Java e sul suo ecosistema. Gli esempi sono tutti scritti in tale linguaggio di programmazione,  spesso rifacendosi anche a framework e librerie specifiche, rendendo il testo molto verticale e non aggiungendo certamente varietà al contenuto.

Le informazioni fornite sono di valore, ma capisco che passati quasi vent’anni dall’uscita del libro, esse non siano più così dirompenti come agli esordi.

Gli spunti più importanti sono stati certamente oggi digeriti e fatti propri dalla comunità di sviluppatori (importanza del testing, importanza delle naming convention, principi SOLID).

Il testo oggi è sicuramente ancora molto citato, anche se talvolta sembra di aver a che fare con il vecchio nonno, burbero e irascibile: lo si ascolta, se ne rispetta la saggezza, ma si sa che non sempre quel che dice va preso alla lettera.

Diverse anche le voci critiche.

L’autore

Robert Cecil Martin , chiamato colloquialmente “Uncle Bob”, è un ingegnere informatico statunitense, istruttore e autore. È noto soprattutto per aver promosso molti principi di progettazione del software e per essere stato autore e firmatario del Manifesto Agile.

Martin è autore di numerosi libri e articoli di riviste. È stato caporedattore della rivista C++ Report e ha ricoperto il ruolo di primo presidente della Agile Alliance.

Martin è entrato nell’industria del software all’età di 17 anni e non ha alcuna formazione universitaria. Come lui stesso afferma, è completamente autodidatta.

I am also self-taught. I never got a degree of any kind. I entered the industry at the tender age of 17 and never looked back. Frankly, school isn’t all it’s cracked up to be — especially in the software field.

— Uncle Bob Martin (@unclebobmartin) December 10, 2018

In cerca di ispirazione?

Leggi tutte le nostre recensioni!