tesi 1 2 rdt no commenti
TRANSCRIPT
UNIVERSITA’ DEGLI STUDI DI SALERNO
FACOLTA’ DI INGEGNERIA
Tesi di laurea
in
INGEGNERIA INFORMATICA
Utilizzo di banche dati bibliometriche per
migliorare la collaborazione durante eventi
scientifici
Relatore:
Ch. mo Prof. Pierluigi Ritrovato
Candidato:
Raffaele Di Taranto
Matr. 0612700665
Anno Accademico 2012/2013
Ringraziamenti
Alla mia famiglia che mi ha dato la possibilità
ed il sostegno morale per affrontare
il corso di studi,
A chi mi è stato vicino
e mi ha stimolato durante il percorso,
Al Professor Ritrovato per la disponibilità,
l’affidabilità e la pazienza dimostrata.
Indice
Introduzione……………………………………………………………………….....1
Capitolo 1 ..................................................................................................................... 3
1 Introduzione .............................................................................................................. 3
2 Database e database scientifici .................................................................................. 4
Capitolo 2 ..................................................................................................................... 6
1 Introduzione ......................................................................................................... 6
2 Piattaforme ed indicatori bibliometrici ................................................................ 7
2.1 Bibliometria ................................................................................................... 8
2.2 Indicatori bibliometrici .................................................................................. 9
2.2.1 Impact Factor ......................................................................................... 9
2.2.2 H Index ................................................................................................. 10
2.2.3 G Index ................................................................................................. 11
3 Modalità di funzionamento ed interfacce verso l’esterno delle banche dati
scientifiche ................................................................................................................. 11
3.1 Scopus di Elsevier ............................................................................................ 11
3.1.1 Esempio di funzionamento Scopus ...................................................... 12
3.1.2 API Scopus: Scopus Integration .......................................................... 17
3.2 Mendeley ..................................................................................................... 20
3.2.1 Esempio di funzionamento Mendeley .................................................. 21
3.2.2 API Mendeley e protocollo OAuth 2.0 ................................................ 23
3.3 Arnetminer ................................................................................................... 30
3.3.1 Esempio di funzionamento Arnetminer ............................................... 33
3.3.2 API Arnetminer e REST ...................................................................... 37
3.4 Google Scholar ............................................................................................ 41
3.4.1 Esempio di funzionamento Google Scholar ......................................... 42
3.5 Web of Science (Web of Knowledge ) ........................................................ 44
3.5.1 Esempio di funzionamento Web of Science ........................................ 45
4 Confronto tra sistemi .......................................................................................... 48
Capitolo 3 ................................................................................................................... 49
1 Introduzione e linee guida di sviluppo ............................................................... 49
2 Registrazione all’applicazione ........................................................................... 50
2.1 Estrapolazione dati da Scopus ..................................................................... 54
2.2 Estrazione dati social network ..................................................................... 61
3 Applicazione: lato Server ................................................................................... 62
3.1 Organizzazione dei dati e tools di sviluppo ................................................. 62
3.1.1 Rappresentazione Java ......................................................................... 65
3.1.2 Strumenti di sviluppo ........................................................................... 66
3.2 Server e Database ........................................................................................ 68
3.2.1 Classe ManageIO ................................................................................. 68
3.3 Server e il mondo esterno: WebService ...................................................... 71
3.3.1 Classe ServerInterface .......................................................................... 74
4 Applicazione: lato Client.................................................................................... 81
4.1 Organizzazione dei dati e tools di sviluppo ................................................. 81
4.1.1 Strumenti di sviluppo Android ............................................................. 83
4.2 Funzionalità e codice ................................................................................... 85
4.2.1 Connessione al Web Service ................................................................ 96
Conclusioni ................................................................................................................ 98
Appendice A ............................................................................................................. 100
A.1 Tabella dei metodi API Scopus ..................................................................... 100
A.2 Tabella dei metodi pubblici API Mendeley .................................................. 102
A.3 Tabella dei metodi privati API Mendeley ..................................................... 104
Appendice B ............................................................................................................. 108
B.1 Classe Manage Scopus .................................................................................. 108
B.2 Query creazione DataBase ............................................................................ 113
B.3 Metodi di matching sulla classe User con KSOAP ...................................... 116
Bibliografia .............................................................................................................. 120
1
Introduzione
Nel corso degli ultimi anni la tecnologia informatica ha permesso lo sviluppo di un
gran numero di applicazioni e servizi, questi ultimi incentrati per lo più sulla base
della oramai tanto celebrata rete Internet. Proprio sulla base di questi concetti, anche
la comunità scientifica ha iniziato ad evolvere il proprio modo di comunicare
riuscendo a muovere, dal formato cartaceo, quasi l’intera totalità dei dati sul Web.
Dal 1665, anno in cui la divulgazione scientifica è iniziata a fiorire su carta stampata,
ad oggi, l’aspetto che è stato più curato nelle comunicazioni di carattere scientifico è
stato di sicuro quello dell’internazionalizzazione, al fine di rendere partecipi delle
scoperte e delle innovazioni quante più persone possibili. Inoltre, è importante
ricordare che, secondo le ricerche dell’istituto “Eurostat”, la mole di opere
scientifiche negli ultimi anni è in grande aumento, e perciò rendere fruibili i dati ad
un pubblico quanto più vasto possibile, mantenendo il supporto cartaceo, è divenuto
praticamente impossibile. E’ per i motivi appena elencati che le pubblicazioni si
sono spostate verso gli “e-journal” mentre le raccolte di articoli, papers e lectures
sono state compiute, a partire dagli anni 2000, su apposite banche dati definite
appunto banche dati scientifiche. Sul Web sono nate, così, circa un centinaio di
piattaforme volte ad un pubblico di diverse proporzioni e categorie; per esempio,
molte di queste sono specializzate in ambito medico, il quale, come risaputo, ha un
ambito di ricerca praticamente sconfinato. La fruizione dei dati su questo tipo di
database avviene con modalità differenti in termini sia tipologici sia economici.
Infatti, alcuni database propongono un accesso a pagamento, altri accesso libero, altri
ancora, invece, permettono un ingresso libero con funzionalità limitate comunque
espandibili previo pagamento. Emblematico è il caso di “Scopus”, una piattaforma
che prevede un accesso a pagamento ma l’accesso stesso è reso disponibile solo sotto
la specifica rete dell’ente (o del privato) che acquista i diritti per la fruizione dei dati
del sistema. Un altro aspetto da ricordare è la modalità di indicizzazione dei dati che
avviene in modo automatico per gran parte delle piattaforme, nonostante venga data
all’utente la possibilità di poter modificare i propri dati nel caso di
2
“misunderstanding”. Detto questo, si può affermare che l’obiettivo di rendere
disponibili, ad un pubblico molto ampio, i dati scientifici raccolti nel tempo, è
riuscito alla perfezione, ed ha semplificato la vita della comunità scientifica; per
questo motivo le scientific platform hanno assunto una grande importanza. Tutto
questo ci ha guidato nel nostro lavoro di tesi, il cui obiettivo è stato quello di,
innanzitutto, scendere nel dettaglio dell’analisi dei sistemi scientifici; poi, rendere le
informazioni “portatili”, creando un’applicazione per sistemi Android che nasce nel
contesto di un congresso di ricercatori. Nel corso della prima fase, ossia in quella
d’analisi, vengono affrontate le problematiche, oltre che della semplice
visualizzazione dei dati contenuti, anche di accesso a questi ultimi; le interfacce
messe a disposizione sui differenti sistemi prevedono, infatti, modalità di
autorizzazione e di accesso differenti. Questi aspetti si sono rivelati, in alcuni casi, di
difficile utilizzo e fruizione; in altri casi, seppure si è riusciti ad accedere ai database,
i dati reperibili dall’esterno si sono rivelati davvero pochi o di scarsa rilevanza.
Dall’unione dei dati scientifici estrapolati da queste piattaforme, con i dati sociali
ottenuti, invece, da sistemi appunto sociali quali Facebook, LinkedIn e Twitter, si è
proceduto a creare un software su dispositivi mobili, basato su un’architettura client-
server, che nasce nel contesto, come prima accennato, di una conferenza (congresso)
di ricercatori e permette di avere un supporto di facile utilizzo e di indubbia utilità
per ogni partecipante. Anche nella seconda parte del lavoro svolto non sono mancate
incertezze, si è dovuto analizzare nel dettaglio la parte teorica, ma anche quella
pratica, riguardante sia la creazione dei web service, sia la programmazione di un
client mobile Android da mettere in comunicazione con i servizi creati sul server
stesso. Il frutto del nostro lavoro, nonché ultimo obiettivo, è stato il creare
un’applicazione dove abbiamo messo a disposizione di qualsiasi utente informazioni
quali la rilevanza del singolo nella comunità scientifica o ancora il numero dei
followers di Twitter, o semplicemente il contatto telefonico. Si è permesso così, a
tutti i presenti alla conferenza, di avere cognizione dei dati pubblici di ogni singolo
utente, di poter effettuare ricerche mirate su aspetti scientifici e/o sociali e di ricevere
suggerimenti personalizzati sulla base degli ambiti di studio, nazionalità, affiliazione,
popolarità.
3
Capitolo 1
Introduzione alle Banche Dati Scientifiche
1 Introduzione
Negli ultimi decenni, grazie all’esponenziale incremento di utenti che utilizzano il
PC, è diventata una vera e propria necessità riuscire ad accedere ai dati in modo
flessibile, ordinato e fluido. Proprio per rispondere a queste esigenze, soprattutto su
grossa scala, sono nati i database, questi infatti sono gli strumenti più utilizzati per
conservare i dati in modo strutturale e consentirne la loro condivisione. In realtà, la
nascita dei database in sé per sé risale già agli anni ’60-’70 con i primi database
organizzati secondo modelli di tipo gerarchico. La rivoluzione è avvenuta con
l’avvento dei database relazionali, per opera di Edgar Frank Todd che propose il
modello “Entità-Relazione” il quale proponeva un modello praticamente matematico
per quanto riguarda la modellazione, la strutturazione e l’archiviazione dei dati. In
tempi molto più recenti, dal ’95 in poi, grazie allo sviluppo delle tecnologie Web, è
divenuto di fondamentale importanza riuscire ad accedere alle informazioni in modo
sicuro e semplice ma soprattutto raggiungerle in ogni istante e da qualsiasi posizione,
da qui la necessità di mettere in comunicazione i database con il mondo esterno e
rendere disponibile anche un’interfaccia d’accesso. La naturale conseguenza di tutto
4
ciò è proprio lo sviluppo dei database online. Unendo gli archivi scientifici, già
esistenti in formato cartaceo, con questa nascente tecnologia ne vengono
naturalmente fuori le banche dati scientifiche.
2 Database e database scientifici
Le banche dati che abbiamo analizzato nel corso degli studi non differiscono molto
da quelle che ci ritroviamo di fronte ogni qualvolta decidiamo di accedere ad un
database scientifico, sia per quanto riguarda l’accesso ai dati, sia per quanto riguarda
l’organizzazione dei dati stessi. C’è però da ricordare che non tutte le banche dati
scientifiche che abbiamo potuto osservare sono modellate allo stesso modo, infatti, in
alcuni casi queste differiscono tra di loro per quanto riguarda le modalità di risposta e
di rappresentazione degli oggetti contenuti. In generale, dunque, si può affermare che
siano banche dati relazionali, ed è per questo motivo che è molto semplice
interrogarle. Ovviamente non è possibile effettuare query SQL, cioè interrogazioni
finalizzate ad operare sui dati contenuti, in modo diretto al database, ma tramite le
interfacce messe a disposizione da ogni piattaforma si riescono ad effettuare ricerche
specifiche e mirate per poi recuperare il record desiderato, sempre con grande
precisione e velocità. I database scientifici, entrando nello specifico, si caratterizzano
nel loro compito per il fatto che contengono informazioni prettamente relative a
personaggi di scienza, che siano illustri o meno. I contenuti che queste banche dati
mettono a disposizione sono di vario tipo, dalle informazioni di tipo anagrafico a
quelle di contatto, ma il cardine dell’intero sistema sono le informazioni attinenti al
lavoro che essi svolgono, dunque, al contributo che apportano alla comunità
scientifica; sono, infatti, presenti documenti, pubblicazioni stilate dai vari utenti ed
edite su periodici scientifici, il titolo di questi ultimi, e ancora le parole chiave che
indicano l’ambito specifico di studio del ricercatore/scienziato in analisi, i suoi
indicatori bibliometrici i quali, come vedremo, ne indicano il peso specifico
5
all’interno della società scientifica, il suo percorso formativo e quello lavorativo, le
collaborazioni alle quali aderisce sempre il profilo dell’utente in analisi. Oltre alle
funzionalità di base appena illustrate, i database scientifici mettono a disposizione
dell’utente anche differenti servizi, i quali si occupano di: inviare degli avvisi mail
riguardanti le nuove pubblicazioni effettuate da parte di uno specifico autore, inviare
dei feed RSS ad un sottoscrittore, salvare le ricerche, creare delle liste di utenti da
seguire, visualizzare statistiche relative a pubblicazioni, periodici e autori. Le banche
dati scientifiche consentono, dunque, la visualizzazione di una grande quantità di
informazioni riguardo autori di pubblicazioni e pubblicazioni stesse, fornendo tutti i
servizi necessari in una forma intellegibile sia ad un utente con conoscenze di
informatica elementari, sia ad un utente più esperto.
6
Capitolo 2
Analisi banche dati scientifiche
1 Introduzione
Nel capitolo precedente abbiamo presentato i principi base delle banche dati
scientifiche, ora il nostro compito di tesi si accentra in modo più evidente su
un’analisi tecnica e specifica delle stesse; procediamo, quindi, proponendo una
visione generale di ogni singola piattaforma per poi andare ad analizzare in dettaglio
ognuna di esse. Per quanto riguarda questo ultimo aspetto è importante, come
vedremo, dare uno sguardo approfondito alle modalità di comunicazione con
l’esterno, in sostanza come interrogare i vari sistemi e quali dati siano effettivamente
reperibili. Ci soffermeremo anche su aspetti di autenticazione, proponendo e testando
come effettivamente questo aspetto sia stato realizzato in questi ambienti. Verranno
trattate le limitazioni all’utilizzo delle suddette interfacce verso l’esterno, in modo
tale da poter capire quali siano i limiti reali esistenti su questo tipo di data base.
Quanto accennato sulla fase di testing, come vedremo, sarà realizzato grazie al
supporto del linguaggio di programmazione ad oggetti Java, questa scelta è stata
effettuata soprattutto tenendo presente il fatto che l’applicazione, che poi è stata
sviluppata, è ideata per essere utilizzata su sistemi operativi Android; quest’ultimo
presenta un ambiente di sviluppo anch’esso ad oggetti ed ancora una volta “Java”.
7
Dunque già in fase di analisi abbiamo ritenuto utile iniziare a pensare con un passo
d’anticipo all’applicativo per sistema Android.
2 Piattaforme ed indicatori bibliometrici
L’analisi che ci siamo preposti di svolgere riguarda un numero di banche dati non
eccessivo, ma sicuramente sufficiente a coprire gran parte del materiale scientifico
disponibile. Nella prima fase abbiamo effettuato una preventiva raccolta di
informazioni, al fine di riuscire ad effettuare una cernita accurata delle piattaforme e
si è proceduto, dunque, all’analisi dei vari aspetti: le differenze tra i sistemi,
l’importanza relativa di ogni singola piattaforma nel senso di mole di dati che mette a
disposizione, il funzionamento corretto da intendersi nello specifico anche
nell’indicizzazione dei documenti e degli utenti; infine, la disponibilità, da parte delle
stesse piattaforme, di fornire indici bibliometrici sulle pubblicazioni dei vari autori.
Da questa analisi preliminare siamo riusciti, dunque, ad effettuare una selezione delle
piattaforme arrivando a decidere di esaminare nello specifico:
Scopus
Mendeley
Arnetminer
Google Scholar
Web of Science
Tra queste piattaforme vi sono differenze in alcuni casi sottili, in altri invece più
evidenti, come vedremo a breve. Ora procediamo nel dettaglio con i singoli sistemi,
solo dopo aver analizzato dei semplici concetti propedeutici al prosieguo della
lettura.
8
2.1 Bibliometria
La nozione di bibliometria è stata usata, negli ultimi decenni, in riferimento ad un
tipo di studio che utilizza tecniche matematiche e statistiche per analizzare i modelli
di distribuzione dell'informazione, ed in particolar modo delle pubblicazioni. Con più
precisione si può affermare che essa è un insieme di metodi utilizzati per studiare e
misurare testi e informazioni. Il suo sviluppo ha avuto come presupposto
l'elaborazione automatica delle bibliografie, confluite nelle precedentemente
presentate banche dati, il suo grandioso successo è dovuto alla ricerca, da parte della
comunità scientifica mondiale, di criteri oggettivi per la misurazione, detti indicatori
bibliometrici, e la conseguente valutazione della scienza e degli scienziati. La
bibliometria ha prestato ampie applicazioni in svariate aree dello scibile e della
scienza, in modo particolarmente estensivo laddove si usano metodi, appunto,
bibliometrici per esaminare l’impatto all’interno delle comunità scientifiche di un
gruppo di ricercatori o di un lavoro scientifico in particolare. Da sempre i metodi
bibliometrici sono stati usati per tracciare le relazioni tra le varie citazioni dei
periodici accademici, per questa ragione i suddetti - più che la bibliometria in senso
lato - rientrano nei campi della LIS: “Library and Information Science” e discipline
ad essa connessa. Tra i metodi bibliometrici troviamo dunque:
L’analisi citazionale che è il metodo più noto ed usa citazioni nelle
produzioni intellettuali scientifiche per definire connessioni ad altri elaborati
o altri ricercatori. Gli accoppiamenti di co-citazioni e accoppiamenti
bibliografici sono modelli specifici dell’analisi citazionale.
L’analisi di contenuto invece, mette in condizione i ricercatori di includere
grandi quantità di informazioni in forma testuale e di identificare
sistematicamente le loro proprietà, in grande rilievo troviamo le frequenze di
apparizione delle parole chiave, o keywords, più usate per individuare i
concetti più importanti del loro contenuto informativo. Queste aggregazioni
di informazioni testuali dovrebbero poi essere categorizzate in accordo a
9
determinati framework teorici, i quali informano i sistemi di data analysis,
fornendo in linea di massima una lettura con significato logico del contenuto
analizzato.
2.2 Indicatori bibliometrici
Gli indicatori bibliometrici, accanto all’uso di strumenti di ricerca propri di ogni
disciplina, sono utilizzati in modo sempre più crescente nelle politiche dei comitati o
delle agenzie che hanno il compito di valutare la ricerca per determinare la qualità e
la produttività di enti ed istituzioni di ricerca. Tra questi indicatori ne ricordiamo in
modo particolare due: l’ “Impact Factor” e l’ “H-Index”.
2.2.1 Impact Factor
L’impact Factor (IF) permette di effettuare misurazioni sul livello della ricerca delle
pubblicazioni scientifiche, sia a livello nazionale sia internazionale. E’ un indice che
risente molto del fattore geografico, è influenzato, infatti, dall’area nella quale la
misurazione viene effettuata; l’IF è una misura del numero di citazioni dei lavori
pubblicati da una certa rivista rispetto al numero totale di lavori pubblicati dalla
stessa negli anni precedenti; risulta, quindi, molto influente sulla misurazione anche
la diffusione del giornale in questione; è scontato che, essendo più vasta la diffusione
in alcune aree di interesse, è presente una certa disparità di giudizio fra le diverse
discipline. Questo indicatore risente, inoltre, di un’ulteriore critica, questa è mossa
dal fatto che non vengono prese in considerazione, nel calcolo dell’Impact Factor
stesso, le riviste che vengono pubblicate in modo poco regolare; in questo modo l’
ISI, l’ente che ha dato i natali all’IF, non ha fatto altro che favorire i grandi editori.
10
2.2.2 H Index
L'H-index o indice di Hirsch, famoso anche con il nome di “indice H39”, si basa sul
numero delle pubblicazioni di un autore e sul numero di citazioni da esse ricevute. Fu
proposto nel 2005 da Jorge E. Hirsch, ricercatore della University of California di
San Diego, per quantificare la prolificità e l'impatto del lavoro di studiosi e
ricercatori. Funziona in modo molto diverso rispetto all'Impact Factor. L’ideatore
infatti spiega così questa sua intuizione riguardo la creazione di questo nuovo indice:
“Uno scienziato possiede un indice H se H dei suoi N lavori hanno almeno H
citazioni ciascuno e i rimanenti (N - H) lavori hanno ognuno meno di H citazioni . ”
Il calcolo dell'indice H viene effettuato in base alla distribuzione delle citazioni che
le pubblicazioni di un ricercatore ricevono, nonostante questo, è possibile applicarlo
anche a piccoli gruppi di ricerca entro un ateneo. Il sistema è abbastanza semplice,
dato un autore (o un gruppo di autori, se si vuole applicare tale indice ad un gruppo
di ricerca) si può procedere come segue:
1. Si definisce un lasso temporale, ad esempio dal 2000 al 2013.
2. Si ordinano le pubblicazioni in senso decrescente in base al numero di
citazioni, mettendo in cima quell’opera, dell’autore in questione, che ha ricevuto
un maggior numero di citazioni.
3. L'indice H è riscontrabile dal numero sequenziale della pubblicazione che
precede quella dove il numero di citazioni risulta più basso rispetto al numero
sequenziale della pubblicazione.
Ma bisogna tuttavia prestare attenzione perché l'indice H è meno superficiale di
quanto potrebbe apparire a prima vista. Per quanto riguarda le pecche dell’indice H
11
possiamo dire che questo indicatore risulta basso per studiosi che hanno avuto una
breve carriera, seppure influente.
2.2.3 G Index
Questo indice è stato introdotto al fine di superare i limiti dell’indice H; infatti,
quest’ultimo non permette di considerare gli articoli più citati, cosa che ovviamente
avviene con l’indice G. Infatti esso viene definito cosi :
“Un numero di articoli ha indice g se gli “g” articoli più citati hanno
complessivamente un numero di citazioni pari ad almeno g^2, con g maggiore o
uguale ad h ossia valore di h-index.”
3 Modalità di funzionamento ed interfacce verso
l’esterno delle banche dati scientifiche
3.1 Scopus di Elsevier
SciVerse Scopus è il più grande database di abstract e citazioni di SciVerse; SciVerse
di Elsevier, a sua volta, è un vivace ecosistema scientifico che facilita la
collaborazione, premia l’innovazione e accelera il processo di ricerca. SciVerse
integra i contenuti noti e affidabili di SciVerse Scopus, della letteratura sottoposta a
revisione paritetica, degli articoli di SciVerse ScienceDirect (in base al tipo di
abbonamento) e del Web con innovative applicazioni sviluppate dalla community
che contribuiscono ad arricchire e accrescere il valore dei contenuti.[1] La piattaforma
in questione, dunque, permette la visita di riassunti, articoli accademici e profili di
12
autori. Dal punto di vista della classificazione degli autori sulla base degli indicatori
bibliometrici, Scopus fa riferimento all’indice Hirish (indice H). Questa scelta è stata
dettata anche da motivazioni di tipo commerciale, infatti l’ente che propose
originariamente l’Impact Factor, l’ISI, ha strette relazioni con uno dei principali
concorrenti di Scopus: Web Of Knowledge. Dal punto di vista economico, o meglio,
per quanto riguarda il corrispettivo in denaro per poter accedere al sistema, Scopus si
rivela molto chiuso, infatti, l’accesso alla piattaforma è possibile solo con la
sottoscrizione di un abbonamento. Traendo le somme da questa analisi è semplice
dedurre che Scopus nasce soprattutto come sistema rivolto ad ambienti universitari o
comunque in ambiti di ricerca e studio.
3.1.1 Esempio di funzionamento Scopus
Il nostro compito ora è quello presentare in modo rapido e semplice un esempio di
ricerca sulla piattaforma in esame. Proseguiremo, quindi, proponendo immagini
corredate da didascalie quanto più dettagliate possibile. Ricordiamo inoltre che è
possibile accedere al sistema dal nostro ateneo, dato che esso ha sottoscritto un
abbonamento.
Nel primo esempio che presentiamo, effettuiamo una ricerca in base ad una parola
chiave, come si può notare possiamo filtrare la ricerca in base a criteri di: range di
pubblicazione, area di appartenenza, tipologia di documento.
13
Esempio di ricerca per parola chiave su Scopus
Dopo aver cliccato su “Search” possiamo ottenere i risultati come di seguito
mostrato.
14
Esempio di ricerca per parola chiave su Scopus, risultato
Come si può notare, è possibile apporre anche dei filtri ai risultati al momento della
loro apparizione; si possono ordinare gli stessi anche in base a numero di citazioni,
rilevanza o in base all’ordine alfabetico dei titoli o degli autori. D’altro canto,
possiamo notare che in alto a sinistra è possibile effettuare anche delle ricerche
sull’autore, sull’affiliazione o effettuare una ricerca avanzata, specificando più filtri
in modo esplicito, come possiamo vedere nel secondo esempio, di seguito riportato.
15
Esempio di ricerca avanzata su Scopus
In questo caso, invece, abbiamo specificato come keyword la stringa “grid”,
selezionato come affiliazione “Salerno”, infine, abbiamo filtrato ulteriormente i
risultati, scegliendo di evitare i documenti nei quali come autore comparisse
“Ritrovato”. E’ possibile, in questo tipo di ricerca, effettuare delle query molto
specializzate, sono inoltre presenti predicati logici tipici dell’algebra booleana (AND,
NOT, OR) che semplificano la scrematura dei risultati. I risultati della ricerca qui
effettuata sono di seguito visualizzabili.
16
Esempio di ricerca avanzata su Scopus, risultato
Come ci aspettavamo la ricerca ha dato i risultati attesi, applicando alla perfezione i
criteri di selezione sul set delle risposte ottenute dal database.
17
3.1.2 API Scopus: Scopus Integration
Dal punto di vista dell’interfacciamento con il mondo della programmazione per la
fruizione dei contenuti, la piattaforma Scopus mette a disposizione delle apposite
API, raccolte sotto il nome di Scopus Integration, queste sono volte allo sviluppo su
applicazioni esterne al network in analisi. Per quanto riguarda il contesto della
programmazione, possiamo dire che l’integrazione di Scopus (Scopus Integration) su
siti Web esterni al framework della piattaforma stessa, si basa sull’utilizzo di
chiamate a funzioni in linguaggio di scripting per fogli HTML: JavaScript. L’accesso
alle API è garantito in modo rapido, inoltre l’accesso ai dati è possibile anche se la
sottoscrizione a Scopus non è totale da parte dell’utente che effettua le richieste; nel
caso in cui l’utente invece abbia la sottoscrizione totale al sistema, è possibile,
tramite le API in considerazione, ottenere una quantità maggiore di informazioni. Per
quanto riguarda la sezione Scopus Integration dobbiamo necessariamente ricordare
che le funzionalità di ricerca messe a disposizione dello sviluppatore riguardano solo
il contesto dei documenti, ovvero, i metodi permettono di effettuare ricerche accurate
su papers, lectures e su tutti i documenti della piattaforma. Infatti, le API di Scopus
Integration non ci consentono di effettuare ricerche sugli autori, ne sulle keywords,
ne sui journal sui quali vengono pubblicati gli articoli scientifici. I metodi che
andremo a presentare, in Appendice A, sono validi per entrambi i tipi di ricerca:
“Cited By Count Search” e “Scopus Search”. La prima tipologia elencata permette di
estrapolare informazioni di citazioni contenute in un singolo documento facente parte
di una raccolta più ampia; quest’ultima a sua volta è rintracciabile per intero solo con
l’invocazione alle seconde API sopra citate, ossia le “Scopus Search”. In Appendice
A, al paragrafo A.1, è disponibile l’elenco dettagliato dei metodi messi a
disposizione dall’interfaccia di programmazione di Scopus. Si ricorda che per
effettuare l’integrazione si necessita di ottenere l’API Key per l’utilizzo delle Scopus
Integration API, ottenibile registrando il proprio sito nell’area “Development” di
Scopus. Una volta effettuato questo primo passo bisognerà procedere inserendo nel
proprio foglio di programmazione HTML, più precisamente nell’header, la chiave
18
API. In questo modo ogni qualvolta vogliamo effettuare delle chiamate alle funzioni
messe a disposizione da Scopus, possiamo autenticarci in modo automatico.
A corredo dei contenuti presentati, ora si riporta di seguito un esempio di utilizzo
delle API per effettuare una ricerca sui documenti in base a delle keywords. Il tutto è
stato effettuato creando un documento HTML ed invocando le librerie di Scopus
tramite JavaScript.
Esempio di utilizzo API Scopus Integration
19
Il risultato che otteniamo, visibile di seguito, ci permette di ottenere i seguenti dati: il
numero di volte che è stata effettuata sul network la ricerca specifica, il numero di
risultati che abbiamo scelto di visualizzare ed i risultati.
Risultato della ricerca usando le API di Scopus Integration
20
3.2 Mendeley
Mendeley è un social network molto innovativo, permette di organizzare documenti,
citare e collaborare con altri utenti. Questa piattaforma mette a disposizione
dell’utente anche un utile tool, per la consultazione della piattaforma da desktop,
denominato “Mendeley Desktop”. Esso si presenta come in figura qui sotto.
Mendeley Desktop
Esplorando questo strumento possiamo anche capire meglio come funziona
Mendeley. Come è facile intuire, il tool mette a disposizione funzionalità
organizzative dei documenti, è possibile importare file dal sito ufficiale, che rimane,
comunque, consultabile anche senza l’utilizzo dello strumento succitato. Inoltre, è
possibile far riferimento e salvare gli utenti preferiti, rimanendo aggiornati su ogni
loro nuova pubblicazione. Utilissimo si rivela anche il “Web Import”, plugin di
“Mendeley Desktop” per l’importazione di documenti selezionati tra oltre 30
database accademici. Sono messe a disposizione dell’utente anche funzionalità
manageriali sotto l’aspetto dei gruppi di lavoro, è possibile, infatti, effettuare
21
collaborazioni e scambiare dati in tutta sicurezza all’interno di gruppi privati, quindi,
il sistema in analisi in sostanza permette anche di sfruttare funzionalità di cloud
system. Questo significa che è possibile effettuare lo storage, cioè l’archiviazione;
infatti, sono a disposizione di ogni utente 2GigaByte di memoria per la
memorizzazione dei propri documenti. Ogni modifica viene, inoltre, referenziata in
modo semplice, in modo tale che in un lavoro di gruppo si capisca dove e come siano
stati realizzati delle modifiche ai documenti. Per ciò che riguarda il supporto ad
indici bibliometrici Mendeley si rivela scadente, o meglio questi sono del tutto
assenti; non è possibile, dunque, capire l’importanza dell’autore semplicemente
visualizzando il profilo dello stesso. Sotto l’aspetto economico, inoltre, Mendeley si
rivela del tutto gratuito. Dopo questa prima visione d’insieme, che sembrerebbe
attribuire alla piattaforma in questione grandi elementi di vantaggio nonostante la
mancanza di indicatori bibliometrici, andiamo a scoprire più nel dettaglio come
funziona e se realmente mantiene le aspettative.
3.2.1 Esempio di funzionamento Mendeley
Così come abbiamo proceduto nel caso del network Scopus, anche con Mendeley
presentiamo degli esempi di fruizione dei servizi offerti. Andiamo, infatti, ad
effettuare la medesima richiesta effettuata per Scopus, ossia una ricerca sui papers
relativi alla keyword “E-Learning”.
22
Esempio di ricerca su papers in base alla keyword “E-Learning”
Come possiamo notare dallo screen-shot, è possibile selezionare l’elemento da
ricercare, la gamma di ricerca è ristretta a sole tre tipologie: ricerca su papers, gruppi
e infine autori. Il risultato della nostra ricerca è il seguente.
23
Esempio di ricerca su papers in base alla keyword “E-Learning”, risultato
E’ facile notare che la piattaforma Mendeley è uno strumento un po’ acerbo rispetto
a quelle che potrebbero essere le richieste di utenti appartenenti a categorie più
elevate rispetto al semplice studente, il quale solitamente compie ricerche più mirate
e ristrette. Oltre a questo aspetto, bisogna tener presente il fatto che non è possibile
raffinare la ricerca, non vi sono infatti strumenti adatti per soddisfare questi requisiti.
In ultima analisi si può facilmente affermare che la piattaforma Mendeley non
soddisfa a pieno sotto molti aspetti, ma sicuramente presenta ampi margini di
miglioramento.
3.2.2 API Mendeley e protocollo OAuth 2.0
Per quanto riguarda l’aspetto di developement, Mendeley mette a disposizione
un’interfaccia di tipo RESTful consultabile dall’area “Developers Portal”. Come nel
caso di Scopus, anche Mendeley presenta queste interfacce come funzioni di
linguaggio Javascript, dunque invocabili da pagine HTML. Volendo utilizzare,
invece, un linguaggio di programmazione ad oggetti per applicazioni desktop,
24
Mendeley propone anche una SDK da integrare in Java. Questo kit di sviluppo è
comunque completo, infatti mette a disposizione tutti i metodi invocabili anche da
Javascript, oltre ad un completo supporto all’autenticazione. Proprio questa, su
Mendeley, avviene tramite il protocollo OAuth 2.0. Prima di procedere alla
presentazione delle API in questione, preferiamo procedere con dei cenni teorici[2] al
protocollo di autenticazione sopra citato, questo è dettato anche dal fatto che ad oggi
OAuth 2.0 è senza dubbio il più utilizzato. Open Authorization o più comunemente
chiamato, appunto, OAuth, è un protocollo di comunicazione open mediante il quale
un’applicazione (o un servizio web) può gestire in modo sicuro l’accesso autorizzato
ai dati sensibili. Il protocollo è compatibile con qualsiasi tipologia di applicazione:
desktop, web e mobile. Il protocollo OAuth è stato ideato da Blaine Cook nel 2006,
mentre lavorava all’implementazione Twitter di OpenID, proponendosi come
alternativa aperta ai molti protocolli proprietari già esistenti, come Google AuthSub,
AOL OpenAuth, Yahoo BBAuth, Flickr API e tanti altri. Dalla versione 1.0
(pubblicata nel 2007) OAuth, ha subìto diverse revisioni, recependo via via le RFC
(Request For Comments) proposte dai vari esperti. In generale le RFC sono un
insieme di documenti di riferimento per la Comunità Internet che riportano
informazioni o specifiche riguardanti nuove ricerche, innovazioni e metodologie
dell’ambito informatico. Gli esperti possono pubblicare dei memorandum per esporre
nuove idee da includere negli standard: seguendo questo iter è stata pubblicata la
prima bozza del protocollo OAuth 2.0. Gli attori coinvolti sono 3:
1. L’applicazione che richiede le informazioni, o Consumer (la nostra applicazione)
2. Il servizio web che fornisce le informazioni, o Service Provider (in questo caso
Mendeley)
3. L’utente dell’applicazione iscritto sulla piattaforma del ServiceProvider
Per poter usufruire del servizio predisposto dal Service Provider, è necessario che
il Consumer registri la sua applicazione nell’area “Developer” ossia “Sviluppo”.
Con quest’operazione, il Service Provider fornisce al consumer le chiavi segrete
25
(Consumer Key e Consumer Secret) le quali verranno utilizzate per lo scambio
dei dati. I principali step della comunicazione Consumer – Service Provider sono i
seguenti:
1. Il Consumer redirige l’utente ad un URL predisposto dal Service Provider per
la fase di autenticazione. Nella richiesta HTTP sono presenti le due chiavi
ricevute in fase di registrazione (Consumer Key e Consumer Secret) e
un’URL alla quale l’utente deve essere reindirizzato al termine
dell’operazione.
2. L’utente accede alla pagina di autenticazione predisposta dal Service Provider
dove inserisce le proprie credenziali di accesso, di solito username e
password. La pagina di autenticazione lavora con il protocollo HTTPS, il
quale garantisce che i dati scambiati tra browser e web server siano codificati
e non vengano trasferiti in chiaro come invece avviene nel protocollo HTTP.
In questo caso la comunicazione risulta molto più sicura in caso di
intercettazione.
3. Il Service Provider verifica l’identità dell’utente. Se la verifica ha esito
positivo, gli presenta il tipo di richiesta avanzata dal Consumer che l’utente
deve approvare. Tale richiesta riguarda, di solito, la durata dell’accesso e la
tipologia di informazioni che verranno rese disponibili al Consumer.
4. Il Service Provider redirige l’utente all’URL inviata precedentemente dal
Consumer (al punto 1). Nella richiesta HTTP è presente una stringa (detta
token) la quale deve essere utilizzata successivamente dal Consumer per
richiedere eventuali informazioni al Service Provider.
5. L’utente accede nuovamente alla pagina del Consumer. Per l’utente meno
esperto, il passaggio da un server ad un altro, è praticamente trasparente.
6. Il Consumer invia una richiesta HTTP al Service Provider nella quale
richiede, ad esempio, i dati dell’utente corrente. Nella richiesta deve anche
fornire il token precedentemente ricevuto. Le informazioni disponibili,
dipendono dal Service Provider.
26
A differenza del protocollo Client/Server, il protocollo OAuth, come abbiamo
potuto notare, non obbliga l’utente a fornire le credenziali di accesso al provider
(il sistema esterno). L’utente viene rediretto sul server del Service Provider per
l’autenticazione al sistema.
Per quanto riguarda le API di Mendeley, in esse troviamo dei metodi suddivisi in
pubblici e privati. Analizzando queste funzionalità possiamo notare che: i metodi
pubblici sono definiti tali perché permettono di accedere a risorse di dominio
pubblico, quelli definiti come privati invece permettono l’accesso a dati privati
visibili solo dall’utente che ha compiuto l’accesso al sistema. Possiamo dare uno
sguardo a quelli che sono i metodi pubblici, riferendoci all’Appendice A, al punto
A.2 di questa tesi, in una tabella che esplica l’indirizzo del metodo e la risposta
attesa. Ricordiamo inoltre che i dati ottenuti saranno rappresentati in formato
JSON, un formato per lo scambio di dati. Quest’ultimo si basa su due strutture
principali : un insieme formato da chiavi/valori e un elenco ordinato di valori.[3]
Per quanto riguarda invece i metodi privati, dobbiamo ricordare che per questi si
farà riferimento sempre all’utente nel senso di user che ha compiuto l’accesso al
sistema. Per utilizzare queste API sarà necessario aver compiuto l’accesso con
l’utilizzo del protocollo di autenticazione prima descritto: OAuth 2.0. Anche i
metodi privati, come quelli pubblici, sono fruibili nell’Appendice A nel punto
A.3. Di seguito presentiamo, invece, degli esempi per la fruizione dei contenuti
della base dati Mendeley tramite l’utilizzo della SDK per linguaggio di
programmazione Java. Il primo passo da effettuare è, come già detto teoricamente
in precedenza, registrare sul network la nostra applicazione e ricevere la
Consumer Key (ossia chiave API) e la Consumer Secret, fatto questo possiamo
autenticarci come di seguito mostrato. Ci siamo, inoltre, avvalsi di un parser
Html: HtmlUnit . Questo, al fine di effettuare il login sul network, necessario per
l’autenticazione dell’applicazione. Si riportano le due classi tramite le quali è
stato possibile effettuare quanto appena detto. Ricordiamo che il parser è uno
strumento che permette di estrapolare dati da pagine HTML analizzandone in
modo automatizzato il sorgente.
27
Classe che realizza l’accesso a Mendeley
28
Classe per ottenere pin, necessario per recuperare il Token di autorizzazione
Una volta realizzato l’accesso è possibile fruire di tutte le funzionalità messe a
disposizione dalle API Mendeley, nonché dall’ SDK in uso. Per esempio, come
29
vediamo di seguito, proviamo a ottenere una lista che indica il numero di
pubblicazioni presenti in ogni categoria del sistema preso in esame.
Classe per il recupero del numero di pubblicazioni per categorie
Risultato della richiesta effettuata tramite PrivateStatsApiSample
30
3.3 Arnetminer
Arnetminer è uno strumento di ricerca e servizio di mining per ricercatori. Sul
sistema sono messe a disposizione servizi automatizzati per: creare un profilo basato
sulla semantica per ogni ricercatore tramite l’estrazione di informazioni da più
piattaforme Web, integrare dati accademici (ad esempio i dati bibliografici) da varie
fonti, effettuare ricerche su reti eterogenee, analizzare e scoprire modelli d’interesse
creati sulla base dei profili dei ricercatori estrapolati dai social network. Le principali
funzioni a disposizione in Arnetminer sono di seguito elencate. [4]
Ricerca profilo: si inserisce un nome di una persona da ricercare e il sistema
permetterà di visualizzare il profilo creato in base alle informazioni ricercate
tramite tecniche di estrapolazione di dati dal Web, nello specifico provenienti
da varie piattaforme. Le informazioni qui integrate e disponibili sono le
seguenti: informazioni di contatto, foto, statistiche di citazioni, valutazioni
accademiche, interessi di ricerca, percorso formativo, grafico personale
indicativo di statistiche di supporto, pubblicazioni.
Ricerca esperta: inserendo una query il sistema permetterà di recuperare i
profili delle persone più rilevanti rispetto al topic ricercato. Inoltre, la
piattaforma suggerisce la conferenza più importante e gli articoli più influenti
sempre inerenti al topic di ricerca. Esistono, inoltre, due algoritmi di
classificazione dell’importanza: VSM e ACT. Gli utenti possono anche
provvedere a recapitare un feedback per i risultati di ricerca in modo da
segnalare errori di ricerca e permettere lo sviluppo del sistema.
Analisi di conferenze: inserendo il nome di una conferenza, il sistema
permetterà di visualizzare gli autori più rilevanti che vi hanno preso parte, in
aggiunta sono presenti, tra i risultati, anche i documenti (papers) di maggiore
importanza presentati alla conferenza ricercata.
31
Ricerca di un corso: inserendo un corso di studi, Arnetminer provvederà a
segnalare gli insegnanti più rilevanti.
Ricerca associati: inserendo il nome di due ricercatori sarà possibile
visualizzare la relazione che esiste tra i due.
Ricerca sotto-grafici: inserendo in questa ricerca una keyword, il sistema
innanzitutto ci farà visualizzare i topic più rilevanti, relativi alla stessa
keyword, quindi, mostrerà il sotto-grafico più importante connesso alla
ricerca.
Browser di topic: è basato sul modello Author-Conference-Topic (ACT),
Arnetminer, così, permette di scegliere tra i 200 topic più ricercati. Per
ognuno di essi, automaticamente viene assegnata un’etichetta nell’intento di
rappresentarne il significato. Inoltre, il browser presenta i ricercatori più
attivi, i documenti e le pubblicazioni più importanti e il trend di evoluzione
del topic.
Classifica accademica: sono definite 8 misure nell’intento di valutare il
lavoro dei ricercatori. Gli indicatori presenti sono: H-index, numero di
citazioni, uptrend, attività, longevità, diversità, socialità, nuove leve. Per ogni
indicatore si effettuano delle classifiche su domini differenti.
Modifica utente: una volta registratosi un utente generico può: modificare le
informazioni estratte su di esso in modo automatico, fornire feedback sui
risultati di ricerca ottenuti, seguire un ricercatore su Arnetminer, creare una
pagina Arnetminer (utilizzabile per organizzare conferenze, pubblicare
materiale).
32
Le informazioni sono organizzate in una base dati ben specificata e strutturata, essa
esplica campo per campo i dati presenti nella singola tupla. La tabella di seguito ci fa
capire meglio.
Section Annotation Subtasks
Basic Information
Person Photo Position
Affiliation Research Interest
Homepage
Contact Information
Email Address Postal Address
Phone
Fax
Educational History
University, Major, Date, and Advisor for Ph.D. Degree University, Major, Date, and Advisor for M.S. Degree
University, Major, Date, and Advisor for B.S. Degree Publication Authored Papers and Technique Reports
Relationship
Co-authorship Work-in-the-same-place
PC-Member-in-the-same-conference
Tabella che mostra l’organizzazione dei dati su Arnetminer
Quindi nella sezione “Basic Information” troviamo, come suggerisce anche la
traduzione, le informazioni di base del profilo utente. Nella “Contact Information”,
invece, sono presenti le informazioni di contatto come la mail o il fax al quale è
raggiungibile il ricercatore. Per quanto riguarda “Educational History”, qui troviamo
un rapido elenco della formazione accademica dell’utente ricercato, nella sezione
“Pubblication”, ovviamente, sono raccolte tutte le pubblicazioni ed i documenti
pubblicati dal suddetto. Infine nella “Relationship” troviamo tutti i dati di relazioni
sociali e di studio del profilo ricercato. In conclusione di questa prima analisi sui
contenuti e l’organizzazione dei dati possiamo facilmente dedurre che Arnetminer ha
un carattere molto incentrato sul ranking, ossia sulla classificazione, dei profili
presenti sul sistema in base ad indici bibliometrici o di altra natura; è molto curato
quindi questo ultimo aspetto analizzato, il che rende la piattaforma in analisi molto
rilevante in ambito accademico e scientifico. Inoltre, la piattaforma Arnetminer mette
33
a disposizione una quantità di pubblicazioni superiori sia a quelle presenti su Scopus,
sia a quelle disponibili su Mendeley. Per quanto riguarda l’aspetto economico,
Arnetminer è del tutto gratuito, il che è un altro punto a favore di questa piattaforma.
Ora, così come abbiamo fatto per le altre piattaforme presentate, procediamo con
esempi di fruizione dei contenuti sul database scientifico, mostrando prove di
richieste al sistema in questione.
3.3.1 Esempio di funzionamento Arnetminer
Le tipologie d’esempio che andiamo a presentare, rispecchiano quelli che già
abbiamo realizzato per quanto riguarda le piattaforme precedentemente analizzate.
Innanzitutto, effettuiamo una ricerca in base al profilo utente, ossia andiamo a
ricercare un autore indicizzato dal sistema Arnetminer. In questo caso abbiamo
effettuato una query del tipo “Expert”, ossia la ricerca letteralmente di un “esperto”
cioè un autore. E’ disponibile, come possiamo osservare in figura, anche una forma
di suggerimento sulla base delle lettere inserite, infatti, vengono consigliati dei profili
che contengono quella serie di caratteri.
34
Esempio di ricerca profilo su Arnetminer
Cliccando su “Search” otteniamo un set di risultati, selezionandone uno, possiamo
visualizzare il profilo dell’utente corredato di tutte le statistiche di tipo sia
bibliometrico sia bibliografico, come vediamo di seguito.
35
Profilo utente su Arnetminer
Sono disponibili, dunque, i valori di H-Index e G-Index; quest’ultimo è un nuovo
indice bibliometrico disponibile al giorno d'oggi solo su poche piattaforme, come già
detto, è volto a superare i limiti dell’indice H. Arnetminer si mostra dunque
all’avanguardia sotto l’aspetto bibliometrico.
36
Un'altra tipologia di ricerca, che distingue Arnetminer dal resto delle piattaforme, è
la ricerca per topic ; ne presentiamo di seguito un rapido utilizzo, ricordando che
basterà cliccare su “Topic” nella home page della piattaforma, senza inserire alcun
carattere nella barra di ricerca. Otteniamo dunque la seguente schermata.
Esempio di ricerca Topic su Arnetminer
Ora interpretriamo i risultati: i topic sono ordinati in base al numero di ricerche
effettuate su di essi (Mechanism design è il più ricercato); i profili presenti, indicati
dalle immagini dei vari profili, indicano i personaggi più influenti su quel
determinato topic; i suggerimenti sulla destra indicano, invece, le conferenze relative.
37
3.3.2 API Arnetminer e REST
Andiamo ora a dare un’occhiata a come Arnetminer si interfaccia all’esterno,
proponendo i propri dati, comprendendo come fruirli e in che modo essi sono
rappresentati. La piattaforma ora in analisi, a differenza delle precedenti, non pone
limiti di autorizzazione; infatti, l’interfaccia di programmazione è liberamente
raggiungibile, l’unica costrizione è quella di essere registrati al database. Arnetminer
anche sotto questo aspetto si mostra dunque molto aperto e flessibile. Dobbiamo però
capire quali sono i dati che possiamo richiedere al sistema, per fare ciò abbiamo
consultato la documentazione delle API, fatto ciò, si è facilmente inteso che i metodi
sono di tipo RESTful. Una API della tipologia appena citata (REpresentational State
Transfer) presenta un’architettura con risorse definite ed indirizzate, permette infatti
di trasferire informazioni direttamente sul livello applicativo di internet, senza
ricorrere a strati ulteriori come invece avviene con il modello SOAP, quest’ultimo
sarà presentato in dettaglio più avanti. Nelle interfacce REST l’accesso ad ogni
risorsa avviene tramite un identificativo univoco definito URI, lo scambio di
rappresentazioni di informazioni avviene su HTTP, la richiesta viene mediata sulla
base di connettori: tunnel, server, cache. Inoltre non è previsto in alcun modo il
mantenimento dello stato, detto questo, dunque, un’applicazione può connettersi ad
una risorsa conoscendo semplicemente l’URI e l’azione richiesta, quest’ultima server
per poter interpretrare il formato della risposta (HTML, XML, JSON). Dopo questo
piccolo excursus riguardo le interfacce REST, passiamo a mostrare le API di
Arnetminer, ricordando che, per effettuare delle richieste, si necessita di inserire il
nome utente, all’interno dell’URI, con il quale si vuole procedere nella richiesta. La
prima che presentiamo rispecchia la ricerca di un profilo presente sulla pagina della
piattaforma: “Ricerca Esperta”.
38
L’URI di riferimento è la seguente:
arnetminer.org/services/searchexpert?q=[q]&u=[u]&start=[start]&num=[num]
&outputjs=[outputjs]&varname=[varname]
Tabella dei parametri per la ricerca esperta
La seconda query di ricerca che possiamo effettuare su Arnetminer è la ricerca per
pubblicazione, raggiungibile all’URI seguente:
arnetminer.org/services/search-
publication?q=[q]&u=[u]&start=[start]&num=[num]
Tabella dei parametri per la ricerca pubblicazioni
Nome
Descrizione Tipo
ricerca esperta Ritorna una lista di esperti
relative ad una keyword
Stringa (formato JSON)
u
Username per accesso Stringa
q
Keyword Stringa
start
Indice di partenza dei risultati Intero
num
Numero dei risultati Intero
outputjs Variabile JavaScript vera se la
ricerca da risultati
Booleano
varname
Nome variabile per i risultati Stringa
Nome
Descrizione Tipo
ricerca pubblicazioni Ritorna una lista di
pubblicazioni relative ad una
keyword
Stringa (formato JSON)
u
Username per accesso Stringa
q
Keyword Stringa
start
Indice di partenza dei risultati Intero
num
Numero dei risultati Intero
39
Successivamente troviamo la ricerca di conferenze e congressi. L’URI in questo
caso:
arnetminer.org/services/search-
conference?q=[q]&u=[u]&start=[start]&num=[num]
Tabella dei parametri per la ricerca conferenze
Di grande importanza è anche la possibilità di accedere ai dati del profilo di un
utente, l’URI per fare ciò è la seguente:
arnetminer.org/services/person/[name]?u=[u]&o=[o] oppure
arnetminer.org/services/person/[id]?u=[u]&o=[o]
Tabella dei parametri per la ricerca profilo
Nome
Descrizione Tipo
ricerca conferenze Ritorna una lista di conferenze
relative ad una keyword
Stringa (formato JSON)
u
Username per accesso Stringa
q
Keyword Stringa
start
Indice di partenza dei risultati Intero
num
Numero dei risultati Intero
Nome
Descrizione Tipo
ricerca profilo Ritorna il profilo di un utente
oppure un id
Stringa (formato JSON)
u
Username per accesso Stringa
o
Opzioni di dettaglio profilo Stringa
name
Nome del profilo ricercato Stringa
id
Id identificativo profilo
ricercato
Intero
40
Dunque se Arnetminer finora si era presentato come il più completo tra i sistemi
analizzati, mostra delle grosse lacune per quanto riguarda i dati fruibili in fase di
programmazione; ha un numero di metodi nelle sue API davvero ristretto, tale da non
permettere la fruizione completa dei dati, nello specifico di quelli bibliometrici. A
titolo d’esempio, nell’ immagine successiva vedremo come interrogare il database di
Arnetminer, effettuando una ricerca “Expert” alla ricerca di profili relativi ad una
keyword specificata nell’URI.
La query che creiamo è la seguente:
http://arnetminer.org/services/search-expert?q=e-
learning&u=oyster&start=3&num=2&outputjs=true&varname=esresult
dove i parametri specificati sono:
q (keyword) = e-learning
u (utente che effettua ricerca) = oyster
start (indice di partenza dei risultati) = 3
num (numero risultati) = 2
varname (variabile Javascript che contiene risultati) = esresult
outputjs (booleano che indica se è valida la ricerca) = true
Otteniamo così la risposta, in formato JSON, sul nostro browser, come di seguito
mostrato.
41
Risultato query Expert
Quello mostrato è il primo risultato, ossia il profilo ed i dati relativi a “Giovanni
Tummarello”, un autore collegato alla keyword ricercata (E-learning).
3.4 Google Scholar
Il sistema di supporto scientifico e accademico, creato dal colosso di Mountain View,
si presenta più come un motore di ricerca che come un vero e proprio database. Esso
consente di individuare testi della cosiddetta letteratura accademica come articoli
sottoposti a revisione paritaria, tesi di laurea e dottorato, libri, sommari, recensioni e
rapporti tecnici di tutti i settori della ricerca scientifica. Google Scholar consente di
reperire articoli da una vasta gamma di case editrici che si rivolgono al mondo dello
studio e della ricerca da associazioni scientifiche e professionali, oltre che dalla
galassia di articoli scientifici e culturali distribuiti sul Web. Gli articoli indicizzati in
Scholar comprendono anche quelli pubblicati da Elsevier, e nella sua funzione è
simile al motore di ricerca interno di Elsevier Scopus. Come sistema è molto simile a
42
quelli a pagamento: Scopus e Thomson ISI Web of Science. Il motto di questa
piattaforma è “Sali sulle spalle dei giganti” ed è un'espressione ricavata dalla famosa
frase di Isaac Newton "Se ho visto più lontano è perché sono salito sulle spalle dei
giganti che mi hanno preceduto". Il motto si riferisce alla possibilità di elevarsi nelle
conoscenze e nelle competenze aperta dalla migliore accessibilità della letteratura
accademica, termine questo da intendersi nel senso lato consentito dal World Wide
Web. In termini di caratteristiche, Google Scholar permette agli utenti di ricercare
per copie fisiche e/o digitali di articoli anche se questi appartengono a biblioteche
online. Se l'articolo è disponibile liberamente sul web, questi collegamenti verranno
mostrati. Dal punto di vista economico bisogna ricordare che esso è del tutto gratuito.
Il numero di documenti presenti, gli indicatori bibliometrici ed il fattore di gratuità
sono tutti elementi a favore della piattaforma in analisi, d’altro canto non è possibile
interrogare il sistema stesso dall’esterno dato che non presenta alcuna interfaccia di
programmazione pubblica.
3.4.1 Esempio di funzionamento Google Scholar
Google Scholar non permette in alcun modo di effettuare ricerche mirate, non è
possibile, infatti, selezionare il tipo di ricerca, come invece era possibile per i sistemi
precedenti; questo potrebbe sembrare un fattore negativo, ma in realtà ogni
interrogazione che andiamo a sottoporre al sistema viene automaticamente
ottimizzata ed indirizzata ai risultati corretti. Nell’esempio che segue effettuiamo la
ricerca in base alla keyword “e-learning”, per equità di trattamento, come già fatto
per i precedenti sistemi.
43
Esempio di ricerca su Google Scholar per keyword “E-Learning”
La ricerca appena effettuata ci permette di accedere ai seguenti risultati che
successivamente commenteremo.
44
Risultati per la ricerca su keyword “e-learning” su Google Scholar
Il set di risultati ottenuti ci permette di visualizzare i documenti più rilevanti rispetto
alla parola inserita nella barra di ricerca; questi risultati possono essere ulteriormente
filtrati in base all’anno di pubblicazione, oppure ordinati per data o ancora
escludendo brevetti e/o citazioni. Nel caso in cui la ricerca fosse stata effettuata su un
autore e non su una keyword, sarebbe stato possibile accedere al profilo dello stesso.
3.5 Web of Science (Web of Knowledge )
L’ultima piattaforma che andiamo ad analizzare è Web of Science, spesso abbreviata
in WoS, proprietà del gruppo Thomson Reuters. Questo sistema si presenta come un
45
punto nevralgico tra le banche dati scientifiche online, ciò è dovuto, ovviamente, alla
sua relativa vecchiaia. WoS infatti nasce all’inizio degli anni 2000 grazie a forti
rapporti di collaborazione tra l’azienda Reuters e l’ISI, quest’ultimo, come sappiamo,
è l’ente per l’informazione scientifica. WoS infatti è una costola di Web of
Knowledge, un database online nato per raccogliere proprio i dati dell’ente sopra
citato. Fatte queste premesse storiche, non bisogna assolutamente sottovalutare la
piattaforma che abbiamo di fronte. Essa presenta infatti un numero di documenti
estesissimo, raccoglie più di 12˙000 journals, 148˙000 proceedings e svariate
migliaia di pubblicazioni.[5] Il funzionamento, in linea di massima, dell’intero
sistema, ricalca quello già analizzato sulla piattaforma Scopus, seppure emergono
delle differenze. Per quanto riguarda i dati a disposizione, abbiamo già parlato delle
quantità, ora possiamo anche analizzarne le qualità. I dati raggiungibili, infatti,
comprendono anche informazioni relative a database di dimensioni inferiori ma nati
per il supporto a specifici settori scientifici, vedi “Chemical Reactions”. Inoltre, per
quanto riguarda l’accesso, questo non è libero come invece avviene per Mendeley o
Arnetminer, ma, come per Scopus, è richiesto un corrispettivo per poter usufruire
delle risorse. Anche in questo caso il nostro ateneo ha sottoscritto un abbonamento
per permettere a studenti e ricercatori di godere dell’immenso database di WoS. Oltre
a questo ultimo fattore negativo, sulla piattaforma in analisi non esistono reali pagine
del profilo, infatti, sono indicizzati solo i documenti, citando gli autori. Cercando di
raggiungere il profilo di un utente ci si ritrova solo dinnanzi all’elenco di tutte le sue
pubblicazioni, conseguenza immediata di ciò è la mancanza di indicatori
bibliometrici relativi agli utenti. A questi aspetti negativi bisogna inoltre aggiungere
che Web of Science non mette a disposizione dei programmatori alcuna interfaccia di
programmazione.
3.5.1 Esempio di funzionamento Web of Science
Ancora una volta, dopo l’analisi generale della piattaforma, scendiamo nel
particolare, mostrando degli esempi semplici di ricerca e illustrando le possibilità che
46
WoS ci offre. Il sistema in questione permette di effettuare ricerche specifiche su:
topic di rilievo, titoli, autori, nome delle pubblicazioni, conferenze, editori, journals,
lingua, stato o nazionalità. Oltre a queste funzionalità, ovviamente, vi sono tutte
quelle di supporto per il filtro dei risultati delle ricerche, ad esempio interessandosi
solo di dati relativi ad un certo arco temporale, o ancora estendendo la ricerca ad altri
database della famiglia Thomson Reuters. La pagina di ricerca che si apre ai nostri
occhi al primo accesso al sistema è quella mostrata nella figura successiva, in questo
caso abbiamo compilato come sempre il campo di ricerca con la keyword
“e-learning”.
Esempio di ricerca su WoS per keyword “e-learning”
Come già anticipato, possiamo aggiungere dei filtri di ricerca, riducendola per lassi
temporali, estendendo la ricerca ad altri database o aggiungendo altri campi alla
ricerca: si può scegliere oltre alla keyword anche un autore o il nome di una
pubblicazione. Detto questo, procediamo mostrando i risultati della ricerca effettuata
nella figura sopra.
47
Risultati per la ricerca su keyword “e-learning” su WoS
Possiamo, come intuibile dal menù sulla sinistra, filtrare i risultati in base a vari
criteri: tipologia di pubblicazione, autore, categoria ed altri ancora.
48
4 Confronto tra sistemi
Dopo aver analizzato le varie piattaforme, esaminando sia l’aspetto quantitativo sia
qualitativo dei dati che esse forniscono, possiamo stilare una tabella che ci permette
di avere un rapido riepilogo visivo dei pregi e dei difetti di ognuna delle suddette.
H-
Index
G-
index
API Autorizzazione
uso Api
Gratuito Cloud
Scopus Si No Si Si No No
Mendeley No No Si Si Si Si
Arnetminer Si Si Si
(poche)
Si Si No
WoS No No No - No No
Scholar
Si No No - Si No
Tabella di confronto tra database scientifici
Quello che emerge è il fatto che nessuna tra le piattaforme, in precedenza analizzate,
può ritenersi completa. Arnetminer, tra i quattro sistemi, offre sicuramente più
servizi per quanto riguarda l’indicizzazione dei profili degli utenti, ma allo stesso
tempo offre scarse opportunità di interfacciamento con l’esterno. Scopus e Mendeley
sono classificabili nel mezzo, non offrono API complete per la fruizione piena dei
dati che contengono, presentano comunque caratteri positivi: Mendeley con il cloud
e la gratuità, Scopus con la presenza di H-index e discrete API. In ultima posizione
possiamo sicuramente porre Web of Science, non è gratuito, non presenta alcun
profilo utente ma solo documenti, di conseguenza non offre alcun indicatore
bibliometrico; a precederlo troviamo Google Scholar il quale, rispetto a Web of
Science, presenta il fattore di gratuità e l’indicatore bibliometrico H index.
49
Capitolo 3
Estrazione dei dati da Scopus e sviluppo
applicazione per sistemi Android
1 Introduzione e linee guida di sviluppo
Nel capitolo 2 di questo documento abbiamo analizzato il comportamento delle
banche dati scientifiche, scovando pregi e difetti di ognuna, soprattutto spostando
l’attenzione verso le interfacce di programmazione invocabili dall’esterno dei vari
sistemi. Una volta completata questa fase, si è deciso di sviluppare un’applicazione
per terminali mobili dotati di sistema operativo Android. Il contesto che è stato
immaginato, al fine di sviluppare al meglio il programma, è quello di un convegno di
ricercatori in ambito scientifico. Sarà capitato praticamente a tutti i ricercatori e
professori di prendere parte ad una conferenza e di non conoscere i campi di ricerca
di un collega o ancora volerne capire il valore bibliometrico (H-Index), oppure di
volersi incontrare con altre persone, magari sconosciute, dello stesso paese e presenti
alla conferenza. Al fine di soddisfare questi quesiti, raccogliendo i suggerimenti del
professore che ci ha guidato durante il percorso di tesi, abbiamo deciso di
intraprendere lo sviluppo di questa applicazione. Ovviamente il fulcro della stessa, la
quale necessita di una struttura client-server, risiede proprio sul server stesso.
50
Ed è per semplificare la lettura del testo che dividiamo il restante capitolo in una
prima parte che mostra il funzionamento del server, ed una seconda dedicata al
client, il tutto non prima di aver presentato la fase preliminare di registrazione.
2 Registrazione all’applicazione
L’applicazione, come già accennato, nasce nel contesto di un congresso scientifico di
ricercatori; in questo tipo di eventi, da prassi, è richiesta una registrazione
preliminare. Analizzando quest’ultimo fattore, abbiamo definito un form di
registrazione che permette all’utente di registrarsi all’evento e di conseguenza
all’applicazione. La realizzazione di questo form ha richiesto lo studio del linguaggio
di programmazione HTML di base e del linguaggio di scripting Javascript, dunque è
stato cosi creato.
51
Form registrazione conferenza
Oltre ai campi tradizionali, sono presenti le opzioni di contatto, ossia indirizzo e-mail
e numero di telefono. L’affiliazione è un campo importante, non c’è bisogno inoltre
che l’inserimento sia preciso (ad esempio: Università degli studi di Salerno) ma basta
anche un’informazione indicativa (del tipo: Salerno); sarà compito delle funzionalità
del server riuscire a reperire l’informazione corretta di affiliazione dell’utente che sta
effettuando la registrazione, ciò avviene, come vedremo, tramite la piattaforma
Scopus. Troviamo, sempre all’interno del form, il campo “Twitter Nickname”,
questa informazione richiesta, ma non obbligatoria, ci permette, tramite delle servlet
52
appositamente studiate in fase di progetto, di recuperare dato il nickname dell’utente
su Twitter, il numero e l’elenco delle persone che seguono e sono seguite da esso.
Come è possibile vedere dalla figura sopra, sono presenti anche due bottoni per la
registrazione tramite Facebook e LinkedIn. Analizziamo ora cosa accade nei due
casi.
Nel caso di Facebook, provando a registrarsi all’applicazione tramite il supporto di
questo social, ci comparirà la pagina di accesso e autorizzazione al prelievo dei dati
dalla social platform da parte della nostra applicazione.
Registrazione tramite Facebook
La registrazione tramite questo social network permette, sempre tramite un’apposita
servlet, di accedere alla lista degli amici dell’utente. A tal proposito vale la pena
ricordare di cosa si intende per servlet: è un programma che viene eseguito su un
server web, scritto in linguaggio Java, il quale potenzia le funzionalità del server
stesso. Per quanto riguarda la registrazione tramite il social network LinkedIn la
situazione è molto simile a quella appena presentata con la prima piattaforma sociale.
I dati rintracciabili sono: nome, cognome, foto del profilo, lista connessioni (molto
simile alla lista degli amici di Facebook). Anche in questo caso abbiamo creato
un’apposita servlet per mettere in comunicazione il server con la pagina di
53
autenticazione. Il protocollo utilizzato per l’autenticazione, sia nel caso di LinkedIn
sia in quello di Facebook è l’OAuth 2.0.
Autorizzazione alla registrazione tramite LinkedIn
Una volta effettuata la registrazione dell’utente alla conferenza, si può procedere nel
comprendere su quali basi è stato progettato il server, analizzando sia la creazione sia
il suo interfacciamento con l’esterno.
54
2.1 Estrapolazione dati da Scopus
La piattaforma che è stata scelta per l’estrapolazione di dati indicizzati è Scopus. La
selezione è stata dettata dal fatto che nessuna piattaforma ci ha permesso di estrarre i
dati in modo completo tramite le API a disposizione, inoltre, Scopus presenta una
quantità di informazioni notevoli e permette di accedere facilmente ai profili degli
utenti, dato che presenta un’apposita pagina di ricerca in base al nome completo
dell’autore. L’estrazione vera e propria è stata realizzata con lo sviluppo di una
classe Java appositamente studiata per effettuare il parsing sulle pagine HTML del
dominio di Scopus. Il parsing è un processo volto ad analizzare uno stream in input
in modo da determinare la sua forma grammaticale. Per creare questa classe ci siamo
avvalsi del supporto di tre librerie gratuite: HTMLUnit, JSoup, Selenium RC Server.
Le prime due sono semplici strumenti di parsing che permettono di analizzare il
contenuto delle pagine HTML ed estrarre i dati da esse. La terza invece è un tool più
completo e in un certo senso complesso, infatti, esso permette di automatizzare la
navigazione tra le pagine; si è reso necessario l’utilizzo di Selenium dato che sulle
pagine di Scopus sono presenti dei controlli nei campi dei vari form di ricerca, questo
rende impossibile il parsing, quindi per effettuare l’interazione abbiamo dovuto
simulare l’inserimento manuale dei dati nel form stesso, per fare ciò la libreria in
questione è stata di vitale importanza. Sempre a tale riguardo, all’avvio del server si
necessita di avviare il server standalone Selenium RC. Per automatizzare il problema
è stato creato un file di estensione .bat che viene eseguito all’avvio del server stesso;
il codice è riportato di seguito.
55
La fase di reperimento dati entra in azione nel momento in cui viene sottoscritto il
form di registrazione, il server è capace di recepire i dati da questo e li invia alla
classe Java che ha il compito di interrogare il database scientifico online Scopus. La
classe elaborata, appena menzionata, rintracciabile, in quanto codice Java, in
Appendice B al punto B.1 è stata rinominata come ManageScopus ed estende la
classe “SeleneseTestBase”, quest’ultima è una classe presente nella libreria
Selenium. Nello specifico in ManageScopus troviamo i seguenti metodi.
public boolean SearchAuthorOnScopus(User user)
Questo metodo permette di effettuare una ricerca di un utente su Scopus, in
modo automatico, inserendo nome, cognome e affiliazione. Questi dati sono
sintetizzati, insieme ad altre informazioni, nella classe User, la quale ha un
ruolo fondamentale nello sviluppo dell’intera applicazione. Se la ricerca su
Scopus tramite browser dà esito positivo, il metodo andrà a completare le
variabili dell’istanza della classe User passatagli e fornirà come valore di
ritorno “vero”, avremo invece “falso” se la ricerca non è andata a buon fine.
Tramite questo metodo, inoltre, è possibile ricavare l’H-index, le keywords e
i journal relativi all’utente in questione.
public String[ ] SearchAuthorsByKey(String k1 , String k2 , String k3)
Codesto metodo a differenza del precedenti, viene richiamato durante
l’esecuzione dell’applicazione e non in fase di registrazione alla conferenza.
Inserendo tre keywords, il metodo permetterà di rintracciare gli autori relativi
ai primi duecento documenti più rilevanti in base al numero di citazioni.
Questa lista di autori viene poi archiviata nella variabile di ritorno.
Per poter usufruire dei dati messi a disposizione da Scopus, la messa in opera e il
successivo esercizio del server, ci siamo serviti della connessione al proxy server del
nostro ateneo, il quale ha effettuato la sottoscrizione al sistema Scopus al fine di
beneficiarne delle informazioni contenute. Dopo questa piccola premessa vediamo
come e quali dati vengono estratti, tramite lo strumento di testing Selenium, dalla
56
piattaforma al momento dell’invio dei dati dal form di registrazione verso il server.
Innanzitutto, viene effettuata una ricerca autore sulla base di tre delle informazioni
inserite nel form di registrazione prima presentato: nome, cognome, affiliazione.
Questo primo step è mostrato nella figura successiva.
Recupero dati Scopus
Questo form di ricerca compilato, ricordiamo, in modo automatico ci porta ad un
risultato preciso, questo perché è stato selezionato il checkbox di matching perfetto
tra i dati inseriti e quelli presenti sul database. Giungiamo, quindi, ai risultati della
ricerca, qui, dato che abbiamo selezionato il match perfetto, riusciamo ad evitare
ambiguità ed omonimie, avendo specificato anche l’affiliazione. Ricordiamo inoltre
che, nel caso in cui non viene trovata corrispondenza tra i dati inseriti e quelli
presenti su Scopus, il server chiuderà il processo di esecuzione del browser senza
57
effettuare la raccolta dei dati dalla piattaforma scientifica, ma permetterà comunque
di inserire nel database le informazioni immesse dall’utente nel form di registrazione.
Di seguito il risultato della ricerca.
Risultato ricerca profilo
Da questa schermata, si procede, automaticamente, cliccando sull’utente trovato nel
database; questo ci porta alla pagina del profilo dell’autore in questione dove
estrapoleremo una parte delle informazioni.
Profilo utente Scopus parte 1
58
Profilo utente Scopus parte 2
La fase di estrazione inizia tramite il prelievo dei dati seguenti: H index, affiliazione
e source history, ossia storia dei journal sui quali l’autore ha effettuato almeno una
pubblicazione. Per quanto riguarda l’affiliazione, questo dato viene prelevato perché
in fase di inserimento potrebbero essere state inserite stringhe che non individuano in
modo preciso la corrispondente rappresentazione dell’affiliazione sul database;
l’estrazione di questa informazione (affiliazione) serve per uniformare i dati. Invece,
per quanto concerne i cosiddetti journal, il prelievo dei dati avviene effettuando una
selezione, non vengono perciò presi in considerazione quei titoli che contengono le
parole “proceeding” oppure “conference”, questa scelta è dettata dal fatto che i
documenti in questione sono relativi a conferenze e congressi, per cui non sono stati
effettivamente pubblicati su alcun journal. L’ultimo dato che ci interessa estrarre
59
sono le keywords relative ad un autore, ossia le parole chiave collegate al profilo
utente, queste indicano i campi di studio dell’autore, sono perciò un dato di grande
rilievo soprattutto sotto il profilo della socializzazione tra ricercatori. Al fine di
prelevare questi ultimi dati, proseguiamo nella navigazione, automatizzata da
Selenium, sulla piattaforma scientifica Scopus, cliccando sulla pagina che mostra i
papers, ossia i documenti scientifici pubblicati dall’autore. Questo passaggio è
indicato, nell’immagine precedente, dalla freccia gialla. La pagina che apriamo è
dunque la seguente.
Estrazione keywords da pubblicazioni autore
L’estrazione delle parole chiave avviene da box segnalato in rosso sulla sinistra.
Quest’ultimo, come i box sopra (Year, Author Name, ecc...), in figura minimizzati,
sono delle applicazioni interne al sistema Scopus. Abbiamo così completato
l’estrazione dei dati in fase di inserimento di un nuovo utente all’interno del nostro
sistema, per completare il quadro delle funzionalità create sulla base della
60
piattaforma Scopus, andiamo ad esplorare la sezione relativa alla ricerca in base alla
rilevanza dell’autore. La premessa da fare in questo caso è quella di specificare il
fatto che questa ricerca è fruibile in fase di utilizzo dell’applicazione da terminale
mobile, può essere considerata una ricerca a runtime, ossia a tempo d’esecuzione.
Innanzitutto, andiamo a spiegare che tipo di ricerca effettuiamo e che dati possiamo
rilevare. La query di ricerca è ci fornisce un set di risultati ordinati per rilevanza sui
documenti, l’utente, inserendo da una a tre keywords, indica al server di cercare su
Scopus i nomi degli autori relativi ai primi duecento documenti connessi alle parole
chiave inserite, ordinati per numero di citazioni. Per ognuno dei documenti
analizzati, Selenium, con l’aiuto della libreria HTMLUnit, va ad estrarre il nome
degli autori ed interroga il database al fine di verificare se in esso sia presente quello
stesso nome, solo in questo caso, l’utente corrispondente a quel profilo d’autore
viene inserito in una collezione di utenti che sarà poi inviata al terminale. La
procedura automatizzata può essere osservata di seguito, in questo caso abbiamo
specificato solo una parola chiave.
Ricerca per rilevanza
Da questa pagina, raggiungiamo l’elenco dei primi venti risultati trovati, li andiamo
ad ordinare per numero di citazioni e scorriamo le successive dieci pagine. Nel caso
in questione, abbiamo supponendo di aver già popolato il database, tra i vari profili
inseriti troviamo anche il profilo del prof. Ritrovato, notiamo che avremo la
corrispondenza in un risultato come di seguito mostrato.
61
Ordiniamo per Cited-by (numero citazioni)
Risultato della ricerca per citazioni
Abbiamo così terminato la fase di estrapolazione dei dati da Scopus, possiamo
dedicarci al resto dello sviluppo dei server e alle restanti funzionalità da mettere a
disposizione.
2.2 Estrazione dati social network
Ricordiamo, solo per fini di comprensione che, l’estrapolazione dei dati dai social
network avviene con le classi SocialFeatures e ControllerPage e negli script collegati
alla pagina di registrazione: scriptfacebook e scriptlinkedin. Ulteriori dettagli sono
disponibili nella tesi complementare a questa, sviluppata dal mio collega Antonio
62
Scaldaferri. Per il prosieguo in una completa lettura ci basti sapere che i dati estratti,
tutti opzionali, relativi all’utente specificato sono il numero e la lista delle
connessioni LinkedIn, la lista degli amici di Facebook, il numero e le liste dei
followers e dei following di Twitter.
3 Applicazione: lato Server
Per quanto concerne lo sviluppo del lato server, abbiamo necessitato di estendere le
nostre conoscenze su molti aspetti di programmazione e progettazione che nel
seguito analizzeremo singolarmente. In generale, possiamo affermare che l’idea di
base che caratterizza questa parte dell’applicazione risiede nell’estrapolare i dati da
una sorgente, scelta sulla base dell’analisi effettuata sui differenti sistemi nel capitolo
2, al momento della registrazione dell’utente alla conferenza. Le informazioni
raccolte devono essere archiviate in modo preciso su una struttura che ne permettesse
un efficiente e rapido accesso, un database. Infine, per quanto concerne il server,
devono essere messi a disposizione del client dei servizi che concedessero di
richiedere i dati alla banca dati, sulla base di un protocollo di comunicazione. E’
stato necessario, quindi, esporre i servizi all’esterno del server tramite Web Service,
il protocollo selezionato per effettuare questo scambio di informazioni con l’esterno
è il SOAP.
3.1 Organizzazione dei dati e tools di sviluppo
Quello che ora ci preme di mostrare è la rappresentazione dei dati in un formato di
semplice comprensione; le informazioni estrapolate con il supporto di Scopus,
Facebook, LinkedIn e Twitter, così come le credenziali di accesso, i dati anagrafici e
63
quelli di recapito vengono archiviati sul server in una struttura di rapido accesso: la
banca dati. La banca dati è un archivio dove le informazioni contenute sono collegate
e strutturate secondo un preciso modello logico: il modello relazionale. La loro
architettura, grazie alla presenza del DataBase Management System (DBMS), è di
tipo client-server quindi interrogabile da un utente generico. Fatta questa premessa,
ci è stato utile ricorrere agli studi fatti durante il percorso accademico, riprendendo i
concetti teorici e gli strumenti necessari al fine di creare il nostro semplice database.
E’ stato così creata una banca dati, a partire dal modello relazionale di seguito
rappresentato, utilizzando il tool Sybase che permette di creare il modello
concettuale, ne ricava quello logico e mette in fine a disposizione dell’utente tutte le
query di creazione delle varie tabelle.
Modello relazionale del database da noi creato
64
Sono state generate così otto tabelle, di cui una principale per il login denominata,
per l’appunto, “login_table”. Questa contiene la corrispondenza tra nome utente e
password. La struttura permette di identificare in modo univoco un utente sulla base
del suo username, le restanti tabelle, infatti, presentano tutte dei vincoli di integrità
referenziale; questo vuol dire, considerando ad esempio la “info_table”, che sarà
necessaria l’esistenza di una tupla, ossia il generico elemento di una relazione con
attributi, relativa ad uno specifico username nella login_table, per rendere possibile
l’esistenza di una tupla, riferita sempre allo stesso username, nella “info_table”.
Un’altra importante osservazione da fare sta nel fatto che le tabelle “info_table” e
“login_table” presentano ambedue come chiave primaria, ossia un insieme, in questo
caso solo uno, di attributi che permettono di identificare univocamente la tupla,
questa è di fatto l’attributo username; nelle restanti tabelle invece la chiave primaria
è identificata dalla coppia formata da un attributo differente di tabella in tabella
(nick_following, nick_followers, ecc…) e l’username, questo vuol dire che in queste
tabelle originariamente avevamo bisogno di un attributo multivalore, in questo modo
ad un utente possono corrispondere più di uno degli altri attributi che in coppia con
l’username fungono da chiave primaria. Tutto questo può essere anche sintetizzato
nel fatto che ad un utente possono corrispondere più keywords, più journals, più
followers di Twitter. Avendo fatto queste premesse, ora possiamo analizzare in modo
rapido quelli che sono i dati contenuti nelle varie tabelle. La “login_table” contiene
la corrispondenza nome utente – password, necessaria in fase di autenticazione per
l’accesso all’applicazione. La “info_table”, invece, presenta tutte quelle informazioni
relative all’utente che hanno un valore unico ma ovviamente non univoco: i dati di
recapito, nome, cognome, Hindex, foto, nazionalità, affiliazione, numero di followers
e following sul social network Twitter, numero di connessioni LinkedIn. La lista dei
followers, dei following, delle connessioni LinkedIn e degli amici di Facebook sono
contenute rispettivamente in: ”Twitter_followers_table”, ”Twitter_following_table”,
“Connection_table” e ”Facebook_Friends_table”. Infine, alcune informazioni estratte
da Scopus: keywords e journals sono immagazzinate nelle tabelle “Keywords_table”
e “Journal_table”. A corredo del lavoro svolto sul database, si allega in Appendice B,
nel paragrafo B.2, le query di creazione.
65
3.1.1 Rappresentazione Java
Avendo pienamente rappresentato la struttura del nostro database, ora dobbiamo
capire come rappresentare i dati in linguaggio Java. Per fare ciò, ci siamo
appositamente creati una classe che permette di racchiudere le informazioni prelevate
dal database: la classe User. Questa classe presenta tutte le informazioni relative al
singolo utente, ad esempio: le parole chiave ad esso correlate, i journals, le
connessioni di LinkedIn, l’H Index e così via. Di seguito vengono mostrati gli
attributi che la compongono.
Classe user
Questa classe presenta attributi privati, infatti, non è qui rappresentato l’intero codice
per motivi di semplificazione, ma è importante sapere che è corredata dei metodi
“getter” e “setter” su ognuno dei suoi attributi, al fine di poter prelevarne e
rispettivamente impostarne il valore per ogni istanza eventualmente allocata. Al fine
66
di permettere la comunicazione su una connessione, la classe necessita di
implementare la classe “Serializable”, la quale permette di non incorrere in problemi
durante la comunicazione in rete; inoltre, la classe presenta, seppure non presente in
figura, un costruttore vuoto, questa è una necessità, dettata dall’utilizzo della libreria
KSOAP, per garantire la corretta comunicazione client-server. Le classi che seguono
queste specifiche, serializzabile, presenza di “getter” e “setter”, costruttore senza
argomenti, sono definite in linguaggio tecnico come JavaBean e servono per
racchiudere oggetti semplici al loro interno, come appunto nel caso sopra in esame.
3.1.2 Strumenti di sviluppo
Per quanto riguarda la creazione dei servizi web che abbiamo dovuto mettere a
disposizione sul server, ci siamo serviti di developer tool molto diffusi. La
programmazione del server è basata su linguaggio Java, visto che il progetto è di
natura prettamente dinamica e basata su un framework web, l’ambiente di sviluppo
designato a risolvere le problematiche in questione è Eclipse con distribuzione
Enterprise (Java Eclipse EE). Con Eclipse EE è infatti possibile automatizzare la
creazione del foglio WSDL, di conseguenza il lavoro che abbiamo svolto ha
riguardato soprattutto il lato della programmazione ad oggetti, ed è bastato dare uno
sguardo al WSDL generato in automatico per capirne la correttezza realizzativa. Per
quanto riguarda il server, come struttura di comunicazione, abbiamo selezionato uno
strumento completo: XAMPP. Questo tool contiene tutti gli strumenti utili per il
mantenimento di un progetto web dinamico: un database MySql, una piattaforma
server web Apache HTTP server ed i linguaggi di scripting PHP e Pearl, questi ultimi
non utilizzati nel nostro caso.
67
Visione in Eclipse del progetto
68
3.2 Server e Database
Andiamo ora ad approfondire quello che è il lavoro che il server deve svolgere,
analizzando come esso si interfaccia per quanto riguarda le operazioni da compiere
sul database mostrato nel sottoparagrafo 2.1. Abbiamo, per i fini appena citati, creato
un’apposita classe che permette di effettuare le operazioni sul database: ManageIO.
La classe in questione effettua, in ognuno dei suoi metodi, delle query al database,
come vedremo tra poco. L’interazione tra banca dati e server avviene sulla base del
JDBC ossia di un connettore, svincolato dallo specifico DBMS, questo supporta due
tipi di istruzioni: statement, la quale viene inviata volta per volta dal programma al
database, e il prepared statement, compilata una sola volta per motivi di efficienza.
Da questa connessione-ponte tra server e database riusciamo ad avere una
comunicazione bidirezionale, query che vanno dal primo al secondo e i result set che
si muovono in direzione opposta. La presenza di un iteratore sul result set permette,
poi, di estrarne i singoli dati da fornire all’ambiente di sviluppo prima, e al client
successivamente.
3.2.1 Classe ManageIO
Non ci preme dilungarci su questa classe, ne facciamo una trattazione sintetica,
seppure essa sia molto rilevante. Innanzitutto presentiamo l’interfaccia di seguito.
69
70
Interfacce classe ManageIO
Fatte queste premesse, entriamo nel merito dell’argomento: ManageIO permette di
interrogare il database. Concede l’inserimento di nuovi record relativi ad una singola
istanza della classe User tramite il metodo “insert”. Troviamo ancora metodi di
controllo: “isUsernameUsed” che viene utilizzato per verificare la presenza nel
database di un utente con uno specifico username, “checkPassword” controlla la
correttezza della password d’accesso all’applicazione da parte di un utente. Oltre a
queste funzionalità di controllo troviamo tutte quelle di ricerca in base a vari criteri,
per nome utente, per cognome, per keyword, per affiliazione, per nazione e, in base
all’username, per aspetti sociali: amici di Facebook, connessioni LinkedIn, followers
71
e following su Twitter, tutte relative ad uno specifico utente. Per quanto riguarda i
metodi privati, la maggior parte di questi sono di supporto a quelli pubblici, di
grande importanza sono i metodi per la creazione e la chiusura della connessione con
il database, rispettivamente: “createConnection” e “closeConnection”.
3.3 Server e il mondo esterno: WebService
La parte consistente dello sviluppo dell’applicazione sul server-side risiede nello
sviluppo dei web service che abbiamo deciso di mettere a disposizione del client. Un
web service è un sistema software, creato sul server, che viene sviluppato per
garantire l’operabilità tra differenti tipi di elaboratori, in poche parole è un insieme di
programmi che serve a permettere l’accesso ai servizi del server a tipologie differenti
di terminali; da questa dichiarazione si evince che, per i nostri fini, è necessaria una
struttura di interfaccia dal server verso l’esterno composta in questo modo. Il
problema che ci siamo posti è stato quello di riuscire a far comunicare un dispositivo
Android ed un software con un’architettura e un sistema operativo differente, si è
reso necessario superare, dunque, i limiti imposti dai cosidetti middleware, infatti, in
un contesto generico potremmo immaginare che per ogni richiesta di un servizio
dall’esterno verso il server, vi sia la necessità di installare un apposito middleware;
ovviamente una situazione di questo tipo non garantirebbe un accesso alle
informazioni sul server ad un numero molto elevato di dispositivi. La comunicazione
tra il web service e l’applicazione mobile che abbiamo sviluppato è avvenuta sulla
base di una delle tre famiglie protocollari disponibili: RPC Oriented, nello specifico
abbiamo scelto il protocollo SOAP, accompagnato da WSDL, appartenente alla
famiglia appena citata. E’ sicuramente di grande interesse approfondire questo
argomento, presentando le tre architetture in questione [6] :
72
RPC Oriented
E’ l’architettura più datata, presenta infatti delle peculiarietà tipiche dei
middleware tradizionali; il suo funzionamento si basa su una richiesta HTTP
di tipo POST del client su una URL che specifica l’intera applicazione server,
nella richiesta sono specificati il nome della procedura remota da invocare ed
i parametri da passare. Il server risponde sempre tramite protocollo HTTP.
Alla famiglia RPC appartiene quello che d’ora in poi citiamo come SOAP,
ma che in realtà è l’unione di due protocolli di comunicazione: SOAP e
WSDL. SOAP nasce come acronimo di Simple Object Access Protocol, e
supera i limiti di RPC-XML, permette dunque di eliminare le problematiche
relative ai tipi di dati trasmissibili su un canale di comunicazione (parametri e
valori di ritorno). Agli esordi, nel 1998, SOAP non presentava alcuna
definizione formale della sua interfaccia, per questo l’IBM introduce, a
partire dal 2000, il WSDL, un linguaggio basato su XML per definire le
interfacce dei web service; un documento WSDL è in sostanza composto da
tutti i protocolli utilizzati, le operazioni disponibili ed i relativi parametri, i
valori di ritorno, i punti di accesso o endpoint dei web service e tutti i tipi non
predefiniti utilizzati dalle varie operazioni disponibili. Questo tipo di file è
disponibile online sul sito che ospita il web service sia perché deve essere
possibile visualizzare eventuali modifiche alle interfacce, sia perché i
linguaggi di tipo dinamico, come Java, possano creare le classi che
rappresentano la comunicazione con il client a tempo di esecuzione. L’unione
tra SOAP e WSDL demanda allo sviluppatore un carico di lavoro molto
leggero sia sul lato server che su quello client, al fine di permettere la
comunicazione, appunto, tra server e client, viene garantita l’interoperabilità
tra i sistemi in comunicazione ed infine è bene ricordare che questo
protocollo non è vincolato al trasporto dei dati solo su HTTP ma anche su
altri protocolli come SMTP.
73
Message Oriented
In questa tipologia di protocolli le applicazioni si scambiano messaggi
unidirezionali, per cui ogni comunicazione di risposta è indipendente da
quella di richiesta, di conseguenza non è importante conoscere l’ordine delle
richieste da parte del server che risponde; l’architettura in questione va ad
alleviare la distinzione netta tra client e server proponendo un modello molto
simile al peer-to-peer. Conseguenza di ciò è sia il disaccoppiamento tra server
e client, sia la difficoltà nel gestire operazioni prettamente sincrone ed
emerge, dunque, la necessità di un livello di trasporto affidabile.
Architettura REST
Nell’architettura di tipo REST acronimo di REpresentational State Transfer,
ogni singolo elemento dell’informazione ha una sua URL, vengono sfruttate
tutte le operazioni disponibili per il protocollo HTTP: DELETE, GET, POST,
PUT per intervenire sui dati. Il tutto porta ad una maggiore semplicità di
implementazione e ad un utilizzo migliore della banda disponibile.
Per la creazione del nostro web service è stato scelto il primo modello tra i tre appena
presentati, questa selezione è stata dettata dalla scelta del linguaggio di
programmazione utilizzato sul server: Java. Il protocollo SOAP infatti si presta bene
in ambiti di programmazione ad oggetti. In fase di programmazione server questo
aspetto viene ben celato da Eclipse EE, il quale, come già detto, automatizza il tutto;
ciò che, fortunatamente, non viene nascosta è la classe che permette al server di
interagire con l’esterno: ServerInterface. Quest’ultima mette a disposizione tutti i
metodi raggiungibili da remoto, in pratica è il punto di appoggio tra il client, che
usufruisce della nostra applicazione, e le informazioni immagazzinate nel database.
74
3.3.1 Classe ServerInterface
Presentiamo ora degli screen-shot autoesplicativi per mostrare la classe
ServerInterface. Innanzitutto mettiamo in evidenza il file WSDL modellato in modo
grafico, successivamente presenteremo la classe in questione ed infine i commenti a
riguardo.
75
f
File Wsdl relativo al web service
76
77
78
79
80
Classe ServerInterface
81
Nella fase iniziale della classe sono presenti istanze delle classi ManageScopus e
ManageIO, al fine di richiamarne le funzionalità nei metodi contenuti dalla
ServerInterface; per quanto riguarda le funzionalità sociali, invece, si è deciso di
creare una classe che presenta metodi invocabili staticamente, dunque, non abbiamo
allocato delle istanze di essa. Come si può notare, i metodi a disposizione sono
numerosi ed ognuno di essi può essere raggiunto da un terminale qualsiasi, purché
l’accesso sia indirizzato dal file WSDL, presente sul server e disponibile
pubblicamente all’endpoint.
4 Applicazione: lato Client
Lo sviluppo di un’applicazione, che permettesse di recuperare i dati presenti sul
database del server, si è rivelato molto stimolante dal punto di vista della
programmazione. I problemi affrontati sono vari: comunicativi, di programmazione,
di design. Come già avvenuto per quanto riguarda la programmazione lato server,
ripercorriamo la stessa strada, introducendo una rappresentazione dei dati e
successivamente entrando nel merito del codice Java. Premettiamo che l’intera
applicazione necessita di una connessione internet per funzionare, questo è dovuto al
fatto che le richieste e le risposte, da e verso il server, ovviamente avvengono a
tempo di esecuzione, ma non si è ritenuto utile salvare alcun dato sul dispositivo
mobile.
4.1 Organizzazione dei dati e tools di sviluppo
Sul dispositivo mobile non vengono archiviati dati, avviene tutto a runtime,
conseguenza di ciò è la necessità di istanziare numerosi oggetti della classe User. La
82
classe in questione rispetta praticamente la stessa classe presente sul server, ma con
alcune particolarità. Innanzitutto ne mostriamo una rappresentazione dal codice.
Attributi classe User sul client
Come possiamo notare, in questo caso la classe User implementa un’altra classe
“KvmSerializable” rispetto alla stessa classe presente sul server, la quale
implementava “Serializable”. Tutto ciò è dovuto al fatto che si è scelto di usare la
libreria KSOAP per lo scambio dei dati tra client e server, dunque, è richiesto che il
dato scambiabile tra le due parti sia un oggetto di un tipo o primitivo oppure
complesso creato come JavaBean che implementi questa classe (KvmSerializable) e,
nello specifico, dei metodi, che permettano di ottenere e settare le variabili presenti
83
nelle istanze della classe User di ritorno, provenienti dalle chiamate ai web service;
sono insomma, quelle funzioni che permettono il matching: getPropertyInfo,
getProperty, getPropertyCount, setPropertyInfo. L’implementazione realizzata per i
metodi appena illustrati è visionabile in Appendice B al paragrafo B.3.
4.1.1 Strumenti di sviluppo Android
La strumentazione necessaria per lo sviluppo di applicazioni per sistema operativo
Android è disponibile presso la pagina ufficiale per sviluppatori del sistema mobile
creato da Google. I tools che abbiamo deciso di considerare per realizzare il nostro
compito sono sostanzialmente due: la distribuzione dell’ambiente di sviluppo Eclipse
per progettazione Android detta Android Developers Tool (ADT) e la libreria nata
per la comunicazione client-server in Java su protocollo SOAP: KSOAP. La prima
contiene tutte le librerie Android per lo sviluppo di applicazioni complete su sistema
mobileed è inoltre molto semplice da utilizzare dato che sono pubblici sia tutta la
documentazione a riguardo sia vari esempi di utilizzo della stessa.
84
Visione d’insieme del progetto
In questa schermata possiamo osservare la composizione del nostro progetto
Android, possiamo notare le varie classi e tra queste focalizzeremo la nostra
attenzione in particolar modo sulla classe “WebServiceInterface”, la quale funge da
interfaccia tra il client mobile stesso e il server.
85
4.2 Funzionalità e codice
L’applicazione che abbiamo sviluppato, ed ora in analisi, si propone di mettere a
disposizione dell’utente tutte quelle funzionalità che possano servire ad avere
informazioni riguardo gli altri utenti presenti alla conferenza. Dopo la prima fase di
registrazione e di archiviazione dei dati, la quale come abbiamo visto avviene sul
server, troviamo la possibilità di visualizzare i dati da sistema mobile. Per
sintetizzare il funzionamento dell’applicazione ci conviene far riferimento
direttamente all’interfaccia disponibile all’utente. Bisogna prima capire però quali
sono le piccole differenze tra la programmazione Java e la programmazione Android,
infatti, quest’ultimo permette di usufruire di molte potenzialità di Java in modo molto
più semplice. L’esempio lampante, che abbiamo largamente utilizzato, è
l’AsyncTask, esso altro non è che un thread separato. Programmando in Android,
infatti, è necessario eseguire qualsiasi operazione in un thread separato da quello
principale, questo ha l’obiettivo di impedire che l’interfaccia grafica rimanga
bloccata nell’attesa dell’operazione in esecuzione. Altre differenze tra le due
tipologie di programmazione risiedono nel modo di progettare, ogni operazione in
Android deve essere pensata per essere racchiusa in un’ “Activity”, ogni pagina della
nostra applicazione corrisponde infatti ad una di queste. Tra le varie activity ne
troviamo alcune specifiche per la visualizzazione di liste di oggetti: le “ListActivity”,
queste, sulla base di un oggetto definito “Adapter”, impostato sulla base della lista
stessa, permettono di selezionare uno tra gli elementi e permettere l’inizio di una
nuova attività collegata ad esso. Dopo questi primi cenni teorici riguardo alcune
caratteristiche che abbiamo utilizzato in fase di sviluppo, procediamo, dunque, passo
dopo passo nella fruizione dei contenuti, partendo dall’accesso al sistema tramite
l’apposita pagina di login.
86
Login applicazione
L’utente qui inserirà le proprie credenziali d’accesso e potrà accedere al menù
principale dell’applicazione.
Menù applicazione
87
Dal menù possiamo selezionare varie opzioni:
My profile
Permette l’accesso al profilo personale dell’utente che sta utilizzando
l’applicazione, presentandone i vari dati.
Profilo
Top 10 HIndex
Mostra i dieci profili degli utenti che hanno H Index più elevato
Top 10 HIndex
88
Search by Name
Permette di ricercare un utente in base al nome e al cognome oppure solo in
base al cognome, in questo ultimo caso potremmo trovare un insieme di
utenti. Selezionando uno di questi ultimi è possibile visualizzarne il profilo.
Inserimento dati Risultato della ricerca
Search by Nation
Presenta prima l’elenco delle nazioni presenti nel database e, selezionandone
una, ci permette di visualizzare tutti gli utenti provenienti da quella.
Lista nazioni Risultato per Gran Bretagna
89
Search by Affiliation
Presenta prima l’elenco delle affiliazioni presenti nel database e,
selezionandone una, ci permette di visualizzare tutti gli utenti provenienti da
essa. Selezionando un utente è possibile visualizzarne il profilo.
Lista affiliazioni Risultato selezionando Università di Salerno
Search by Keyword
Mostra innanzitutto l’elenco delle keywords presenti nel database e,
selezionandone una, ci permette di visualizzare tutti gli utenti relativi ad essa.
Selezionando un utente tra questi, è possibile visualizzarne il profilo.
Lista keywords Risultato selezionando “E-Learning”
90
Search by Relevance on Papers
E’ una ricerca a runtime sulle pagine del database scientifico Scopus,
permette di visualizzare gli utenti che presentano un numero elevato di
citazioni su documenti relativi ad una o più, massimo tre, keywords.
Inserimento keywords
Sul server intanto avviene in modo automatico la ricerca come mostrato di
seguito.
Ricerca per keyword “e-learning”
91
Il server estrae quei nomi già presenti nel database
Una volta trovati e collezionati gli utenti in questione, viene creata una
collezione che sarà presentata sul terminale mobile.
Risultato della ricerca effettuata
92
Suggestions…
Dal bottone suggerimenti si accede ad un ulteriore menù che permette di
ricevere suggerimenti personalizzati in base ai dati relativi all’utente che sta
utilizzando l’applicazione.
Menù suggerimenti
By your Keywords
Vengono qui visualizzate prima tutte le keywords dell’utente, poi,
selezionandone una si accede alla lista degli utenti che sono relativi ad essa.
Selezionando un utente dall’elenco si accede al suo profilo.
Keywords per Pierluigi Ritrovato Risultato per “Learning systems”
93
Your Country
Suggerisce tutti gli utenti provenienti dalla stessa nazione dell’utente che sta
utilizzando il programma Android. Selezionandone uno si accede al profilo.
Lista persone stesso paese per Ritrovato
Your Affiliation
Suggerisce tutti gli utenti provenienti dalla stessa affiliazione dell’utente che
sta fruendo i dati. Selezionandone uno si accede al profilo.
Suggerimenti per affiliazione per Ritrovato
94
Suggerisce tutte le persone che sono amiche su Facebook dell’utente
registrato e che sono presenti alla conferenza. Come sempre, selezionando un
utente si può accedere al suo profilo.
Suggerimenti Facebook per Antonio Scaldaferri
Suggerisce tutte le persone che sono nelle connessioni LinkedIn dell’utente
registrato e che sono presenti alla conferenza. Selezionando un utente si può
accedere al suo profilo.
Suggerimenti LinkedIn per Raffaele Di Taranto
95
Your Followers
Suggerisce tutte le persone che sono tra i followers di Twitter dell’utente
registrato e che sono presenti alla conferenza. Cliccando su un utente si può
accedere al suo profilo.
Suggerimenti Twitter followers per Antonio Scaldaferri
Your Following
Suggerisce tutte le persone che sono tra i following di Twitter dell’utente
registrato e che sono presenti alla conferenza. Selezionando un utente si può
accedere al suo profilo.
Suggerimenti Twitter following per Antonio Scaldaferri
96
4.2.1 Connessione al Web Service
Abbiamo appena mostrato come funziona il sistema, quali sono le funzionalità e il
modo nel quale esso presenta i dati che alloggiano sul server remoto; proprio a
questo punto riteniamo di grande importanza capire come avviene la richiesta di
connessione dal client verso il server. Come accennato precedentemente, la classe di
riferimento è composta da metodi statici ed è denominata: “WebServiceInterface”.
Essa presenta tutte le funzionalità per la connessione al server, sfrutta l’architettura di
riferimento imposta da KSOAP. Per comprendere meglio l’intero funzionamento,
prendiamo in considerazione uno dei metodi contenuti nella classe in analisi, ad
esempio il metodo “searchUsersByKey”, presentiamo, dunque, il codice in più
frammenti e lo commentiamo.
Il metodo in questione invoca l’operazione sul web service detta
“searchUsersByKeyword”, per permettere il raggiungimento del server bisogna
specificare l’URL componendola dall’indirizzo IP del server seguito dall’URI che
permette l’accesso al file WSDL presente.
97
Viene creata quindi un’istanza di SoapObject che serve ad effettuare la richiesta al
server, viene, ad essa stessa, aggiunto un oggetto che specifica il parametro che viene
passato al metodo sul web service. Ancora, viene specificato un mapping ossia un
matching, una corrispondenza, tra la classe User presente sul client e quella presente
sul server. Infine, avviene la chiamata al web service tramite il metodo “call”
sull’istanza della classe HttpTransportSE.
Nell’ultima parte di codice che compone il metodo in analisi, viene prelevata la
risposta dall’ ”Envelope” e vengono estratti i singoli dati, che compongono la
risposta stessa, tramite un iteratore su istanze della classe SoapObject; in questo caso
viene prelevata la singola istanza del set di risposta proveniente dal web service,
ossia un array di User.
98
Conclusioni
Al termine di questo lungo percorso, tanto esteso quanto formativo, possiamo trarre
le conclusioni del lavoro svolto, analizzando gli aspetti che hanno caratterizzato la
realizzazione del compito assegnato. Innanzitutto, compiamo un breve riepilogo:
abbiamo analizzato le banche dati scientifiche, per i nostri obiettivi di estrazione dei
dati è stato scelto il database di Scopus, sono state sviluppate le funzionalità per
svolgere tale compito e dunque, creando una banca dati supportata da un web
service, sono stati messi a disposizione tali dati all’esterno. Infine, è stata sviluppata
un’applicazione per sistemi Android, la quale nasce nel contesto di una conferenza,
ai fini di visualizzare i dati sul nostro database e suggerire eventuali profili
d’interesse. Il lavoro assegnato si è rivelato molto formativo ed interessante, oltre a
permetterci una consolidazione delle conoscenze sia del linguaggio di
programmazione ad oggetti Java, sia della creazione e dell’interrogazione dei
database, ci ha concesso di acquisire nuove conoscenze per quanto riguarda la
programmazione di pagine Internet. Si è rivelato necessario conseguire i fondamenti
di HTML e del linguaggio di scripting Javascript, sia per la realizzazione di parsing
automatici, sia per la fruizione delle API sia dei sistemi sociali coinvolti.
Successivamente, ci sono stati forniti i concetti per la realizzazione e la
comunicazione tra client e server, per cui abbiamo dovuto approfondire le nostre basi
teoriche riguardo i protocolli coinvolti. Una volta creati i web service, abbiamo
dovuto preoccuparci di testare gli stessi; per farlo abbiamo utilizzato uno strumento
molto importante e già conosciuto: la libreria Java Selenium, tra l’altro già utilizzata
in fase di estrapolazione dei dati. Infine, si è proceduto con la creazione di
un’applicazione per dispositivi mobili con sistema operativo Android, abbiamo,
dunque, dovuto rielaborare i concetti già conosciuti del linguaggio Java, ed adattarli
al contesto in esame. La programmazione Android alleggerisce il carico di lavoro
dello sviluppatore, ma allo stesso tempo presuppone che i concetti di base come i
layout e la loro realizzazione, gli AsyncTask, le Activity e il linguaggio di supporto
XML siano ben consolidati; ci siamo dunque impegnati per comprendere tutti questi
99
aspetti e riuscire a realizzare in modo adeguato l’applicazione “InCongress”, la quale
permette di presentare i dati archiviati sulla banca dati creata in modo davvero user-
friendly, mettendo a disposizione tutte quelle funzionalità di suggerimento in base
agli interessi dell’utente registrato. Bisogna dunque rendere merito della buona
riuscita dell’intero lavoro al corso di laurea, il quale ci ha fornito i fondamenti del
pensiero informatico ed ingegneristico, inculcandoci la forma mentis necessaria per
affrontare problemi e tematiche come quella illustrata in questo documento, con
questa filosofia abbiamo affrontato l’argomento in analisi; in questo modo ci è stato
possibile comprendere in modo rapido tutti i nuovi concetti, dei quali avevamo una
conoscenza insufficiente o in alcuni casi inesistente, esaminati in questo capitolo
conclusivo.
100
Appendice A
A.1 Tabella dei metodi API Scopus
Metodi
Descrizione
Informazioni suppletive
areSearchResultsValid () Ritorna vero o falso in base al
fatto che la ricerca sia stata
completata o meno
getContent ()
Ritorna il contenuto del set
ricercato
getField (position, field)
Ritorna un singolo campo di un
documento nella specifica
posizione
Valido solo se
areSearchResultsValid() è vera
getFields ()
Ritorna i campi del set
(stringhe) separati da comma.
getLastSearchRequest()
Torna searchObj per la ricerca
precedente, null se non vi è
stata una ricerca precedente
getNumResults ()
Ritorna il numero dei risultati
trovati
Valido solo se
areSearchResultsValid() è vera
getSearch ()
Ritorna il set di ricerca
getSearchResults ()
Ritorna l’oggetto o meglio I
risultati della ricerca
Valido solo se
areSearchResultsValid() è vera
getOffset ()
Ritorna il corrente set d’offset
getPosition ()
Ritorna l’offset Valido solo se
areSearchResultsValid() è vera
getSort () Ritorna il corrente set ordinato
101
getSortDirection ()
Ritorna la direzione di
ordinamento del set ordinato
getTotalHits ()
Ritorna il numero delle volte
che è stata effettuata la ricerca
corrente
Valido solo se
areSearchResultsValid() è vera
renderDocument (position)
Restituisce il documento alla
specifica posizione nel
documento HTML e lo mostra
tramite renderer
Valido solo se
areSearchResultsValid() è vera
runSearch (searchObj)
Effettua una ricerca in base alla
stringa che gli viene passata;
permette di visualizzare i
risultati senza invocare il
renderer
search (searchObj)
Effettua una ricerca in base alla
stringa passatagli. In questo
caso viene invocato il renderer
selectRenderer (renderer)
Permette di selezionare il
renderer tra una lista proposta
da Elsiever. Al momento
l’unico supportato è il “list”
setCallback
(functionJavascript)
Setta il metodo Javascript da
invocare al termine
dell’esecuzione della ricerca
opzionale
setAPIKey (APIKey)
Setta l’APIKey necessaria per
poter effettuare la chiamata alle
funzioni di Scopus Integration
setFields (fields)
Permette di selezionare i campi
da ritornare nelle operazioni di
ricerca. Per gli
utenti/sviluppatori non
registrati non è possibile
ottenere i campi: abstract e
firstauth.
setNumResult (numResult)
Permette di selezionare il
numero di risultati che ci
aspettiamo dalla ricerca.
102
Intervallo (1-20) per utenti non
registrati, (1-2000) per utenti
registrati
setSearch (search)
Setta la stringa di ricerca, è
valida ogni stringa anche
proveniente da form avanzati
Tabella di consultazione delle API di Scopus Integration
A.2 Tabella dei metodi pubblici API Mendeley
Indirizzo metodo Risposta Requisiti
http://api.mendeley.com/oapi/stats/authors/ Lista degli autori
più rilevanti tra le varie discipline
GET
http://api.mendeley.com/oapi/stats/papers/ Lista dei
documenti più
rilevanti tra le varie discipline
GET
http://api.mendeley.com/oapi/stats/publications/ Lista delle
pubblicazioni più
rilevanti tra le varie discipline
GET
http://api.mendeley.com/oapi/stats/tags/<discipline id>/ Lista delle
discipline più
cercate nelle
ultime tre
settimane
Id_disciplina
/ GET
http://api.mendeley.com/oapi/documents
/search/<terms>/
Lista di
documenti
ricercati in base
ai parametri
specificati in
<terms> (anno,
autore, ecc..)
Terms / GET
http://api.mendeley.com/oapi/documents/details/<id>/ Informazioni di
citazione per un
documento
specifico
identificato in
id (del
documento) / GET
103
<id>
http://api.mendeley.com/oapi/documents/related/<id>/ Lista di 20
documenti in
relazione con
quello specificato
in <id>
id (del
documento) / GET
http://api.mendeley.com/oapi/documents/authored/<name>/
Lista delle
pubblicazioni
relative all’
autore specificato in <name>
Name / GET
http://api.mendeley.com/oapi/documents/tagged/<tag>/ Lista di
documenti
relative ad uno specificato <tag>
Tag / GET
http://api.mendeley.com/oapi/documents/categories/ Lista delle
categorie
http://api.mendeley.com/oapi/documents
/subcategories/<category id>/
Lista delle
sottocategorie
relative ad una
categoria
specificata in <category_id>
Catogory_id / GET
http://api.mendeley.com/oapi/documents/groups/ Lista di gruppi
presenti su Mendeley
GET
http://api.mendeley.com/oapi/documents/groups/<id>/ Dettagli relativi
ad un gruppo,
come URL
pubblico ecc.. ,
specificato in <id>
Id / GET
http://api.mendeley.com/oapi/documents/
groups/<id>/docs/?details=true
Lista di
documenti
relativi al gruppo
specificato in <id>
Id / GET
http://api.mendeley.com/oapi/documents/groups/<id>/people/ Lista degli utenti
appartententi ad
un gruppo
identificato in
<id>
Id / GET
Tabella metodi pubblici Mendeley API
104
A.3 Tabella dei metodi privati API Mendeley
Indirizzo metodo Risposta Requisiti/
Metodo
http://api.mendeley.com/oapi/library/authors/ Lista dei 5
miglior
autori nella
libreria dell’utente
GET
http://api.mendeley.com/oapi/library/tags/ Tag recenti
utilizzati
nella
libreria
dell’utente
GET
http://api.mendeley.com/oapi/library/publications/ Top 20
papers in libreria
GET
http://api.mendeley.com/oapi/library/ Lista di
tutti i
documenti in libreria
GET
http://api.mendeley.com/oapi/library/documents/authored/ Lista dei
documenti
pubblicati
dall’utente
GET
http://api.mendeley.com/oapi/library/documents/<id>/ Dettagli a
riguardo di
un
documento
identificato in <id>
Id / GET
http://api.mendeley.com/oapi/library/documents/ Crea un
nuovo
documento
da passare
tramite un
oggetto JSON
Oggetto
JSON / POST
http://api.mendeley.com/oapi/library/documents/<id>/ Modifica
ad un
documento
specificato in <id>
Oggetto
JSON, id / POST
http://www.mendeley.com/oapi/library/documents/<id>/ Upload di
un file
id ,
oauth_body
105
specificato in <id>
_hash / PUT
http://api.mendeley.com/oapi/library/documents/<id>/file/<file_hash>/
<group_id>/
Download
di un file
specificato in <id>
id ,
file_hash / GET
http://api.mendeley.com/oapi/library/documents/<id>/ Rimozione
di un file,
specificato
in <id>
dalla
libreria
id /
DELETE
http://api.mendeley.com/oapi/library/groups/ Lista dei
gruppi
presenti in libreria\
GET
http://api.mendeley.com/oapi/library/groups/<group_id>/people/ Lista
persone
registrate
al gruppo
specificato
in
<group_id>
group_id /
GET
http://api.mendeley.com/oapi/library/groups/<group_id>/ Documenti
relativi al
gruppo
specificato
in
<group_id>
group_id /
GET
http://api.mendeley.com/oapi/library/groups/<group_id>/<document_i
d>/
Dettagli
relativi ad
un
documento
,
specificato
in
<document
_id>,
pubblicato
da un
gruppo
identificato
da
<group_id>
group_id ,
document_id / GET
http://api.mendeley.com/oapi/library/groups/<group_id>/folders/ Crea nuova
cartella nel
group_id /
POST
106
gruppo
specificato
in <group_id>
http://api.mendeley.com/oapi/library/groups/<group_id>/folders/<folder_id>/<document_id>/
Cancella
documento
specifico
<document
_id> in una
cartella
specifica di
un gruppo
group_id,
folder_id,
document_i
d /DELETE
http://api.mendeley.com/oapi/library/groups/ Crea nuovo
gruppo
nella libreria
POST
http://api.mendeley.com/oapi/library/groups/<group_id>/ Cancella
gruppo
group_id /
DELETE
http://api.mendeley.com/oapi/library/folders/ Cartelle in
libreria
GET
http://api.mendeley.com/oapi/library/folders/<id>/ Documenti
presenti in
una cartella
specificata
in <id>
id / GET
http://api.mendeley.com/oapi/library/folders/<folder_id>/<doc_id>/ Aggiunge
documento
specificato
in
<document
_id> ad una cartella
folder_id,
document_id / POST
http://api.mendeley.com/oapi/library/folders/ Crea
cartella
POST
http://api.mendeley.com/oapi/library/folders/<id>/ Cancella
cartella
specificata in <id>
id /
DELETE
http://api.mendeley.com/oapi/library/folders/<folder_id>/<doc_id>/ Cancella
un
documento
da una
cartella
folder_id,
doc_id / DELETE
http://api.mendeley.com/oapi/profiles/contacts/ Lista
contatti dell’utente
GET
107
http://api.mendeley.com/oapi/profiles/contacts/<id>/ Permette
all’utente
di
aggiungere
un utente
specificato
in <id> alla
lista
contatti
POST
http://api.mendeley.com/oapi/profiles/info/<profile_id>/ Informazio
ni del
profilo
dell’utente
specificato
in
<profile_id>
GET
Tabella metodi privati Mendeley API
108
Appendice B
B.1 Classe Manage Scopus
109
110
111
112
113
B.2 Query creazione DataBase
114
115
116
B.3 Metodi di matching sulla classe User con KSOAP
117
d c
118
119
120
Bibliografia
[1] Scopus Guida Utenti
[2] http://www.html.it/articoli/introduzione-ad-oauth-20-con-java-1/
[3] http://www.json.org/json-it.html
[4] http://arnetminer.org/introduction#b363
[5] http://wokinfo.com/media/pdf/WoSFS_08_7050.pdf
[6] Corso di programmazione in rete, prof. Pasquale Foggia