Archive for December, 2006

Microsoft brevetta RSS

Saturday, December 23rd, 2006

Summary: it seems Micro$oft is trying to patent RSS

Per la serie “i brevetti servono a stimolare l’innovazione”, abbiamo la società dell’uomo più ricco del mondo che brevetta una cosa che è stata inventata molti anni prima da persone che non lavorano per Micro$oft. Che vergogna. E comunque non c’era bisogno di un altro argomento per dimostrare che tutti i brevetti sul software sono ingiusti.

Do they think it’s good that Microsoft comes into a market that was doing pretty well without them, and before they ship a single product, are already putting up barriers to keep others out? That’s good?? Really. Why?
Dave Winer

Three interesting Java libraries

Friday, December 22nd, 2006

Sommario: tre interessanti librerie Java

The standard Java date/time classes suck. There’s not much arguing about that. You either use the good, old, reasonable java.io.Date constructors that take year, month and date, but are deprecated thanks to the political correctness police; or you use the brain-damaged GregorianCalendar that wants, hear this, 0-offset months (that is, you pass it 2 and it means March). I’ve seen novices and not-so-novice programmers waste heaps of time trying to do simple date manipulations that should be dead easy. I certainly have.

So it’s good luck that some good people wrote the Joda library: it’s a simple and sane complete replacement for the Java date and time classes.

  *       *
      *

David Eric Evans is the author of Domain Driven Design, that is sitting in my pile of Books I Will Read Next since a long time. This book teaches how to concentrate on the “domain” part of software, which is in a sense a return to object-oriented basics. Recently David Eric released a free summary of his book. In the interview that goes with it I found out about the Time and Money library, that implements in Java a fragment of domain model that is common to many business applications. This is worth looking into, in a “let’s read software not just write it” way.

  *       *
      *

I strongly dislike Java Server Pages. It’s not the idea of mixing Java and Html that I don’t like; in fact, I’m perfectly comfortable with Rails’ ERuby templates. The thing I don’t like is that it’s very difficult to test them; you essentially need to run them in a servlet container, and that makes it nearly impossible to unit test them.

For this reason a while ago I used Velocity in a web application project. I’m not too keen on Velocity either, since it’s way more complicated than necessary to set up. So I’m happy that there are alternatives: the now apparently dead OpenSails project has the Viento template engine. And Terence Parr, the author of the ANTLR parser generator, wrote StringTemplate.

  *       *
      *

So in the end that makes it four libraries. I lied :)

Merry Christmas — Un Natale di Pace a tutti!

Ma quale ingegneria?!

Tuesday, December 19th, 2006

Summary: they often say that software engineering is about transitioning from craftsmanship to craft + science. The flaw in this reasoning is that practice in software development is not yet at the craftsmanship stage. (By a similar reasoning we see that even computing science is not really science, but is at a pre-science stage.)

Employers … complain that they do not know what a graduate of either a CS program or a traditional engineering program can be expected to know about software development.

— David Parnas

Si sente spesso dire che l’idea di software engineering consiste nel passare da uno stadio artigianale, caratterizzato da modi di lavorare provati dall’esperienza, a uno stadio scientifico, in cui la scienza ci permette di andare oltre gli schemi tramandati dalla tradizione per scoprirne di nuovi.

Sono perfettamente d’accordo con questa immagine di come la scienza, combinata a un sapere empirico artigianale, conduce all’ingegneria. Nel caso dello sviluppo software, però, c’è un piccolo problema. Noi non siamo ancora a uno stadio artigianale. Siamo a uno stadio pre-artigianale.

E’ facile dimostrare questa mia asserzione. Si prendano due praticanti qualsiasi dello sviluppo software (e intendo persone che siano realmente in grado, personalmente, di realizzare software; non astratti architetti che promulgano documenti che vengono puntalmente ignorati da chi fa il lavoro veramente.) Si prendano, dicevo, due praticanti a caso. Non saranno d’accordo su praticamente nulla. In questo mestiere non ci sono metodi universalmente riconosciuti come validi. Dalla maniera di scrivere i commenti fino alla scelta degli strumenti, i nostri due ipotetici praticanti saranno in totale dissenso su quasi tutto.

E questo resta vero anche se scegliamo due praticanti a caso all’interno della stessa tribù; ad esempio due sviluppatori Java o due sviluppatori C#. Saranno d’accordo sulla scelta del linguaggio di programmazione, ma cominceranno a discutere sulla maniera di accedere al database, sulla scelta dei framework e, indubbiamente, sulla maniera di scrivere i commenti.

