L'autore in questo libro offre un punto d'unione tra due dei testi fondamentali nello sviluppo di software object oriented, vale a dire Design Patterns della Gof e Refactoring di Martin Fowler (che non per niente firma la prefazione di RtP). Quello che offre questo testo è infatti una serie di percorsi guidati alla implementazione dei più importanti Design Patterns a partire da codice esistente, funzionante ma dal design errato oppure limitato.

In particolare, tutta la parte iniziale del libro offre una discreta introduzione sui patterns e soprattutto su quando seguirne i dettami: divertente e formativo è l'esempio di codice dell'onnipresente Hello World (riportato in appendice alla recensione), implementato però in questo caso attraverso lo Strategy Pattern, a cui seguono le conclusioni dell'autore circa l'inutilità di un approccio in casi così semplici... oppure ancora l'accenno alla Singletonite, la malattia comune a tutti gli sviluppatori che tendono ad abusare del Singleton Pattern ...

Un capitolo è inoltre dedicato ai Code Smells , vale a dire gli elementi presenti in una determinata porzione di codice, di per sè perfettamente funzionante, che indicano errate scelte di design e/o di implementazione, e che rendono il codice stesso difficilmente comprensibile, manutenibile ed espandibile.

Alla risoluzione di questi "difetti" è dedicata la restante, e corposa, parte del libro, organizzata in sezioni principali:

• Creation: miglioramento del design nella fase di costruzione degli oggetti, ad esempio sostituendo un elevato numero di costruttori (che si differenziano tra loro solo per il numero e tipo di parametri) con dei metodi di creazione maggiormente esplicativi.
• Simplification: semplificazione di codice attraverso la modifica, eliminazione, sostituzione o isolamento di ben definite porzioni di codice, ad esempio creando metodi brevi e il cui nome comunichi immediatamente la loro funzione e il loro contesto di utilizzo.
• Generalization: trasformazione di un codice altamente specifico in un codice più generico e quindi maggiormante riutilizzabile, ad esempio attraverso l'uso dei Composites in luogo delle relazioni uno-a-molti.
• Protection: miglioramento della protezione del proprio codice, ad esempio per evitare InvalidCastExceptions o le NullReferenceExceptions.
• Accumulation: linee guida di design per migliorare il modo di recuperare informazioni da una gerarchia omogenea od eterogenea di oggetti, ad esempio usanto il Visitor pattern.
• Utilities: refactorings di utilità generale, ad esempio l'unificazione di interfacce o l'estrazione di parametri.

Il catalogo completo dei refactorings presenti è visualizzabile sul sito web, insieme ad ulteriori refactorings proposti dall'autore e dai suoi collaboratori.

Refactoring To Patterns è semplicemente una lettura indispensabile per qualsiasi sviluppatore interessato a migliorare il design e la qualità del proprio codice. Innanzitutto è un libro molto pratico: tutti i refactorings proposti per "abbracciare" un determinato pattern sono versioni semplificate di refactoring effettivamente sperimentati dall'autore su progetti reali, quindi niente esempi fini a se stessi.

Inoltre, la chiarezza espositiva è esemplare, in pieno stile GoF. Per ogni refactoring trattato viene infatti presentato nell'ordine:

• Schema UML del codice pre-refactoring e del codice a refactoring completato
• Spiegazione sintetica del refactoring.
• Introduzione "storica", ovvero la descrizione del progetto reale da cui proviene e le motivazioni che hanno portato alla necessità di effettuare le modifiche.
• Tabella riassuntiva sui benefici e sugli eventuali problemi derivati dall'adozione del refactoring.
• Dettaglio delle meccaniche di trasformazione, vale a dire tutti i refactoring steps necessari per modificare il codice al fine di migliorarne il design.
• Uno o più esempi completi, con spiegazione dettagliata di tutti i passaggi necessari.

Il testo è inoltre molto interessante per vedere "in campo" alcune tecniche di sviluppo di cui magari si sente spesso parlare ma che per limiti teorico-pratici o di tempo non è mai stato possibile applicare ai propri progetti software: innumerevoli sono infatti i riferimenti ad alcune pratiche di Agile Development (ad esempio il DRY - Don't Repete Yourself - ovvero l'evitare in ogni modo le duplicazioni di codice), e di Extreme Programming (spesso l'autore cita il contributo del suo "compagno di tastiera" nell'elaborazione dei corretti refactorings); in aggiunta, praticamente ogni esempio del libro è realizzato in base al Test-Driven Development, giudicato dall'autore l'unico metodo realmente efficace per affrontare in tutta sicurezza i refactorings più spinti.

Consiglio quindi senza riserve a tutti questo testo, sia per la chiarezza espositiva (il libro è perfettamente fruibile anche da parte di sviluppatori non particolarmente a proprio agio con i Design Patterns o con le pratiche di refactoring, anzi può essere considerato un valido stimolo per l'approfondimento) che per gli innumerevoli suggerimenti di sviluppo che contiene: non sarà raro, leggendo gli esempi riportati, pensare ai propri progetti e a come migliorarli in base ai dettami del libro.

L'unica nota "negativa" del testo: il codice riportato negli esempi è codice Java! Ciò non pregiudica in alcun modo la leggibilità o la comprensibilità degli esempi, soprattutto per sviluppatori C++ o C#, ma ferisce un pò l'orgoglio degli sviluppatori .NET...

P.S: inevitabilmente, una volta letto il libro vi verrà voglia di comprare pure ReSharper...

Fonte: SlashDot - Conceptual models of a program?