ISBN: 9788850329212
Autori: Massimo Carli
Editore: Apogeo
Lingua: Italiana
Anno: 2010
Pagine: 576
Allegati: Nessuno

Prima di procedere con la recensione di "Android: Guida per lo sviluppatore", ho la necessità di spiegare con che profilo e da quale prospettiva mi sono avvicinato alla lettura del testo. Dopo alcuni anni, posso ritenermi uno sviluppatore esperto, ma neofita rispetto al mondo Android, che si è trovato nelle condizioni di dovere leggere un manuale sul tema, in grado di avvicinare alla piattaforma, spiegando prima i concetti chiave e, col passare dei capitoli, entrando sempre più nel dettagli e nelle “raffinatezze” specifiche del framework.

Il fatto di approntarmi alla lettura di un manuale concepito e scritto in italiano (e tutti sappiamo che c’è una bella differenza tra volumi concepiti in italiano e volumi in lingua italiana, ma tradotti) e redatto da una persona di cui più volte avevo letto contributi nel corso degli anni (sulle pagine di Mokabyte) non ha fatto altro che aumentare la mia curiosità e il mio interesse. Ho così affrontato il testo tutto d’un fiato, senza leggere a priori opinioni, altre recensioni o commenti dell’autore.

A seguito della lettura, la mia valutazione non è completamente positiva. Quando nella lettura del testo sono incorso in paragrafi inutilmente complessi, contenenti intere pagine di esempi spiegati mediante lunghe frasi, piene zeppe di anticipazioni e rimandi, ammetto di avere incontrato alcune difficoltà. L’essere costretto a rileggere tre o quattro volte l’intera pagina nuovamente, al fine di capire cosa l’autore intendesse dire, oltre a infastidirmi, mi ha dato l’impressione di perdere tempo e di non comprendere appieno le intenzioni dell’autore.

I dubbi e le impressioni negative hanno trovato una motivazione (magari parziale) nelle parole che l’autore stesso dice a proposito del libro sulle pagine del suo sito e che qui riporto: “L’obiettivo non è stato solo quello di dire come si fanno le cose ma soprattutto perché si fanno in questo modo e quali possono essere le conseguenze. Questo approccio, forse più italiano, a mio parere permette infatti di andare oltre il semplice utilizzo di quello che esiste già, ma di passare alla customizzazione ed estensione dei diversi componenti, aspetto essenziale di un framework. Se l’obiettivo è il fare tutto subito, non compratelo”.

Ebbene, probabilmente nella mia esperienza di programmatore, prima che di recensore, sono stato negli anni abiutato a leggere manuali, per usare il paragone dell’autore, redatti secondo un approccio anglosassone — dunque sintetico, pragmatico e volto alla diretta spiegazione del problema e alla presentazione della soluzione — dove i capitoli più teorici, in genere, sono debitamente introdotti e contestualizzati, a volte addirittura proposti sotto forma di appendici.

Detto questo, riportare solo le impressioni negative non rende giustizia all’autore che, è giusto riconoscerglielo, ha fatto un grande sforzo per assemblare un libro che è tutto fuorché banale. Alcuni aspetti del framework sono davvero passati ai raggi X, la numerosità e, questo soprattutto è l’aspetto positivo, la completezza del codice sorgente associato al testo è davvero notevole e apprezzabile.

Rispetto ai contenuti, chiunque può consultare la scheda del libro e l’indice per verificare i temi e gli aspetti trattati. In questa occasione, ritengo più utile citare i passi più significativi.

Certamente interessante e ben strutturato è il capitolo 1, in cui Carli introduce il framework, descrivendo come esso sia nato, sull’esperienza di altre piattaforme Java per il mobile, dalla composizione di diverse librerie e framework opensource, tutti accomunati dall’avere come punto di forza l’efficienza.

Dopo una rapida descrizione dell’ambiente di sviluppo (SDK, plug-in Eclipse con emulatore di dispositivi), a cui è dedicato il secondo capitolo, Carli dedica i successivi quattro capitoli alla spiegazione dei concetti alla base del framework e alla descrizione dei componenti grafici di creazione delle interfacce. Questa parte del testo è certamente la più importante e, purtroppo, quella più ostica e complicata.

Nel capitolo 3 vengono introdotti i componenti chiave del framework (Activity, View, Intent, Service, Content Provider), ma è solo un’anticipazione, ciascuno di questi verrà analizzato nel dettaglio in capitoli successivi. Allora l’autore passa a descriverci le risorse statiche, i meccanismi e le convenzioni per referenziarle, poi introduce l’argomento degli stili e dei temi e infine tratta l’internazionalizzazione. Il capitolo introduce poi il meccanismo di definizione dichiarativa delle risorse, che ricorrerà in quasi tutti i capitoli e in molti ambiti dell’architettura Android.

