Social graph is a popular subject due to the time and attention that people have invested in Social Media. Social media has amassed a lot of useful information. The amount of useful information on social media encourages the library of congress to archive our public tweets. People spend so much time on Facebook until it exceeded Google as the number 1 visited site in US. Recruiters are using social media to pre-screen candidates. Examining the social graph of a user gives a lot of valuable information that service providers can use to create a better and richer user experience. Let us look at some of social graph enabling protocol.
I talked about how Web 2.0 extends our relationship beyond interpersonal relationship in the first series of my social graph articles. Web 2.0 extends our relationship to other social objects on the web such as websites or events. The real value of this connection comes when we can identify the type of relationship that we have to these social objects. We can deduce the type of relationship by observing the social gesture or the relationship protocol semantic that we make towards these social objects.
Web 2.0 has enabled us to create a more meaningful gestures on the web. Twitter allows us to retweet conversations in the Twittersphere to indicate that we find that a Tweet bear some value to us. We Digg stories and articles on the web to let others know that these stories worth their time and attention.We bookmarked websites and share them over at Delicious. Bookmarking, Retweeting, Digging are example of social gestures that people can do on the web.
Observing these gesture gives information how we relate to a particular social object. We may deduce that a person likes a particular conversation or stories by looking at their Diggs, Retweets, or Bookmarks. Social gestures enable application developer to give recommendation and personalised content to a user. I will discuss some of the interesting personalisation and recommendation engine on the web in the next series.
Protocol is a set of rules that we abide to exchange information. A protocol helps us define how to put meanings on our relationship with the social objects on the web on the languages that created the web. These protocols are embedded in mark up languages such as HTML or RDF. I will explore some of these protocol and how they help put meaning on our relationship in Web 2.0.
Google Social Graph
Google social graph allow developers to trace sites and people who connects to a user. Google indexes XFN and FOAF pages to define the relationship between the social objects on the net. Google provide a simple interface for application developers to extract meaning from a user social graph. A good starting point with Google Social Graph is by looking through their documentation or joining their discussion groups for FAQ. Google provides a simple URL that developers can call to obtain information on a user social object relationship.
There are two types of social graph relationship that can get from Google. The lookup social graph from Google returns a list of social objects that are connected to me and the their relationship type based on my twitter account.
The graph below is a pictorial representation of a subset of my Google lookup social graph.The ‘me’ arrows show that Google Social Graph thinks that these sites Delicious, Friend Feed, Facebook represents my other self on the web.The ‘Contact’ arrows shows that Aza Raskin and Rob Diana is listed as my contact in Twitter.
The otherme social graph from Google gives application developer an overview a user other social identity on the Web. The diagram below is a pa subset of my social identity according to Google otherme social graph. The otherme social graph recognize that I have Delicious and FriendFeed account.
Google Social Graph derives the social objects by looking at the XFN and FOAF semantic that are attached into these social objects. The next two section gives some introduction on XFN and FOAF. An overview of these 2 social graph standard gives us a better overview on how Google Social Graph works.
XFN Social Graph
FOAF Social Graph
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:admin="http://webns.net/mvcb/"> <foaf:PersonalProfileDocument rdf:about=""> <foaf:maker rdf:resource="#me"/> <foaf:primaryTopic rdf:resource="#me"/> <admin:generatorAgent rdf:resource="http://www.ldodds.com/foaf/foaf-a-matic"/> <admin:errorReportsTo rdf:resource="mailto:email@example.com"/> </foaf:PersonalProfileDocument> <foaf:Person rdf:ID="me"> <foaf:name>Zainul Franciscus</foaf:name> <foaf:title>Mr</foaf:title> <foaf:givenname>Zainul </foaf:givenname> <foaf:family_name>Franciscus</foaf:family_name> <foaf:nick>Zainul</foaf:nick> <foaf:mbox_sha1sum>b26e54382c07faec5d0e595c75e1f62ef6821f80</foaf:mbox_sha1sum> <foaf:homepage rdf:resource="https://zfranciscus.wordpress.com"/> <foaf:knows> <foaf:Person> <foaf:name>One of my friend</foaf:name> <foaf:mbox_sha1sum>e3727c47664d8fc385e92fdbe13676de3a02bb22</foaf:mbox_sha1sum></foaf:Person></foaf:knows></foaf:Person> </rdf:RDF>
We can publish this data through FOAF Bulettin board,or via auto discovery. An FOAF parser can find our FOAF rdf file by looking at the link to our RDF file. We can embed this link inside the <link> tag in an HTML page:
<span style="font-family: Courier New;"><html> <head> <link rel="meta" type="application/rdf+xml" title="FOAF" href="foaf.rdf" /> </head> <body> ... </body> </html></span>
The open graph protocol was originally developed in Facebook. Open graph protocol provides a set of meta tag in an HTML document to define social object relationship on the net. Below is an example of an Open Graph implementation in IMDB:
<span style="font-family: Courier New;"><html xmlns:og="http://opengraphprotocol.org/schema/"> <head> <title>The Rock (1996)</title> <meta property="og:title" content="The Rock" /> <meta property="og:type" content="movie" /> <meta property="og:url" content="http://www.imdb.com/title/tt0117500/" /> <meta property="og:image" content="http://ia.media-imdb.com/images/rock.jpg" /> ... </head> ... </html> </span>
At the time of writing this blog, open graph let us define a website by attaching the following metadata (1) basic metadata (title, type, image, url), (2) location, (3) contact, (4) Object Type (activity, business, groups, organisation, places, products and entertainment, websites).
The table below summarizes each feature of these graph:
||API or Parser
|XFN||Humanistic qualities such as friendship or romance||Embedding attributes in HTML anchor tag.|
|FOAF||Contact information such email, work phone, website, school||Generating an RDF file.|
|Open Graph||Define the structure and intention of a website||Embedding HTML meta tags|
Valuing Each Graph Contribution
Each social graph protocol provide different semantic and allow application provider to measure different relationship type between the social objects on the net. XFN tends to help user define their personal relationship qualities with other users on the net. XFN allow us to define our relationship in term of ‘humanistic’ relationship such as ‘Friendship’ , ‘Romance’, ‘Colleague’, etc. FOAF allow us to define our contact information on the net in great detail. FOAF acts like our business card on the net. Open Graph allow user to define their website structure. Open Graph allow web page producer to define the website intention and purpose on the net.
Imagine a website has an FOAF reader that reads through the our published FOAF RDF File and auto create or suggest a profile based on the RDF. This will save a lot of time re creating the same profile information every time we create an account in different website. Social Media aggregator such as Giza Page, Xeesm, or Google Profile can crawl through our XFN tag in wordpress blog or twitter page to consolidate the different website that we are connected to. This will save our time in specifying each of our accounts on the net in different websites. Web site producers can include the OpenGraph tag to define the purpose of their website, allowing search engines to get more relevant information for a user.
Web producer can realize the full potential of these social graph protocol by combining their semantics. For example, If my friend want to find out where I am, a search engine can look for location based websites that specify ‘location’ OpenGraph meta tag. The search engine can crawl through these location based website and use Google Social Graph to figure out which one I am connected to. My friends will then be able to visit each one of these websites to see my location based activity to get a glimpse on where I am or what particular events I am participating.
There are a lot of technologies aimed to enrich the relationship meaning between the social objects on the web. The next series of my post will review technology such as Facebook like button that enrich our relationship between these objects.
My Articles On Social Graph: