papo we(b)log

la scorsa settimana è stata davvero intensa, piena di cose da fare, ma anche di grandi soddisfazioni. dopo aver lasciato il mio vecchio lavoro per potermi dedicare a tempo pieno alla tesi e dopo essermi laureato, ho finalmente ora una nuova occupazione. per quale motivo sono così contento? intendo, quali sono gli aspetti che rendono particolari queste novità? con ordine...

il primo obiettivo che mi ero posto, quando ormai avevo le idee chiare sul periodo in cui mi sarei laureato, era di ricercare, almeno in una prima fase, un'azienda che mi desse la possibilità di continuare a lavorare su quanto avevo potuto sperimentare per il mio lavoro di tesi: test-driven development, integrazione continua, sviluppo agile. finita una prima "tornata" di ricerche avrei poi un po' "abbassato il tiro" e avrei iniziato a ricercare un più generico impiego come sviluppatore. non sono molti i contatti che sono riuscito a trovare: in tutto, meno di una decina, di cui solo la metà mi hanno dato la possibilità di propormi per un lavoro (inoltro curriculum, incontri per colloqui).

prima novità: ho trovato un nuovo lavoro e devo dire che sono stato davvero fortunato. mi hanno dato infatti la possibilità di unirmi ad un gruppo di eXtreme Programming! quello che intendo dire non è che "poichè è un gruppo xp lavorerò con i più bravi", ma semplicemente che lavorare in un gruppo xp rispetta esattamente quanto mi ero prefissato. ad esempio, durante il colloquio ho fatto una breve sessione di pair-programming, per la realizzazione test-driven di un (semplice) modulo. se questo rappresenta anche solo in parte quello che farò quotidianamente, ho davvero centrato l'obiettivo!

seconda novità: si cambia ambiente. per i prossimi tempi avrò a che fare quasi esclusivamente con Java. (... tempo per eventuali commenti ... ok, avanti... ) l'idea non mi fa nessun effetto: ho realizzato sistemi in .NET negli ultimi due anni e mezzo, ho imparato quali sono i problemi del software aziendale e quali i principali ambiti in cui ricercare le soluzioni. tecnologia e strumenti sono (nel limite del possibile) dettagli, almeno per me. Java è pieno di difetti, ma grazie all'uso intensivo di .NET posso ora vederne anche gli enormi pregi.

quando me ne hanno parlato per la prima volta era in un corso universitario: Java come linguaggio di programmazione. no, non mi soddisfa del tutto, lo ammetto, sopratutto dopo aver giocato con C# 2.0 per un bel po'. ma Java è anche un'ambiente (virtual machine e librerie standard), così come lo è CLR. dopo aver aver provato a realizzare un progetto, per un corso in università, basato su socket e thread, il tutto in C++ e dopo averlo riscritto almeno un paio di volte senza grandi successi, ho deciso di usare C# e .NET (Java per me era ancora solo un linguaggio). le cose sono state davvero più semplici: garbage collector, collezioni, etc.. solo allora ho capito l'utilità di un ambiente di esecuzione.

