This paper presents from a theoretical point of view the idea of having web User Interface components that are fully described via RDF. Also, we offer a close look on the possibility of generating these components by a MDA framework starting from their RDF description as a model. The final part of the paper settles some future directions for both RDF and MDA and presents some conclusions regarding this approach.

1. RDF based User Interfaces
Ungureanu Vlad-Costel1 and Honciuc Irina1
Computer Science Faculty, ”Al. I. Cuza” University of Iasi
Software Systems Engineering specialization
Abstract. This paper presents from a theoretical point of view the idea
of having web User Interface components that are fully described via
RDF. Also, we offer a close look on the possibility of generating these
components by a MDA framework starting from their RDF description
as a model. The final part of the paper settles some future directions
for both RDF and MDA and presents some conclusions regarding this
approach.
1 Introduction
If you have ever used a search engine then you probably know that the results of
a search are not always what you where looking for. Not that the search engine
didn’t do a good job, but rather the page you ended up at didn’t contain the
information you where searching for. To give you an example, let’s say I typed
”James Cameron Avatar Trailer” in Google [10]. The search returned 2.800.000
results, out of which only the first two links on page one actually led to pages
containing the actual trailer for the movie. The other three or four just contained
the specified words.
Now, imagine you had an option in Google to enable it to show you only
those pages that actually had a media component that could display the trailer
and that component was correctly bound to ”James Cameron Avatar” trailer,
seen as a resource on a major social network (for example). To further refine the
search you could, theoretically, ask Google to find only those pages that also had
a component for a list of links, representing the cast, a component for rating,
and a component for a large chunk of text all correctly bound to the previously
named resource.
Let’s consider another example in which you were fortunate enough to catch
on film a happy moment in your life and, of course, you want to share it with
the rest of the world, with the help of a social network. What if, instead of
going over the huge list of links Wikipedia [15] provides in order to find a social
network site that allows movies upload, you could tell the search engine to look
for those social network sites that have an upload component and a movie gallery
component on them. Of course people that have been socializing over the web
for a long time know exactly where to go, but new users (old people, teenagers,
people from third world countries) might want a little help adjusting to the
magnitude of the World Wide Web.

2. 2 Ungureanu Vlad-Costel and Honciuc Irina
One last example of this Interface Based Word Wide Web would by repre-
sented by the existence of a specialized framework that could either create a
desired user interface based on abstract description, while holding the seman-
tics intact, or creating a user interface for a certain service based on the same
principle.
Based on the concepts presented in the previous examples we will discuss the
technologies and concepts that could help us shape this special kind of Web, re-
ferring to: User Interfaces (UI) as resources, Resource Description Format (RDF)
as an abstract means for describing the interfaces, Model Driven Architecture
(MDA) as architectural pattern that would allow UI generation based on some
abstraction and finally to some examples on how all this could be achieved (at
least on a theoretical level).
1.1 Motivation
You could consider this as a manifest for the importance of User Interface, but
the argument we present in this paper makes a clear point. It so happens that
most people are ”wired” in such a way that, when they encounter something new
they judge it by the way it looks. This does not mean people are shallow, but
rather that they are adapted to get involved with only the things that appeal to
them. As an example consider the following situation: will a person buy a suit
that he/she thinks is very ugly only because it is cheap, practical and has a high
quality? No, any market researcher will tell you that most people will buy the
suit that they like the most regardless of the previously mentioned qualities, this
is why we have Marketing. It becomes our concern when we want to promote a
service in the web, not to trick people in visiting our web page, but rather to
keep the user interested until we can present the functionality of a good looking
application. This is why User Interface plays a immense role in getting users to
use your application rather than look for something else.
2 User Interfaces as Resources
Since we already mentioned that the Interface Based World Wide Web, we should
put an emphasis on the subject. At the moment we have several distinct views
over the web that try to put some sort of order in the multitude of resources,
services, and information the web is made up of. We could say that the web
is a repository for various documents, movies and images and we would not be
far from the truth. Most of the web is centered around sharing information like
news, facts, research, personal information with the rest of the world. In order
to use this specific type of web you have to be able to search it based on key
words that you think are contained in web pages, regardless of what they mean
(their semantics).
Another way the web could be seen is as a provider of services. You find
the service you need, like e-mail, organizer, on-line shop or even more complex
applications, you create an account, pay a fee if required and you can use all

