papo we(b)log

Customer Test-Driven Development with FIT and FitNesse

papo — Sun, 06 Jul 2008 10:08:53 GMT

no, non è un post in inglese. il titolo si riferisce alla sessione che io e il mio collega Tommaso abbiamo tenuto lo scorso giovedì per i ragazzi della ESSAP (European Summer School on Agile Programming) presso Villa Toeplitz a Varese. è stata un'esperienza stupenda, sia per il fatto che ci siamo tutti divertiti moltissimo, sia per l'interesse che i partecipanti (un po' assonnati per il post pranzo!) hanno dimostrato verso i temi esposti.

putroppo, questa era la prima volta che la sessione prendeva corpo, e quindi sicuramente non siamo stati efficaci quanto speravamo: l'argomento è insidioso perchè offre il fianco a lunghe discussioni puramente tecniche, errore in cui siamo caduti anche noi. il pubblico, una ventina di ragazzi da tutta europa, era molto eterogeneo, chi vedeva per la prima volta le tematiche legate ai metodi Agili, accanto a chi invece già adotta alcuni principi e pratiche nel proprio lavoro ed era lì per affinarli o capire come farli meglio funzionare.

abbiamo scelto di dividere la sessione in due parti. prima un'introduzione al concetto di iterazione e test di accettazione scritti da/con il cliente, quali possibili forme usare per scriverli e quali tool esistono a supporto. abbiamo descritto in dettaglio il funzionamento di FIT e FitNesse e mostrato le principali fixtures usate, quelle di FIT e alcune di FitLibrary.

nella seconda parte della sessione invece abbiamo fatto un esercizio, partendo da un esempio scritto da noi (una variazione di quello che i ragazzi avevano già visto in altre sessioni): un semplice gioco di ruolo per il quale abbiamo realizzato una decina di user stories, corredandole di test unitari e test di accettazione. quindi abbiamo eletto a customer uno dei ragazzi nel pubblico, chiesto a lui di inventarsi la prossima user story e iniziato a descriverla in forma testuale su una lavagna. prendendo spunto da quanto già fatto per le altre storie, abbiamo poi scritto un test di accettazione, sempre su lavagna, e tradotto poi in forma tabellare.

il resto del pomeriggio (troppo breve!) i ragazzi hanno così lavorato in coppie cercando di implementare la storia richiesta, partendo dalla traduzione in FitNesse del test di accettazione, collezzionando una bella "barra rossa", doverosa a inizio iterazione. hanno poi iniziato a decidere dove porre le responsabilità richieste, e mi pare che tutti abbiano deciso di assegnarle a oggetti già esistenti, iniziando così a scrivere i test unitari, a vederli fallire uno ad uno, per poi modificare il sistema e godersi il premio di una barra verde!

anche se l'esempio era molto semplice e le modifiche da aggiungere davvero limitate, ho notato la soddisfazione sopratutto dei ragazzi nuovi alle tematiche ad ogni esecuzione con successo dei test unitari. è quello che in eXtreme Programming viene detto il valore del feedback, assolutamente fondamentale.

prima di andare a casa, tutte le coppie sono riuscite a chiudere la micro-iterazione, verificando che il loro lavoro fosse corretto e concluso, vedendo passare con successo anche il test di accettazione. qualche coppia, avendo finito in anticipo, ha iniziato a lavorare su una seconda carta, inventata al momento. mi spiace solo che l'abbiano scelta loro invece di coinvolgere il "customer-per-un-giorno", ma è comprensibile dato l'entusiasmo e la brama di giocare col la pratica e lo strumento.

a me non resta che ringraziare tutti: gli organizzatori (primo tra tutti il mio coach Matteo) per l'occasione concessa e i partecipanti per le ottime domande a cui abbiamo cercato di rispondere in modo conciso. da parte mia, è stata una giornata splendida, mi ha fatto crescere come "speaker", ruolo per me nuovo, ho avuto anche l'occasione per conoscere di persona alcuni nomi "digitali" (come Luka), e si è conclusa con uno ottimo social-dinner!

il materiale della sessione sarà presto disponibile sul sito della ESSAP, nel frattempo è raggiungibile qui:

mindmap
esercizio (in java)

le nostre gesta sono anche state immortalate! più le rivedo e più sorrido. in ogni caso, sono qui, qui, qui e qui (peccato non si veda la scritta sul mio tesserino "Jacopo - xtreme guitarist", nascosta dalla maglia rosso acceso!).

grazie ancora a tutti, spero la scuola possa farsi conoscere ancora di più, magari nelle prossime edizioni ci troveremo anche molti della comunità ugidotnet!

a presto.
-papo

[OT] eXtreme Programmers cercasi

papo — Mon, 28 Apr 2008 17:16:33 GMT

segnalo questo annuncio di lavoro, che qualcuno avrà già letto sulla mailing list di extreme-programming italia.

il mio team vuole allargarsi!
siamo alla ricerca di giovani agilisti nella zona di milano, chiunque fosse interessato può contattare direttamente Matteo, che attualmente ricopre il ruolo di coach.

spero di poter incontrare presto qualcuno di voi!
ciao
-papo-

[OT] 365 motivi per essere soddisfatto

papo — Thu, 17 Apr 2008 20:38:37 GMT

se c'è una cosa che mi dispiace davvero è aver permesso che il mio blog rimanesse in silenzio per così tanto tempo. è passata una vita dal mio ultimo post, ma sopratutto tante sono le cose successe. occasione, che cerco oggi di cogliere, è un particolare anniversario che cade questa settimana: un anno da quando ho iniziato a lavorare come eXtreme Programmers, un anno che vivo da solo, un anno in una città come milano.

il 2008 si è aperto con una grossa novità, una grandissima occasione: si è conclusa la collaborazione che mi ha visto impegnato per gran parte dello scorso anno ed è iniziato il mio nuvo impiego, a tempo indeterminato, per una piccola ma attivissima realtà nel panorama Agile italiano. nello stesso tempo, mi sono impegnato a tempo pieno come membro dello XP User Group locale, organizzando alcuni incontri sia nella vecchia azienda che in quella nuova. con i ragazzi dello xpug abbiamo anche partecipato alla scorsa edizione dell'Agile Day, in cui ho avuto modo di dare un volto a mille dei nomi conosciuti in rete.

un anno, tempo di tirare le somme. mi vergogno quasi un po' a dirlo, questo anno appena passato è stato per me davvero importante: ho imparato un mestiere, il mestiere che mi sono scelto e che mi appassione ogni giorno di più, affiancando dei veri professionisti e toccando con mano il valore dell'approcio Agile allo sviluppo del software. e sono cresciuto sopratutto come persona, imparando a vivere fuori casa, ad organizzarmi la vita.

la novità più grossa è che mi è stata offerta la possibilità di fare mentoring. da oltre due mesi infatti sto seguendo un team di una grossa banca italiana nel suo percorso di avviamento all'agilità. particolarmente interessante è la formula scelta: un team misto, in cui alterniamo attività di formazione ad altre di sviluppo puro. tutto questo è decisamente stimolante, passare in così poco tempo da apprendista stregone a sciamano! la portata della responsabilità è notevole, ma è altrettanto grande la soddisfazione nel sentirsi dire, da sviluppatori che fanno questo mestiere da anni, "grazie di avermi fatto scrivere tutti questi test", o nel vedere riconosciuto il valore del customer on-site e della continua comunicazione.

questo è quanto, non posso che considerarmi soddisfatto dei mie miseri 27 anni. auguro a molti miei coetanei che vengano loro offerte le stesse opportunità che ho ricevuto io, e che sappiano farne buon uso!

dimenticavo l'ultima novità: sto scrivendo da un bellissimo MacBook Pro!

a presto
-papo-

Model-View-Presenter per Compact Framework

papo — Fri, 26 Oct 2007 07:19:39 GMT

stavo per rispondere a Jeremy , che è curioso di sapere quale variante di Model-View-Presenter sia maggiornente diffusa tra i suoi affezionati, indicando come nel mio caso si tratti del Passive View. però poi mi sono accorto che era uno spunto buono per un post... [continua]

Re: Unit test e build server

papo — Thu, 28 Jun 2007 07:32:00 GMT

stavo per rispondere a questo post, poi mi sono accorto che e' disabilitato il feedback, quindi posto qui il mio commento.

in realta' non hai *risolto* il problema, prima o poi qualcuno dovra' fixare il codice che ha 'rotto' la build. hai soltanto aggiunto un ritardo tra quando il problema e' stato introdotto (durante la scrittura del codice), a quando il problema sara' visibile (la build di CC.NET che fallira').

in realta' chi notera' che la build si e' rotta potresti non essere tu (o chi ha aggiunto il codice incriminato) e quindi sara' piu' difficile localizzare e correggere l`errore. 5 minuti non mi sembrano affatto molti, prova a considerare i vantaggi che hai nel feedback immediato sulla correttezza del tuo codice, rispetto a dover correggere a posteriori l`errore di qualcun`altro.

in azienda noi seguiamo una politica di questo tipo: mentre sviluppi esegui solo i test della parte che *pensi* sia influenzata dal nuovo codice (classi correlate e qualche test di accettazione che tocca quella parte), ma poi prima di integrare e committare le modifiche viene eseguita tutta la suite di test, due volte: la prima solo sulla propria versione del codice, la seconda dopo aver prelevato le modifiche dal repository e corretto i conflitti.

questo perche' la rottura di una build e' una cosa seria: in alcune aziende ci sono riti di fustigazione pubblica dei colpevoli (cappelloni ridicoli da dover indossare per tutto il giorno) o sirene di allarme che suonano per l`ufficio! questa invece e' una lava-lamp collegata a CC.NET

ciao!
-papo-

qualche novità all'orizzonte

papo — Tue, 10 Apr 2007 12:11:00 GMT

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-

XP, prime impressioni

papo — Fri, 18 May 2007 07:09:00 GMT

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-

[semi-OT] presentazione TDD in Java e .NET

papo — Sun, 18 Mar 2007 19:38:00 GMT

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:

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-

Jeek project: primo rilascio

papo — Mon, 26 Feb 2007 13:07:00 GMT

finalmente ho pubblicato il progetto Jeek, un generatore di classi stub/mock per il testing di unità in .NET. si tratta della versione iniziale (che ho indicato come 0.1 alpha) che corrisponde alle prime due iterazioni di sviluppo. al momento quindi copre solo la generazione di classi concrete (fake) e stub ed è avviabile da riga di comando. si tratta del progetto che ho realizzato come caso di studio per la mia tesi di laurea specialistica (di cui parlavo in alcuni post precedenti), ma che s

Esempio (semplice) di UI Test-Driven con MVP

papo — Mon, 29 Jan 2007 14:12:00 GMT

ho pubblicato un articolo sulla mia esperienza nel realizzare test-driven una UI WinForm, usando il pattern Model-View-Presenter.
si tratta solo di un inizio, e mi sono focalizzato più sulla specifica dei comportamenti tramite test (di accettazione e di unità), meno sull'implementazione (magari in un prossimo post).
ecco il link:
http://blogs.ugidotnet.org/papo/articles/69048.aspx