Matteo Marchionne: Foaf e feed reader
Upcoming SlideShare
Loading in...5
×
 

Matteo Marchionne: Foaf e feed reader

on

  • 349 views

Project by Matteo Marchionne

Project by Matteo Marchionne
Course "Innovation and New Technologies" - University of Camerino
(teacher C. Vaccari)

Statistics

Views

Total Views
349
Views on SlideShare
231
Embed Views
118

Actions

Likes
0
Downloads
0
Comments
0

1 Embed 118

http://camerino20.wordpress.com 118

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

CC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Matteo Marchionne: Foaf e feed reader Matteo Marchionne: Foaf e feed reader Document Transcript

  • 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 View slide
  • 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. View slide
  • 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/.