Nella lettura di questo capitolo, ho avuto per la prima volta la sensazione di una trattazione degli argomenti non troppo lineare, come dimostrato dai continui rimandi o dalle frequenti frasi del tipo "come vedremo più avanti nel testo" o "come dicevamo", a cui l’autore è costretto a ricorrere per guidare il lettore in una lettura che, nonostante questi tentativi, è davvero tortuosa. L’alternanza di paragrafi chiari e scorrevoli a paragrafi poco lineari e ostici sarà un motivo ricorrente in tutto il testo.

Nel corso dei capitoli, mi sono accorto anche che le spiegazioni dei concetti ricorrono, magari con diversi gradi di dettaglio. Questo causa indubbiamente un eccesso di teoria, che non facilita certamente la consultazione puntuale del testo. La stessa scelta di proporre in successione tanti piccoli esempi di codice è a volte spiazzante e costringe il lettore a saltare da un argomento all’altro. Sarebbe stata preferibile l’esposizione di esempi riepilogativi, magari più complessi, costruiti per gradi e relativi a più aspetti.

Oltre a perplessità sullo stile narrativo, in questo capitolo ho incontrato le prime imprecisioni nella proposizione delle immagini a corredo dei paragrafi: il dover girare pagina, avanti e indietro, per consultare uno schema o vedere un’immagine citata nel testo fa pensare che si sarebbe dovuto procedere a una più corretta impaginazione.

Nel capitolo 4 vengono approfonditi i concetti di Activity e Intent: viene spiegato il ciclo di vita di un’Activity; è analizzato il legame tra quest'ultima e il Processo, l'Intent e il Task;, vengono introdotti i concetti di Intent espliciti e a run-time resolution. Per la spiegazione di questi concetti qualche schema o diagramma in più sarebbe stato gradito. Più che in ogni altro capitolo, in questo ricorre spesso il "come vedremo", accanto ad accenni e rimandi. Come già detto, tutto ciò può indurre nel lettore la sensazione che l’autore "non la racconti giusta" e che solo più avanti gli venga detto come stanno realmente le cose.

Il capitolo 5 tratta il tema delle risorse grafiche Drawable, delle view, dei View Group, dei layout e degli adapter. Anche questo capitolo, come il precedente, è davvero molto ostico e a fine capitolo mi è rimasta l'impressione di non aver capito appieno i concetti presentati, i quali, sebbene di per sé non banali, alla fine non sono più complicati rispetto ad argomenti analoghi in altri framework. Il fatto di esporli in un modo inutilmente arzigogolato e complesso, rende la comprensione dei contenuti davvero difficile. Ad ogni modo, il capitolo 5 è, tra quelli proposti, forse il primo che può essere utilizzato in chiave manualistica. La numerosità degli esempi proposti è davvero notevole.

Il capitolo 6 è dedicato ai widget, agli eventi e ai meccanismi per la loro gestione (Listener o Event Handler). Come per il precedente, il lettore può trarre dal capitolo una ricca gamma di esempi da recuperare al momento del bisogno, cosa senza dubbio positiva. Il capitolo 7 si occupa di animazioni, menu, dialoghi e Toast (messaggi temporanei) e ha le stesse caratteristiche espositive dei due precedenti.

A partire dall’ottavo capitolo, e siamo già ben oltre la metà del volume, fino alla fine del testo, la leggibilità migliora, sarà forse perché il lettore ci ha fatto il callo, o perché, nonostante tutto, un’idea di massima del funzionamento dei meccanismi ormai ce l'ha. In quest'ultima parte del volume, l’autore introduce i concetti più avanzati di Android, che sono poi quelli che normalmente si trovano in tutte le piattaforme di sviluppo per dispositivi mobili: si parla così di accesso e gestione dei dati, di persistenza, di DBMS, di infrastruttura a servizi, di rete, di navigazione web fino ad arrivare a temi di contorno (ma ugualmente importanti), a cui l’autore dedica poche pagine per ciascuno, quali la sicurezza, l’accesso alle mappe, le gesture, il text-to-speech, fino alla gestione multimediale e, per ultimo, all’uso del Bluetooth. E anche per questi temi gli esempi non mancano.

Col senno di poi, il volume può essere ritenuto adatto a un lettore che ha già approcciato lo sviluppo in Android. Un tale lettore avrebbe apprezzato più di quanto ho fatto io il volume e anzi avrebbe colto l’occasione di leggerlo per approfondire concetti e riordinare le idee. A tal proposito, cito le parole di altre persone che hanno letto il libro e con cui ho avuto occasione di scambiare un’opinione: questo è il tipico testo che uno sviluppatore può apprezzare maggiormente alla seconda, terza rilettura, magari compiuta di fronte alla necessità di rispolverare i concetti contro cui ci si è già scontrati nell’attività di sviluppo giornaliero.

Fra gli aspetti positivi, la ricchezza degli esempi di codice che accompagnano il libro e da cui lo sviluppatore può prendere spunto.

Fra le pecche del testo, l’inutile complessità del linguaggio e la poco linearità nella proposizione degli argomenti, specie nella prima parte della trattazione.