Matteo Marchionne: Foaf e feed reader

1
FOAF
And
Totem feed reader
Di Matteo Marchionne

2
Indice
1 - INTRODUZIONE .................................................................................................................................. 4
1.1 - L’informazione.......................................................................................................................... 4
1.2 – Informazione nel Web.............................................................................................................. 5
1.3 - Idea base di FOAF .................................................................................................................... 6
2 - ALTERNATIVE CENTRALIZZATE NEL CAMPO DELL'INFORMAZIONE E DEL "SOCIAL".......................... 8
2.1– Pagine web che utilizzano standard per la rappresentazione di contenuti Web ................. 9
2.1.1 – Standard RSS ....................................................................................................................... 9
2.1.2 – Sviluppo RSS....................................................................................................................... 10
2.1.3 – Codice RSS.......................................................................................................................... 11
2.2 – Applicazione “Feed Reader” per Totem .............................................................................. 13
2.2.1 – WordPress ......................................................................................................................... 14
2.2.2 – App Totem ......................................................................................................................... 16
2.2.3 – Librerie utilizzate ............................................................................................................... 16
2.2.4 – Modifiche al sorgente della libreria................................................................................... 17
2.2.5 - Verifica connessione........................................................................................................... 20
2.2.6 - Lettura URL......................................................................................................................... 22
2.2.7 - Schermata principale ......................................................................................................... 23
2.2.8 - Schermata di espansione articolo ...................................................................................... 27
2.2.9 - Aggiornamento contenuti.................................................................................................. 32
2.2.10 - Grafica.............................................................................................................................. 32
2.3 – Realtà centralizzate di social network.................................................................................. 33
2.3.1 – Il successo dei social network............................................................................................ 33
2.3.2 – Meccanismo dietro il social network tradizionali.............................................................. 34
3 - SEMANTIC WEB............................................................................................................................... 38
3.1 – Tecnologie utilizzate............................................................................................................... 40
3.1.1 - Esprimere concetti in RDF .................................................................................................. 40
3.1.2 - RDF Schema........................................................................................................................ 42
3.1.3 - Web Ontolgy Language...................................................................................................... 43
4 - FOAF................................................................................................................................................. 44
4.1 - Meccanismo base di FOAF .................................................................................................... 44
4.2 - Obbiettivi................................................................................................................................. 46
4.3 - Definizione............................................................................................................................... 46

3
4.4 - Esprimere una identità univoca in FOAF............................................................................. 47
4.5 - Struttura FOAF usando XML............................................................................................... 48
4.6 - Approfondimento immagini................................................................................................... 49
4.7 - Come creare una rete che collega i vari file FOAF.............................................................. 50
4.8 - Vocabolario FOAF.................................................................................................................. 53
4.9 - Pubblicazione del file FOAF .................................................................................................. 55
4.10 - Applicazioni di FOAF........................................................................................................... 55
4.11 - Privacy ................................................................................................................................... 55
4.11.1 - WebID............................................................................................................................... 57
4.11.2 - TLS/SSL ............................................................................................................................. 57
4.11.3 - Funzionamento di WebID................................................................................................. 57
Bibliografia ............................................................................................................................................ 60

4
1 - INTRODUZIONE
1.1 - L’informazione
In generale, un'informazione ha valore in quanto potenzialmente utile al
fruitore per i suoi molteplici scopi: nell'informazione, infatti, è spesso
contenuta conoscenza o esperienza di fatti reali vissuti da soggetti terzi, che
possono risultare utili senza dover essere necessariamente sperimentati da
ognuno. Sotto questo punto di vista, il concetto utile di informazione e la
parallela necessità di comunicare o scambiare informazione tra individui, nasce
nel corso della storia con l'elaborazione del linguaggio e si sviluppa con la
successiva invenzione della scrittura come mezzo per tramandare
l'informazione ai posteri. Secondo quest'ottica, la storia e l'evoluzione della
società umana sono frutto dell'accumulazione di conoscenza sotto forma di
informazione. Nell'informazione, ad esempio, è contenuto il “know how”: esso
è utile per eseguire una determinata attività o compito, cosa che rende
l’informazione una risorsa strategica in ambito economico ad esempio.
Col progredire delle conoscenze umane, il concetto di informazione si è evoluto
divenendo via via più vasto e differenziato: Informazione è in generale
qualunque notizia o racconto e ogni comunicazione scritta o orale contiene una
specifica informazione.
I dati in un archivio sono informazioni, ma anche la configurazione degli atomi
di un gas può essere considerata un’informazione. L'informazione può essere
quindi misurata come una qualsiasi entità fisica ed è sempre esistita, anche se
la sua importanza è stata riconosciuta solo nel XX secolo.
Negli ultimi decenni, l'importanza e la diffusione dell'informazione è tale che ci
si riferisce alla società moderna con l’appellativo di “Società dell'Informazione”.
Nel passato, la carta rappresentava l’unico mezzo per la comunicazione di
massa; la scoperta di nuove tecnologie ha permesso l’individuazione di nuovi
mezzi di informazione, a cominciare dalla televisione fino ad arrivare
all’informazione via Internet.
Il trend a cui stiamo assistendo è quello di una informazione sempre più
digitalizzata, dove la documentazione via web sta prendendo sempre più piede.

5
1.2 – Informazione nel Web
Quasi la totalità degli utenti utilizza motori di ricerca (Google, Bing, ecc) per
individuare in semplicità pagine Web che trattano gli argomenti di proprio
interesse. Tali siti agevolano la navigazione web, ma utilizzano un metodo di
ricerca che non attribuisce un significato al testo cercato. Essi producono una
ricerca sintattica, non efficiente, che spesso rende difficile individuare
l’informazione di interesse.
Un altro fenomeno, a cui negli ultimi anni stiamo assistendo, è quello dei Social
Network (es. Facebook, Twitter, Google+, ecc): quasi la totalità degli individui
che si interfacciano alla rete posseggono almeno un account in un sito social,
utilizzato per rimanere in contatto con i propri amici e per condividere con loro
i propri interessi.
Figura 1. 1: Loghi di social network conosciuti
Tutta la mole dei dati che ho sopra accennato è immagazzinata in migliaia di
database sparsi per il mondo, detenuti e gestiti in maniera centralizzata dalle
aziende di informazione e di social networking.
Tali aziende impongono all’utente le condizioni alle quali sottostare per poter
sia utilizzare, sia immettere informazioni di interesse: nel caso ad esempio dei
siti social network, l’utente deve sottoscrivere le condizioni di iscrizione prima
di poter accedere ad una rete di amicizie.

6
Il progetto FOAF ha l’arduo intento di cambiare il conosciuto web sintattico
centralizzato nel più efficiente web semantico decentralizzato, dal punto di
vista dell’informazione in generale e nello specifico nel campo social
networking.
1.3 - Idea base di FOAF
Lo scopo principale del Web è quello di fornire collegamenti tra vari elementi,
FOAF fornisce alcuni meccanismi di base che aiutano il Web a trovare le
connessioni tra gli elementi che sono importanti per noi.
Migliaia di persone, descrivendo se stessi e i propri interessi sulle loro
homepage, contribuiscono a creare i collegamenti tra gli elementi del web di
loro interesse. Con l’utilizzo di FOAF, è possibile aiutare le macchine a “capire”
la propria home page e per questo conoscere le relazioni che connettono
persone, luoghi e cose descritti sul web. FOAF utilizza la tecnologia RDF ideata
dal W3C (World Wide Web Consortium) per integrare le informazioni dalla tua
home page con quella dei tuoi amici, con quella degli amici dei tuoi amici e così
via ...
FOAF definisce perciò una tecnologia aperta e decentralizzata per connettere
siti web, come ad esempio differenti social network.
Figura 1. 2: Rete sociale decentralizzata

8
2 - ALTERNATIVE CENTRALIZZATE
NEL CAMPO DELL'INFORMAZIONE E
DEL "SOCIAL"
Un sito web è un insieme di pagine web correlate, ovvero una struttura
ipertestuale di documenti. Tale struttura risiede, tramite hosting, su un web
server ed è accessibile all'utente client che ne fa richiesta tramite un web
browser sul World Wide Web della rete Internet, digitando in esso il rispettivo
URL o direttamente l'indirizzo IP.
Dal punto di vista dell'organizzazione o struttura dei contenuti, un sito web è
tipicamente composto da una home page, che rappresenta la pagina principale
di presentazione del sito e dei suoi contenuti, e dalle pagine web secondarie,
raggiungibili dal menù presente nell'home page tramite link interni al sito.
Quando il sito web costituisce una porta di ingresso ad un gruppo consistente
di risorse di Internet o ad una Intranet, si parla più propriamente di portale
web. Spesso un sito web si accoppia/accompagna ad un database nello stesso
web server per la memorizzazione strutturata di dati e informazioni.
Dal punto di vista della struttura e della tecnologia utilizzata, i siti web si
possono distinguere sommariamente in due tipologie principali:
• siti statici
• siti dinamici
I siti web statici, formati da pagine statiche, presentano contenuti di sola ed
esclusiva lettura. Solitamente vengono aggiornati con una bassa frequenza e
sono mantenuti da una o più persone che agiscono direttamente sul codice
HTML della pagina (tramite appositi editor web). Si tratta storicamente della
prima generazione di siti web.
I secondi sono formati da pagine web dinamiche che presentano, a differenza
dei primi, contenuti redatti dinamicamente (in genere grazie al collegamento
con un database) e quindi forniscono contenuti che possono variare in base a
più fattori. Questi sono caratterizzati da un'alta interazione fra sito e utente.
Alcuni elementi che caratterizzano la dinamicità di un sito possono essere:

9
l'interazione con uno o più database, la visualizzazione dell'ora server,
operazioni varie sul file system (tipo creazione dinamica di documenti, ecc.), il
cloaking basandosi su vari parametri (tra i quali lo user agent, o il browser, o la
risoluzione dell'utente), l’indirizzo IP dell’utente e altro ancora. Essi possono
essere scritti tramite linguaggi di scripting come ASP, PHP, etc.
La particolarità dei siti dinamici si basa sul fatto che le varie "pagine" del sito
vengono generate all'atto della chiamata da parte dell'utente (fatta eccezione
per i sistemi che adottano una cache) in quanto i contenuti non sono
memorizzati direttamente nel codice sorgente della pagina, bensì in sistemi di
memorizzazione esterni allo stesso, come le già citate basi di dati.
Le pagine di un sito web sono accessibili tramite una radice comune (detta
"nome di dominio", per esempio "www.kernel.org"), seguita da una serie
opzionale di "sotto cartelle" e dal nome della pagina. Il nome completo di ogni
pagina è detto "indirizzo web" o, più tecnicamente, URI (o URL).
Al giorno d’oggi, è consuetudine per la maggior parte degli utenti cercare la
pagina web desiderata tramite motori di ricerca invece che digitare l’URL
completo nel browser, sia per un fatto di comodità sia perché molto spesso gli
indirizzi web sono complicati da memorizzare.
Come detto in precedenza, il web semantico utilizza tecnologie in grado di dare
significato, e quindi semantizzare, le informazioni date alla macchina, in modo
da produrre una ricerca più efficace e pertinente.
2.1– Pagine web che utilizzano standard per la rappresentazione
di contenuti Web
Questo capitolo tratta degli standard utilizzati per la distribuzione di contenuti
web, come l’RSS, che rappresentano una prima forma di semantizzazione del
web.
2.1.1 – Standard RSS
L’RSS (RDF Site Summary, spesso riportato come Really Simple Syndication, o
Rich Site Summary) è uno dei più popolari formati per la distribuzione di

10
contenuti Web; è basato su XML, da cui ha ereditato la semplicità,
l'estensibilità e la flessibilità. Esso è noto principalmente per i flussi RSS, i quali
permettono alle applicazioni che ne fruiscono di essere aggiornate su nuovi
articoli o commenti pubblicati nei siti di interesse, senza che tali siti debbano
essere visitati manualmente uno ad uno.
RSS definisce una struttura adatta a contenere un insieme di notizie, ciascuna
delle quali sarà composta da vari campi (nome autore, titolo, testo, riassunto,
etc.). Quando si pubblicano delle notizie in formato RSS, la struttura viene
aggiornata con i nuovi dati; dato che il formato è predefinito, un qualunque
lettore RSS potrà presentare, in maniera omogenea, notizie provenienti dalle
fonti più diverse.
Figura 2. 1: RSS logo
2.1.2 – Sviluppo RSS
L’RSS venne lanciato per la prima volta da Netscape. Si trattava di un formato
derivato da RDF (un linguaggio generico utilizzato per rappresentare
informazioni su Web) per la gestione dei contenuti del portale web My
Netscape Network: il formato permetteva la visualizzazione sul portale di
headline e link relativi a notizie pubblicate su altri siti e rese disponibili
attenendosi a specifiche ben precise. Fu subito un grande successo: in breve,
centinaia di fornitori di contenuti aderirono all'iniziativa e il portale My
Netscape poté beneficiare di una vasta raccolta di notizie a disposizione dei
propri utenti registrati.

11
Nel frattempo, lo stesso formato (e le sue variazioni successive) fu adottato
progressivamente dalla comunità dei blogger: i post di un blog potevano essere
facilmente esportati in RSS, in modo da essere resi disponibili a servizi di
raccolta di contenuti. La popolarità dei blog è forse una delle ragioni principali
del successo di RSS: migliaia di weblog, infatti, iniziarono a produrre contenuti
in RSS. A seguito di ciò, iniziarono a proliferare siti che raccoglievano una
selezione di post dai blog più seguiti (i cosiddetti blog aggregator) e programmi
per fruire i contenuti di un blog direttamente sul proprio desktop o su altri
dispositivi (lettori RSS).
Attualmente RSS è lo standard de facto per l'esportazione di contenuti Web. I
principali siti di informazione, i quotidiani online, i fornitori di contenuti, i blog
più popolari sembrano tutti aver adottato il formato RSS. Gli utenti possono
oggi accedere a migliaia di flussi RSS: alcuni siti (directory) raccolgono i
riferimenti agli innumerevoli flussi RSS disponibili sul Web.
L'utente finale sfrutta la tecnologia RSS attraverso due macro-tipologie di
software. La prima è quella dei lettori di Feed RSS, l'altra è quella degli
aggregatori, i quali riescono a visualizzare più fonti RSS e, attraverso algoritmi
specifici, visualizzano le notizie raccolte.
2.1.3 – Codice RSS
Oggi come oggi esistono tre versioni di RSS che vengono utilizzate:
• RSS 0.91: il più vecchio tra gli standard oggi in uso, diretta evoluzione del
formato usato originariamente da Netscape. In alcuni casi si è preferito
usare il successivo RSS 0.92;
• RSS 2.0: rilasciato da Userland nel 2002, è l'evoluzione del formato 0.92,
di cui eredita la semplicità, ma a cui aggiunge il supporto per moduli
aggiuntivi;
• RSS 1.0: è il formato ufficiale del W3C, conforme ad RDF, estensibile e
modulare.
Chi produce contenuti da distribuire in formato RSS è costretto a scegliere
quale versione utilizzare o, come avviene nella maggior parte dei casi, a
esportare i propri contenuti in tutti i formati disponibili.

12
Nonostante le differenti implementazioni delle varie versioni, i documenti RSS
condividono tutti la stessa struttura di base che prevede:
• un elemento <channel>, che contiene le informazioni sulla fonte dei
contenuti (nel caso di un quotidiano online potrebbe contenere il nome
della testata, la data di pubblicazione, informazioni sul copyright, ecc.)
• una serie di elementi <item>, ognuno dei quali corrisponde ad un singolo
elemento di contenuto (ad es. l'articolo di un giornale) e ne presenta
tutte le informazioni (titolo, testo completo, nome dell'autore, ecc.). [1],
[2]
Di seguito è riportato un esempio di RSS 2.0:
<rss version="2.0">
<channel>
<title>Il piatto piange o no ?</title>
<link>http://albertopolzonetti.wordpress.com</link>
<description>an example feed</description>
<language>it</language>
<textInput>
<title>Search this site:</title>
<description>Find:</description>
<name>q</name>
<link>http://example.com/search</link>
</textInput>
<skipHours>
<hour>24</hour>
</skipHours>
<item>
<title>1 < 2</title>
<link>http://example.com/1_less_than_2.html</link>
<description>1 < 2, 3 < 4.
In HTML, <b> starts a bold phrase
and you start a link with <a href=
</description>
</item>
</channel>
</rss>

13
2.2 – Applicazione “Feed Reader” per Totem
Durante lo stage che ho svolto presso lo spin-off Elios s.r.l., mi è stato chiesto di
sviluppare un’applicazione che permettesse la visualizzazione sul Totem della
facoltà di notizie reperite dal web.
Il Totem è semplicemente un pc fisso a cui è collegato uno schermo full-hd
touchscreen posizionato in verticale. Il nome deriva dalla forma che ricorda
vagamente un palo totem tipico delle tribù native nordamericane. La sua
struttura è così progettata per facilitare la lettura da in piedi: infatti esso è
pensato per la comunicazione di contenuti in pieno stile “digital signage” (Nel
digital signage i contenuti come foto, video, suoni, informazioni dinamiche
vengono presentati ai destinatari attraverso grandi display o totem posizionati
in luoghi pubblici).
Figura 2. 2: Totem Unicam

14
Per potersi interfacciare con questo computer vi è solamente lo schermo
touchscreen, che risulta essere molto più comodo rispetto a mouse e tastiera,
specialmente nel nostro caso. Il sistema operativo al suo interno è Windows 7,
che ci offre nativamente strumenti per utilizzare, nel migliore dei modi, un
eventuale schermo sensibile al tocco.
I requisiti principali dell’applicazione sono:
• Essa deve lavorare in primo piano, impedendo qualsiasi tentativo da
parte dell’utente di uscire dal contesto e quindi svolgere attività
indesiderate;
• Deve avviarsi all’avvio del computer.
• Deve reperire le informazioni da visualizzare via internet, in modo tale da
poterle aggiornare da qualsiasi terminare connesso alla rete.
Se per il secondo punto la soluzione è semplice ed immediata, bisogna fare
delle riflessioni riguardo i restanti punti. Parlando del primo requisito, è
necessario creare un programma che lavori a schermo intero e bisogna fare in
modo che, in nessuna occasione, sia possibile accedere alla tastiera virtuale di
Windows 7. Riguardo l’ultimo requisito, la soluzione più efficace è creare una
applicazione in grado di reperire feed RSS dal web, in modo da avere
informazioni contenute in file XML che seguono uno standard ben definito,
consentendo così la possibilità riprodurre informazioni da miglia di siti
semplicemente cambiando l’URL dato come input. Il servizio di riferimento che
verrà utilizzato per la pubblicazione del materiale sarà WordPress.com.
2.2.1 – WordPress
WordPress è una piattaforma software di "personal publishing" e content
management system (CMS); è sviluppata in PHP e usa MySQL come database.
Consente la creazione di un sito internet formato da contenuti testuali o
multimediali, facilmente gestibili ed aggiornabili. Attualmente esso è sviluppato
dalla società Automattic ed è distribuito con la licenza GNU General Public
License.

15
Figura 2. 3: WordPress logo
Per ogni blog registrato, WordPress.com offre un indirizzo permanente di terzo
livello del tipo “ nomescelto.wordpress.com “ che aiuta l'ottimizzazione nei
motori di ricerca.
Ogni pagina creata in WordPress.com ha un link che ci collega alla voce RSS del
sito. Tale link ci permette quindi di reperire il file XML contenente i dati di cui
abbiamo bisogno.
Se la pagina è reperibile all’indirizzo:
nomescelto.wordpress.com
allora la voce RSS avrà l’indirizzo:
nomescelto.wordpress.com/feed

16
2.2.2 – App Totem
L’applicazione è stata sviluppata in Java. Fatte le considerazioni iniziali, l’unico
input di cui abbiamo bisogno sono gli URL dei feed RSS. Per aggiungere o
eliminare facilmente un URL da cui scaricare gli articoli, bisogna modificare il
file Urls.xml che ho creato.
Es. tipo di file “Urls.xml”:
<?xml version="1.0" encoding="UTF-8"?>
<urls>
<caso numUrl="http://marchions.wordpress.com/feed/"></caso>
<caso numUrl="http://albertopolzonetti.wordpress.com/feed/"></caso>
<caso numUrl="http://motorinpistanews.wordpress.com/feed/"></caso>
</urls>
Per immettere un nuovo link bisogna aggiungere una nuova “riga” del tipo:
“<caso numUrl="link-da-aggingere”></caso>“
È importante che il link sia il riferimento alla voce RSS, che normalmente è in
formato XML.
Per eliminare un link, è sufficiente cancellare la “riga” contenente il
collegamento che si vuol cancellare.
2.2.3 – Librerie utilizzate
A questo punto, per la consultazione dei dati è stata utilizzata la libreria
“feed4j”, realizzata da Carlo Pelliccia e reperibile presso il suo sito. [3]
Feed4j implementa un parser di feed XML per la piattaforma Java. Si possono
interpretare diversi formati di feed XML e gestire il loro contenuto attraverso il
modello ad oggetti realizzato dalla libreria. I formati supportati da feed4j sono:
RSS 1.0 (comprese le estensioni Dublin Core), RSS 2.0 (il che significa anche RSS
0.91 e RSS 0.92), Atom 0.3 e Atom 1.0 (IETF standard). Feed4j è distribuito con

17
licenza LGPL, pertanto è Free Software e il codice sorgente è reso disponibile
dallo sviluppatore.
Le librerie utilizzate a sua volta da feed4j sono:
• dom4j ver. 1.6.1, utilizzata per leggere i campi XML del feed;
• NekoHTML, che implementa un parser HTML;
• Xerces e Xml-apis, che implementano due parser XML.
Per la lettura del file Urls.xml ho utilizzato la libreria “jdom”.
2.2.4 – Modifiche al sorgente della libreria
Feed4j fornisce solamente metodi per estrapolare elementi base dal feed,
come l’autore, il titolo e una anteprima del corpo del testo. Siccome la libreria è
open source è stato possibile modificarla a mio piacimento, riuscendo così a
reperire:
• L’intero corpo del testo dei singoli articoli;
• Gli URL delle immagini dai singoli articoli.
Per il primo punto è stato sufficiente aggiungere al parser del feed una
condizione per individuare il tag “<content:encoded>” che contiene il corpo
dell’articolo in HTML e aggiungere alla classe che gestisce gli elementi di ogni
singolo articolo (FeedItem.java) i metodi setContentAsHTML,
getContentAsHTML, setContentAsText e getContentAsText:
else if (ename.equals("encoded")) {
evalue = HTMLOptimizer.optimize(evalue);
if (evalue.length() > 0) {
item.setContentAsHTML(evalue);
item.setContentAsText(HTMLFragmentHelper.fromHTMLtoTextPlain(evalue));
}
}
Nel frammento di codice sopra esposto ename contiene il nome del tag, evalue
il suo valore e item è l’entità di tipo FeedItem che identifica un singolo articolo,
mentre il metodo fromHTMLtoTextPlain ottimizza la stringa che contiene campi
HTML in testo leggibile.

18
Per il secondo punto, visto che feed4j non supporta la gestione delle immagini
di un singolo articolo, ma solo le immagini inerenti alla pagina in generale, in
primo luogo ho dovuto modificare Feeditem.java inserendo un array di
elementi FeedImage (classe che gestisce le immagini del feed) e vari metodi per
la loro gestione:
private FeedImage image;
private FeedImage imageArray[]=new FeedImage[6];
private int imageCount=0;
public void setImage(FeedImage image) {
if(imageCount<6){
this.imageArray[imageCount]=image;
imageCount++;
}
this.image = image;
}
public FeedImage getImage() {
return image;
}
public int getImageCount() {
return imageCount;
}
public void setImageCount(int imageCount) {
this.imageCount = imageCount;
}
public FeedImage[] getImageArray() {
return imageArray;
}
public FeedImage getImageArray(int i) {
return imageArray[i];
}
public void setImageArray(FeedImage imageArray[]) {
this.imageArray = imageArray;
}
Dal codice sopra riportato si evince che è possibile salvare in memoria un
massimo di 6 immagini.
Come per il corpo del testo, è stata aggiunta una condizione nel parser che
permettesse di individuare il tag “<media:content>” contenente l’URL delle
immagini dell’articolo:

19
else if (ename.equals("content")) {
item.setImage(handleImageItem(element));
}
Il metodo handleImageItem individua tutte le proprietà descritte nel tag XML e
le attribuisce all’immagine di tipo FeedImage.
Un altro limite della libreria è l’impossibilità di scaricare le immagini contenute
dell’XML, perché con la classe FeedImage.java è possibile memorizzare
solamente l’URL di essa. Per ovviare a questa mancanza, è stato modificato il
metodo setImage in modo tale che l’immagine, tramite il suo riferimento,
venga recuperata, ridimensionata e salvata in memoria.
public void setImage(URL url1) {
URLConnection conn = null;
try {
conn = url1.openConnection();
} catch (IOException e) {
e.printStackTrace();
}
BufferedImage image = null;
try {
image = ImageIO.read(conn.getInputStream());
}
ImageIcon img=new ImageIcon(image);
Image newimg2= img.getImage();
if(newimg2.getHeight(null)>350){
newimg2 =
newimg2.getScaledInstance(newimg2.getWidth(null)*350/newimg2.getHeight(null), 350
, java.awt.Image.SCALE_SMOOTH);
}
if(newimg2.getWidth(null)>((int)Toolkit.getDefaultToolkit().getScreen
Size().getWidth())*4/5*4/5){
newimg2 =
newimg2.getScaledInstance(((int)Toolkit.getDefaultToolkit().getScreenSize().getWid
th())*4/5*4/5,
(((int)Toolkit.getDefaultToolkit().getScreenSize().getWidth())*4/5*4/5)*newimg2.ge
tHeight(null)/newimg2.getWidth(null), java.awt.Image.SCALE_SMOOTH);
}
ImageIcon newIcon = new ImageIcon(newimg2);
img=null;
newimg2=null;
this.immagine = newIcon;
}

20
Come si evince dal codice, nel metodo viene aperta una connessione per il
download dell’immagine; se l’immagine caricata è troppo grande per la nostre
necessità, essa viene ridimensionata tenendo conto delle caratteristiche dello
schermo del computer. Al termine l’immagine viene salvata nella variabile
immagine di tipo ImageIcon. Per poterla recuperare è stato creato il metodo
getImage.
2.2.5 - Verifica connessione
Fondamentale per il funzionamento dell’applicazione è una connessione
internet. Appena l’applicazione entra in funzione, occuperà tutto lo schermo
per evitare comportamenti indesiderati da parte dell’utente e immediatamente
effettuerà un test per la connessione internet. Se il totem è connesso alla rete
si procederà subito al download degli articoli, mentre se esso risulta non
connesso ci sarà un tentativo di connessione ogni 30 secondi.

21
Figura 2. 4: Screenshot durante primo tentativo di sincronizzazione con la mancanza di connessione

22
Per la verifica della connessione, è stata creata la classe VerificaConn.java che
al suo interno ha il metodo verificaConn che tenta la connessione a
http://www.google.com e indirizza lo stream di dati in un BufferedReader che
sarà dato in output. Se quest’ultimo è nullo significa che non c’è connessione,
in caso contrario il computer è connesso alla rete.
public BufferedReader verificaConn(){
URL url = null;
try {
url = new URL("http://www.google.com");
} catch (MalformedURLException e) {
}
URLConnection uc = null;
try {
uc = url.openConnection();
System.out.println("no connection");
}
BufferedReader br = null;
try {
br= new BufferedReader(new inputStreamReader(uc.getInputStream()));
System.out.println("no connection2");
}
return br;
}
2.2.6 - Lettura URL
La prima operazione che viene effettuata alla primo avvio dell’app, dopo la
verifica della connessione, è la lettura degli URL dal file Urls.xml. Per questo è
stata creata la classe ReadURLs che contiene il metodo readURLs:
public static URL[] readURLs(String fileName)throws IOException, JDOMException{
ArrayList<String> urls = new ArrayList<String>();
SAXBuilder builder = new SAXBuilder();
Document document = builder.build(new File(fileName));
Element root = document.getRootElement();
/** Estraggo i figli dalla radice */
List children = root.getChildren();
Iterator iterator = children.iterator();
int contFeed = 0;
while (iterator.hasNext()){
Element caso = (Element) iterator.next();
String numUrl=caso.getAttributeValue("numUrl");
urls.add(numUrl);
contFeed++;
}

23
URL urlArray[]= new URL[contFeed];
Iterator<String> ii = urls.iterator();
int i=0;
String temp;
while (ii.hasNext()){
temp = ii.next();
urlArray[i]=new URL(temp);
i++;
}
return urlArray;
}
Come espresso dal codice, si esamina il file XML con un iteratore e gli URL
individuati vengono aggiunti ad una lista. Allo stesso tempo viene incrementato
il contatore contFeed che, in un successivo momento, viene utilizzato per dare
la giusta dimensione all’array che andrà a contenere gli indirizzi. Come output si
ha l’array contenente dli URL.
2.2.7 - Schermata principale
La schermata principale contiene tutte le anteprime degli articoli, ordinati per
data di pubblicazione, ed è principalmente formata da un JScrollPane per poter
visualizzare il contenuto non visibile. Ogni anteprima è rappresentata da un
JPanel contenente immagine profilo e nome dell’autore, titolo e una breve
descrizione della pubblicazione.

24
Figura 2. 5: Screenshot schermata iniziale con articoli visualizzati

25
La JScrollPane viene creata inserendo in input al costruttore standard un
elemento JPanel. Nel nostro caso, è stata creata una classe PanelItem che
estende la classe JPanel, il cui costruttore è:
PanelItems(URL[] urlArray ,int contFeed, JPanel pannello,DrawPanel drawpanel){
Feed feedArray[]=new Feed[contFeed];
int countItemsTot=0;
for(int i=0;i<contFeed;i++){
try {
feedArray[i] = FeedParser.parse(urlArray[i]);
} catch (Exception e) {
System.out.println("connessione mancata durante il
parse/download di un feed "+ urlArray[i].toString());
DrawPanel.label2.setText("connessione venuta a mancare durante
lo scaricamento degli arcoli " + urlArray[i].toString());
Main.timerIniziale.schedule(new TaskIniziale(),30000,30000);
}
countItemsTot=countItemsTot+feedArray[i].getItemCount();
}
this.setLayout(new GridLayout(0, 1));
this.setBorder(null);
Feed feed;
FeedIndiceItem itemsArray[]=new FeedIndiceItem[countItemsTot];
int z=0;
for(int i=0;i<contFeed;i++){
feed=feedArray[i];
int itemsCount = feed.getItemCount();
for (int j = 0; j < itemsCount; j++) {
itemsArray[z]= new FeedIndiceItem(feed,j);
z++;
}
}
FeedIndiceItem temp;
int k = itemsArray.length-1;
while(k>0){
for(int i=0; i<k; i++){
//controllo valori adiacenti; scambio se il corrente è > del successivo
if(!itemsArray[i].getFeed().getItem(itemsArray[i].getPos()).getPubDate().after(ite
msArray[i+1].getFeed().getItem(itemsArray[i+1].getPos()).getPubDate())){
//esegue lo scambio
temp=itemsArray[i];
itemsArray[i]=itemsArray[i+1];
itemsArray[i+1]=temp;
}
}
k--;
}
for (int j = 0; j < countItemsTot; j++) {
CustomPanel c3=new
CustomPanel(itemsArray[j].getFeed(),itemsArray[j].getPos(),pannello,drawpanel);
this.add(c3);
}
this.setOpaque(false);
}

26
Nella parte di codice sopra descritta ci sono quattro cicli iterativi molto
importanti che hanno rispettivamente il compito di:
• Reperire le informazioni dai rispettivi siti: all’interno c’è infatti un
controllo per evitare arresti involontari dell’applicazione, nel caso in cui
si presentino problemi durante il download degli articoli;
• Immettere tutti gli articoli in un unico array di elementi di tipo
FeedIndiceItem (è un semplice costrutto composto da un elemento di
tipo Feed e un int che mi verrà utile per la rappresentazione
dell’articolo);
• Riordinare l’array contenente tutti gli articoli per data di pubblicazione,
con i più recenti all’inizio;
• Aggiungere tutte le anteprime ordinate nell’istanza creata dal costruttore
stesso. L’elemento aggiunto che rappresenta l’anteprima è di tipo
CustomPanel, una classe che ho creato estendendo nuovamente JPanel.
Il costruttore CustomPanel ha il compito di create elementi JPanel con delle
caratteristiche ben stabilite, tra cui la più importante è l’aggiunta per ogni suo
elemento di due listener:
• MouseMotion;
• AlClickMouse.
Il primo è una classe che implementa l’interfaccia MouseMotionListener e
quindi permette di definire procedure da eseguire al semplice movimento del
mouse, con il metodo mouseMoved, e al movimento del mouse con il tasto
sinistro premuto con il mouseDragged. Solo il secondo metodo è stato definito,
poiché si aveva la necessita di dover scorrere il JScrollPane come una lista in
uno smartphone, visto la presenza dello schermo touchscreen che simula un
mouse.
public void mouseDragged(MouseEvent e) {
DrawPanel.listScroller.getVerticalScrollBar().setValue(DrawPanel.listScrolle
r.getVerticalScrollBar().getValue() - e.getY()/3);
}

27
Dal codice si intuisce che spostando il mouse in su o in giù viene modificata la
posizione della scrollbar del pannello scrollabile.
Il secondo listener permette, al semplice click del mouse, di espandere una
determinata anteprima.
2.2.8 - Schermata di espansione articolo
Al click del mouse su di un’anteprima, il relativo articolo viene riportato su di
un nuovo JPanel, più precisamente in un elemento ImgPan (classe che ho
creato per estendere nuovamente JPanel) che ha caratteristiche ben precise,
tra cui uno sfondo preimpostato.

28
Figura 2. 6: : Screenshot visualizzazione generico articolo

29
Come si evince dalle immagini, in questa schermata viene rappresentato
l’intero articolo e quindi sono riportati:
• Nome Homepage;
• Titolo articolo;
• Data pubblicazione;
• Immagini dell’articolo;
• Corpo del testo.
Se l’articolo ha più di una immagine da visualizzare, tramite un click sull’unica
immagine visualizzata sarà possibile visualizzare le successive. Per avvertire
l’utente della presenza di più immagini comparirà un messaggio per notificarlo,
a destra della data di pubblicazione.
Figura 2. 7: Screenshot articolo con più immagini da visualizzare

30
Figura 2. 8: Screenshot articolo con visualizzazione della seconda immagine dell'articolo
Se lo spazio adibito al testo non è sufficiente per rappresentarlo, comparirà uno
scrollbar a destra di esso per la visualizzazione del testo sottostante (perché il
testo è inserito in un JScrollPane).

31
Figura 2. 9: Screenshot articolo con testo visualizzato tramite scrollbar
Al di sotto del testo è sempre presente un pulsante che permette di ritornare
alla schermata principale.

32
2.2.9 - Aggiornamento contenuti
Per garantire notizie sempre sincronizzate con quelle presenti nei rispettivi siti,
l’applicazione si aggiornerà automaticamente ogni 30 minuti e sarà anche
possibile aggiornarla manualmente con l’apposito pulsante in fondo alla
schermata.
BufferedReader br= new VerificaConn().verificaConn();
if (br != null) {
System.out.println("aggiornamento in corso");
PanelItems panel1=new PanelItems( urlArray, contFeed, pannello,iniziale);
JScrollPane listScroller2 = new JScrollPane(panel1);
listScroller2.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLL
BAR_NEVER);
listScroller2.setPreferredSize(new java.awt.Dimension((int)
Toolkit.getDefaultToolkit().getScreenSize().getWidth()*4/5, ((int)
Toolkit.getDefaultToolkit().getScreenSize().getHeight())-
DrawPanel.label.getHeight()-10-200));
………..
System.out.println("prima gc"+java.lang.Runtime.getRuntime().freeMemory());
System.gc();
System.out.println("dopo gc"+java.lang.Runtime.getRuntime().freeMemory());
num++;
System.out.println("aggiornamento numero "+num);
}else{
System.out.println("Momentaneamente non c'è nessuna connessione internet,
impossibile aggiornare");
}
Il codice sopra riportato è adibito all’aggiornamento automatico (quello per
l’aggiornamento manuale è molto simile) ed è contenuto nel metodo run della
classe TaskAutoAggiornamento che estende TimerTask, e quindi può essere
richiamato tramite un timer. Ovviamente ad ogni tentativo di aggiornamento
viene ricontrollata la presenza della connessione internet. Ad ogni
aggiornamento viene chiamato il Garbage Collector di Java per evitare che
l’applicazione occupi troppa memoria RAM (causata dalla precarica di tutte le
immagini di tutti gli articoli).
2.2.10 - Grafica
Si è cercato di rendere l’interfaccia più semplice ed intuitivo possibile, cercando
di non dare più rilevanza grafica ad un articolo rispetto ad un altro. I colori
prendono spunto dallo stemma dell’università e dallo stesso totem. Per

33
adattare i vari elementi grafici ho dovuto rendere conto dei pixel dello schermo
con qui stavo lavorando.
2.3 – Realtà centralizzate di social network
Come detto in precedenza, al giorno d’oggi milioni (se non miliardi) di utenti
hanno almeno un account in un social network.
Un servizio di rete sociale, o servizio di social network, consiste in una struttura
informatica che gestisce nel Web le reti basate su relazioni sociali.
Secondo la definizione data dagli studiosi Boyd-Ellison, si possono definire siti
di reti sociali i servizi web che permettono:
• la creazione di un profilo pubblico o semi-pubblico all'interno di un
sistema vincolato;
• l’articolazione di una lista di contatti;
• la possibilità di scorrere la lista di amici dei propri contatti.
Attraverso ciò, questi servizi permettono di gestire e rinsaldare online amicizie
preesistenti o di estendere la propria rete di contatti.
2.3.1 – Il successo dei social network
I social network sites ebbero un'esplosione nel 2003, grazie alla popolarità di
siti web come Friendster, abcTribe.com e LinkedIn. Google ha lanciato Orkut il
22 gennaio 2004. Kidzbop, una social network in spagnolo e portoghese, ha
debuttato anch'esso nel 2004. In Italia, il primo dei grandi portali convertito in
questo tipo di rete sociale è stato superEva, ma sono comunque vivissime
anche le comunità di italiani su Orkut e LinkedIn. In Italia, fra il 2003 e il 2004,
abbiamo assistito anche all'esplosione di MSN.
Uno studio del 2010, basato sul confronto dei dati di traffico risultanti dai
motori Alexa, Google Trends for Websites e ComScore, mostra l'avanzata di
Facebook in un numero crescente di nazioni, anche laddove MySpace
opponeva maggiore resistenza. Al giorno d’oggi, possiamo affermare che lo

34
studio sopra citato aveva basi ben fondate visto che l’impero di Mark
Zuckerberg ha raggiunto una utenza inimmaginabile.
L'uso di reti sociali sta diffondendosi anche come un'evoluzione delle radio on
line. I siti non si limitano a proporre musica in formato mp3, ma interpretano i
gusti e propongono artisti e canzoni simili, permettendo di estendere le proprie
conoscenze a nuovi artisti, nuovi stili e nuovi ritmi. Attraverso siti come
Pandora.com, lastfm.it, musicovery.com, è possibile creare delle comunità
virtuali (in inglese “virtual communities”) invitando i propri amici e anche
ascoltando la musica proposta dai "vicini", persone con preferenze simili alle
proprie. [4]
Le reti sociali possono essere organizzate attorno a professioni lavorative o
svilupparsi su base territoriale, ad esempio per siti dedicati esclusivamente a
cultura e tempo libero in una determinata città.
2.3.2 – Meccanismo dietro il social network tradizionali
Per entrare a far parte di una rete sociale online occorre costruire il proprio
profilo personale, fornendo informazioni come il proprio indirizzo email, i
propri interessi e passioni (utili per le aree "amicizia" e "amore"), le proprie
esperienze di lavoro e le relative referenze (informazioni necessarie per il
profilo "lavoro").
A questo punto è possibile invitare amici a far parte della propria rete, i quali a
loro volta contribuiscono ad allargare la cerchia di contatti invitando altri amici,
e così via.
Diventa quindi possibile costituire delle comunità tematiche in base alle proprie
passioni o aree di affari, aggregando ad esse altri utenti e stringendo contatti di
amicizia o di affari.
Oltre ai vantaggi che ovviamente si hanno quando si fa parte di una rete
sociale, il sistema centralizzato ha come punto a sfavore il fatto che l’utente
debba accettare le “condizione d’uso”, le quali genericamente rappresentano
un possibile fastidio per l’user.
Tali condizioni sono in genere:

35
• Tutti i dati che noi forniamo durante la fase di registrazione e durante la
permanenza del sito (preferenze, interessi, ecc), diventano “proprietà”
del social network. I detentori di siti social possono trarre guadagno dalla
fornitura a terzi di tali informazioni;
• Gli user riceveranno pubblicità mirata in base ai siti visitati, link aperti,
permanenza media e alle informazioni da loro stessi inserite.
• Non è permesso all’utente l’accesso ai propri dati senza passare per il
sito di social network.
• Non è possibile connettersi ad un proprio conoscente, se lui non accetta
le condizioni del sito.
Figura 2. 10: Immagine che rappresenta un social network centralizzato

36
FOAF grazie alla sua struttura mirata ad implementar l’idea del web semantico,
può sostituire il sistema basato sulla centralizzazione dell’informazione,
rendendo l’utente meno “schiavo” delle condizioni imposte dai tradizionali siti
di social networking e permette una creazione pressoché automatica della
propria rete di interessi e amicizie.
Figura 2. 11: immagine che rappresenta la chiusura reciproca tra siti social

38
3 - SEMANTIC WEB
Alla base del progetto FOAF c’è un idea che, per via del suo potenziale, sarà
importante per l’Internet del prossimo futuro: il “Web Semantico”.
Figura 3. 1: Logo Semantic Web
Quando formuliamo una frase creiamo una sintassi, ossia una serie di parole
con una precisa forma, e vi associamo un ben determinato significato: il
significato degli elementi di una frase è di fatto la semantica.
D’altro canto, quando riceviamo una frase come -per esempio- “Ciao Papà”, il
nostro cervello comprende automaticamente, per un meccanismo naturale

39
sviluppato durante la nostra evoluzione, che siamo stati salutati da nostro
figlio.
Elevando la cosa, possiamo definire:
• Sintassi: come si manifesta un insieme di elementi di un linguaggio
• Semantica: che cosa significa un insieme di elementi di un linguaggio
Il Web, come lo conosciamo oggi, è un insieme di dati raccolti in pagine, le quali
vengono lette dalla macchina e interpretate secondo un approccio “sintattico”.
Quando facciamo una richiesta http, il nostro browser processa un insieme di
costrutti linguistici che determinano cosa dovrà essere rappresentato
all'utente, però la natura di questi dati non è d'interesse per la macchina.
Infatti essa applica una elaborazione lineare sulla base del contenuto della sua
sintassi, e da il risultato all'utente.
Quindi attualmente il browser processa i dati non attribuendo loro alcun
significato.
Se riuscissimo a “far comprendere” ad una macchina ciò che noi vogliamo
esprimere, essa potrebbe agire come una intelligenza vera e propria, capace di
fare proprio il contenuto del messaggio ed eventualmente modificare il
messaggio stesso.
Questo scenario fu ipotizzato per la prima volta da Tim Berners-Lee, l’inventore
del Web, in una sua dichiarazione dove auspicava un futuro di macchine capaci
di interagire tra loro in maniera intelligente (semanticamente) rendendo la
navigazione per l’utente più efficiente.
Possiamo quindi pensare che, con applicazioni capaci di elaborare informazioni
semantizzate e che utilizzano un nuovo approccio per la conservazione dei dati,
tutto il web verrebbe riconcepito come un enorme database!

40
3.1 – Tecnologie utilizzate
Le tecnologie per la definizione dei dati semantici si chiamano RDF, RDFS e
OWL che sono estensioni di un caratteristica delle vecchie pagine web: i
cosiddetti “metadati”.
Una pagina html contiene normalmente un insieme di descrizioni racchiuse nei
tag <meta></meta>, che permettono di avere informazioni molto generali del
tipo: titolo, autore, parole chiave, tipo di contenuto, etc. Questi tag html,
decisamente sotto-utilizzati nel vecchio www, sono un esempio primitivo di
semantizzazione!
3.1.1 - Esprimere concetti in RDF
Sul web, una tecnologia che possiamo usare per descrivere vari tipi di cose e le
loro interrelazioni si chiama 'RDF' ( Resource Description Framework). RDF è
una relativamente nuova specifica prodotta dal World Wide Web Consortium
(W3C).
Questa tecnologia ha le seguenti caratteristiche:
• Un linguaggio per rappresentare risorse nel World Wide Web.
• general-purpose.
• Un sistema basato sugli statement, rappresentati per mezzo di vocaboli.
• Una tecnologia di base su cui si sviluppano altre tecnologie per effettuare
una semantizzazione di più alto livello (FOAF).
Qualunque cosa descritta da RDF è detta risorsa. Principalmente una risorsa è
reperibile sul web, ma RDF può descrivere anche risorse che non si trovano
direttamente sul web.
Quindi ogni risorsa viene identificata da un URI (Universal Resource Identifier).
Gli URL con cui ci si collega alle pagine sono, di fatto, un sotto-insieme degli
URI. Per questo un URL è sempre un URI, ma non tutti gli URI sono URL. Questo
da garanzie di integrabilità col vecchio sistema.
Il modello di dati RDF è formato da risorse, proprietà e valori. Le proprietà sono
delle relazioni che legano tra loro risorse e valori, e sono anch'esse identificate

41
da URI. Un valore, invece, è un tipo di dato primitivo, che può essere una
stringa contenente l'URI di una risorsa.
Figura 3. 2: Immagine che rappresenta l'unione tra una descrizione RDF e una risorsa creata dall'URI
L'unità base per rappresentare un'informazione in RDF è lo statement.
Tipicamente uno statement è una tripla del tipo Soggetto – Predicato –
Oggetto, dove:
• Il soggetto identifica la risorsa che deve essere descritta nello statement,
appartiene a Resource;
• Il predicato identifica la proprietà della risorsa che si sta descrivendo e
viene anche chiamata proprietà. Serve per rappresentare attributi,
caratteristiche o relazioni di una risorsa.
• L’ oggetto identifica il valore della proprietà. Appartiene a Resource o a
String (è quindi anche un URI che punta ad un'altra risorsa), così
possiamo costruire sistemi che combinano automaticamente tali dati da
fonti multiple.
Figura 3. 3: Rappresentazione tipo di uno statement

42
Una pagina potrebbe dire che "marco.rossi@gmail.com lavori-in
http://ferrari.org/". Un altro potrebbe dire che "http://ferrari.org/ base-a
Maranello". Su questa base, gli strumenti RDF potrebbero concludere che la
persona il cui indirizzo e-mail è marco.rossi@gmail.com lavora per una
organizzazione con sede a Maranello.
RDF è quindi un Framework per esprimere gli statement: mette a disposizione
un insieme di URI (o vocaboli) da utilizzare per strutturare lo statement,
indicando alla macchina “qui sta il soggetto, qui il predicato e qui l'oggetto”
oppure da usare direttamente come soggetti, predicati od oggetti dello
statement stesso.
3.1.2 - RDF Schema
D'interesse per il progetto è invece l'RDFS (o RDF Schema) [5], che permette di
estendere il vocabolario di base della sintassi RDF.
In RDF Schema (RDFS), ogni predicato è in relazione con altri predicati e
permette di dichiarare l'esistenza di proprietà di un concetto, che permettano
di esprimere con metodo sistematico affermazioni simili su risorse simili.
RDF Schema permette di definire:
• Nuovi tipi di classe e sottoclasse e consente di definirne delle gerarchie.
In RDF si possono rappresentare le risorse come istanze di classi e
definire sottoclassi e tipi.
• Proprietà: nuovi tipi di predicati, modellabili secondo i loro possibili
valori.
• Datatypes: nuovi tipi di valori letterali.
Inoltre usando le Utilities si possono estendere le classi in orizzontale,
garantendo legami di somiglianza, e fare retro-ereditarietà.
L'RDFS, di fatto, mette insieme delle tipologie (schemi, appunto).
Queste tipologie sono estremamente potenti, ma hanno come limite che sono
vincolate all'uso degli RDF. Cosa fare se si volessero dei vocaboli “liberi” da

43
usare per definire le nostre risorse? A questo punto entra in gioco il concetto di
OWL, Web Ontolgy Language.
3.1.3 - Web Ontolgy Language
L’ontologia utilizzata per RDF è la “Dublin Core” [7](infatti segue lo standard
OWL) che definisce l’insieme di termini che utilizzeremo per definire il nostro
dominio di concetti.
Le direttive OWL possono essere serializzate direttamente in XML7 in modo
parzialmente o completamente indipendente dalle parti definite con
RDF/RDFS: in effetti OWL non si basa sulle triple o statement che usa RDF, ma
sugli “axiom” (assiomi) che possono avere da due a un numero variabile di
elementi, sono quindi potenzialmente più semplici, espressivi e dinamici di uno
statement. Ognuno dei singoli elementi di un axiom viene definito “entity”
(entità). [6] [8]
Con la semantizzazione dei dati e la possibilità di estrarli dalle singole pagine,
tutto il web viene riconcepito come un enorme database su cui si possono
effettuare interrogazioni in SPARQL, similmente a ciò che fa SQL.

44
4 - FOAF
Il progetto FOAF ("Friend of a Friend") è uno sforzo della comunità per definire
un vocabolario RDF e per esprimere i metadati relativi a persone, i loro
interessi, relazioni e attività. Fondata da Dan Brickley e Libby Miller, FOAF è
quindi un'iniziativa aperta che sta affrontando l’obbiettivo del Semantic Web.
Nell’ambito “Social network” FOAF facilita la creazione del Semantic Web
equivalente alle homepage personali e, proprio come nella versione HTML, i
documenti FOAF possono essere collegati tra loro per formare una rete di dati
avente una semantica ben definita.
Figura 4. 1: FOAF logo
4.1 - Meccanismo base di FOAF
Si consideri un Web di home page inter-connesse, dove ciascun utente descrive
i propri interessi per un gruppo di amici. Ogni homepage arricchisce il Web con
fatti e notizie che rendono la rete una miniera di frammenti sconnessi di
informazioni. FOAF fornisce un metodo per integrare tutti questi frammenti.
Ecco ad esempio, un frammento “tipo” del database FOAF.
Innanzitutto elenchiamo alcune affermazioni per poi descrivere come il sistema
FOAF esplora il Web per apprendere tali informazioni.

45
• Davide vive a Treia con Matteo e Fabio.
• Indirizzo e-mail di Davide è davide@gmail.com.
• Indirizzo e-mail di Matteo è matteo@gmail.com.
• Indirizzo e-mail di Fabio è fabio@gmail.com.
• Davide e Matteo lavorano per un'organizzazione chiamata "ILRT" il cui
sito è al http://ilrt.org/.
• Fabio lavora per "Ferrari", un'organizzazione il cui sito web è a
http://www.ferrari.com.
• La fidanzata di Matteo è Gloria e vive a Fermo con Silvia.
• Silvia e Gloria lavorano presso "Ferrari".
Questo tipo di informazioni si trova in genere nelle homepage degli utenti.
Queste brevi frasi ci dimostrano quanto facilmente esse possano essere usate
per caratterizzare una rete di relazioni tra persone, luoghi, organizzazioni e
documenti.
Queste informazioni molto probabilmente sarebbero distribuite attraverso le
pagine Web create dalle varie persone elencate (ad esempio l’informazione
“Matteo e Gloria lavorano al McDonald” sarà una informazione distribuita sia
da Matteo che da Gloria).
Molto probabilmente, le home page delle persone elencate si collegheranno
direttamente o indirettamente, alle home page di innumerevoli altri amici-di-
amici-di-amici.

46
4.2 - Obbiettivi
Rendendoci conto delle informazioni con cui abbiamo a che fare, FOAF si pone i
seguenti obbiettivi per il progetto:
• Ottenere un miglior modo di tenere traccia dei frammenti di dati sparsi
attualmente nel web;
• Essere in grado di trovare i documenti nel Web in base alle loro proprietà
e interrelazioni;
• essere in grado di trovare informazioni sulle persone in base alle loro
pubblicazioni, dettagli del lavoro, appartenenza di gruppo e interessi
dichiarati.
• essere in grado di condividere annotazioni, valutazioni, segnalibri e
frammenti di dati arbitrari utili utilizzando alcune infrastrutture comuni.
• Ottenere un sistema di ricerca Web che è più simile a un database e
meno a una ricerca fortunosa.
• C’è la necessità di fare tutto questo in maniera distribuita, decentrata, e
con contenuto neutrale.
FOAF, in caso di successo, dovrebbe aiutare il Web fare il genere di cose che
sono attualmente l'offerta esclusiva di servizi centralizzati. [9]
4.3 - Definizione
FOAF è semplicemente un vocabolario RDF (l’ultima versione è la 0.98).
Come qualsiasi vocabolario, FOAF pubblica sia il suo schema che le sue
specifiche nel suo URI: http://xmlns.com/foaf/0.1. La documentazione è
completa e include le definizioni di tutte le classi e le proprietà nell’RDF-schema
associato.
Essendo un'applicazione RDF, FOAF può rivendicare il vantaggio di raccogliere e
aggregare facilmente i dati. Come tutti i vocabolari RDF, i vocabolari di FOAF
possono essere facilmente combinati con altri vocabolari, consentendo la
cattura di un ricco set di metadati

47
4.4 - Esprimere una identità univoca in FOAF
Quando si inizia a immettere informazioni del mondo reale, in un sistema
informatico, si incontra la difficoltà di creare un nome univoco per ogni cosa.
Nel caso delle persone, è ovvio che il nome di una persona non è sufficiente a
identificare in modo univoco tale persona in rete.
Quindi, se si considera il sistema FOAF - dove chiunque è libero di creare e di
utilizzare i dati, ma in cui si desidera un solo nome per persona - è necessaria
una strategia di denominazione decentrata. Il Web ha una strategia abbastanza
consolidata di denominazione univoca: l'URI (come detto in precedenza). Per
l’identificazione di persone, si potrebbe pensare all’indirizzo e-mail. Tuttavia,
non è semplice come sembra. Un approccio ingenuo potrebbe portare uno
sviluppatore a scrivere, ad esempio:
• edd@gmail.com vive in Italia
Con un attimo di attenzione si dimostra che questa affermazione è in realtà
non vera, anche perché si può affermare:
• edd@gmail.com è un indirizzo e-mail
Chiaramente una persona e l'indirizzo e-mail di quella persona non sono la
stessa cosa, quindi non è possibile utilizzare praticamente l’indirizzo e-mail di
una persona come il nome globale. Inoltre, una persona può avere più indirizzi
di posta elettronica, ognuno utilizzato per uno scopo diverso.
Eppure il principio di utilizzare un indirizzo di posta elettronica per identificare
una persona non è viziato: in generale, se si invia un messaggio di posta
elettronica ad un indirizzo, ci si aspetta di raggiungere una certa persona.
D’altra parte non si può creare un nome globale per una persona, però si può
ragionevolmente supporre che tutte le descrizioni di una persona includenti
l’informazione "Indirizzo e-mail di questa persona è edd@gmail.com" facciano
riferimento alla stessa persona.
Quindi, si potrebbe correttamente scrivere:
• La persona con e-mail edd@gmail.com vive in Italia.

48
Questa è la tecnica utilizzata per identificare una persona in FOAF. Al fine di
combinare informazioni sui singoli individui, il presupposto è che un indirizzo e-
mail è una proprietà univoca che solo una persona possiede.
La proprietà che descrive la mail dell’utente è la “mbox”, per esempio:
<foaf:mbox rdf:resource="mailto:matteo.marchionne@studenti.unicam.it" />
Ma più comunemente, nel FOAF file generator, viene utilizzata la proprietà
“mbox_sha1sum” che sfrutta lo Sha1sum per rendere unica la proprietà e allo
stesso tempo verificarne l’integrità. Ecco un esempio:
<foaf:mbox_sha1sum>cf2f4bd069302febd8d7c26d803f63fa7f20bd82</foaf:mbox_sha1sum>
In questo documento verrà utilizzato la proprietà “mbox” per descrivere la mail
di un utente, per rendere più leggibile e di facile comprensione il testo.
4.5 - Struttura FOAF usando XML
La forma più comune del FOAF è RDF/XML, quindi il tipico file FOAF è in
estensione RDF con le informazioni rappresentate all’interno di campi XML.
Un esempio con le proprietà base:
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:foaf="http://xmlns.com/foaf/0.1/">
<foaf:Person>
<foaf:name>Matteo Marchionne</foaf:name>
<foaf:mbox rdf:resource="mailto:matteo.marchionne@studenti.unicam.it"
/>
</foaf:Person>
</rdf:RDF>
In questo esempio ci viene comunicato che "vi è una persona di nome Matteo
Marchionne il cui indirizzo e-mail è matteo.marchionne@studenti.unicam.it."
Altre proprietà che possono descrivere meglio l’utente sono:
• Nick: stringa che identifica l’utente, per esempio in chat

49
• Homepage: URL dell’homepage dell’utente
• Workplacehomepage: URL dell’homepage del luogo di lavoro
• Depiction: URL dell’immagine dell’utente che si sta definendo
Che possono essere facilmente aggiunte al file FOAF tra i tag XML
“<foaf:Person>” come in questo esempio di codice:
<foaf:Person>
<foaf:name >Matteo Marchionne</foaf:name>
<foaf:mbox rdf:resource="mailto: matteo.marchionne@studenti.unicam.it " />
<foaf:nick >marchions</foaf:nick>
<foaf:workplacehomepage rdf:resource="http://www.unicam.it/" />
<foaf:depiction
rdf:resource="http://dropbox.com/marchions/images/matteo.jpg" />
</foaf:Person>
4.6 - Approfondimento immagini
In precedenza abbiamo definito come e quando definire la proprietà
“foaf:depiction”, la quale viene utilizzata per indicare l’immagine in cui è
rappresentata la persona descritta (infatti questa proprietà si trova nei tag
“foaf:Person”). FOAF supporta anche una struttura diversa, “foaf: depicts”, che
ci permette di fare affermazioni del tipo: "Questa immagine è una foto di
questa risorsa". L'esempio seguente illustra entrambe queste proprietà.
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<foaf:Person rdf:ID="peter">
<foaf:name>Peter Parker</foaf:name>
<foaf:depiction rdf:resource="http://www.peterparker.com/peter.jpg"/>
</foaf:Person>
<foaf:Person rdf:ID="spiderman">
<foaf:name>Spiderman</foaf:name>

50
</foaf:Person>
<foaf:Person rdf:ID="green-goblin">
<foaf:name>Green Goblin</foaf:name>
</foaf:Person>

<foaf:Image
rdf:about="http://www.peterparker.com/photos/spiderman/statue.jpg">
<dc:title>Battle on the Statue Of Liberty</dc:title>
<foaf:depicts rdf:resource="#spiderman"/>
<foaf:depicts rdf:resource="#green-goblin"/>
<foaf:maker rdf:resource="#peter"/>
</foaf:Image>
</rdf:RDF>
In questi casi RDF diciamo con la proprietà depiction che l'immagine
“http://www.peterparker.com/peter.jpg“ è una foto che ritrae Peter Parker,
mentre successivamente si definisce fuori dal tag “foaf:Person” un
“foaf:image”, cioè un'immagine che può essere trovata in un URI specifico, poi
dove con la proprietà “foaf:depicts” si esprime che l’immagine raffigura
Spiderman e Goblin. L’ultima proprietà descritta è fondamentale per dichiarare
una foto al fuori delle descrizioni delle singole persone, potendo così collegare
l’immagine a più individui successivamente. Gli elementi dello spazio dei nomi
Dublin Core (proprietà dc) sono spesso aggiunti ai documenti FOAF per dare un
titolo, ecc. Si noti inoltre che Peter Parker è definito come l'autore delle
immagini dalla proprietà “foaf:maker”, la quale collega una risorsa al suo
creatore.
4.7 - Come creare una rete che collega i vari file FOAF
Una proprietà fondamentale che ancora non abbiamo menzionato è la
proprietà “knows”. Con quest’ultima è possibile creare un collegamento fra
due persone che si conoscono. Per fare ciò, è essenziale identificare

51
univocamente l’individuo che volgiamo aggiungere alle nostre conoscenze,
cosa di cui abbiamo parlato in precedenza.
Ecco un pratico esempio per aggiungere una conoscenza nel nostro FOAF, deve
essere aggiunto tra i tag XML “<foaf:Person>” quello che segue:
<foaf:knows>
<foaf:Person>
<foaf:mbox rdf:resource="mailto:gloria.silveri@studenti.unicam.it" />
<foaf:name>Gloria Silveri</foaf:name>
</foaf:Person>
</foaf:knows>
Con questo frammento di codice possiamo dire che noi conosciamo l’utente
Gloria Silveri, che viene identificato con la mail:
“gloria.silveri@studenti.unicam.it”.
In questo caso non si è aggiunta una vera e propria proprietà, ma si è creato un
collegamento tra i due utenti che utilizzano FOAF. Ovviamente è possibile
aggiungere più amici.
Figura 4. 2: Immagine che rappresenta la rete sociale decentralizzata creata da FOAF

52
Definito dalle specifiche RDF Schema, la proprietà “rdfs: seeAlso” indica una
risorsa che può contenere ulteriori informazioni inerenti alla risorsa associata,
ad esempio l’URL del file FOAF associato ad una determinata persona.
La proprietà “seeAlso” è molto importante perché viene utilizzata da FOAF per
costruire una rete di metadati leggibili dalla macchina, dato che può essere
considerata un collegamento ipertestuale per costruire un database di dati
FOAF. Poiché con questo campo possiamo rappresentare il nostri collegamenti
con i nostri amici, sorge spontanea una domanda:
se tu mi conosci, io devo conoscere te automaticamente?
Questo aspetto è volutamente lasciato indefinito. Per ovvie ragioni, la
modellazione delle relazioni interpersonali rappresenta una questione
complicata. Il progetto FOAF ha quindi fatto un passo prudente permettendo
semplicemente un rapporto da definire, senza qualifica supplementare. Spetta
ad altre comunità (e vocabolari) definire ulteriormente i diversi tipi di relazioni.
L'aspettativa è che vocabolari aggiuntivi verranno formulati per perfezionare il
FOAF generale e per creare qualcosa di più specifico. Il modo per raggiungere
questo obiettivo è quello di dichiarare nuove sotto-proprietà di “FOAF: knows”.
Facendo per un momento un passo al di fuori di FOAF, siamo in grado di
mostrare brevemente un esempio di quest’aspetto, utilizzando lo schema di
relazione creato da Eric Vitiello che definisce una serie di sotto-proprietà di
foaf:knows e che include parentOf, siblingOf, friendOf, ecc.
Il seguente esempio utilizza tali proprietà per chiarire i rapporti tra Peter Parker
e alcuni suoi contemporanei:
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:rel="http://www.perceive.net/schemas/relationship/">
<foaf:Person rdf:ID="spiderman">
<foaf:name>Spiderman</foaf:name>
<rel:enemyOf rdf:resource="#green-goblin"/>
</foaf:Person>
<foaf:Person rdf:ID="green-goblin">
<foaf:name>Green Goblin</foaf:name>

53
<rel:enemyOf rdf:resource="#spiderman"/>
</foaf:Person>
<foaf:Person rdf:ID="peter">
<foaf:name>Peter Parker</foaf:name>
<rel:friendOf rdf:resource="#harry"/>
</foaf:Person>
<foaf:Person rdf:ID="harry">
<foaf:name>Harry Osborn</foaf:name>
<rel:friendOf rdf:resource="#peter"/>
<rel:childOf rdf:resource="#norman"/>
</foaf:Person>
<foaf:Person rdf:ID="norman">
<foaf:name>Norman Osborn</foaf:name>
<rel:parentOf rdf:resource="#harry"/>
</foaf:Person>
</rdf:RDF>
Mentre è possibile modellare relazioni abbastanza dettagliate con questo
metodo, le applicazioni più interessanti saranno quelle che verranno dedotte in
base ai metadati. Ad esempio, se essi hanno collaborato sullo stesso progetto,
allora hanno lavorato per la stessa azienda, e così via. [10] [11]
4.8 - Vocabolario FOAF
L’ultimo vocabolario FOAF è la versione 0.98 rilasciato il 9 agosto del 2010 ed è
stato ritenuto stabile dalla comunità. [12]
FOAF raggruppa una discreta varietà di termini e alcune applicazioni ne
ignorano differenti parti, comunque i termini principali possono essere
raggruppati in:
• Core: queste classi e proprietà sono il nucleo di FOAF. Descrivono le
caratteristiche della persona e dei gruppi sociali.

54
• Social Web: sono i termini che descrivono gli account internet e altre
attività basate sul web. Queste possono essere utilizzate per collegare
svariati profili e creare quindi una sotto rete di account già esistenti.
Figura 4. 3: Vocabolario principale di FOAF

55
4.9 - Pubblicazione del file FOAF
Dopo la creazione della propria descrizione FOAF, cioè un file con estensione
rdf, il passo successivo è quello di mettere in rete il file FOAF e di collegare
queste nuove informazioni nella rete dati FOAF esistente.
Ci sono differenti vie:
• Tramite “foaf:knows”, cioè tramite gli utenti che ci conoscono, quindi
quando ci descrivono con la proprietà “rdfs:seeAlso” dovranno inserire
l’URI del nostro file;
• Attraverso il bollettino FOAF, cioè la pagina wiki che collega centinaia di
file FOAF;
• Per via dell’auto divulgazione, ossia pubblicare il proprio link FOAF
usando pagine Html.
4.10 - Applicazioni di FOAF
L'applicazione FOAF, che più sarà utile ad un utente che ha appena pubblicato
la propria descrizione, sarà il FOAF Explorer di Morten Frederikson [13], il
quale è in grado di generare una visualizzazione HTML di dati FOAF, completa
di immagini di riferimento e collegamenti ad altri dati.
LiveJournal.com, Tribe.net, and Buzznet.com sono alcune reti di comunicazione
che pubblicano i dati degli utenti in FOAF.
Plink.org era un social network basato su FOAF. Esso era finalizzato alla
pubblicazione di dati FOAF in maniere totalmente libera. Poco dopo la sua
apparizione, esso è stato però forzatamente chiuso per motivi di privacy, dato
che molti utenti hanno denunciato che i propri dati sensibili erano resi
eccessivamente accessibili.
4.11 - Privacy
Sicuramente l’esempio di Plink.com ci fa riflettere.
Alla base del web semantico c’è la facilità di condividere e reperire informazioni
di nostri interesse e sulle persone di nostra conoscenza. Purtroppo l’utente

56
medio, che aderisce alle varie iniziative nel web, generalmente non si cura
affatto delle condizioni che il sito obbliga a sottoscrivere. Questo
atteggiamento poco attento costringe iniziative di indiscusso interesse e
potenzialità, come plink.com, a rivedere i propri obiettivi fino a rende vano il
tentativo di portarli a termine.
Al giorno d’oggi si presta molta importanza alla tematica della privacy e il
progetto FOAF sembrerebbe non tutelare molto l’utente finale.
Anche se sicuramente FOAF deve crescere in questo campo, l’utente ha la
facoltà di scegliere quali contenuti condividere e questo progetto può essere
implementato senza alcun problema dagli enti che vogliono fare pubblicità di
loro stessi.
D’altro canto FOAF, fornendo un sistema decentrato e distribuito, deve essere
comprensibile a tutti e quindi senza particolari limitazioni d’accesso. Per lo
stesso motivo può essere considerato uno strumento per reperire dati
strutturati per gli spammer.
Basti pensare che un qualsiasi file FOAF contenga la proprietà SHA1hash, grazie
alla quale si può dedurre e verificare la mail della persona descritta. Per
esempio, tramite la proprietà data di nascita, lo spammer può inviare mail per il
compleanno, con all’interno false promozioni di un negozio online descritto nel
file FOAF del malcapitato!
La privacy dei profili FOAF è stata discussa da alcuni ricercatori.
In merito a ciò è stato proposto:
• di crittografare parti del file FOAF per limitare accessi non autorizzati.
• di partizionare il file FOAF, dove ogni partizione ha una specifica visibilità.
Queste soluzioni, tuttavia, non sono ampiamente usate, perché i file FOAF
devono essere facilmente reperibili per non andare incontro ad una
contraddizione con l'iniziativa Open Data.
Un metodo per evitare mail indesiderate di spam potrebbe essere quello di
filtrare la mail in arrivo, consentendo solamente la ricezione delle mail da parte
dei propri conoscenti. Come è facilmente intuibile, questa soluzione risulta una
forzatura.

57
4.11.1 - WebID
Visto che FOAF è decentralizzato, anche il sistema di autenticazione deve
esserlo, per questo il W3C ha creato FOAF+SSL (noto anche come WebID), un
protocollo di autenticazione sicuro e decentrato, che utilizza le informazioni
del profilo FOAF e allo stesso tempo il SSL/TLS security layer, virtualmente
disponibile in tutti i browser web moderni.
4.11.2 - TLS/SSL
In telecomunicazioni e informatica Transport Layer Security (TLS) e il suo
predecessore Secure Sockets Layer (SSL) sono dei protocolli crittografici che
permettono una comunicazione sicura dalla sorgente al destinatario (end-to-
end) su reti TCP/IP (come ad esempio Internet), fornendo autenticazione,
integrità dei dati e cifratura operando al di sopra del livello di trasporto. La
crittografia utilizzata è a chiave asimmetrica.
Diverse versioni del protocollo sono ampiamente utilizzate in applicazioni come
i browser, l'e-mail e la messaggistica istantanea. Un esempio di applicazione di
SSL/TLS è nel protocollo HTTPS.
4.11.3 - Funzionamento di WebID
Il funzionamento del certificato può essere spiegato con questa immagine che
rappresenta una sequenza semplificata per l’autenticazione tramite WebID:

58
Figura 4. 4: Schema illustrativo per autenticazione con protocollo WebID
1. Nella prima connessione l'utente (Romeo) arriva sulla home page di
Juliet, dopo aver ricevuto un suo invito per una festa. Questa pagina
contiene il link per il collegamento al contatto.
2. Romeo fa click sul collegamento, un URL https del tipo
https://juliet.example/login
3. Il server di Juliet al ricevere della richiesta HTTPS chiede al client il suo
certificato. Come conseguenza viene chiesto tramite un popup nel
browser a Romeo di scegliere il suo WebID. Romeo sceglie uno di loro e il
corrispondente certificato X.509 viene inviato al server, il quale verifica
che il browser di Romeo possiede la chiave privata associata alla chiave
pubblica presente in esso, utilizzando il protocollo HTTPS standard.
4. Il certificato contiene anche un WebID, un URL, ad esempio
http://romeo.example/#me, che è stato inserito nel campo Subject-
Alternative-Name del certificato. Il Server di Juliet farà HTTP GET su di
esso.

59
5. Se il risultato di HTTP GET denota che http://romeo.example/#me ha la
chiave pubblica specificata nel certificato, significa che il server è riuscito
a verificare che all’estremità della connessione c’è proprio
http://romeo.example/#me.
6. Ora il Server di Juliet può consultare nel suo database se
<http://romeo.example/#me> è conosciuto da uno dei suoi amici, come
specificato nei file FOAF pubblicati sui loro server.
7. Il server di Juliet ha autorizzato Romeo per vedere il file FOAF della sua
amica.
La verifica degli utenti è stabilita in modo ricorsivo. Ogni singolo individuo
aggiunge i propri amici scambiando il loro WebID e il proprio file FOAF. Queste
persone, a loro volta, fanno lo stesso con i propri conoscenti, creando così una
rete web di fiducia tra “amici di amici”.
FOAF+SSL utilizza lo standard Public Key Infrastructure (PKI); [14] [15]

60
Bibliografia
[1] B. Hammersley, Content Syndication with RSS, O'Reilly Media, 2003.
[2] B. Hammersley, Developing Feeds with RSS and Atom, O'Reilly, 2005.
[3] C. Pelliccia. [Online]. Available: www.sauronsoftware.it.
[4] L. Freeman, The Development of Social Network Analysis: A Study in the
Sociology of Science, Vancouver: Empirical Press, 2004.
[5] [Online]. Available: http://www.w3.org/2000/01/rdf-schema.
[6] 2004. [Online]. Available: http://www.w3.org/TR/webont-req/.
[7] [Online]. Available: http://purl.org/dc/elements/1.1/.
[8] [Online]. Available: http://www.w3.org/2002/07/owl.
[9] «Foaf project,» [Online]. Available: http://www.foaf-project.org/.
[10] E. Dumbill, «XML Watch: Finding friends with XML and RDF,» 2002 .
[Online]. Available: http://www.ibm.com/developerworks/xml/library/x-
foaf/index.html.
[11] L. Dodds, «An Introduction to FOAF,» 2004. [Online]. Available:
http://www.xml.com/pub/a/2004/02/04/foaf.html.
[12] L. M. Dan Brickley, «FOAF Vocabulary Specification 0.98,» 2010 . [Online].
Available: http://xmlns.com/foaf/spec/.
[13] M. Frederikson, «FoaF Explorer,» [Online]. Available: http://xml.mfd-
consult.dk/foaf/explorer/.
[14] «Foaf+ssl,» [Online]. Available:
http://www.w3.org/wiki/Foaf%2Bssl#How_does_it_work.3F.

61
[15] «WebID - Universal Login and Identity for the Web,» [Online]. Available:
http://webid.info/.

Matteo Marchionne: Foaf e feed reader

Recommended

Recommended

More Related Content

Similar to Matteo Marchionne: Foaf e feed reader

Similar to Matteo Marchionne: Foaf e feed reader (20)

More from Carlo Vaccari

More from Carlo Vaccari (20)

Matteo Marchionne: Foaf e feed reader