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

7

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());

} catch (IOException e) {

e.printStackTrace();

}

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) {

e.printStackTrace();

}

URLConnection uc = null;

try {

uc = url.openConnection();

} catch (IOException e) {

e.printStackTrace();

System.out.println("no connection");

}

BufferedReader br = null;

try {

br= new BufferedReader(new inputStreamReader(uc.getInputStream()));

} catch (IOException e) {

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

37

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>

<!-- codepiction -->

<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/.