Another login, another password checking, another… Boooring. Given the nature of the application I decided that this time I could cut the mess down and go only with the «Use your Google account» “one click” login. Why not? Lot of people have an google account already and it’s OpenID!

The usual Google documentation page is this one. The good news is that if you follow this guide you probably will not need to read that whole page :) Later on you should integrate this very document with the Google one.

The first thing to know is that you are going to write an OpenID client/consumer. OpenID 2 protocol is indeed the system behind the whole client/server scenario from your application (the client) and the Google accounting system (the server). I have to assume that you know what that means (at an high level, at least). The examples here are in PHP and below I will provide some sample code for you to play with.

OK; so here are the relevant points:

• This one is theoretical, but it’s how Google deployed the OpenID protocol on top of his already existing authentication system. Normally, in a “pure” OpenID environment, during the login process the user will give you his/her openid identifier (an URL); using that identifier your program will discover (via the Yadis protocol) which is the corresponding server party to talk to for the authentication process. In the Google scenario you don’t know which is the user’s OpenID identifier (the user, of course, is not even aware that there’s something like “openid” involved in the way s/he logs in). You have NOT to ask her for her “google account”; you have to make him press a button or follow a link to “Login with your Google account”. But you DO know who you have to ask for protocol informations and not have to infer it from the user’s OpenID (technically, a discovery process is needed anyway). Upon a succesfull login you WILL have the user’s OpenID identifier; it’s something like a generated string, not choosen by the user and crafted by Google itself.
• You need a recent OpenID library that supports OpenID 2.0 XRI and Yadis discovery. This excludes (as for now) the Zend Framework OpenID component (it does support OpenID 2.0, but not the discovery part in the version Google uses). Too bad. You then need to go straight to the JanRain library
• Don’t bother thinking about Simple Registration (SREG): Google does support the more advanced (and useful) Attribute Exchange (AX) extension only
• Speaking of profile data, there is nothing much you can get: email, name and surname. I noticed that unless you specify each one as mandatory (within the AX request), the user is not even asked – by Google – to give them to you. There’s probably somethng I misunderstood, but this is it.

On your side, the login process will consist of two distint phases: one that initiates the login process the and one that finalizes it.

Normally you point your “Login with Google…” link to the script that implements the initiation phase (let’s say “login.php”). The finalize script (let’s say “finalize.php”) will be called by the Google server as per protocol. There is a lot more to know about the OpenID process, of course, but the library should hide the gory details for you.

The login script will immediately and trasparently forward the user to the real Google account login page. The finalize script will have the logic that checks if the authentication has been succesfull or not and act consequently.

I’m about to show you some code, but keep in mind that this is NOT valid PHP code; I want you to understand what’s going on rather than being able to just copy/paste. To further limit clutter I did not even add basic error checking. Please check the JanRain library examples for full fledged (and working) code.

So, for the login process:

# Requires the needed JanRain scripts
require_once "Auth/OpenID/Consumer.php";
require_once "Auth/OpenID/FileStore.php";
require_once "Auth/OpenID/AX.php";

# Setup the library (leaved blank on purpose).
# Will also create the $store variable used below
...

$consumer = new Auth_OpenID_Consumer($store);

$auth_request = $consumer->begin("https://www.google.com/accounts/o8/id");

# Create attribute request object (this is where you prepare the Attribute Exchange request)
$attribute = array();
$attribute[] = Auth_OpenID_AX_AttrInfo::make('http://axschema.org/contact/email', 2, true, 'email');
$attribute[] = Auth_OpenID_AX_AttrInfo::make('http://axschema.org/namePerson/first', 1, false, 'firstname');
$attribute[] = Auth_OpenID_AX_AttrInfo::make('http://axschema.org/namePerson/last', 1, false, 'lastname');

# Create AX fetch request
$ax = new Auth_OpenID_AX_FetchRequest();

# Add attributes to AX fetch request
foreach($attribute as $attr){
  $ax->add($attr);
}

$auth_request->addExtension($ax);

$return_to = sprintf("http://%s:%s%s/finalize.php", $_SERVER['SERVER_NAME'], $_SERVER['SERVER_PORT'], dirname($_SERVER['PHP_SELF']));
$trust_root = sprintf("http://%s:%s%s/", $_SERVER['SERVER_NAME'], $_SERVER['SERVER_PORT'], dirname($_SERVER['PHP_SELF']));

$form_html = $auth_request->htmlMarkup($trust_root, $return_to, false, array('id' => 'openid_message'));

