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, inizia ad essere anziano tanto quanto qualche sviluppatore Junior.

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.

Dal capitolo 11 in avanti gli esempi di codice diventano molto prolissi e alcuni spunti di discussione piuttosto filosofici, più da dibattito che da libro di testo.

I passaggi più importanti:

  • 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.

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, etc.), intervallati da illustrazioni caricaturali.

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.

In cerca di ispirazione?

Leggi tutte le nostre recensioni!

aziona risorse ebook guida al debito tecnico

Scarica l’ebook “La guida definitiva alla comprensione del Debito Tecnico”

Iscriviti alla newsletter e scarica l’ebook.

Ricevi aggiornamenti, tips e approfondimenti su tecnologia, innovazione e imprenditoria.