quando poi, negli ultimi mesi, ho ripreso in mano Java (mi sono comprato e studiato un bel libro per aggiornarmi su J2SE 5, ho intensificato l'uso di Eclipse, ho messo in piedi qualche webapp con Tomcat e ovviamente imparato la sintassi di jUnit e di librerie di mock objects) sono stato quasi sorpreso di aver sempre avuto sotto gli occhi uno strumento del tutto analogo (a .NET), e non essermene mai accorto. a questo devo aggiungere che i principali strumenti che ho usato per lavoro derivano (porting o ispirazione) dal mondo Java, come NHibernate, Spring.Net, Log4Net, NAnt, etc... il punto è quindi: non mi spaventa affatto abbracciare Java e credo che il passaggio sarà non troppo doloroso.

terza novità , direi la più importante: cambio città! mi trasferisco a Milano! questa è la sfida più ardua e che più di tutte spero di poter vincere: vivere da solo, in una città che non conosco. ho trovato un appartamento a una decina di minuti di metro dal posto di lavoro, quindi altra grande fortuna. questa settimana trasloco, e poi via! si inizia!

neanche due mesi fa pensavo a cosa togliere dalla presentazione per la tesi, a scegliere le parole più adatte. ora mi dovrò preoccupare di gestire casa, coinquilini, nuovi colleghi, un lavoro nuovo. credo proprio di essere in uno di quei "punti" di passaggio che ci mettono alla prova, ma che ci offrono anche grandi soddisfazioni.

alla prossima!
-papo-

finalmente, non so come, trovo il tempo di postare le prime impressioni sulla mia nuova situazione: nuovo lavoro e nuova città, nuovi colleghi e nuova casa. è passato appena un mese, eppure sono tantissime le cose che avrei da raccontar(mi). per ora voglio focalizzare le idee solo sugli aspetti di lavoro. quindi...

come avevo accennato nello scorso post, ho avuto la possibilità di unirmi ad un gruppo di eXtreme Programming avviato, imparare quindi da chi queste cose le vive quotidianamente da anni. il team al momento non è esteso, e questo mi ha permesso di poter "sperimentare" il lavorare in coppia con tutti gli altri elementi del gruppo, a turno, su problemi diversi. in questo modo ho avuto la possibilità di toccare tutte le parti di cui è composto il progetto, entrando di volta in volta nel vivo dei problemi.

la prima cosa che ho imparato è il rapporto con il tempo. in passato, io e il tempo non siamo sempre andati d'accordo, diciamo che generalmente vinceva lui: finiva la giornata, io ero distrutto, a volte per la fretta di concludere, che mi portava a intensificare il lavoro per lunghi periodi, con l'evidente stress che ne derivava. ora le cose sono diverse, e posso dire di essere sulla strada buona per prendermi qualche rivincita!

il tempo è scandito da una unità atomica, che nel nostro caso è il pomodoro: 25 minuti di lavoro seguiti da 5 minuti di pausa. questo significa che non mi è concesso occupare la mente per un periodo più lungo di una mezz'oretta, c'è sempre una piccola sosta per riposare il pensiero e riprendere le forze. ma la cosa più importante è imparare a stimare l'effort necessario a completare una qualche attività: è perciò fondamentale poter misurare e tracciare come il tempo venga speso durante una giornata. per questo per ogni compito e funzionalità che prendiamo in consegna, rappresentati da carte (sì sì, simpatici foglietti di carta con un nome scritto sopra e in caso qualche annotazione), vanno segnati quanti pomodori sono stati utilizzati e come questi sono stati spesi: esplorazione, codice, rifattorizzazione, integrazione, etc. a fine giornata poi, prima di andare a casa, inseriamo queste informazioni in uno strumento di tracking: ci saranno utili per trarre alcune considerazioni sull'andamento dell'iterazione di sviluppo, confrontando misuarazioni e stime iniziali.

infine l'altra novità, decisamente piacevole, è stata scoprire che parte del mio lavoro consiste nello studio. dico "decisamente piacevole" perchè si tratta di qualcosa che ho sempre fatto per passione e che ora sono chiamato a fare per mestiere. design patterns, principi di progettazione del software, articoli e interi capitoli dei libri della letteratura di riferimento (xp, refactoring) sono alcune delle cose che ho potuto (ri)prendere in considerazione, analizzare, schematizzare (ad esempio con delle mappe mentali) e discutere con il resto del team: qualcuno risponde alle domande che mi sono fatto e anch'io contribuisco a chiarire i dubbi di qualcun'altro. come qualsiasi altra attività, anche il tempo dedicato allo studio (in genere un'ora al giorno) di ciascun argomento viene stimato e misurato.

non posso quindi nascondere la soddisfazione nello scoprire quanto spazio mi sia concesso per crescere professionalmente. primo perchè il lavoro è svolto sempre in coppia (pair programming): questo favorisce il confronto e la collaborazione continua. e nonostante io sia il più giovane e meno esperto si fa tesoro anche della mia esperienza in questioni tecniche (come la gestione della persistenza - Hibernate e il suo cugino .NET sono parenti strettissimi!). secondo, per gli stimoli allo studio, ovviamente finalizzato all'applicazione in pratica di quanto appreso. la "biblioteca" interna è infinita e ghiottissima! e, se non bastasse, sono anche disponibili account per leggere articoli di alcune riviste online.