# This will actually redirect to Google
print $form_html;

This is what I have in my finalize.php script:

# Requires the needed JanRain scripts
require_once "Auth/OpenID/Consumer.php";
require_once "Auth/OpenID/FileStore.php";
require_once "Auth/OpenID/AX.php";

# Setup the library (leaved blank on purpose).
# Will also create the $store variable used below
...

$consumer = new Auth_OpenID_Consumer($store);

$return_to = sprintf("http://%s:%s%s/finalize.php", $_SERVER['SERVER_NAME'], $_SERVER['SERVER_PORT'], dirname($_SERVER['PHP_SELF']));
$response = $consumer->complete($return_to);

$msg = '';

switch($response->status) {

  case Auth_OpenID_CANCEL:
    # This means the authentication was cancelled by the user
    $msg = 'Verification cancelled.';
    break;

  case Auth_OpenID_FAILURE:
    $msg = "OpenID authentication failed: " . $response->message;
    break;

  case Auth_OpenID_SUCCESS:
    # "$openid" is the user openid given by Google
    $openid = $response->getDisplayIdentifier();
    $ax_resp = Auth_OpenID_AX_FetchResponse::fromSuccessResponse($response);
    # Here you could save the user data in session for further references...
    ...

    # Redirect the user to her dashboard
    header('Location: /account');
    exit();

}

Si è fatto tanto parlare in questi giorni di questa faccenda, ovvero del fatto che Google si sia comprata una delle maggiori e più innovative aziende che fanno business con il famoso, mai troppo compreso web semantico.

Recentemente, per conto di un progettino di cui mi sto occupando, ho cercato di capire un po’ meglio chi siano e cosa fanno questi di Metaweb. Sono rimasto abbastanza impressionato, ma avrei desiderato un qualcosa di più. In questo articolo cercherò di mettere in chiaro quello che ho capito e quali potrebbero essere i risvolti per Google e anche in che modo Freebase e Metaweb possono già essere utili a tutti noi (e lo sono già da un po’, a dire il vero).

Prima di tutto, chi sono e cosa fanno? Freebase e Metaweb sono due entità distinte, accomunate dalle persone che le gestiscono: la prima, che si definisce un social database, offre un enorme repository organizzato e maniacalmente categorizzato di entità (immaginate una entità come fosse “Harry potter” o “Steve Mc Queen” o l’”iPhone4″ o “La regina d’inghilterra”). Al momento sono catalogate 12 milioni di queste entità. Il secondo – Metaweb – cerca di fare business utilizzando come base dati il repository di Freebase implementando, per esempio, algoritmi di correlazione tra queste entità.

Dove sta la “ricchezza” di Freebase? Freebase non è un database qualunque, non è un semplice elenco di robe suddiviso per categorie. Ha diverse caratteristiche molto interessanti e peculiari (oltre alla sue notevoli dimensioni).

• ogni entità è definita primariamente dal suo tipo (raggruppati poi in domini), come ad esempio “Persona”, “Persona morta”, “Imbarcazione”, “Libro” – si noti che esiste anche il concetto di eredità tra tipologie, in quanto una “Persona morta” è comunque una “Persona” – , e da un set di proprietà o attributi che la definiscono, come “lunghezza”, “numero di posti”, “colore”, eccetera. L’insieme di questi attributi costituisce lo schema di ogni tipo e, come si può, intuire, esistono decine di diversi schemi contenenti le singole precise caratteristiche di ogni entità. In altri termini, lo schema altro non è che l’ontologia del type dell’entità.
• questa categorizzazione e alimentazione dei dati è fatto sia dal team di Freebase che dalla sua comunità. Un po’ come Wikipedia, chiunque può aggiungere schemi, tipi o alimentare la base dati di schemi di entità già presenti.
• tutti i dati dentro Freebase sono utilizzabili secondo le licenze Creative Commons (versione 3.0).

Dunque c’è uno sforzo enorme dietro Freebase: uno sforzo concettuale (la creazione degli schemi), uno sforzo manuale (il recupero, l’alimentazione e l’aggiornamento delle basi dati) e un sforzo iniziale derivato dalla costruzione e dalla messa in opera di un meccanismo siffatto che fosse al contempo rigoroso e scalabile. La difficoltà di creare e mantenere un sistema del genere si intuisce anche leggendo le pagine relative al capitolo Challenges del wiki di freebase (vi si accede dalla home page).

