Semantic web browser

Semantic Web
Browser
1/24/2011
Faculty of Computer Science, University of Al. I.Cuza, Iasi, Romania
Butnaru Maria; Dorofte Andra-Calina, Iarca Daniela

2 Butnaru Maria; Dorofte Andra Calina; Iarca Daniela

CONTENT

1. Introduction

2. Theory
2.1. RDF – Resource Description Framework
2.2. FOAF – Friend of a Friend
2.3. EndPoint
2.4. SPARQL
2.5. OpenID
2.6. Google Search Mash Up
2.7 . Youtube Api
2.8. Retrieving related videos
2.9. Google Api
2.10 SemWeb.Net
2.11 MemoryStore

3. Crocoo
3.1. Description

4. Conclusion

5. Future work

Semantic Web Browser 3

Semantic Web Browser

Butnaru Maria; Dorofte Andra Calina; Iarca Daniela

Abstract Provide a solution for Semantic Web issues - metadata vocabularies,
ontological modeling resources, automated reasoning according to user profile -
within a Web browser. It focused on issues such as automatic classification of
sites visited by the user, with some similar references in terms of content or
design.

Keywords: semantic web, metadata vocabularies, rdf, foaf, openid, google
search api, youtube api, mashup, dotnetAuth, SemWeb.NET

1 Introduction

With the emergence of the World Wide Web, analyzing and improving
Web communication has become essential to adapt the Web content to the
visitors' expectations.
Semantic Web is a mesh of information linked up in such a way as to
be easily processed by machines, on a global scale. You can think of it as
being an efficient way of representing data on the World Wide Web, or as a
globally linked database.
The main purpose of the Semantic Web is driving the evolution of the
current Web by allowing users to use it to its full potential thus allowing users
to find, share, and combine information more easily. The Semantic Web, on
the other hand, is about having data as well as documents on the Web so that
machines can process, transform, assemble, and even act on the data in useful
ways.
The Semantic Web agent does not include artificial intelligence –
rather, it relies on structured sets of information and inference rules that allow
it to “understand” the relationship between different data resources. The
computer doesn’t really understand information the way a human can, but it
has enough information to make logical connections and decisions.
Crocoo is a web application which offers to the user a mashed up
information about searches via world wide web. The mash up is made with
YouTube and Google. To keep the users information and profile data, we use
RDF, composed only by FOAF tags. Also in this data base we store a top 5


topic interests of the user. To grab the information from the RDF we use
SPARQL Query.

2 Theory

2.1 RDF – Resource Description Framework

The Semantic Web is generally built on syntaxes which use URIs to
represent data, usually in triples based structures. A triple can simply be
described as three URIs. A language which utilises three URIs in such a way
is called RDF
RDF is an abstract model, a way to break down knowledge into
discrete pieces, and while it is most popularly known for its RDF/XML
syntax, RDF can be stored in a variety of formats.
RDF is a general method to decompose knowledge into small pieces,
with some rules about the semantics, or meaning, of those pieces. RDF
statements are often referred to as “triples” that consist of a subject, predicate,
and object, which correspond to a resource (subject) a property (predicate),
and a property value (object). By creating triples with subjects, predicates, and
objects, RDF allows machines to make logical assertions based on the
associations between subjects and objects.

2.2 FOAF – Friend of a Friend
This ontology is used to describe people and social relationship on the
Web. It is mostly focused on people's existence in the virtual world, with
many properties related to online activity or identity
A popular application of the semantic web is Friend of a Friend (or
FoaF), which uses RDF to describe the relationships people have to other
people and the "things" around them. FOAF permits intelligent agents to
make sense of the thousands of connections people have with each other, their
jobs and the items important to their lives; connections that may or may not
be enumerated in searches using traditional web search engines. Because the
connections are so vast in number, human interpretation of the information
may not be the best way of analyzing them.
FOAF is an example of how the Semantic Web attempts to make use
of the relationships within a social context.


2.3 End Point
Every service is associated with an address that defines where the
service is, a binding that defines how to communicate with the service, and a
contract that defines what the service does. The endpoint is the fusion of the
address, contract, and binding.
Every endpoint must have all three elements, and the host exposes the
endpoint.
Conceptually, even in C# or VB, an interface is an endpoint: the
address is the memory address of the type’s virtual table, the binding is CLR
JIT compiling, and the contract is the interface itself. Because in classic .NET
programming you never deal with addresses or bindings, you take them for
granted.

2.4 SPARQL

SPARQL is the standard query language for the Semantic Web and
can be used to query over large volumes of RDF data. dotNetRDF provides
support for querying both over local in-memory data using it's own SPARQL
implementation and for querying remote data using SPARQL endpoints or
through other stores SPARQL implementations.

2.5 OpenID
Third-party web sites and applications can now let visitors sign in using
their Google user accounts. Federated Login, based on the OpenID standard,
frees users from having to set up separate login accounts for different web
sites--and frees web site developers from the task of implementing login
authentication measures. OpenID achieves this goal by providing a framework
in which users can establish an account with an OpenID provider, such as
Google, and use that account to sign into any web site that accepts OpenIDs.
Google supports the OpenID 2.0 protocol, providing authentication
support as an OpenID provider. On request from a third-party site, Google
authenticates users who are signing in with an existing Google account, and
returns to the third-party site an identifier that the site can use to recognize the
user. This identifier is consistent, enabling the third-party site to recognize the
user across multiple sessions.


2.6 Google Search Mash Up
Third-party web sites and applications can now let visitors sign in using
their Google user accounts. Federated Login, based on the OpenID standard,
frees users from having to set up separate login accounts for different web
sites--and frees web site developers from the task of implementing login
authentication measures. OpenID achieves this goal by providing a framework
in which users can establish an account with an OpenID provider, such as
Google, and use that account to sign into any web site that accepts OpenIDs.

Google supports the OpenID 2.0 protocol, providing authentication
support as an OpenID provider. On request from a third-party site, Google
authenticates users who are signing in with an existing Google account, and
returns to the third-party site an identifier that the site can use to recognize the
user. This identifier is consistent, enabling the third-party site to recognize the
user across multiple sessions.

2.7 Youtube Api
The YouTube APIs and Tools enable you to integrate YouTube's video
content and functionality into your website, software application, or device.
We incorporate YouTube functionality into our own application
performing searches after tags or see related content.
The YouTube Data API provides standard feeds selected based on a
variety of criteria. Standard feeds are sitewide rather than user-specific. They
contain lists of videos that either reflect YouTube user behavior, such as top-
rated and most viewed video feeds.

2.8 Retrieving related videos
Each video entry in a video feed identifies the URL for another video feed
that contains videos related to the entry, as determined by YouTube. The
following code shows how to retrieve and print information about the related
videos for a particular Video.

Uri videoEntryUrl = new
Uri("http://gdata.youtube.com/feeds/api/videos/ADos_xW4_J0");
Video video = request.Retrieve<Video>(videoEntryUrl);
Feed<Video> relatedVideos = request.GetRelatedVideos(video);
printVideoFeed(relatedVideos);


2.9 Googpe API
The Google API stands for ‘Application Programmable Interface’. As it’s
name implies, it is an interface that queries the Google database to help
programmers in the development of their applications.
Google API’s consist basically of specialized Web services and programs
and specialized scripts that enable Internet application developers to better
find and process information on the Web. In essence, Google APIs can be
used as an added resource in their applications.

2.10 SemWeb.Net
We use SemWeb.NET , a Semantic Web/RDF open-source library
written in C sharp. The library can be used for reading and writing RDF
(XML, N3), keeping RDF in persistent storage (memory, MySQL, etc.),
querying persistent storage via simple graph matching and SPARQL, and
making SPARQL queries to remote endpoints. Limited RDFS and general-
purpose inferencing is also possible. SemWeb's API is straight-forward and
flexible.

2.11 Memory Store

The MemoryStore is the main storage mechanism for small amounts of
data.

Although the MemoryStore inherits from Store, which can be used to
group multiple data sources together, it is illegal to call AddSource on a
MemoryStore.

3 Crocoo

3.1 Description
We have an ASP.NET MVC application that have both public and private
features. Typically this is done by implementing an authentication /
authorization gateway to gain access to the private features. We use OpenID
to provide an authentication layer.

 Authentication – You are who you say you are. The application
knows your identity.


 Authorization – Based upon your identity (via Authentication), the
application provides access to features. Public access is provided to
base features. Private access to enhanced features.

OpenID allows you to use an existing account to sign in to multiple
websites, without needing to create new passwords. With OpenID, you
control how much of that information is shared with the websites you visit.
With OpenID, your password is only given to your identity provider, and
that provider then confirms your identity to the websites you visit. Other than
your provider, no website ever sees your password, so you don’t need to
worry about an unscrupulous or insecure website compromising your identity.

Our web application starts by presenting an area that allows the user
to log in by offering a set of log-in options, including using their Google or
Yahoo account., or to sign up for an new openid using myopenid.com or
myid.net, as authentication providers. The following screenshot shows this
area.

Clicking on one of the providers starts the authentication process.
OpenID uses a series of redirects to get the user authenticated. The key is that
the authentication occurs on the provider’s site and that’s where the
passwords are stored. Clicking one of the above providers results in a post to
our application’s server. Our server then redirects to the provider’s server
(after possible adding information to the post data). Here is a screenshot of the
myopenid.com authentication page after the redirect to the myopenid.com
provider.


OR

Clicking the “Agree” or “Allow” button causes post to the
myopenid.com servers and another redirect. This time back to our
application’s server. This redirect includes information about you that is
supplied by the OpenID providers. At minimum the redirect supplies a
‘username’ back to the application. After you are in the user’s page, if the user
is connecting for the first time to Crocoo, a new <foaf: Person> tag is made.
The <foaf:nick> tag receive the user’s id and all the other tags get “none”.


Our application can then look up the ‘username’ in the database to
determine if the user is allowed access. Users that are allowed access will
have the above login area swapped out for a panel that provides access to
features only available to authenticated users. The username and your picture
are now displayed. The search area and other buttons are now available. The
following screenshot is an example.

After you logged in successfully, the user can edit his/her profile, find or add
friends, and he/she can see some video from youtube classified by tags, links,
images, video or news collected with yahoo search api. You may see other
video recommended for you from your friends, or last viewed. In the edit
profile area the user can edit his/her profile by mentioning surname, first
name, gender, e-mail address and browsing a profile picture.


In the RDF file the tags that have “none” value are replaced with the value
from the text box from the profile.

We use Google search api within our asp .net application to retrieve
photos from the Google photo sharing service using a variety of feeds - public
photos and videos, favorites, friends, news, discussions, and more. We display
them on the page, according with the search. Responses can be formatted in
XML.


We use dotnetopenauth 3.2 to implement Openid in an ASP.NET
project. We get the username (or email address) when the user logs in by
sending a FetchRequest for email marked as a required attribute.
The OpenIdRelyingParty.GetResponse() method returns an
IAuthenticationResponse interface that has a ClaimedIdentifier property on it
you can get.

When using the youtube search api you can find videos in two
different ways: searching via tags or via “full sentence”. I recommend to
search via tags because videos are saved by word keys ( categories ). These
categories are saved in rdf in the topic interest tag and then we can use them
to recommend to show users other videos related to the one already saw.


One of the most important features of our application is on the find
friend page. Here, with the help of the one of the most rigorous sparql queries
we find all the users with surname provided by the Crocoo’s client and return
all the profiles that exists. You can also select one of them and press the Add
friend button. When pressing it, in the RDF file is created a new node called
<foaf:knows> tag. The value of this tag is the selected person’s nick.
On recommended for you link,you parse the rdf and get the last search
of the user. After that, you are moved to youtube and retrieve the most 5
related videos for that topic.

4 Conclusions

Our application is more a mashup one, and it can be use by anyone who
want to have a more precise and detailed search without open all search tools.
The user will receive also some recommendations related with his/her
searched words or others viewed by their friends. We think that this
application can be used like a real browser because it offers diverse
possibilities of search and half of the user’s searches are saved in a rdf data
base and then used to get relevant information ( blogs, pictures, videos, web
sites, books, news ).


5 Future plans

This application can be improved by adding other functions and
utilities. For example a classification related with the user’s interests. The
idea : user1 is friend with user2, user 2 likes topic1, then, user1 may like
topic1. To classify all sites viewed by user in good and bad ones, in
correlation with their feelings about the topic.
The most important update for this application can be changing it into
an extension.


References

1. http://www.asp.net/

2. http://www.rankforsales.com/google-api-s-and-their-uses.html

3. http://infomesh.net/2001/swintro/

4. http://razor.occams.info/code/semweb/

5. wikipedia.org

6. http://www.altova.com/semantic_web.html

7. http://www.fiftyfoureleven.com/

8. http://en.csharp-
online.net/WCF_Essentials%E2%80%94Endpoints

9. http://openid.net/

Semantic web browser

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

Similar a Semantic web browser

Similar a Semantic web browser (20)

Semantic web browser