Social networks are widely accepted application of Semantic Web technologies and are also interesting for general public. Nowadays there is a lack of quality user-friendly browser which could express meaning of the metadata stored in the most of FOAF profiles and present this knowledge in human-understandable form. The aim of the article is to inform about development of the AFE (Advanced FOAF Explorer) which is intended to perform these services and supersede one similar project.
to restrict the term to on-line social networks. It is an on-line community based on a Website which allows each member to communicate, make friends among other members, to discuss topics which are interesting to this community … FOAF allows to store information about member of any community, the relationships among them (and type of the relation such as friend of someone, parent of someone, enemy of someone, roommates with someone …). This is interesting for most of the people because making contacts, making friends and entertainment are the basic needs of almost everyone. 1.2
The basic explanation is that FOAF is ontology. It is defined using RDF Schema [
an example in XML [
As you can see, the FOAF defines terms for commonly required properties such as
name, mailbox, and gender. But the specification defines many more of them such as
chat IDs for instant messaging services (AIM, ICQ, Jabber, Yahoo!, and MSN), it
allows to state, that any person has a homepage, a weblog, to link depiction, personal
interests. The most interesting property is <foaf:knows> which states that a
person knows any other person. The type of the relation is not defined. If you want to
explicitly define the quality of the relationship between to persons, you have to use
extension RELATIONSHIP [
profile into the code of any Website. You can store your profile in the file and link it to the page using element <link> with parameter rel=”meta”.
can find at http://w3.org/RDF <?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:foaf="http://xmlns.com/foaf/0.1/" <foaf:Person rdf:ID="adam-smith"> <foaf:name>Adam Smith</foaf:name> <foaf:gender>male</foaf:gender> <foaf:mbox rdf:resource="mailto:adam@smith.name" /> <foaf:knows> <foaf:Person> </foaf:Person> </foaf:knows> </foaf:Person> </rdf:RDF> <foaf:name>John Doe</foaf:name> <foaf:knows rdf:resource="#adam-smith"/>
this explorer started was, and why it is called to be “advanced”. In the years in which the FOAF itself was created there was a need for quality and extendible browser which could serve information stored in such profiles to the user in XHTML format.
metadata. But they have various problems. First of all they do not interpret all or at least most of the FOAF terms. If an application interprets all terms, its output does not have a nice look or the information are presented in illogical order so the user is confused and cannot find what he is looking for. They often do not show relations among various resources (people, people and projects ...). Another problem is that FOAF allows easy extendibility and there are many widely used 3rd party extensions.
3
summer 2004. The very first goal was to quickly create first beta-version for viewing of authors’ profiles. Further development should have focused on cleaning the application code and to implements most commonly used FOAF extensions.
3.1
Parsing of the RDF files is done using the library RDF API for PHP [
− URIref of the resource − URIref of the property describing the resource − Auto incremented integer identifying the values of the property.
After that, huge function format_person($data, $model, $id_person) goes through this array and for each resource generates XHTML code which will appear in the output page. It also generates anchors which allow the user to click on it and see the relations between the resources (on the figure 3 there is shown simple output from an existing profile). You can imagine that this solution is quite “dirty”, it lacks any design patterns but it was chosen for quick implementation of the problem.
function get_data_structure ($model) { $res = array(); for ($iter = $model->getStatementIterator(); $iter->hasNext();) { $statement = $iter->next(); $predicate = $statement->getLabelPredicate(); if (!is_array($res)) { if (!is_array($res[$predicate])) {
$res[$predicate] = array(); $res[$predicate][] = $statement->getLabelObject(); } 4 4.1 }
} } return $res;
logic which loads and manipulates with the data. In modern programming languages such as Java or .NET there various frameworks, which allows simple use of the pattern of Model – View – Controller. We can mention Struts2 and JavaServer
of such frameworks. The most advanced is component-driven framework called PRADO3, but it is too complex to be easily implemented. Better way is to implement own simple MVC solution. The new library is based on PHP5 object model. All important components are defined using interfaces andd errors are handled using exceptions.
AfeApplication::run();, the application will recognize name of template from the PHP file name. For index.php is assigned the template views/_index.php. The templates are written also in PHP using foreach construction and using getter methods of all objects from data model.
data in any model object and the calls a viewer which uses given template and according to the instruction views the information. The core class also catches any thrown exception and accesses it by a getter method. Using getter and setter methods is the basic concept of the design of this class – it makes the API clearer.
request variables (information sent by GET or POST methods) as well. Further development of this MVC framework will introduce common configuration files in INI or XML4 format. 4.2
FOAF, it is necessary to store the data about browsed files. To maximally simplify the task, it is designed simple database table containing three columns: URI of the viewed file, date and time when the request was received from a user and count of triples stored in the profile. Data may be store in any relation database but the best for simple use in PHP5 are integrated database SQLite or MySQL 4.1 Both of them offers object-oriented approach to the API (through the SQLiteDatabase, or mysqli object respectively). The structure of the database table is shown in figure 3.
CREATE TABLE ‘history’ ( ‘uri’ VARCHAR(255) NOT NULL, ‘dt’ DATETIME NOT NULL, ‘triples’ INT UNSIGNED NOT NULL,
PRIMARY KEY ( ‘uri’ , ‘dt’ ) );
To create fully persistent approach, there is a class History in the application with methods for loading and saving the data. If it is necessary to change the database, the implementation will be changed only in this class and the rest of the application will be not influenced by this change. The question is if implement this class straight or define an interface and implement classes using drivers for all considered database drivers (which were mentioned previously).
To complete the persistence, there is the object HistoryItem which represents one row from the table. It defines getter and setter methods for manipulation with the data in the object. 4.3
The biggest change from the first version is the data model. Due to ineffective work with the solution of an associative array it was left and now fully object – oriented solution is going to be created. The basic concept is to represent all known RDF resources as classes and their properties as getter methods which return array with values of property of the same type. We can also describe the hierarchy of the resource, e.g. that <foaf:Person> is a subclass of <foaf:Agent> (using keyword extends). It means, that Person may have all of properties, which are defined for the Agent and it also may have some new properties which the Agent does not have. It also allows easily extend the application model. Changing the properties or creating new classes is a question of seconds.
In the Java, the class in the hierarchy of classes is java.lang.Object. Also our data model has a super class which defines common methods and properties.
<rdf:Resource>. There is also interface Labelable which defines one common methods called getCommonLabel(). This method offers label which will appear in the name resource (such as headers or image titles). The code of this interface and the super class RdfResource is shown in the figure 5.
As you can see, the method __toString() is used for testing purposes. It returns the dump of structure of the class. The most interesting method is parseRequiredProperty() it has to be called in the constructor of the model classes for every property which we intend to read from the RDF graph. Note down that it is necessary that if we declare any subclass, we have to send the parameters to the super class otherwise it will not be loaded values of properties defined in the parent classes. interface Labelable {
public function getCommonLabel(); } class RdfResource implements Labelable { private $uriRef; private $rdfType; private $foafName; public function __construct(&$model, &$resource) { $this->uriRef = $resource; $this->parseRequiredProperty($model, $this->rdfType, RDF::TYPE());
$this->parseRequiredProperty($model, $this->foafName, FOAF::NAME()); } protected function parseRequiredProperty(&$model, &$objectProperty, &$property) {
for ($i = $model->find($this->uriRef, $property, NULL)-> getStatementIterator(); $i->hasNext();) { $stmt = $i->next(); if (is_null($objectProperty)) $objectProperty = array();
$objectProperty[] = $stmt->getLabelObject(); } } public function getRdfType() { return $this->rdfType; } public function getFoafName() { return $this->foafName; } public function __toString() { return print_r($this, true); } } } public function getCommonLabel() {
if (count($this->foafName)>0) return explode(', ', $this ->foafName);
else return $this->uriRef->getUri(); Fig. 5. The code of the RdfResource class and the interface Labelable
have to separate labels from the index and output page, store them in one place and create multiple translations. If we consider existing solutions for internationalizations, there is mechanism represented by function gettext5. It is standard for PHP application so it is not necessary to create any other now framework.
these texts into languages different from Czech or English. In sure, that if we
announce new version on the FOAF IRC [
generate data model classes from given RDF Schemas and ontology. Even if it is a good idea, we did not find any existing tool for this purpose. Our project is not targeted to create any kind of this application. But it could be useful for developers from the Semantic Web community. There is space for other developers to implement it …
modules are stored in different files. Some of them are Ontologies in OWL and some of them only RDF Schemas. So this tool should generalize the generate model and ignore some constructions which are not common for RDFS and OWL (and its versions). 5
which extension support – the most important extension is the module
defining a lot of new sub-properties. After that there should not be any problem which could slow down the development. The most important goal of this project is to show that building of any Semantic Web application is not so hard as many of developers think.
After releasing the tool and announcing it to the international FOAF community we expect big interest in the source codes, details about the implementations and volunteers who can create multiple translations. The aim of the project is to pay attention to the Semantic Web, especially FOAF and to promote its using among ordinary (understand non-programmers) users. After finishing all of these tasks, we
can focus on improving our MVC framework, to the development of other RDF tools which may help our author easier build their applications based on RDF graphs.