L’accesso a questa enorme base dati è permesso attraverso tecniche all’avanguardia: non solo un set di API che ritornano JSON e JSONP, ma anche un vero e proprio linguaggio per l’interrogazione degli stessi, il MQL. E come se non bastasse si sono inventati pure ACRE, un sistema per scrivere direttamente (dal sito stesso, ebbene sì), e ospitare piccole applicazioni verticali che possono sfruttare direttamente l’intera base dati.

Una delle attività più importanti fatta da Freebase all’interno della sua base dati è relativa a:

• accorgersi che due entità con lo stesso nome siano in effetti due entità distinte (Henry Ford l’industriale e Henry Ford il giocatore di baseball)
• accorgersi che “presidente del consiglio italiano” e “silvio berlusconi” siano OGGI la stessa entità (per questo si fa uso di un tipo di proprietà che si chiama CVT), oppure risolvere tutti i problemi relativi agli acronimi e nomi simili; nel video introduttivo, sul sito di Metaweb, è il caso del termine Boston.

Tutto molto bello e potente, condito da un sito web moderno ed efficiente (sebbene non intuitivissimo da usare, se non sai esattamente quello che cerchi. Forse un poco ancora troppo “accademico”).

È dunque questo il famoso web semantico? No, affatto. Freebase è solo un maestoso strumento che mi può aiutare a fare applicazioni e siti che – loro sì – potranno creare il web semantico. Il fatto che all’interno dell’entità relativa a Tom Hanks sia presente la sua pagina di Wikipedia e il suo account Twitter non serve a niente, se non ho qualcosa che mi esponga in superficie questa informazione e, soprattutto, la metta in correlazione con altre informazioni (magari di tipo diverso). Fare browsing all’interno della base dati di Freebase è un po’ come fare browsing nel CD di Encarta (passatemi il paragone ai limiti dell’offensivo).

Ci vuole dunque qualcuno che prenda questa informazioni e ci faccia qualcosa di utile.

Questo è il mestiere di Metaweb. Di massima offre i seguenti servizi:

• consulenze per integrare le ricerche in Freebase all’interno del dominio di informazioni del cliente (es: in una testata giornalistica) o per collegare i “topic” del cliente ai “topic” di Freebase (se il cliente gestisce i film, avrà sicuramente già una propria catalogazione degli stessi, che deve essere mappata sulla catalogazione di Freebase)
• offrire un sistema di correlazione tra le entità (non ho trovato traccia neanche di esempi, sul sito. Immagino si tratti di tecnologia proprietaria)
• offre due strumenti utilizzabili da tutti, gratuitamente: un sistema sofisticato di autocomplete ajax sulla base dati Freebase (utile anche per offrire un sistema di tagging molto intelligente), e un plugin per WordPress (e altre piattaforme di blogging) per inserire dei “flayout” contenenti informazioni addizionali e integrative relativamente a ciò che vogliamo (es: dell’azienda o del personaggio di cui stiamo parlando). I dati vengono prelevati un po’ dappertutto, non solo da Freebase, e sono presenti anche dati molto recenti come le news headlines. Potete provare questo sistema dalla pagina dei topicblock.

Cosa se ne può fare Google, dunque, di questo sistema?

Prima di tutto potrebbe riprendere un po’ di terreno rispetto a Bing, visto che se non ho capito male la Microsoft un paio di anni fa aveva acquistato un’azienda con skill simili (Powerset) e ne sta già usando la tecnologia per fornire risposte più sensate alle query sul suo motore di ricerca.

Poi sappiamo tutti, ormai è lampante, che con la quantità e la tipologia di fonti di informazioni che ci sono oggi, la semplice ricerca testuale non basta più. Occorre investire in strumenti semantici, davvero, che capiscano il contesto e che magari si adattino al mio personale pattern di ricerca. Chissà.

L’importante, ma questo è stato apertamente dichiarato, è che Freebase rimanga free.

Se siete interessati all’argomento, vi consiglio caldamente la visione del simpaticissimo video in home page del sito Metaweb.

Quando sposti un marker trascinandolo (dragging…), appena lo lasci quello… boing, boing, boing… rimbalza con un effetto molto figo.

Ho pensato “Uh, ganzo, adesso lo faccio palleggiare appena lo CREO, ‘sto marker“… Eh NO!… non si può… anzi, si può perché loro (biG) lo sanno fare. Ma non è documentato… e se non è documentato TI ATTACCHI perché il codice non lo puoi leggere :)

Non c’è scampo: il software proprietario è SEMPRE, per un motivo o per l’altro, UNA MERDA (quando lo è il FOSS, puoi perlmeno modificartelo).

Amore & Odio