Che cosa caratterizza l’artigianato? La cosa che maggiormente lo caratterizza è l’apprendistato: il giovane apprendista acquisisce il suo know-how direttamente da un artigiano di provata capacità. In questo modo si formano scuole che hanno un loro modo di fare le cose. Ci saranno senz’altro grosse differenze fra il modo di lavorare delle scuole, così come l’architettura tradizionale ha un suo diverso carattere in tutte le parti del mondo; ma se prendiamo due artigiani a caso nella stessa scuola avranno un insieme di modi di lavorare condivisi.

Nel mondo dello sviluppo software invece… Sappiamo benissimo che non è così. Ognuno impara a fare le cose essenzialmente da solo. All’università si lavora da soli, o magari in gruppo con altri studenti che però sono anche loro inesperti. Al lavoro ci si aspetta che ognuno lavori in maniera indipendente. Non capita mai che a un progammatore junior si affianchi uno senior che lo segua e spenda del tempo per trasmettergli il know-how. Lo so bene, per le reazioni scioccate che osservo quando propongo di fare pair programming: il capo progetto obietta “ma così spendo il doppio per fare le stesse cose,” senza capire che così sia lo junior che il senior progrediscono rapidamente e riescono a produrre un valore che è ben maggiore della somma di quello che potrebbero realizzare lavorando sempre da soli.

Immaginate una cosa simile in una società preindustriale, se ogni muratore imparasse da solo, senza guida di un esperto, a costruire i muri. Salterebbe fuori che 99% dei muri sarebbero storti e sbilenchi, e fragili. Solo quell’1% di persone baciate dalla fortuna di un talento naturale riuscirebbero a costruire un bel muro dritto e robusto.

Noti qualche somiglianza con il mondo dello sviluppo software oggi? Hai provato a osservare l’orrendo casino che passa per codice scritto dai programmatori professionisti?

Se hai seguito il mio ragionamento, dovresti trovare facile capire, a questo punto, il grande successo di Extreme Programming e degli altri metodi agili. Sono un tentativo di uscire dalla fase pre-artigianale per raccogliere un corpus di metodi provati dall’esperienza. Kent Beck ha detto che XP non è altro che una codifica organica di cose che i migliori programmatori hanno sempre fatto. Sono molto contento di quello che vedo nella scena XP, perché i practitioner hanno una comprensione condivisa di una serie di cose che sono state provate efficaci dall’esperienza. Non solo: c’è una condivisione di valori, che permettono di lavorare insieme, al di là delle preferenze personali in fatto di linguaggi di programmazione.

Posso concludere il mio ragionamento su una nota polemica? Certo che sì, questo è il mio blog. Estendiamo il mio esperimento concettuale di prima al mondo della computing science o informatica. Prendiamo due computer scientist a caso: non saranno d’accordo su praticamente nulla. Con ogni probabilità le rispettive tribù parleranno linguaggi così diversi che non saranno nemmeno in grado di spiegarsi l’un l’altro in cosa consiste il loro lavoro. Il mondo della ricerca informatica è finemente suddiviso in miriadi di sottotribù che si occupano magari delle stesse cose, ma usano metodi e linguaggi completamente diversi. Gli articoli pubblicati sono mediamente illeggibili dai non-membri della minuscola tribù dell’autore. Un esempio su tutti: lo studio della concorrenza. Dalle cosiddette “teorie dei processi” di Milner/Hoare alla teoria dei linguaggi di programmazione alla teoria delle basi di dati, non c’è verso di avere non dico una teoria, ma nemmeno un linguaggio unificato su problemi che alla fine sono comuni. Con il risultato che fra la ricerca e la pratica in informatica c’è un baratro di incomunicabilità, che tende ad allargarsi.

[Grazie a Federico per la discussione che ha fatto emergere questi pensieri]

Saggiare le rotaie

Friday, December 15th, 2006

Summary: nice screencast about doing proper testing in Ruby on Rails

Ho l’impressione che ci sia poca documentazione in giro su come fare sviluppo test-driven in Rails. Il che è un peccato perché il framework offre ottimo supporto per il testing. Non è male questo screencast, che purtroppo non è gratis ma costa un modesto $9. Permette di vedere in azione uno che ha molta pratica con il framework. Fa una rapida dimostrazione delle tecniche basilari di test, e dimostra parecchi plugin addizionali, sia per il testing che per altro. Il codice dell’applicazione di esempio è fornito.