3. RDF based User Interfaces 3
these services without downloads, installations, costly hardware upgrades. In
order to use this type of web you need to have the required third party software
(browser, plug-in, runtime environments) and a way to locate a certain service
on the web. While most third party software is free the real problem is locating
the service you desire. Ever tried typing ”mail” in your search engine? Locating
the necessary web mail service can prove rather difficult when you can chose
from more than 544.000.000 results.
And of course there is the social web, a place where people gather to share
their unique personalities, thoughts, opinions [11]. The social web provides the
mean to find and get to socialize with people form any part of the world, any
race, culture or language, braking the barriers of space and prejudice. But, as
previously stated finding the right social site for your needs might prove a little
too difficult, making all that socializing not that tempting.
What if there was another way to see the web, a way that does not change
anything in the present structure, but rather extends the semantics of the web.
What if a piece of information, a service, or a social entity was also defined by the
functionality it literally posses or exposes? We are referring to a way which allows
for the actual user interface components to be described in terms of semantics
and functionality, like the media component we spoke of previously. Such a web
would then be based on the functionality it can offer the user (for example:
digital signatures for the company email) or the functionality it provides for it’s
user (for example: social networks based on image galleries like ”Lumea e Mica”
[13] or ”Hi5” [12]).
We will try to describe the attributes of a Interfaces Based Web in order to
provide a definition for it. First, the perception of the interface should change
into seeing components as actual resources. For this, an interface should hold
some value, in order to quantify the components importance inside a page. The
value of the component could be given by:
– functionality: what functionality it exposes compared to other similar compo-
nents. For example an upload movie component that allows multiple format
types;
– complexity: while complexity is sometimes a good thing, most of the time
a heavy function component is both slow and rather hard to use. A simple
component with complex functionality should be ranked higher;
– technology: the technology used to generate the component should count
in terms of speed, performance and the services it can encapsulate. Some
technologies better suited for image galleries while others may have higher
performance in handling multiple parallel Ajax requests;
– related components: while a certain component might offer exactly what is
expected of it, the other components of a page might lack many desired
features. For example: an organizer that has a drag and drop calendar but
has a limited address book, no alerts and only allows for 20 characters of
details for each planed activity.
Now that we have covered the importance of the components we should
focus on the request, or more precisely the people that would be interested in

4. 4 Ungureanu Vlad-Costel and Honciuc Irina
user interface components. The main issue is getting people to care about the
components found in the pages they visit. In this case the people might care
(and they actually do) about some of these factors:
– simplicity: a service that does a great job after 30 minutes of page navigation
is a very poor service;
– features: aside from actual content (which is rarely the main concern) the
features held in the page make the biggest impact. For example: a news site
with the best news ever, with the best graphics ever and with no search is
almost useless;
– design: while for constant users of a service this doesn’t mean a lot, for new
users the design is crucial. Take into consideration ”Craig’s List”’s [14] previ-
ous design that chased away a lot of people. Several features seem mandatory
out of which we can name: links to all main pages from each page and paging
for more that 10 items.
We can conclude that user interface components might hold a value and that
higher ranking components might be more desirable than lower raking ones.
With this in mind we are ready to give a definition to the Interface Based World
Wide Web: the web in which components hold a value based on the qualities
that the users considered most important and in which navigation and usage
depend on the given value of the interface. As complicated as it might sound a
shorter version should be sufficeint: the web in which the UI matters.
3 Resource Description Framework
RDF (Resource Description Framework) represents a method of describing and
modeling information about web resources [6, 9]. In RDF, the statements about
web resources respect the subject-predicate-object format. This is also called a
RDF triple. The subject refers to the resource, and the predicate denotes at-
tributes of the object or expresses the relations between the subject and the
object. The object is the resource that is referred by the predicate or it en-
capsulates a value. For example, the statement ”Surrealism is a current.” can
be expressed by a RDF triple in which the subject is ”Surrealism”, the predi-
cate ”is a” denotes ”belongs to” and expresses the relation between the subject
(surrealism) and the object (painting current).
Both the subject and the object of the triple are resources that can be found
at a specific URL. The predicate is also a resource that has a URL and describes
a relationship. Note that the object could also be a blank node, in this case
we don’t know what is the value, but we know it exists. We can state that a
collection of RDF triples form a labeled, directed graph so we could look at a
future (web or webs) as a larger graph formed by RDF triples. The labels on
this graph edges are actualy the predicates in the triples.
RDF has multiple serialization formats. The most common is the XML for-
mat, but there are also Notation 3 or N3, Turtle and N-Triple formats. A simple
example of a RDF triple expressed in XML format is listed below:

5. RDF based User Interfaces 5
RDF fragment in XML format
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="http://en.wikipedia.org/wiki/Ren%C3%A9_Magritte">
<painting:currents>Surrealism<painting:currents>
</rdf:Description>
</rdf:RDF>
The example above states that the ”painting current” attribute of the resource
at http://en.wikipedia.org/wiki/Ren%C3%A9_Magritte is Surrealism.
RDF is also a key element in semantic web. The RDF notation is supposed
to provide ”a formal description of concepts, terms, and relationships within a
given knowledge domain.” [7] The main idea that describes a semantic web is
that information is linked at a global scale, forming a large database that offers
an eficient way of retrieving relevant data about anything. [8] The RDF is like
a building block in semantic web because it offers the possibility of describing
data and associate an actual meaning (a semantic) to it.
4 Model Driven Architecture
The objective of the Model Driven Architecture [4, 5] is to generate code for soft-
ware applications starting from abstract specifications offered as models. MDA
is used to develop, compare, verify and transform models (UML, XML) or meta-
models (CWM - ”common warehouse model”). The architecture of a software
application is model driven if:
– the software application can create and modify models and metamodels;
– the models can be verifyed against the modeling language;
– the models can be coneverted to metamodels and backwards;
– there can be represented relationships between models (inheritance, multi-
plicity, etc.);
– starting from the models and metamodels we can obtain a part of another
application or even an application.
There are some steps that apply in order to obtain an application that has a
model driven architecture:
– describe each aspect of the application: logic, functionality, persistency, ob-
jects, interactions;
– after obtaining complete specifications, a modelling tool is used to create
the model of the application; this step also includes setting the relationships
between objects and describing the application logic;
– after the model is created, a MDA tool is used (any application or frame-
work that can generate code starting from a model) to obtain a part of the
application or the whole application);
– after verifying the correctness of the generated code (its sintax), the appli-
cation is finalized by adding the code that couldn’t be generated from the
model, such as actions and navigation rules.

6. 6 Ungureanu Vlad-Costel and Honciuc Irina
MDA has some important advantages, such as:
– it’s easy to integrate with programming, software engineering and struc-
ture standards because any portion of generated code can have a predefined
shape, reflecting the actual rules and necesities;
– we can reuse parts of the application by inserting the model we used in
another application’s model;
– the developing time is decreased because a large part of the code is auto-
matically generated from the model;
– it avoids repetivive code like ”user interface code” (especially for web/enterprise
applications)
MDA has also some disadvantages. Although there are unchanged standars and
concepts, MDA depends also on some less theoretical aspects. For example,
the lack of a language that can model actions (like xtUML which is just pure
theoretical) limits the possibilities of generating application code for actions and
navigations rules. Also, when integrating with databases or persistency models,
a model driven architecture is hard to adapt to changes in schemas or other
structures because the code generation is done starting from a statical model.
Also, in order to work with MDA it’s necessary to have strong knowledge in
programming languages, databases and persistency, UML tools, etc.
5 A RDF-UI Framework
In order to describe the development of an Interface Based World Wide Web we
can take a step by step approach into how this would be implemented. We have
seen that RDF offers a way to abstractly describe any resource we want. An
UI should make no exception from this, so the first step would be describing a
certain UI component with the help of RDF. While there are many vocabularies
for RDF none of them can properly serve in describing an interface. At the same
time it is not the purpose of this paper to propose such a vocabulary, so keeping
that in mind, we will exemplify a possible RDF description of an interface:
RDF description for an interface
<rdf:component rdf:url="link_to_page_containing target_component">
<rdf:description rdf:about="#ui_componet_name" >
<rdf:association rdf:resource="#semantic_resource" />
<rdf:type rdf:media="movie_clip_upload"/>
<rdf:media_format rtf:format="avi" />
<rdf:media_format rtf:format="mvk" />
<rdf:media_format rtf:format="mpeg" />
</rdf:type>
<rdf: property rdf:size="10" rdf:measure="mb"/>
<rdf:description>
</rdf:component>

