|
 |
|
|
|
|
 |
|
La scheda del libro
Autore: Sandro Pedrazzini
Prezzo: € 29,90
Caratteristiche: 298 pag - 17x24 bn
ISBN: 8848119166
Anno di edizione: 2006
Editore: Tecniche Nuove |
 |
|
|
|
|
|
|
I capitoli del libro
Questo libro è diviso in ventiquattro capitoli raggruppanti in quattro parti, nelle quali poco alla volta si affrontano i temi cardini per diventare un buon designer del software utilizzando una corretta ed agile progettazione. Nella prima parte, per mezzo di un esempio, si affrontano i primi passi per un design object-oriented, nella seconda parte si procede con il descrivere ed analizzare una serie di design pattern, spiegandone il significato e il loro utilizzo. La terza parte è dedicata alla fase di test, utilizzando principalmente la tecnica del JUnit. Infine nella quarta e ultima parte, si affronta il tema del refactoring; qui come nel resto del libro, ci sono alcuni esempi a garantire la comprensione dello stesso. Vediamo ora il contenuto dei singoli capitoli.
Capitolo 1: Introduzione
Nel primo capitolo viene fatta una breve panoramica di tutto il libro. Vengono introdotti in modo generico i metodi agili, i quali si contrappongono ai metodi tradizionali per la loro capacità adattativa; i design pattern, nati dall'esperienza della progettazione; i metodi di refactoring, che lasciano immutata la funzionalità di un programma, ma nel contempo ne modificano la struttura interna e infine i metodi di test unitari.
Parte I Visione Generale : verso un design object-oriented
Capitolo 2: Problema iniziale
Nel secondo capitolo viene presentato un esempio pratico di semplice design, che adempie alle funzionalità richieste. Successivamente sono introdotti i primi concetti di test di unità per la verifica di consistenza.
Capitolo 3: Prima verifica e fattorizzazione
Nel terzo capitolo si continua a prendere in considerazione l'esempio presentato nel capitolo precedente, con lo scopo di andarlo a migliorare introducendo alcuni passi di refactoring. Il refactoring è utile per capire meglio l'assegnazione delle responsabilità da dare alle classi Java.
Capitolo 4: Fattorizzare per il test
Il quarto capitolo è formato da poche pagine e dopo aver ripreso l'esempio visto in precedenza viene sottolineato dove è possibile avere problemi di prestazioni legati alla fattorizzazione del codice.
Capitolo 5: Problemi di classificazione
Nel quinto capitolo vengono dati preziosi suggerimenti su come evitare la duplicazione dei controlli all'interno di un programma.
Capitolo 6: Condivisione della sequenza
Con il sesto capitolo si chiude la prima parte del libro. Qui si ottimizza l'esempio presentato nel secondo capitolo. Inoltre si introduce il pattern legato all'ereditarietà denominato Template Method Pattern il quale costruisce il template che specifica la struttura complessiva di un algoritmo.
Parte II Design pattern
Capitolo 7: Introduzione all'idea di pattern
Nel settimo capitolo vengono introdotti i design pattern. L'idea alla base è la conoscenza e l'esperienza nel design e nel redesign. Questa metodologia di progettazione si addice meglio nel rivedere continuamente il design per adattarlo il più possibile ai nuovi requisiti. I metodi agili partono da un numero limitato di funzionalità e con l'aggiunta di nuove attività si inseriscono i pattern nell'architettura che evolve.
Capitolo 8: Design e programmazione object-oriented
L'ottavo capitolo riassume i concetti fondamentali per la programmazione object-oriented utili a comprendere le strutture dei design pattern. I concetti analizzati sono l'information hiding e data abstraction, l'ereditarietà e la composizione, il polimorfismo, il binding dinamico
Capitolo 9: Definizioni di design pattern
Nel nono capitolo viene analizzato il Pattern Proxy che ha come scopo quello di utilizzare un oggetto B al posto di quello effettivo A, ossia delegare all'oggetto B le richieste destinate all'oggetto A, così da utilizzare (creare, istanziare) l'oggetto A quando se ne ha veramente bisogno.
Capitolo 10: Utilizzo di un pattern: Iterator
Nel capitolo dieci viene analizzato il Pattern Iterator. Con l'uso di poche righe di codice, si analizzano quali sono gli svantaggi che nascono dall'uso di un array e di una lista semplice che vengono risolti con l'uso del relativo pattern.
Capitolo 11: Affrontare il design
Nell'undicesimo capitolo ci si sofferma su come si passa da un'analisi accurata dei requisiti al design. I passi intermedi suggeriti sono: produrre diagrammi UML (Unified Modeling Language), diagramma delle classi, diagramma di sequenza, diagrammi dei casi d'uso permettono di avere un'architettura del sistema. Utilizzare sia l'eXtreme Programming così da avere una visione minima del design, che i design pattern. Inoltre è preso in considerazione anche il riutilizzo interno, esterno(toolkit), ed in framework object-oriented.
Capitolo 12: Applicare i pattern
Nel dodicesimo capitolo vengono presentati una serie di design pattern. Il primo design pattern analizzato è il Pattern Strategy che ha come scopo quello di separare un algoritmo all'interno di un oggetto. Il secondo pattern è il Pattern Template, il suo fine è definire la struttura di un algoritmo utilizzando operazioni da definire in sottoclassi. Il terzo design è il Pattern Decorator, utile per togliere od aggiungere funzionalità in modo dinamico. Come ultimo viene presentato il Pattern Observer adoperato per tenere sotto controllo lo stato di diversi oggetti.
Capitolo 13: Pattern per il Web
Nel tredicesimo capitolo sono presenti i design pattern per il WEB (World Wide Web). In particolare sono trattati i Pattern Trasform View, utile per regolare la trasformazione dei dati che arrivano dal modello in dati HTML per l'utente finale; il Pattern Two Step View dove si crea la struttura logica della pagina HTML e successivamente si modifica la pagina in HTML.
Capitolo 14: Canoo ULC e il pattern Half-Object
Nel quattordicesimo capitolo viene presentato il design Pattern Half-Object utile quando si vuole gestire in maniera uniforme oggetti che dovrebbero stare in più spazi di indirizzamento.
Capitolo 15: A caccia di pattern
Il quindicesimo capitolo conclude la seconda parte del libro, viene ripreso brevemente il concetto di framework e illustrato in modo rapido il design Pattern Bridge.
Parte III Test di unità
Capitolo 16: Test automatico
Il sedicesimo capitolo è dedicato ai test di tipo automatico. I motivi per cui si dovrebbero utilizzare tali test sono: propensione al cambiamento e all'utilizzo del refactoring. Inoltre verificando il codice si aumenterebbe la produttività. Nella programmazione agile è pertanto necessario l'impiego di tale strumento.
Capitolo 17: JUnit
Il diciassettesimo capitolo è indirizzato ai test di tipo JUnit. Tali test sono utili per testare nel software le sue funzionalità sia nella fase di progettazione che nella fase di manutenzione. I JUnit sono test semplici, automatici e componibili. Tali test fanno uso del procedimento di assert.
Capitolo 18: Sviluppare con JUnit
Il diciottesimo capitolo mostra un esempio che utilizza lo strumento JUnit. Il suo utilizzo è stato introdotto nel momento in cui si è interamente capito cosa bisognava verificare. Proprio con l'uso del JUnit si procederà con l'aumentare il design.
Capitolo 19: Design by testing
Nel diciannovesimo capitolo si introduce una delle tecniche più all'avanguardia dei nostri tempi: il Design by testign. Tale tecnica parte dalla creazione di test per realizzare successivamente le funzionalità e quindi l'intero design.
Capitolo 20: Test-driven development
Nel ventesimo capitolo si espone la tecnica TDD(Test-driven development), nata dall'eXtreme Programming. Il TDD non parte dallo sviluppo del software, ma dall'analizzare qual è la funzionalità del programma. Inizialmente si comincia con lo scrivere poco codice e poi si passa subito alla fase di test, dopo questa fase si riscrive il codice partendo dal soddisfare il test. Una volta verificata la correttezza del test, si passa alla fase di refactoring che renderà il codice più generico, così oltre a soddisfare il test iniziale, rivestirà l'intero dominio del problema. Inoltre vengono presentate le tre strategie del TDD: l'implementazione fasulla, la realizzazione diretta e la triangolazione.
Parte IV Refactoring
Capitolo 21: Introduzione al refactoring
Nel ventunesimo capitolo viene trattata la metodologia del refactoring ossia della fattorizzazione del codice. Tale tecnica è utile per evitare che ci siano delle inesattezze nel design e anche per non avere impatti negativi con l'introduzione di nuove funzionalità.
Capitolo 22: Primi esempi di refactoring
Il ventiduesimo capitolo propone due esempi di codice abbastanza semplici su cui si applica il refactoring.
Capitolo 23: Refactoring complessi
Nel ventitreesimo capitolo vengono presentati metodi di refactoring complessi partendo dal modello MVC(Model view controller). Il refactoring proposto è il Separate Doman From Presentation che offre la possibilità di avere una struttura modulare partendo da una struttura legacy (struttura massiccia).
Capitolo 24: Design by refactoring
Il ventiquattresimo capitolo è l'ultimo del libro. In esso è presentato il design pattern denominato Pattern Visitor. Tale pattern ha come finalità quella di cercare di adattare e modellare il più che sia possibile una operazione sugli elementi di un'intera struttura di oggetti. L'introduzione di questo design pattern è stata proposta tramite il refactoring ed è proprio per tale motivo che tale tecnica viene chiamata design by refactoring.
Gli esempi allegati
Il libro non è dotato di CD o DVD, ma sia in tutti i capitoli che nel Appendice A viene presentato il codice sorgente degli esempi Java. Come acquistare il libro
Se desiderate acquistare questo libro, lo potete fare direttamente online da questo sito.
Conclusioni
Il libro affronta in modo chiaro i temi di una buona ed agile progettazione, il linguaggio utilizzato è semplice e comprensibile, ma sicuramente è consigliato ad un lettore che vuole migliorare la propria conoscenza sulla progettazione del software. Il libro infatti presuppone che il lettore abbia una certa dimestichezza ed abilità con il linguaggio di programmazione Java. Nel libro alla fine di tutti i 24 capitoli, è presente un riepilogo utile a riprendere e rimarcare in modo veloce i temi trattati.
L'autore della recensione
Fiammetta Pascucci
Ingegnere informatico con specializzazione in Ingegneria del Software e conseguimento del master thesis presso la Linköping University. Le aree informatiche di mio maggior interesse sono quelle relative all'informatica grafica (modellamento e realizzazione di volti 3D), human computer interaction e applicazioni in ambiente mobile. Attualmente sono un'analista tecnico e sviluppo applicazioni in ambiente J2EE.
Il suo blog è visibile all'indirizzo: http://fiammettapascucci.blogspot.com/
Note sul copyright
Questa recensione è stata fornita con esplicito consenso dell'autore sotto licenza Creative Commons.
Leggi la licenza d'uso.
|