Va detto che il tipo non fa TDD “by the book”, ma spesso scrive codice in anticipo rispetto ai test. Mi piacerebbe vedere un documento scritto bene (non screen/podcast) su TDD e Rails. Se lo trovi, apprezzerei un link!

Classic paper: On the Criteria To Be Used in Decomposing Systems into Modules

Tuesday, December 5th, 2006

Summary: my comments on a classic paper by David Parnas

I would advise students to pay more attention to the fundamental ideas rather than the latest technology. The technology will be out-of-date before they graduate. Fundamental ideas never get out of date. However, what worries me about what I just said is that some people would think of Turing machines and Goedel’s theorem as fundamentals. I think those things are fundamental but they are also nearly irrelevant. I think there are fundamental design principles, for example structured programming principles, the good ideas in “Object Oriented” programming, etc.

David Lorge Parnas ACM Fellow Profile

Uno dei pochi, pochissimi principi universalmente accettati nell’ingegneria del software è che l’unica maniera di scrivere un programma di grandi dimensioni è scomporlo in moduli. Quello che non è completamente chiaro è come scomporre il sistema in moduli; qual è un principio razionale per decidere quale funzionalità deve andare in quale modulo? Questo problema sembra banale, e non degno di attenzione accademica. Eppure è fondamentale per la realizzazione di un buon design.

When you watch programming from the outside, everyone seems to love the hard problems and its widely celebrated as the interesting accomplishments.

But there are so many simple problems that haven’t been solved. Or haven’t been solved well. I’d rather solve them.

David Heinemeier Hansson, Not so clever; or why I don’t like hard problems

Nel suo classico On the Criteria To Be Used in Decomposing Systems into Modules, Parnas sostiene che ogni modulo esiste per nascondere un segreto. Il termine “information hiding” è opera sua. Un’altra maniera di vedere questo concetto è di pensare a tutte le decisioni di progetto che bisogna prendere per realizzare un sistema: quale algoritmo, quale database, quale … e nascondere ciascuna di queste decisioni in un modulo. E come possiamo valutare la bontà di una scomposizione in moduli? Si ipotizza di cambiare una decisione, e si vede se ci tocca modificare un solo modulo (bene) oppure più di un modulo (male).

The … decomposition was made using “information hiding” as a criterion. The modules no longer correspond to steps in the processing. The line storage module, for example, is used in almost every action by the system. … Every module … is characterized by its knowledge of a design decision which it hides from all others. Its interface or definition was chosen to reveal as little as possible about its inner workings.

We have tried to demonstrate by these examples that it is almost always incorrect to begin the decomposition of a system into modules on the basis of a flowchart. We propose instead that one begins with a list of difficult design decisions or design decisions which are likely to change. Each module is then designed to hide such a decision from the others. Since, in most cases, design decisions transcend time of execution, modules will not correspond to steps in the processing.

E’ difficile non essere d’accordo con Parnas: ogni modulo racchiude una decisione. Realizzare questa idea però può non essere facile in pratica. Credo che ci vogliano esperienza, fantasia e impegno per riuscire a “contenere” le decisioni in un modulo, in maniera che sia possibile poi modificare queste decisioni senza alcuna ripercussione sul resto del sistema. Io vedo questo come un’istanza del problema di rimuovere la duplicazione.

Ad esempio, se nel mio programma Java devo leggere dei file, mi ritroverò a scrivere questa noiosa pappetta in più punti del mio programma:

  BufferedReader in = new BufferedReader(new FileReader("infilename"));
  String str;
  while ((str = in.readLine()) != null) {
      process(str);
  }
  in.close();

(grazie a javaalmanac.com per lo snippet.) A prima vista niente di strano; le operazioni di I/O sono incapsulate nelle classi di java.io in perfetto amore object-oriented. Eppure questo frammento racchiude una serie di decisioni: e se io non volessi più usare il BufferedReader? E se volessi specificare un encoding? E se volessi testare senza toccare il filesystem? Sarebbe meglio incapsularlo in un modulino:

  MyReader in = new MyReader("infilename");
  while (in.hasNextLine()) {
    process(in.nextLine());
  }

o anche

  MyReader in = new MyReader("infilename");
  in.eachLine(process);

Questo per dire che non sempre è facile riconoscere la duplicazione ed eliminarla.

The DRY (Don’t Repeat Yourself) Principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

Don’t Repeat Yourself

che può essere espresso anche come

Each and every declaration of behavior should appear OnceAndOnlyOnce.

Once And Only Once

Agile Day 2006

Sunday, December 3rd, 2006

Summary: my report of the Italian Agile Day 2006