7. RDF based User Interfaces 7
The RDF example above describes a user interface named ”ui component name”
that has the type ”movie clip upload” and can be found at the specified URL
address. Further more the upload components is known to support three specific
formats for clips not larger than 10MB. If you are looking for a video share site
with support for .MKV format then this component is the one you need.
The next step is to describe the referenced component is such a way that a
MDA framework could interpret it and generate the desired component. Note
that with the definition of a suitable RDF vocabulary the first step could be
applied to the existing web with little effort. At the same time it would prove
more efficient to generate the component based on the same RDF file, since the
generated component will encapsulate all the elements of the description thus
adding reliability to the Interface Based World Wide Web.
RDF description for a component
<rdf:ui rdf:ui_component="ui_component_name">
<rdf:ui_element rdf:entity="entity_that_encapsulate_movie_upload"
<rdf:ui_element rdf:ui_type="file_upload" rdf:field="file_field_in_entity" />
<rdf:ui_element rdf:ui_type="button" rdf:action="method_in_entity" />
</rdf:ui>
Using this abstract description a MDA framework could generate a ”file
upload” as an input text field followed by a ”browse button”. The selected
file would be associated with a file object in the specified entity. It would also
generate another button that will have associated the upload method also defined
in the entity. The third step would be to add the component to a web page and
to associate the RDF to that page. Even though the MDA framework is not to
be neglected in the integration of RDF with UI, the process seems simple and
practical. Regardless of the implementation methods and technology used, the
MDA framework based on the RDF description would provide a multitude of
benefits to this approach out of which the most important are:
– reducing development time because new application would use already cre-
ated components, while the developers would only need to develop compo-
nents for the new functionality;
– continuity in usage methods, design and functionality over an entire web site
or web application;
– the possibility of using various technologies that best suite the functionality
exposed in the UI. For example a PHP component for the picture gallery
and a Java component for uploading and encoding pictures;
– adding semantic meaning to the information presented by the component
with the help of RDF. For example, the RDF could present the service the
component provides, the information that is presented in the component and
even if other entities have recommended it, for its high value.

8. 8 Ungureanu Vlad-Costel and Honciuc Irina
6 Further development
We proposed a model in which an abstraction could describe a UI component and
could facilitate it’s generation by a MDA framework, so we can now go deeper
into the subject and talk a little about the technical challenges this approach
would represent.
RDF is now beginning to receive more attention even though the specifica-
tions were finalized five years ago. Of course, none of the major search engines
base their searches on this format and it may still take a while before this could
become a key feature. On it’s own, RDF proves to be powerful and flexible, but
in the current context it may allow faulty descriptions of the UI components
both in terms of semantics and logic. For example you could describe a user
interface like in the previous example as a cosmetic product as long as RDF
remains lacked of any measure of control. The last point about RDF challenges
refers to the query language that lacks the simplicity and power of the stan-
dard SQL (joins, unions, views, procedures, agregates, etc.,). In time, solutions
for all this problems may be provided as more and more people put effort into
development.
MDA has seen it’s first steps several times until now and it still lacks the
maturity and the standardization that a good architecture requires. Several at-
tempts have been made to raise the MDA standards, some even being suited
for commercial use [1, 2]. Even so, dynamic generation of components based on
highly abstractions (like XML and similar formats) are still in a theoretical stage
[3]. MDA still has a long way to go before it can facilitate RDF based UI, but
the possibilities seem promising enough to make it worth the effort.
7 Conclusions
Starting form a technological point of view, the Web is not yet ready to adopt
the RDF based User Interface, but from what we have seen this changes might
prove a great step forward for the enhancement of the user experience. From a
theoretical point of view this approach promises to facilitate the development
process for most applications and the association of semantics to actual compo-
nents. Several emerging technologies provide a good starting point, with some
minor problems that can be easily overcome.
The web can benefit from the appearance of a new perspective in which visual
components play a major role both in functionality and in structure, as the UI
can describe itself, the content it has and based on this description it can also
generate itself using the technology that you choose.
Last, but not least, the association of two technologies that are currently at
the beginning of their evolution can only prove constructive for both of them.
As a personal opinion, we believe that such a Web would become easier to use
since the exact functionality you need in a web page may be only a search away.

9. RDF based User Interfaces 9
References
1. Andromeda, http://www.andromda.org/
2. JMatter, http://jmatter.org/
3. Frasinaru, Cristian; Ungureanu, Vlad-Costel: ”A generic component approach for
dynamic generation of user interfaces”, 2009, RoCHI Conference.
4. http://www.omg.org/mda
5. http://www.ibm.com/developerworks/rational/library/3100.html
6. http://en.wikipedia.org/wiki/Resource_Description_Framework
7. http://en.wikipedia.org/wiki/Semantic_web
8. http://infomesh.net/2001/swintro/
9. http://profs.info.uaic.ro/~busaco/teach/courses/wade/presentations/
web03RDF-ResourceDescriptionFramework.pdf
10. http://www.google.com
11. http://en.wikipedia.org/wiki/Social_network
12. http://hi5.com/
13. http://www.lumeaemica.ro/
14. http://www.craigslist.org/about/sites
15. http://en.wikipedia.org/