Progetto MasterWork di Giovanni Baldini per il Master in Tecnologie del Software Libero e Open Source dell'Università di Bologna, anno 2004-2005.
Le tecniche per analisi dell'informazione statica non riescono ad affrontare con efficacia grandi moli di dati, tanto meno se si rende necessaria la comprensione del loro evolversi continuo.
L'obiettivo è quindi quello di abbandonare un'analisi di tipo quantitativo per una di tipo qualitativo, sottolineando i processi dinamici con una rappresentazione basata su tecniche di Organic Information Design.
Nello specifico si studia un prototipo di software in grado di visualizzare la fruizione di un sito web di grandi dimensioni senza conoscerne a priori la struttura.
Una delle difficoltà maggiori che si incontrano nell'analisi del traffico web di grandi siti è la comprensione di come gli utenti li usano.
Ovviamente l'analisi dei log è una sorgente indispensabile, ma districarsi in questa mole di dati può non essere banale. Inoltre la semplice analisi dei log non rende giustizia ad una caratteristica fondamentale dell'uso di un sito web: la dinamicità dell'interazione fra gli utenti ed il sito stesso.
Il dato grezzo registrato dal server deve dunque essere elaborato in una forma strutturata che rappresenti non tanto il sito quanto l'uso che ne viene fatto e che quindi si modifica nel tempo. Proprio questa dinamicità può comunicare informazioni utili allo sviluppatore.
Ci sono numerosi studi che cercano di risolvere la questione, infatti i risvolti pratici sono di indubbio interesse. Riuscire ad analizzare grossi volumi di informazione dinamica è vitale in ambiti come le ricerche genetiche, la sicurezza, il marketing e l'analisi economica.
I tre progetti che seguono sono tutti volti all'analisi della struttura o del traffico web e offrono alcune risposte convincenti al problema.
Uno studio di Tamara Munzner della Stanford University cerca di rappresentare grafi interconnessi di grandi dimensioni utilizzando spazi iperbolici tridimensionali come ambienti di immersione.
La scelta è appropriata in quanto l'incremento volumetrico degli spazi iperbolici è esponenziale, come la crescita media dei rami di un grafo semplicemente connesso. Sebbene i grafi che meglio rappresentano la struttura del web siano in genere più complessi la forma rappresentativa regge e permette una lettura sufficentemente chiara delle strutture ad albero e di concetti quali "perifericità".
D'altra parte rimane irrisolto uno dei problemi: la rappresentazione di dati dinamici.
Le rappresentazioni di H3 sono oggetti statici, che hanno forse più attinenza a rappresentare internet che il web.
H3Viewer è sviluppato come un software a sé stante e, sebbene gratuito per scopi non commerciali, viene rilasciato con licenza proprietaria.
L'analisi di Benjamin Jotham Fry parte da un'ottica diversa. Un sito web è una struttura debolmente gerarchica dove una eventuale organizzazione per sezioni tende a confondersi via via che si espande e che interagisce pesantemente con sé stessa e con l'ambiente circostante.
L'idea è quindi di modellare la rappresentazione di un sito web come se si trattasse di un organismo vivente. Questo è un modello che è, quantomeno a priori, in grado di ben rappresentare la crescita, l'evoluzione, l'interazione con l'ambiente esterno e le strutture auto-riproducenti.
Il dato rappresentato inoltre non è una struttura preordinata: una pagina web viene rappresentata se e quando è consultata e solo per il modo in cui viene consultata, ignorando la struttura concepita dallo sviluppatore.
Anemone è un progetto che usa i concetti di Organic Information Design [BFre97]. Ponendo alla base un'associazione fra pagine web e rami dell'anemone, la lettura dei log del server web governa la nascita e la crescita dei rami dell'organismo, inoltre vengono implementate regole che simulano atrofia per i rami che non vengono usati, fino alla loro rimozione. Quello che quindi viene messo in risalto non è il numero di consultazioni di ogni pagina, ma la rapidità con cui ricevono nuove visite.
Le idee alla base di Anemone sono particolarmente efficaci, soprattutto nell'analisi degli aspetti dinamici. La bidimensionalità è una limitazione notevole e quando la mole di informazioni diventa molto grande la leggibilità degrada velocemente.
Di Anemone non è disponibile che la versione compilata.
Sempre nell'ambito delle ricerche di Organic Information Design [BFre97] Ben Fry ha sviluppato un secondo software: Valence.
Valence intanto sfrutta la terza dimensione che riduce la leggibilità immediata ma che si presta bene a rappresentare molti più dati di quanti era possibile fare con Anemone. Inoltre sfrutta un'altra struttura organizzativa, non più un'organismo vivente ma un cluster stellare.
La rappresentazione di grandi qualtità di informazione tramite strutture a cluster stellari è stata oggetto di studio e di formalizzazione da parte di Javed Aslam, Katya Pelekhov e Daniela Rus, vedi [AsPR97] e [AsPR98].
Valence ha avuto un riscontro ottimo, sia per le qualità di strumento scientifico sia per le qualità estetiche, compare infatti nei film The Incredible Hulk e Minority Report. Ma l'applicazione che ne ha comprovato la validità è l'uso nell'ambito dell'analisi del genoma umano, da qui è nato un progetto dedicato: Genome Valence, iniziato nel 2002.
Una peculiarità particolarmente interessante di Valence è l'esser stato sviluppato usando Processing [PrRe05], un linguaggio di sketching per software visuali creato da Ben Fry con Casey Reas.
Di Valence è disponibile solo una versione semplificata in forma compilata e nonostante le richieste l'autore non intende rilasciarne i sorgenti, probabilmente per gli enormi introiti economici che in potenza Valence e Genome Valence possono generare.
Valence è stato poi riscritto in C++ per sfruttare ancora meglio le risorse computazionali, ma Processing è stato diffuso con una licenza libera ed ha iniziato a vivere di vita propria, aggregando una vitale comunità di utenti e sviluppatori.
Processing 0.91 - ActionScript - Lingo - Design By Numbers
Processing è un linguaggio orientato alla programmazione in contesti visuali e più generalmente multimediali, con librerie che permettono la manipolazione di suoni e interazione con hardware per fare musica. Ha un approccio di tipo software sketchbook, ovvero offre un buon ambiente dove provare idee relative all'elaborazione di immagini, animazioni e suoni.
Viene sviluppato per iniziativa di Ben Fry (Broad Institute) e Casey Reas (UCLA Design | Media Arts) come un progetto aperto ed evolve dalle idee nate attorno al ACG presso il MIT Media Laboratory.
In poche parole vuol essere un'alternativa libera a linguaggi come ActionScript e Lingo di Macromedia. Può considerarsi un erede di Design By Numbers, linguaggio nato per introdurre alla programmazione designers e artisti visuali.
Processing è al momento in fase beta, l'ultima release è la 0.91, del giugno 2005. L'insieme delle librerie che definiscono Processing sono rilasciate sotto licenza GNU LGPL, le rimanenti porzioni di codice, come l'ambiente di sviluppo, sono invece rilasciate sotto licenza GNU GPL.
Processing è fornito di un suo ambiente di sviluppo che traduce il codice, denominato sketch, in codice Java. In genere programmi ottenuti da Processing sono significativamente più performanti degli equivalenti ottenuti con ActionScript o Lingo e più semplici da implementare rispetto a linguaggi come Python o Java stesso.
Inoltre Processing è attivamente mantenuto su piattaforme Windows, MacOS X e Linux, mentre ActionScript e Lingo mancano su Linux.
Gli ambiti implementativi di Processing sono particolarmente eterogenei.
Wiring è un linguaggio di programmazione derivato da Processing volto all'integrazione con hardware dedicato per l'interazione uomo-macchina in ambiti di electronic arts e tangible media.
Wiring è uno dei primi frutti della scelta di fare di Processing un software libero, ne è un vero e proprio fork, anch'esso ovviamente libero.
Arduino è una piattaforma opensource fisica basata su una semplice scheda input/output ed un ambiente di sviluppo basato sui linguaggi Processing e Wiring.
Al momento l'obiettivo principale di Arduino è la didattica.
Mobile è una versione di Processing dedicata al mondo delle piattaforme handheld.
Processing ha vinto il PRIXARS 2005, Prix Ars Electronica - International competition for CyberArts, organizzato dall'Ars Electronica Center di Linz, nella categoria "Net Vision" con la seguente motivazione:
As an innovative, easily understood programming language, "Processing" enables students, artists, designers and architects to design and produce virtual prototypes. The program can be utilized as both a sort of virtual sketchbook as well as a professional graphics program.
"Processing" is an open project that was initiated by Casey Reas and Benjamin Fry. The program was developed jointly by a large group of artists working together on a voluntary basis, and is still constantly being revised and updated. This open-source software opens up completely new possibilities of doing artistic work on the computer.
Processing è stato utilizzato in innumerevoli progetti di arte visuale e sonora.
I cinque qui riportati sono solo gli ultimi in ordine di tempo:
Processing è utilizzabile in tre differenti modi: Basic per immagini statiche, Continuous per animazioni e Java.
Per i dettagli sulla sintassi si veda il manuale ufficiale [FrRe05].
In questa modalità semplificata ad ogni riga di codice corrisponde un effetto sullo schermo.
A titolo di esempio: lo sketch seguente disegna un rettangolo rosso su sfondo bianco.
size(200, 200); background(255); noStroke(); fill(255, 0, 0); rect(30, 20, 50, 50);
In questa modalità il programma viene diviso fra due strutture. In setup(){} vengono definite le caratteristiche dell'ambiente di visualizzazione mentre in draw(){} si trovano i comandi che effettivamente tracciano l'output.
setup(){} viene eseguita solamente una volta e draw(){} viene invece eseguita a ciclo continuo.
A titolo di esempio: lo sketch seguente disegna un rettangolo che segue il puntatore del mouse.
void setup(){
size(200, 200);
rectMode(CENTER);
noStroke();
fill(0, 102, 153, 204); }
void draw(){
background(255);
rect(width-mouseX, height-mouseY, 50, 50);
rect(mouseX, mouseY, 50, 50); }
Le istruzioni Java sono considerate istruzioni valide di Processing. In definitiva Processing può essere esteso tramite Java e venire usato come un completo linguaggio ad oggetti.
Si noti che comunque Processing non è un linguaggio a macro costruito su Java. Processing fa riferimento a proprie librerie e viene implementato con una filosofia diversa che tende a lasciare in disparte le complessità programmatiche per avere una corrispondenza più intuitiva fra codice e grafica.
A titolo di esempio si riporta lo sketch Processing per ottenere uno sfondo nero e l'analogo in Java.
background(0); //---------------------------// g.setColor(Color.black) fillRect(0, 0, size.width, size.height);
OpenGL è un insieme di librerie per lo sviluppo di applicazioni grafiche 2D e 3D interattive.
Nato nel 1992, il progetto OpenGL è diventato lo standard di fatto per l'industria grafica. Il software prodotto viene licenziato opensource.
Per il rendering 3D Processing usa P3D, un motore interno al progetto. In alternativa può interfacciarsi alle librerie OpenGL e sfruttare l'accelerazione hardware attraverso JOGL, un progetto opensource di SUN.
Con Processing non si ottiene una vera compilazione, l'azione equivalente qui è l'export, che genera un file contenente la traduzione in Java dello sketch il quale viene passato a Jikes per la compilazione sotto forma di applet.
Jikes è un compilatore Java ad alte prestazioni prodotto da IBM. La prima versione risale al 1997 ed è del 1998 la prima versione per Linux.
È da notare che Jikes è storicamente, era il dicembre 1998, il primo progetto opensource di una certa consistenza ad essere stato creato da IBM.
Si noti che per lavorare con Processing non è necessario installare una Java Virtual Machine, l'esecuzione dello sketch è a carico di Jikes.
La scelta è quella di seguire il ragionamento di Ben Fry e di implementare uno sketch sulla falsa riga di Valence.
Dal punto di vista topologico si tratterà dunque di un cluster di oggetti che rappresentano le pagine web, collegati fra loro da curve per rappresentare la navigazione. Una pagina web sarà rappresentata tanto più lontana dal centro del cluster quanto più questa viene visitata nell'unità di tempo, in modo da avere espansione e collasso in conseguenza. Per dare una rappresentazione più fine faremo variare la rappresentazione dei link, invecchiandoli allo scorrere del tempo.
Il nome scelto per il nostro progetto è Reclus.
La geometria delle figure che rappresenteranno gli oggetti del cluster è importante soprattutto ai fini computazionali.
Seguendo l'analogia cluster stellare-sito web sembrerebbe naturale scegliere delle sfere per rappresentare le pagine, ma una sfera viene realizzata approssimandola come un poliedro con molti vertici. Di default Processing disegna una sfera approssimandola con un poliedro con un vertice ogni 12 gradi decimali, per un totale di più di 400 verici e altrettante facce, su cui dover applicare effetti di emissività, riflessione della luce, ombre.
Computazionalmente si impone la scelta di usare cubi. È da notare che in Valence la scelta è la medesima.
È ovviamente possibile cambiare il dettaglio con cui vengono rappresentate le sfere, ma per arrivare a livelli comparabili a quelli del cubo si perde comunque la riconoscibilità della sfera.
La rappresentazione dei link percorsi durante la navigazione del sito può essere fatta con curve di Bezier che collegano i cubi, il carico computazionale è adeguato e del tutto paragonabile all'uso di altri tipi di curve, inoltre hanno un aspetto più "liscio".
La natura "fisica" del cluster suggerisce l'uso di un paradigma ad oggetti: ovvero trattare il cluster come un unico oggetto composto di due liste di altri oggetti, le stelle e i link.
È in questa fase che compare uno dei limiti del lavorare con software ancora in fase beta: mancano funzioni che ci permettono di manipolare array a dimensione dinamica. In teoria questo non è vero, sono infatti documentate funzioni quali append() e shorten() ma nella pratica queste operano solo su array di tipi elementari, come numeri e stringhe. Una volta superata la fase Beta Processing gestirà array dinamici anche con tipi definiti dall'utente.
Faremo quindi overloading di queste funzioni, che ci necessiteranno per la manipolazione delle liste di stelle e link.
La scala cromatica dei link è scelta con in mente l'idea di "invecchiamento", per questo si sono scelti toni di verde che degradano al giallo.
Si noti che la scala è composta da due parti cromaticamente contigue ma distinte, la prima metà è un classico gradiente di colore che varia linearmente dal verde puro al giallo puro, mentre la seconda è costruita come un gradiente da un colore pieno fino alla trasparenza totale.
Volendo ottenere un forte effetto di contrasto per mantenere la leggibilità del cluster si è scelto di rappresentare i cubi con un colore opposto al verde, il rosa.
Il rosa emesso dal materiale dei cubi è stato poi reso più luminoso impostando una luce ambientale blu che fa virare ad un tono scuro ma non grigio le facce non esposte al punto luce e marcando gli spigoli con un tono di rosa semi-trasparente.
Per quanto riguarda lo sfondo si è optato per un colore scuro: il blu petrolio, che offre un contrasto netto, non stanca la vista ed è appropriato al tema "notturno" del cluster stellare.
In Processing questo si ottiene con:
emissive(255, 0, 255); lights(); ambient(0, 0, 255); background(0, 15, 45); stroke(255, 180, 255, 128);
Si noti che le scelte fatte sono in accordo con uno schema classico della teoria dei colori: lo schema bicomplementare o tetradico. In pratica si scelgono due colori dominanti e si completa lo schema con i rispettivi opposti.
Lo schema tetradico, sebbene difficile da rendere armonioso, permette di massimizzare i contrasti e al tempo stesso di avere una vasta gamma di cromie utilizzabili.
Il cluster viene implementato nel modo seguente:
class Star proprietà: float theta, phi, r // coordinate sferiche attuali float r0 // orbita obiettivo String name // url della pagina float spin // posizione angolare int touch_count // numero di link metodi: void update() // aggiorna l'orbita obiettivo void text_draw() // scrive l'url void draw() // disegna Star //--------------------------------- class Link proprietà: int id_from // identificativo della stella di partenza int id_to // identificativo della stella di arrivo int birth // data di nascita, in secondi dall'inizio dell'analisi float alpha_from // angolo di uscita float strenght_from // magnitudo del link in uscita float alpha_to // angolo di ingresso float strenght_to // magnitudo del link in ingresso metodi: void draw() // disegna Link //--------------------------------- class Cluster proprietà: Star[] star // lista delle Star Link[] link // lista dei Link int birth // data di nascita, ovvero timestamp del primo dato rappresentato int death // data di morte, ovvero timestamp dell'ultimo dato previsto int present // data attuale, timestamp metodi: void new_data() // immette nuovi dati nel cluster void read_data() // legge i dati da rappresentare void update() // aggiorna la struttura di Cluster int get_star_id() // trova l'identificativo di una Star, dato il name int create_star() // crea una nuova Star, restituendone l'identificativo int create_link() // crea un nuovo Link, restituendone l'identificativo void draw() // disegna Cluster
Disegnare oggetti predefiniti in un sistema di coordinate ortogonali, sferiche, coniche o cilindriche è particolarmente semplice con Processing, anche mischiando questi sistemi per ottenere una singola rappresentazione: essenzialmente si tratta di combinare rototraslazioni.
Per disegnare due stelle del cluster si potrebbe ad esempio scrivere:
float C0, C1, C2 // coordinate ortogonali del centro del Cluster float A_theta, A_phi, A_r // coordinate sferiche della stella A nel Cluster float B_theta, B_phi, B_r // coordinate sferiche della stella B nel Cluster translate(C0, C1, C2); pushMatrix(); rotateY(A_theta); rotateZ(A_phi); translate(A_r, 0, 0); box(); popMatrix(); pushMatrix(); rotateY(B_theta); rotateZ(B_phi); translate(B_r, 0, 0); box(); popMatrix();
Si noti l'uso delle funzioni pushMatrix() e popMatrix(): rispettivamente sospendono e ripristinano rototraslazioni precedenti. Senza l'uso di queste funzioni le coordinate di B sarebbero state disegnate a partire da A e non dal centro del Cluster.
Questa è una considerevole semplificazione, ma genera un problema con la rappresentazione dei link.
Ogni link è rappresentato da una curva di Bezier, la quale ha bisogno di quattro punti per essere definita: i due punti di partenza e arrivo e di altri due punti, uno per estremo, che segnano i vettori tangente. I primi due punti sono quindi noti ed espressi in coordinate sferiche centrate nel centro del cluster, gli altri vengono espressi in coordinate sferiche centrate nelle rispettive stelle. A questa complicazione si aggiunge il fatto che la funzione bezier() accetta solo coordinate cartesiane ortogonali.
Questo impone l'esplicitazione delle coordinate sferiche:
x = r*cos(phi)*cos(theta); y = r*sin(phi); z = -r*cos(phi)*sin(theta);
Inoltre le coordinate devono essere ricalcolate spostando il centro di volta in volta sulla posizione delle varie stelle.
Nello sketch si vedano le funzioni expSphericalX(), expSphericalY() e expSphericalZ().
Il calcolo della distanza della stella dal centro del cluster avviene sulla base del numero di link che collegano questa ad altre stelle o al centro del cluster stesso, che rappresenta con una stella sferica bianca tutto ciò che è esterno al sito. Viene poi applicata una scala logaritmica, per mantenere la compattezza della visione.
Da ultimo si noti che le stelle che accelerano verso l'esterno a seguito di una visita ruotano su sé stesse, un surplus di dinamicità per attirare lo sguardo.
Sito ufficiale della Federazione Regionale Toscana Associazioni Antifasciste e della Resistenza
I dati che rappresenteremo sono dati reali, provengono dai log di www.resistenzatoscana.it per le tre settimane che vanno da lunedì 4 marzo 2005 a domenica 24 marzo 2005. Sono stati depurati dalle visite di robot, crawler e altri software risultando in un totale di poco meno di 12000 pagine visitate.
www.resistenzatoscana.it è il sito ufficiale della "Federazione Regionale Toscana Associazioni Antifasciste e della Resistenza" ed è composto di oltre 500 pagine. Al netto di robot e crawler ogni giorno conta fra le 400 e le 600 pagine viste ed è gerarchizzato in sezioni e sottosezioni.
Ha caratteristiche insomma che si prestano a verificare l'efficacia del nostro software.
È stata implementata un'interfaccia elementare per la navigazione del cluster, oltre alla rotazione orizzontale e verticale rispetto agli assi del cluster che si ottiene trascinando il cursore del mouse sono attivi i seguenti comandi da tastiera:
'a' // zoom in 'z' // zoom out space // visualizza/nasconde url delle pagine
La visualizzazione dei dati è stata accelerata in modo tale che in un minuto scorrano i dati di un giorno.
L'algoritmo implementato legge i dati tutti insieme e poi li scandisce in successione temporale, leggendone solo la porzione che al momento è necessaria, simulando un live datafeeding. Sulla destra trova posto un indicatore verticale dello stato di avanzamento della simulazione.
Una volta lanciato il software propone subito alcune stelle, risultato della navigazione immediatamente successiva alla mezzanotte del 4 marzo 2005. Poi si ferma: durante la notte non ci sono state visite.
Con l'arrivo del giorno le attività riprendono mostrando l'insistenza sulle pagine principali delle varie sezioni del sito: loc=home, loc=documenti, loc=luoghi, loc=protagonisti etc.
Questo ci mostra che la navigazione degli utenti si incanala nella struttura pensata dall'autore del sito.
Si noti che la nuova notte, quella fra il 4 ed il 5 marzo, viene messa in risalto dalla stasi delle stelle e soprattutto dalla predominanza di link "vecchi" di colore giallo.
Questo dà immediato riscontro del fatto che il sito in questione viene consultato principalmente da persone che vivono in un fuso orario vicino a quello italiano.
Nei giorni successivi saltano all'occhio alcune stelle che emergono dal cluster. Uno di questi è la pagina relativa alla strage di Sant'Anna di Stazzema, avvenuto nell'agosto 1944. Difatti nei giorni di cui si analizza il traffico sono usciti sui notiziari nazionali informazioni sul processo istituito dalla Procura di La Spezia su quell'eccidio. Si noti anche che almeno in questo caso gran parte dei link arrivano a quella stella partendo dal centro del cluster, indicando una navigazione che parte dai motori di ricerca.
Questo è un dato che si evidenzia facilmente anche con l'analisi tradizionale, ma in maniera molto meno intuitiva.
Il passo successivo è ovviamente una reimplementazione che ottenga i dati in tempo reale, questo può essere fatto in maniera abbastanza semplice usando l'estensione di Processing Library-NET che permette la comunicazione tramite HTTP. Lato server basterà una semplice API, scritta ad esempio in PHP.
È da considerare anche una reimplementazione in C++, per costruire uno strumento locale per analizzare il traffico su server remoti.
Se invece si pensa a Reclus come a uno strumento da affiancare all'analisi tradizionale offerta da servizi come Sitemeter o Webstat l'implementazione in Processing è adeguata, fornendo come prodotto finale un applet Java che può immerso in una pagina HTML. Una reimplementazione in Java non porterebbe benefici.
C'è un problema che fino ad adesso è stato sottaciuto: Java. Se Reclus viene distribuito come applet questo implica che l'utente abbia installato sulla propria macchina una virtual machine Java, che non è disponibile come software libero.
È un problema questo di non facile soluzione. In fondo l'unica alternativa è quella di fornire il nostro software come oggetto Flash, ma questo pone ancora maggiori problemi: non solo si finisce per necessitare di un plugin per il browser della stessa natura proprietaria della Java Virtual Machine di SUN, ma mancherebbe anche un ambiente di sviluppo libero.
Può essere ragionevole non voler inseguire SUN o Macromedia sul loro stesso terreno ma d'altra parte non è neppure ragionevole chiedere che il mondo del software libero rimanga senza una tecnologia del genere.
Reclus risulta così un software imperfettamente libero.
Perché "Reclus"?
Reclus in francese significa "prigioniero". In questo modo si vuole sottolineare la non perfetta libertà di questo software.
Inoltre per analogia con Valence, che deve il proprio nome a una cittadina francese.
Si noti anche che questa parola può essere vista come combinazione di Re (lettere iniziali del sito usato per i test) e Clus (da cluster).
E l'insieme dei link del cluster non formano forse una rete, una gabbia?
Firenze 17.10.2005, Giovanni Baldini