Sto riprendendo il fiato dopo la giornatona di Agile Day 2006… è stato molto divertente. Nella prima sessione plenaria, dopo che Marco Abis ha introdotto la giornata, abbiamo sentito Nicola Canalini e Luca Minudel, del team Ferrari Racing, che hanno presentato la loro situazione lavorativa, e come hanno implementato le pratiche agili nella loro realtà. Molto interessante, soprattutto vedere come le pratiche agili vengano adattate alle necessità molto particolari di questo team (una particolarità su tutte: alle 14:00 ora locale inizia il Gran Premio, e non ci sono “se” o “ma”!)

Dopo la sessione plenaria, è iniziato l’esperimento Open Space; come diceva Abis, si tratta di una conferenza in cui le chiacchiere nei corridoi sono preponderanti rispetto alle presentazioni programmate. Non avevo mai partecipato a un open space; devo dire che la possibilità di gironzolare e saltare da un gruppo a un altro è molto interessante. Se ho ben capito, in un Open Space “classico” non c’è nemmeno un programma definito; chi vuole iniziare una discussione si porta un flip chart e inizia a parlare. Nel nostro caso un programma c’era, anche se ha subito numerose variazioni in corso d’opera. Uno dei temi della giornata è stato il “pomodoro“, grazie alla presenza di Francesco Cirillo, inventore della tecnica del pomodoro, che ha recentemente pubblicato il suo atteso articolo; e grazie anche alla presenza di numerosi fan del pomodoro, come Enrico Mangano, che ha spesso bloggato sull’argomento.

Io ho tenuto una sessione sul Test-Driven Development, che secondo me è una pietra angolare dello sviluppo agile. E’ ormai la quarta volta che presento questo argomento; la dimostrazione pratica segue da vicino il kata del bowling di Robert Martin. Sono molto contento della partecipazione numerosa e attenta.

Nel pomeriggio ho tenuto una lunga sessione di XP Game, che è una simulazione di planning e iterazione XP inventata da Pascal Van Cauwenberghe e Vera Peeters. Pascal e Vera mi hanno gentilmente passato i file Word originali, così ho potuto tradurlo, per renderlo più accessibile al pubblico italiano. Sono convinto che questo gioco sia utilissimo per capire come funziona il planning agile. Come molte pratiche agili, il planning agile è così semplice che sembra impossibile che possa funzionare; e invece… basta imparare come funziona! Comunque, la sessione è stata molto partecipata e divertente. (Mi scuso per il baccano con gli altri partecipanti… l’acustica ci ha colti un po’ impreparati.) Paolo Polce ha tenuto un’altra sessione di XP Game al mattino.

Putroppo non sono riuscito a seguire quasi niente delle sessioni degli altri; c’era molta gente in gamba che mi è un po’ spiaciuto di non essere riuscito a sentire.

Un problema è stato l’acustica del locale, che rendeva difficile comunicare nell’open space: se uno non era sufficientemente vicino allo speaker non riusciva a sentire, e il rumore delle sessioni vicine aumentava la difficoltà. L’ideale forse sarebbe avere dei paraventi mobili per creare una barriera per il rumore, senza impedire la mobilità della gente fra una sessione e l’altra.

La sessione di pair programming remoto consisteva non in una sessione live, ma in una registrazione audio-video di Davide Varvello e Piergiuliano Bossi che facevano pair programming fra l’Italia e il Canada. La sessione in sè era molto carina; è bello vedere gente che sa fare pair programming bene, e che scrive codice ben scritto, cooperando e commentando quello che stanno facendo. Però non sono convinto che abbassare tutte le luci sia stata una buona idea; era subito dopo pranzo e mi è venuto subito sonno :-/ E poi non si riusciva a leggere bene il codice sullo schermo. Forse sarebbe stato meglio presentarla come una sessione fra le tante, ripetuta a ciclo continuo, piuttosto che come sessione plenaria. Spero che venga messa presto online.

La serata si è conclusa per me presso la prestigiosissima Trattoria Righini, in un posto che chiamare “fuori mano” è un eufemismo, ma che ci ha proposto un menu lodigiano-piacentino veramente eccellente. Raccomando i ravioli di zucca :) Abbiamo fatto una specie di pranzo di nozze per 35 euro, un prezzo che mi pare più che onesto. Complimenti agli XPer bolognesi, che hanno scelto il posto!

Concludendo: mi sembra ieri che partecipavo curioso, intimidito e titubante all’Agile Day 2004… sono stati tre eventi per me epocali. Grazie a Marco Abis, e a tutti i partecipanti!