ho solo scalfito la superficie degli argomenti che avrei voluto affrontare, ma per questa volta direi che può bastare (se solo penso al fatto che questo post è stato abbozzato due settimane fa mi vengono i brividi!). spero di poter raccontare i dettagli di quanto resta da qui in avanti.

a presto
-papo-

finalmente sono riuscito a finire di sistemare il materiale per una presentazione che darò la prossima settimana, che ho chiamato "Sviluppo software guidato dal testing, metodologie e strumenti", che in sostanza si tratta di un approfondimento degli argomenti che ho affrontato nel mio lavoro di tesi.

la cosa fantastica è che la presentazione la devo fare nella mia (ex) università! il docente che mi ha seguito per il lavoro di tesi mi ha infatti messo a disposizione un'ora del suo corso per esporre ai suoi studenti le tematiche che ruotano attorno al TDD, e di certo non mi sono tirato indietro!

così, ho articolato il tutto in modo che ci sia una prima parte di introduzione alle metodologie, per ciascuna indicando alcuni strumenti Open-Source disponibili, e poi mostrando un esempio pratico di sviluppo. il corso (di ingegneria del software, modulo B) usa come riferimento Java, quindi è questo il linguaggio che ho usato per il progetto, ma nella presentazione metto sempre a confronto Java e .NET, e poi in ogni caso gli argomenti sono applicabili in un qualasiasi ambiente.

ecco una breve descrizione dei contenuti:

• riepilogo tipologie di testing : in piccolo (unità), in grande (integrazione, accettazione), nuovo significato di testing
• Test-Driven Development : progettazione e test di unità, red-green-refactor, xUnit (jUnit e NUnit), isolamento (fake, stub, mock), testing basato sullo stato e basato sulle interazioni, mock objects dinamici (EasyMock e Rhino.Mocks)
• Customer Test-Driven Development : requisiti, test di accettazione e layer dell'applicazione, FIT e FitLibrary, principali tipologie di fixture
• demo: "simple login", servizio di autenticazione utenti, CTDD delle regole del dominio e dello strato di presentazione, scrittura fixture di FIT, TDD delle singole classi, stub e mock per le dipendenze
• strumenti usati : Fit, FitLibrary, FitNesse, jUnit, EasyMock e Eclipse

il materiale si trova qui:

• slide, http://jacopo.franzoi.googlepages.com/slideTDDunibs.pdf
• progetto, http://jacopo.franzoi.googlepages.com/simplelogin.zip

il progetto contiene test di accettazione per FitNesse, test di unità e sistema. dopo aver copiato le pagine di FitNesse bisogna modificare l'homepage del progetto (raggiungibile come [root]/SimpleLogin) con il path al percorso contentente il progetto compilato.

a presto.
-papo-

ed eccomi finalmente a scrivere questo post. è da qualche tempo che ce l'ho in mente, ma solo ora sono in grado di poterlo fare. si tratta di una "richiesta di commenti" riguardo al tema che ho analizzato e sviluppato nella mia tesi di laurea, che a breve porterò a termine (qualche settimana al più).

con questo post faccio ricorso (per la prima volta) "alla community" poichè sono interessato a sapere quanto realmente possano interessare e/o essere considerati utili gli argomenti che mi hanno visto impegnato, ormai, per più di un anno. il tema trattato riguarda le pratiche di sviluppo software guidate dal testing e l'adozione di un modello di processo in cui queste siano inserite. lo chiedo per un paio di motivi:

• ovviamente, cercare di rivalutare la qualità del mio lavoro! ormai ho iniziato a dubitarne (principalmente rispetto all'attualità dei temi)
• dato che ho intenzione di cambiare a breve occupazione, vorrei trovare un lavoro in cui poter applicare le pratiche che ho affrontato. vorrei quindi capire quanto la mia tesi sia "spendibile".

quindi, chiedo semplicemente a chi ne abbia voglia di lasciare un commento dicendo quanto i temi risultino interessanti, e in particolare quanto si avvicinino al "reale" lavoro di sviluppo del software. non nascondo che sono particolarmente interessato a conoscere come "funziona" all'estero, quindi anche esperienze a rigaurdo sono più che ben accette.

ok, di seguito cercherò di costruire una sorta di riassunto del mio lavoro, prendendo alcune parti direttamente dalla tesi (come l'abstract). in alcuni punti invece inserisco solo dei brevi commenti, dato che il grosso della tesi è il "report" dello sviluppo di un'applicazione concreta, che adesso vi descrivo.

ringrazio già da ora chi vorrà partecipare a questa sorta di esperimento, non ha effetto diretto sul lavoro visto che tra poco si stampa, quindi non abbiate paura a dirmi di buttare via tutto! mi serve invece per sondare il campo in vista di quella che sarà una delle mie preoccupazioni principali tra qualche mese: trovare un nuovo lavoro. buona lettura!

tesi dal titolo : " Sviluppo software guidato dal testing: un caso di studio".

sommario: "In questo lavoro viene presentata e discussa la pratica dello "sviluppo guidato dal test" (Test-Driven Development), estendendo la stessa con i più recenti aggiornamenti in letteratura e applicando quanto esposto a un caso di studio concreto. L’attenzione si sofferma sulla stesura dei requisiti delle applicazioni, tramite test di accettazione, e sulla progettazione e implementazione di software a oggetti, entrambe attività guidate dal testing in piccolo, evidenziando le differenze tra testing basato sullo stato e testing delle interazioni. Per ogni metodologia vengono presentati alcuni strumenti oggi disponibili, scelti fra quelli Open-Source e rilasciati con licenza libera. L’ambiente di riferimento è il framework .NET, sebbene dove possibile viene sempre fatto un confronto con quanto disponibile per Java. Il caso di studio scelto per illustrare le metodologie proposte è esso stesso uno strumento a supporto allo sviluppo test-driven, trattandosi di un generatore di classi stub e mock. Il lavoro si conclude con valutazioni critiche che vertono a mostrare i vantaggi dello sviluppo iterativo e incrementale unito all’approccio guidato dal test: la produzione di software di qualità e soggetto a un numero ridotto di malfunzionamenti".

indice (capitoli principali):

• Progettare per la testabilità: tecniche di Quality Assurance nel software, principali tipologie di verifica, approcci per aumentare la testabilità dei requisiti (Specification By Example) e dell'architettura (controllabilità e osservabilità dei moduli).
• Metodologie e tecnologie:
  • Iterative and Incremental Development: iterazioni, timeboxing, Unified Process, metodi Agili (XP, Scrum, AUP).
  • Test-Driven Development: principali caratteristiche di un buon test di unità automatizzato, infrastruttura xUnit, test basato sullo stato e stub, guida del design (red-green-refactor) e "refactoring to design patterns", test basato sulle interazioni, mock objects (statici e dinamici), processo di ricerca delle interfacce ("interface discovery"), metriche per i test di unità (copertura e analisi mutazionale).
  • Customer Test-Driven Development: test e criteri di accettazione, customer test e scrittura dei requisiti funzionali, tabelle e fixture di FIT, tipologie di specifica e layering di un'applicazione (regole del dominio e Business/Domain Layer, casi d'uso e Presentation Layer o test funzionali UI per la User Interface).
• Caso di studio: generatore di stub e mock statici partendo da un'interfaccia (scritta in codice sorgente C#), versione a console, estendibile per IDE (es: SharpDevelop).
  • presentazione del progetto: dominio, processo iterativo, ambiente di sviluppo con Integrazione Continua (Trac, FitNesse, Subversion, CruiseControl.NET).
  • prima iterazione: raccolta dei requisiti con pagine wiki in FitNesse (e principali tipologie di fixture di FIT e fitlibrary),  progettazione layering e package, test di unità (NUnit) basati sulle interazioni (Rhino.Mocks) per l'Application Controller, test di integrazione per la prima iterazione, implementazione: realizzazione delle fixture di FIT e scrittura del sistema (test di unità, implementazione e refactoring).
• Considerazioni e valutazioni: pratiche più utili, confronto con altre tecniche di specifica e progettazione (UML, design pattern), correttezza e costi.
• Appendici: risultati dell'ultima iterazione di sviluppo, introduzione a .NET