IMPROVING THE USABILITY OF INTEGRATED APPLICATIONS … · Improving Integrated Applications by...

International Journal of Computer Science and Applicationsc© Technomathematics Research Foundation

Vol. 8 No. 2, pp. 1 - 37, 2011

IMPROVING THE USABILITY OF INTEGRATED APPLICATIONS

BY USING INTERACTIVE VISUALIZATIONS OF LINKED DATA

HEIKO PAULHEIM

Technische Universitat Darmstadt

Knowledge Engineering GroupDarmstadt, Germany

[email protected]

http://www.ke.tu-darmstadt.de/staff/heiko-paulheim

Today, data is contained in many different, heterogeneous information systems. For turn-

ing that data into valuable information, those systems need to be integrated. System

integration on the user interface level, e.g., in portals or mashups, allows users to accessmultiple applications in parallel and explore the information contained therein while

reusing familiar and powerful user interfaces. Linked data can significantly add value by

allowing uniform access to the data contained in the systems, and by letting reasonersdiscover hidden, non-explicit knowledge from that data. A common ontology may serve

as a shared conceptualization for unifying different implementation models in a single

visual representation.In this paper, we present an approach combining both paradigms, i.e., integrated user

interfaces and visualization of linked data. A framework for integrating user interfaces

is enhanced by the Semantic Data Explorer, which is interlinked with the integratedapplications in a hybrid view. With a quantitative user study conducted in the emergency

management area, we show that hybrid visualizations of annotated data help gatheringinformation from integrated systems, even for users who are not trained with ontologies

and semantic networks.

Keywords: Linked Data, Visualization, Application Integration, User Interfaces,

Performance

1. Introduction

Today, data is most often contained in different, heterogeneous information sys-

tems. A typical information worker has various information needs, which he typi-

cally satisfies by looking up information in different of those information systems

and combining it manually [Hardman et al., 2009]. Applications are more often

isolated from each other than integrated with each other, and they may use differ-

ent vocabularies and presentation mechanisms for providing information to the end

user. Furthermore, the amount of available information is generally very large and

growing larger. These factors make information search a task of finding a needle not

only in one haystack, but in a stack of somewhat related, heterogeneous haystacks.

1

2 Heiko Paulheim

Different remedies have been proposed to ease this task. One is the integration of

applications and their existing user interfaces, e.g., in portals or mash-ups [Daniel

et al., 2007]. These approaches have the advantages that a large degree of reuse

is achieved, as whole applications, including their user interfaces, are reused and

combined to new systems. Furthermore, users already trained with the individual

applications have a steep learning curve when operating the integrated system. As

an additional benefit of UI integration, the reused powerful user interfaces do not

only provide sophisticated ways for displaying, but also for creating and manipulat-

ing data. On the other hand, each of the integrated user interfaces provides access

to only a part of the complete information, but there is no single point of interaction

with all information.

Another promising approach, developed mainly by the semantic web community,

is the linked data approach [Bizer et al., 2009a]. Information systems can publish

their information as linked data – basically RDF representations of the data con-

taining links to data contained in the same or other systems. To this end, the

systems provide endpoints which deliver RDF data at dereferencable URIs – i.e.,

URIs that are used as identifiers for resources and, at the same time, as pointers

to additional information on those resources. SPARQL [W3C, 2008] may be used

as a unified querying language across the different data sets. If formal ontologies

are used for defining the categories and relations of linked data, reasoners may run

on combinations of linked data providers and draw conclusions from information

contained in different systems, i.e., discover implicit knowledge.

Applications consuming linked data can use that data, and additional knowledge

discovered by reasoning, and provide a meaningful user interface to the whole set

of information – such as a query interface or a visual browser. However, those

interfaces are then isolated from the information systems’ original user interfaces.

Furthermore, despite the presence of different linked data editors [Davies et al., 2010;

Luczak-Rosch and Heese, 2009], created and edited linked data cannot easily be fed

back into the original information systems – thus, in many cases, it is still a one

way street from the information system to the end user [Berners-Lee et al., 2009],

and the user interfaces to linked data are typically less powerful than original user

interfaces. Furthermore, as linked data is an approach for data integration, not to

UI integration, the degree of reuse is typically lower, as new user interfaces are

required [Paulheim and Probst, 2010a].

Table 1 lists some of the main benefits both of integrated UIs and of linked

data. It shows that integrated user interfaces could gain additional value from the

combination with visualized linked data. In this paper, we present the Semantic

Data Explorer, which visualizes the data contained in integrated applications. The

platform underlying the Semantic Data Explorer consumes linked data provided

by the applications and uses a reasoner for inferring implicit information. We have

integrated the Semantic Data Explorer in a framework for user interface integration.

The result is a powerful solution of an integrated information system which provides

Improving Integrated Applications by Using Interactive Visualizations of Linked Data 3

Integrated

User Interfaces

Visualized

Linked Data

Powerful legacy UIs + -

Large degree of reuse + -

Overview on whole dataset - +

Inferred implicit knowledge - +

Table 1. Comparison of the main benefits that UI integration and linked data can provide.

access to information both through the original user interfaces and through an

integrated view on the underlying data.

In a case study from the field of emergency response, where users have to com-

bine large amounts of information from different systems for quickly gathering an

overview on a catastrophic situation, we show how visualized linked data and an in-

tegrated user interface provide efficient access to information. With a user study, we

show that our approach leads to better usability of integrated information systems,

even for users not particularly trained with ontologies and semantic networks.

The rest of this paper is structured as follows. Section 2 provides an overview

of related work both on UI integration and on visualization of linked data. Section

3 introduces our framework for user interface integration, as well as the Semantic

Data Explorer, and describes their implementation. Section 4 presents a case study

from the emergency management domain used for an evaluation with end users,

and discusses the evaluation results. We conclude with a summary and an outlook

on future work.

2. Related Work

User interface integration as well as visualization of semantic and linked data have

been well researched in isolation of each other. This section gives a brief overview

of the state of the art in both areas.

2.1. User Interface Integration

Application integration on the user interface level, or UI integration for short, is a

technique for integrating software systems in a way that, following Fowler’s three

layer model [Fowler, 2003], all three layers of the integrated software systems (data

storage, business logic, and user interface) can be reused [Daniel et al., 2007].

One of the first approaches to UI integration was Snap Together [North and

Shneiderman, 2000], an approach which couples the data views of different ap-

plications. It uses a set of fixed events and operations to provide various ways of

coupling, such as synchronized scrolling and highlighting, coordinated overview and

detail views, etc.

4 Heiko Paulheim

Portals are frameworks that provide access to several applications with a com-

mon access point, typically combined with features such as single sign on [Wege,

2002]. Applications are encapsulated in portlets, e.g., using the JSR-268 stan-

dard [Heppner, 2008]. Besides the JSR-268 reference implementation Apache Pluto

[Apache Software Foundation, 2010], examples for well-known portal platforms are

JBoss GateIn Portal [JBoss Community, 2011], IBM WebSphere [IBM Corporation,

2008], and SAP Netweaver Portal [SAP AG, 2011].

While portals are targeted at professional developers, mashup platforms follow

the vision of providing skilled end users with the possibility to assemble different

applications [Yu et al., 2008]. The result is most often web-based, with different

views on data running in one web platform and some reasonable amount of in-

teraction possible between them. While the often-cited Yahoo Pipes [Yahoo! Inc.,

2011] is rather a tool for mashing up data than user interfaces, popular UI mashup

platforms are Google Mashup Editor [Google Inc., 2010] (meanwhile discontinued),

JackBe Presto [JackBe Corporation, 2011], Intel MashMaker [Ennals, 2010], and

IBM Mashup Center [IBM Corporation, 2010].

There are also some non-web-based approaches to integration on the user inter-

face level. Microsoft has proposed component application blocks (CAB) [Microsoft

Corporation, 2005], as well as the more recent Prism [Microsoft Corporation, 2010].

Both are restricted to integrating Microsoft/.NET based user interfaces. A well-

known approach for Java applications in the Eclipse Rich Client Platform (RPC)

[Rubel, 2006; Birsan, 2005], which underlies the widespread Eclipse integrated de-

velopment environment.

There is also a number of prototypes from academia. Besides the already men-

tioned Snap Together, notable appraoches are the Open Interface Workbench [Law-

son et al., 2009], CRUISe [Pietschmann et al., 2009b], as well as Mixup [Daniel and

Matera, 2008] and mashART [Daniel et al., 2009]. Unlike the approaches discussed

above, most of these prototypes are based on proprietary modeling languages –

CIDL [Lawson, 2008] used in the Open Interface Workbench, UISDL [Pietschmann

et al., 2009a] used in CRUISe, XPIL used in Mixup, and MDL and UCL used in

mashART. All those languages are proprietary to the respective approaches. In

contrast, the prototype discussed in [Kotsalis, 2009] is built upon the user interface

description language UsiXML [Vanderdonckt, 2005], a language which has a larger

adoption in the user interface development community.

Most of the approaches to application integration on the user interface level

share a common set of shortcomings. In [Daniel et al., 2007], the authors name

the lack of formal models and limited capabilities for event exchange between in-

tegrated applications as current shortcomings of UI integration approaches. While

some of the prototypes from academia aim at creating formal models, those are

typically proprietary, XML-based languages with little prevalence and tool sup-

port. Furthermore, most of the approaches are focused on one technology (such as

.NET or web-based user interfaces) and cannot cope with technologically hetero-


geneous user interfaces [Paulheim and Erdogan, 2010], and the support for data

exchange involving a transformation between different, heterogeneous data mod-

els is most often very rare. Therefore, it is hard to achieve seamlessly integrated

user interfaces with current approaches, especially if technically and conceptu-

ally heterogeneous applications are involved. In our previous works on UI inte-

gration, we have presented an approach using ontologies, which are a widely rec-

ognized representation formalism, for overcoming those issues [Paulheim, 2010b;

Paulheim and Probst, 2010a]. We will briefly sketch that approach in section 3.1.

2.2. Visualization of Linked Data

Linked data, or data annotated with ontologies, can be used for different purposes

in user interfaces. For example, the presentation of information can be improved by

adding visualizations and explanations, the usability can be enhanced by providing

input assistance and ontology-based browsing of information, and automatically

generated help may be provided to the user. A detailed survey on the usages of

ontologies and annotated data in user interfaces is given in [Paulheim and Probst,

2010b]. Visualization of linked data falls into the category of ontology-based brows-

ing of information, where semantic annotation of data is used for supporting the

exploration of that data.

As linked data builds upon the RDF standard, visualizing linked data is strongly

related to visualizing RDF data. Many ontology authoring tools and suites come

with a number of graphical views of RDF and ontology data. For example, the

ontology engineering tool Protege, the most widespread in its field [Cardoso, 2007],

comes with plugins such as IsaViz, OwlViz, or Jambalaya, all providing different

visual representations of ontologies and RDF data [Lanzenberger et al., 2009].

Among the variety of other generic RDF visualization tools, two of the best-

known are RDFGravity [Goyal and Westenthaler, 2004], and the visualization pro-

vided by the W3C’s RDF validation service [W3C, 2007]. They display the graph

underlying an RDF document, showing each resource and literal as a node and each

predicate as an arc between the respective nodes. RDF graphs can also be interac-

tive, i.e., allowing user interactions such as opening and closing nodes or rearranging

the graph, as demonstrated in [Schmitt et al., 2010].

Linked data is special as it does not consist of a single document holding a whole

RDF graph, but is distributed, either across different information systems within an

organization, or even across the whole web. Various tools have been developed for

accessing linked data which respect this distributed nature of linked data. Examples

for straight forward linked data browsers are Disco [Bizer and Gauß, 2007], Marbles

[Bizer et al., 2009c], and Zitgist DataViewer [Open Linked Software, 2009], which

essentially provide a navigable triple representation without any graphical visual-

ization, although some of them resolve links to images, such as foaf:depiction,

by displaying the image. A refined approach is taken by Sig.Ma [Tummarello et al.,

6 Heiko Paulheim

2010], which provides additional features, such as data consolidation and advanced

labeling of properties.

Tabulator [Berners-Lee et al., 2006] was one of the first tools for browsing linked

data. Its basic view presents a tree-like structure of the starting concept, with

each relation unfolding a new level containing the related concepts. Furthermore,

it contains specialized map and timeline views for visualizing spatial and temporal

relations.

Fenfire [Hastrup et al., 2008] provides a straight-forward graph view of linked

data, allowing the user to start from a resource and see all the linked resources. The

user can follow links to browse the graph of linked data. Fenfire also provides some

basic editing functionality of the underlying RDF data.

Humboldt [Kobilarov and Dickinson, 2008] is a tool that allows for querying,

searching, and browsing linked data, offering faceted browsing and pivoting (i.e.

using one facet of the result as the starting point for the next query) for filtering

and exploring results. The authors also present a qualitative evaluation with a

group of semantic web researchers, showing that the users can use the tool for

finding information in linked data with little effort. Explorator [de Araujo and

Schwabe, 2009] is another linked data browser based on facets, which allows users to

directly manipulate result sets with set operators. The recently discussed extension

RExplorator [Cohen and Schwabe, 2010] allows for reusing and recombining those

facets. A user study presented by the authors shows that the tool is better suitable

for users with prior knowledge on the underlying formalisms, such as RDF and

ontologies.

visR [Weiss et al., 2008] is a tool for browsing and editing linked data. It features

a hybrid view, showing the RDF triples as well as a graph view of the underyling

data in parallel in two synchronized views. The authors also present a user study

with a group of semantic web engineers where they both evaluate qualitative feed-

back, as well as quantitative data such as the completion time for different tasks.

DBpedia Mobile [Becker and Bizer, 2008], based on Marbles (see above), is an

example for providing linked data based on the user’s location. The mobile ap-

plication provides information from DBpedia [Bizer et al., 2009c], a large online

database containing information about persons, cities, places, etc., and provides it

to the user on a mobile phone. The user may configure different filters according to

his information needs.

RelFinder [Lohmann et al., 2010] is a specialized tool which, unlike the ones

discussed so far, does not use one, but two concepts within linked data to start

with, and finds and visualizes links between those two concepts. It is thus a tool

directed at knowledge discovery in linked data, which creates explanations for a

specific query (i.e., the relation of two things).

Fusion [de Araujo et al., 2010] aims at mapping application models to linked

data and thereby providing customized, application specific views on linked data,

and also provides means to locally store additional data, which can be merged with


data from other endpoints. The user interface provides various means of assistance

to the user, such as automatic discovery of paths.

ThinkPedia and ThinkBase [Hirsch et al., 2009] provide a hybrid view on Wiki-

pedia and Freebase, respectively, combining an RDF graph view with the original

user interfaces. The authors present a qualitative, but not a quantitative user study.

A similar approach is presented with SemanticWonderCloud [Mirizzi et al., 2010],

which provides a visual interface to DBPedia, combining explicit relations with

statistical information, such as the usage of concepts for tagging.

Bridging information silos with semantic web technologies is a topic also ad-

dressed by the semantic desktop [Sauermann et al., 2005]. In projects such as

Haystack [Quan et al., 2003] and IRIS [Cheyer et al., 2005], tools have been devel-

oped which allow for accessing data in different desktop applications by providing

explicit semantic annotations and visual representations of those. In [Groza et al.,

2009], an approach is presented which enriches data on the semantic desktop with

information drawn from the linked open data cloud.

The approach presented in this paper is different from most of the works dis-

cussed above in two main aspects: first, it combines legacy user interfaces and

visualized linked data to a hybrid view involving arbitrary legacy systems, and sec-

ond, it is targeted as the domain expert as an end user, not a semantic web expert.

Consequently, we present a quantitative user study which also encompasses users

who are not experienced in the semantic web area, and analyze our results with

respect to prior experience with ontologies and semantic networks.

3. Prototype

The main objective of this paper is to demonstrate the value that visualized

linked data can add to integrated applications, especially integrated user inter-

faces. Therefore, we have integrated our Semantic Data Explorer into a framework

for integration of applications on the user interface level. This framework provides

means for combining technologically heterogeneous applications and enabling cross-

application interactions while preserving the original interfaces.

3.1. An Ontology-based Framework for Application Integration on

the User Interface Level

Our framework follows the rationale that all parts of existing applications, includ-

ing their user interfaces, can be reused, and that users can work with mashed-up

applications that they already know, instead of having to learn how to operate

on a new user interface. While ontologies have been proposed as a means for in-

tegrating user interfaces already some years ago [Rauschmayer, 2005], our frame-

work is the first running prototype of such an approach. We use ontologies for

describing both the technical components of the integrated applications’ user in-

terfaces and the information objects they process [Paulheim and Probst, 2010a;

8 Heiko Paulheim

Paulheim, 2011]. The framework is written in Java and based on the OntoBroker

infrastructure [Decker et al., 1999].

Figure 1 shows the framework’s basic architecture. Each application which is

integrated with our framework runs in a container. There are different container

implementations for each UI technology, i.e., a Java container, a Flex container, etc.

This allows for the integration of heterogeneous UIs to one coherent system [Paul-

heim and Erdogan, 2010]. Each container provides different services for performing

the application integration:

• An event handling service is used to exchange events with other compo-

nents. To this end, each application is connected to a central event bus. The

event handling service is also responsible for semantically annotating each

event, so it can be unambiguously interpreted by each recipient. Being the

main communication means between applications, events can be raised by

and lead to invocations of both an application’s user interface and business

logic.

• A drag and drop handling service provides special functionality for enabling

drag and drop across applications, especially across applications developed

with different underlying UI technologies, such as Flex and Java [Paulheim

and Erdogan, 2010]. It keeps track of drag and drop operations across ap-

plications, makes the respective components provide visual feedback, and

handles the objects that are dragged and dropped. The drag and drop ser-

vice uses the event handling service for coordination with other containers.

• An object transformation service transforms information objects from the

application into a common RDF format, as well as objects serialized as

RDF back into the applications’ own information object format. To allow

for maximum flexibility with respect to different object model, we use a

rule-based approach for object transformation (see section 3.2. This allows

for an automated exchange of objects between applications with different

underlying object models, as well as different technological platforms [Paul-

heim, 2010b].

• A linked data provider service keeps track of the different UI components,

their states, and the information objects they process, and provides that

information to the central reasoner as linked data. The linked data endpoint

utilizes the object transformation service for creating RDF representations

from the underlying applications’ objects.

When integrating applications, it is often desirable to establish links between

information objects from those applications in a new way that has not been foreseen

by the developers of the original applications. For example, one might want to link

contact data from an address book to paper authors in a literature database. As

neither the address book’s nor the literature database’s data model provides a means

to store those links, they have to be stored in a separate component. To that end,


Central Event Processor

Eve

nt

Ha

nd

ling

Reasoning Module

A-b

ox C

on

ne

cto

r

T-b

ox C

on

ne

cto

r

Link Repository

Application Container



Application

User Interface

Business Logic

Data Storage

invoke update

read write

Eve

nt H

an

dlin

g

Dra

g a

nd

Dro

p

Ha

nd

ling

Lin

ke

d D

ata

Pro

vid

er

Ob

ject

Tra

nsfo

rma

tio

n

read

read

useuse

de

leg

ate

dis

trib

ute

invoke

invoke

Annotation

Rulesuse

Application

Ontology

Event Bus

UI and Inter-

actions

Ontology

Real World

Domain

Ontology

access

read

read

rea

d

Link Storage

Eve

nt H

an

dlin

g

Lin

ke

d D

ata

Pro

vid

er

Lin

k C

rea

tor

invoke

write

rea

d

access

invo

ke u

se

use

Inte

gra

tio

n

Ru

les

pro

ce

ss

Figure 1. Architecture of our integration framework. The figure shows the containers for Flex

and Java applications. Each container may be instantiated multiple times for integrating differentapplications.

10 Heiko Paulheim

Central Event

Processor

T-box

Connector

A-box

Connector

initialize (1)

load

integration

rules

Application

Container

Linked Data

Provider

instantiate (2)

initialize

register

notifyassign base

URI

Object Trans-

formation Service

user interaction (3)

send event

Reasoning

Module

query (4)

request application

ontology

read t-box

data

read a-box

data (5) request

object

encode

object (6)

notify (7)

reaction (8)

decode

object

Application in which

the event was

triggered

Application reacting

to the event

Each Application

For each applicationIntegration framework

Any applications

from which instance

data is required

Figure 2. Sequence diagram of the event processing process. As a simplification, it only shows one

application container and omits the link repository, as well as the details of the event exchange.Usually, the container sending an event and the container notified to perform a reaction will not

be the same.

our framework provides a link repository where such links may be stored [Braune

et al., 2011]. This repository, like the application containers, provides its data as

linked data, and it may exchange events with containers.

One key design rationale of the integration framework was that the integrated

applications should be only loosely coupled, i.e., that no direct dependencies should

be introduced between applications, e.g., by making applications register event lis-

teners with other applications. Thus, a central event processor has been introduced

which serves as an indirection between the integrated applications. By means of

the central event processor, no application container communicates directly with


Figure 3. Screen shot of the Semantic Data Explorer (SDE)

other containers, but all communication is coordinated at a central point, thus re-

ducing the complexity and increasing the maintainability of the integrated system

[Paulheim, 2010b].

This central event processor uses a reasoner, which computes reactions to the

events issued by each application. The reasoner, which is also connected to the

central event bus, uses three different types of input for computing the results:

• Different domain ontologies. A domain ontology of user interfaces and in-

teractions is used to define basic categories of objects (such as widgets,

windows, controls, ...) as well as events (such as select, drag, drop, ...) that

can be used to describe user interfaces and their components. A real world

domain ontology defines the real world items the application deals with

(such as books or customers). Application ontologies can define concepts

for specific applications based on those ontologies.

Those ontologies are used to annotate both the data provided by the

linked data providers and the events emitted by each application. The on-

tologies are provided to the reasoner by the T-box connector.

• Instance data, describing the system’s current state, as well as the infor-

mation objects that are processed by each integrated application. This

information is made available by the individual applications’ linked data

12 Heiko Paulheim

providers (see above) and read into the reasoner by the A-box connector.

The A-box connector addresses the linked data providers dynamically when-

ever information from any of those endpoints is needed to resolve a query.

Section 3.4 describes the high-performance implementation of A-box con-

nectors in more detail.

• Integration rules define the desired interactions between the integrated ap-

plications and provide the wiring of those applications. Essentially, an in-

tegration rule is an Event-Condition-Action (ECA) rule [Anicic and Sto-

janovic, 2008], which uses the vocabulary of the different ontologies for for-

mulating events, conditions, and actions. In our framework, we use F-Logic

[Angele and Lausen, 2009] for formalizing those rules.

The following example of linking views, i.e. highlighting related objects [Eick and

Wills, 1995], illustrates how the framework works in detail. The underlying integra-

tion rule states that upon a selection event with an object, all applications which

hold information objects representing the same object are required to highlight

those information objects. The corresponding logic rule looks as follows [Paulheim,

2010a]:

∀?ua, ?ut, ?co1, ?d1, ?co2, ?d2, ?o : user activity(?ua)

∧ activate task(?ut) ∧ sequences(?ut, ?ua)

∧ computational object(?co1) ∧ use of(?ua, ?co1)

∧ data(?d1) ∧ realizes(?co1, ?d1)

∧ visualcomputational object(?co2)

∧ data(?d2) ∧ realizes(?co2, ?d2)

∧ identifies(?d1, ?o) ∧ identifies(?d2, ?o)

⇒ ∃?ca, ?ct : computational activity(?ca)

∧ causally follows(?ca, ?ua)

∧ highlight(?ct) ∧ sequences(?ct, ?ca)

∧ use of(?ca, ?co2) (1)

The rule states that whenever the user performs an activity which corresponds

to an activation taska, all visual objects identifying the same real world object (such

as a customer) are highlighted as a consequence of that task. Figure 2 shows the

steps performed to process this rule and facilitate the corresponding interaction:

(1) During system startup, the integration rules are loaded into the reasoner.

aThe separation of activities and tasks is done in accordance to the DOLCE DnS top level ontol-

ogy [Masolo et al., 2003]. It allows for supporting different types of interactions, such as mouse,keyboard, touch or speech interactions, which all implement the abstract task of activating an

object [Paulheim and Probst, 2011].


(2) When a new container is instantiated, the corresponding linked data provider

is set up and registered at the A-box connector. It is assigned a base URI to

use for creating URIs for the objects it provides. Furthermore, the application

ontology for the contained application is loaded by the T-box connector.

(3) When the user selects an object, the corresponding annotated event is sent via

the event bus. The event contains the URIs of the selected information objects

and the component that the event was performed with.

(4) The central event processor’s event exchange service reads the event and queries

the reasoner for reactions.

(5) The reasoner uses the A-box connector to resolve the URIs of components and

information objects delivered with the event and retrieve the corresponding

instance data. As the interaction rules may require more information about

other components and related information objects, the A-box connector queries

the applications’ linked data providers for the required data, while the required

T-box data can be delivered directly by the T-box connector.

(6) When an object is requested from a linked data provider, the container’s object

transformation services are used to provide the required information, i.e. an

RDF representation of the requested object.

(7) Based on the results of the integration rules, the reasoner answers the query. In

the particular example, the result list contains the action of highlighting objects

related to the object selected by the user.

(8) The central event processor sends events to notify the applications to perform

the respective actions.

(9) Each notified application receives the event, decodes the object contained

therein using its object transformation service, and performs the highlighting

action as a reaction.

Other interactions between applications can be defined and processed similarly.

Those include interactions involving data input actions requiring input in different

applications (e.g. customer data in one application and accounting data in a dif-

ferent application) or drag and drop between applications. For the latter case, our

framework also allows highlighting suitable drop locations and augmenting them

with tool tips when the user starts dragging an object, thus supporting the user

in understanding the interaction possibilities of the integrated system [Paulheim,

2010a].

Creating links in the integrated system works similar to cross-application inter-

actions: an integration rule is defined, stating that, e.g., whenever the user drops an

address book entry in the address book application to an author in a bibliography

application, a link between the two should be created. When the drop event occurs,

the reasoner evaluates the rule and sends the respective event to the link repos-

itory, which creates and stores the link and makes it available through its linked

data provider service.

14 Heiko Paulheim

Person

name : String

sex : Sex

«enumeration»

Sex

MALE = 1

FEMALE = 2

Person

Man Woman

NamehasName

:p0 rdf:type :Man.

:p0 :hasName "Peter".

Figure 4. A typical mismatch between an implementation model (left) and an ontology (middle).

The RDF representation of the object using the ontology (right) cannot be created with a simple1:1 mapping between the implementation model and the ontology.

3.2. Lifting Data from Implementation Models to Ontologies

The applications which are used in an integrated scenario may be heterogeneous

both with respect to the underlying technology (such as the programming language)

as well as the conceptualization manifested in the class model. Thus, the framework

has to be able to cope with technological as well as conceptual heterogeneity. Espe-

cially when using a common ontology as a shared conceptualization for exchanging

and visualizing data, the data represented in implementation models has to be lifted

from those implementation models to the common ontology.

Our framework is developed in Java. Non-Java applications run in Java contain-

ers, which provide access to those applications’ functionality and data. With such

containers, technological heterogeneity can be overcome, as all containers provide a

unified Java interface [Paulheim and Erdogan, 2010].

While technological heterogeneity mainly imposes engineering problems, con-

ceptual heterogeneities are a lot harder to tackle. While there are a number of

programming frameworks for mapping class models into RDF, which can be used

for making data objects from the integrated applications accessible to a reasoner,

those frameworks are most often too inflexible for realistic scenarios. In particular,

they do not account for typical deviations between implementation models and for-

mal ontologies [Paulheim et al., 2011]. Figure 4 shows a typical example for such a

deviation.

Frameworks like RDFReactor [Volkel and Sure, 2005] or bridges between EMF

and Java [Hillairet et al., 2008] most often rely on the presence of 1:1 mappings

between the class model of the application and the ontology used by the reasoner

(see [Paulheim et al., 2011] for a detailed overview of such frameworks and a more

in-depth discussion of the issue). Since the programming models of the individual

integrated applications may differ among each other, as well as from the ontology

used for visualization, they are not flexible enough to be used in this scenario.

To overcome these issues, we have created a mapping approach that does not rely

on 1:1 mappings between the class model and the ontology. Instead, we use a rule-

based mapping approach that is flexible enough to cope with various heterogeneities

between class models and ontologies. For mapping classes into an ontology, the

rules evaluate XPath expressions on the class model, and create a set of RDF


triples with variables that can be filled from such XPath expressions. For mapping

an ontology to class model, SPARQL queries are used to dynamically construct

objects. Furthermore, constructs such as regular expressions are supported in the

rules to allow for very flexible mapping constructs. The example depicted in figure 4

can be addressed with rules which dynamically determine the RDF statements to

create, depending on the value of an attribute. Two example rules for mapping the

class Person in the example to the corresponding ontology classes would be:

/[sex = "MALE"]→ uri(.) "<rdf:type>" <#Man> . (2)

/[sex = "FEMALE"] → uri(.) "<rdf:type>" <#Woman> . (3)

With those rules, an instance of #Man or #Woman, respectively, is created, de-

pending on the value of the attribute value sex. Such conditional mappings cannot

be achieved with a static, 1:1 mapping approach. Further examples for rule-based

mappings can be found in [Paulheim et al., 2011].

3.3. The Semantic Data Explorer (SDE)

The Semantic Data Explorer visualizes information objects, their attributes and

relations to other objects, as a semantic network. It uses the RDF visualization

proposed by the W3C [W3C, 2004], showing objects (or resources) as ellipses and

data values in rectangles, connected by directed edges. Instead of URIs or URI

fragments, labels (i.e., rdfs:labels) are used as captions for resources, if present.

As the SDE is an exploration and explanation tool merely for domain experts,

rather than a debugging device for developers, it uses the concepts and labels defined

in a domain ontology, not the class and attribute names of the underlying objects.

It thus reflects a conceptual view on the information, not a technical one.

The Semantic Data Explorer has been developed an extension to the integration

framework shown above. From the framework’s point of view, it is implemented

as a special container, which uses a direct interface to the reasoner for reasons of

performance (unlike the other containers, which do not directly access the reasoner).

Figure 5 shows how the semantic data explorer is integrated in the framework. A

data access component is used as an interface to the reasoner. It accesses the data

from both the applications as well as the link repository indirectly through the

reasoner. The same holds for the T-box data, which is especially used for labeling

nodes and edges in the semantic network. The SDE is also connected to the event

exchange bus to allow interactions with the other applications:

(1) When the user drags and drops an object from an application onto the SDE,

a graph view of that object is shown by the SDE, containing the object itself

and its directly connected neighbors. To get a deeper view of the object’s con-

nections, the user can double click nodes in the graph to expand and collapse

them.

16 Heiko Paulheim

Semantic Data ExplorerCentral Event Processor

Ev

en

t

Ha

nd

lin

g

Reasoning Module

A-b

ox

Co

nn

ec

tor

T-b

ox

Co

nn

ec

tor

invo

ke u

se

use

Inte

gra

tio

n

Ru

les

pro

ce

ss

Link Repository



Application ContainerE

ve

nt H

an

dlin

g

Lin

ke

d D

ata

Pro

vid

er

Application

Ontology

Event Bus

UI and Inter-

actions

Ontology

Real World

Domain

Ontology

access

read

read

rea

d

access

...

......

Eve

nt H

an

dlin

g

Lin

ke

d D

ata

Pro

vid

er

...

...

Eve

nt H

an

dlin

g

Visualization

Da

ta A

cce

ss

no

tify

dis

trib

ute

de

live

r /

req

ue

st

access

Figure 5. Architecture of the Semantic Data Explorer (bottom right) and its integration into the

framework. The details of application containers and the link repository are omitted; they aredepicted in figure 1.

(2) When the user selects an object in an application, and that object is contained

in the graph currently shown by the SDE, the corresponding node in the graph is

highlighted. Likewise, if the user selects a node in the graph, the corresponding

objects in other applications are highlighted. This allows the user to keep track

of information objects in the conceptual view provided by the SDE, as well as

in the original applications’ user interfaces.

These interactions are implemented using the same mechanisms as for interac-

tions between two applications in our integration framework. Therefore, no particu-

lar adaptations have to be made to integrated applications for adding the semantic

data explorer; the SDE is thus transparent for the applications.


Technically, displaying as well as expanding a node in the semantic data explorer

results in a call on the reasoner, querying for outgoing and incoming object relations

as well as for data relations. Unlike querying the individual linked data endpoints,

interfacing the reasoner has the advantages that implicit, inferred relations and

class information are returned as well. From a software engineering point of view,

the reasoner again serves as an indirection between the SDE and the applications

holding the data to visualize.

3.4. Performance Considerations

For an interactive visualization, it is essential that the application ensures a reason-

able reactivity. For example, when opening a node in a visualized graph, the graph

should rearrange in a comparatively short amount of time. Thus, we have analyzed

several alternative implementation variants with respect to performance.

As discussed above, our general architecture foresees that the Semantic Data Ex-

plorer addresses a reasoner, which, in turn, retrieves the instance data from different

applications. Thus, it is essential that the reasoner can efficiently access instance

data from the applications. Following our findings in previous works [Paulheim,

2010a], we let the reasoner access the applications via connectors, using a pulling

mechanism, instead of letting it maintain its own redundant A-box, to which the

applications can send updates via a pushing mechanism.

There are a number of aspects that can influence performance. In our experi-

ments, two aspects turned out to have essential influence: the design of the rules

that invoke a connector, and the use of local caches in the connectors [Paulheim and

Meyer, 2011]. The performance of the overall system may be different, depending

on which type of queries are issued. To be able to make qualified statements about

the performance advantages and drawbacks of different solutions, we have analyzed

a number of different, elementary queries, as shown in table 2.

To make the reasoner invoke a connector, a rule is needed whose head indicates

the type of information the connector will deliver, and whose body contains a state-

ment for actually calling that connector. Technically, a connector is wired to the

reasoner with a predicate. For example, a connector providing instance data for an

object can be addressed as followsb:

instance connector(?I, ?C)⇒?C(?I). (4)

The reasoning framework, OntoBroker in our case, is responsible for dispatching the

use of the predicate instance connector to an implementation of that connector,

i.e. a Java method. This method then provides a set of bindings for the variables

(in this case: ?I and ?C). If some of the variables are already bound, the contract is

that the method returns the valid bindings for the unbound variables which yield a

bWe use the common SWRL human readable syntax for rules, although in SWRL, variables arenot allowed for predicates. In our implemented prototype, we have used F-Logic for formulating

the rules, which allows for using variables for predicates.

18 Heiko Paulheim

Description Query in SPARQL

1 Get all objects of

type C

SELECT ?I WHERE {?I rdf:type C.}

2a Get all objects of

type C in a

relation R with

object O

SELECT ?I WHERE {?I rdf:type C. ?I R O.}

2b SELECT ?I WHERE {?I rdf:type C. O R ?I.}

2a+b SELECT ?I WHERE {{?I rdf:type C. ?I R O.}

UNION {?I rdf:type C. O R ?I.}}


type C in any

relation with

object O

SELECT ?I WHERE {?I rdf:type C. ?I ?R O.}

3b SELECT ?I WHERE {?I rdf:type C. O ?R ?I.}

3a+b SELECT ?I WHERE {{?I rdf:type C. ?I ?R O.}

UNION {?I rdf:type C. O ?R ?I.}}


any type in a

relation R with

object O

SELECT ?I WHERE {?I R O.}

4b SELECT ?I WHERE {O R ?I.}

4a+b SELECT ?I WHERE {{?I R O.}

UNION {O R ?I.}}


any type in any

relation with

object O

SELECT ?I WHERE {?I ?R O.}

5b SELECT ?I WHERE {O ?R ?I.}

5a+b SELECT ?I WHERE {{?I ?R O.}

UNION {O ?R ?I.}}

Table 2. The different query types we used to analyze the performance impact of different variants,

and their SPARQL representation.

true statement given the already bound ones. Consider the following example query,

asking for all instances of a class #Person:

SELECT ?I WHERE { ?I rdf:type #Person } (5)

The resolution of this query leads to the invocation of rule 4 with the variable

?C bound to #Person. The connector method now returns a set of bindings for

the variable ?I for which the statement #Person(?I) is true. The reasoner then

substitutes the results in the query and returns the result.

The mechanism defined in rule 4 is the most basic way of integrating a connector

which delivers information about instances and the classes they belong to. As it has

to be evaluated in each condition in a rule’s body where statements like ?C(?I)

occur (either unbound or with one or both of the variables bound), the connector

is invoked very frequently. Since invoking a connector may be a relatively costly

operation (even with caches involved, as described below), this is a solution which

may imply some performance issues.

A possible refinement is the use of additional constraints. The idea is that for

each integrated software component, the set of possible ontology classes the data


objects may belong to is known. Given that the union of those sets over all compo-

nents is #Class1 through #ClassN, the above rule can be refined to:

(equal(?C,#Class1) ∨ equal(?C,#Class2)... ∨ equal(?C,#ClassN))

∧ instance connector(?I, ?C)

⇒ ?C(?I) (6)

Assuming a left to right order of evaluation of the rule’s body, the connector is now

only invoked in cases where the variable ?C is bound to one of the given values.

Therefore, the number of the connector’s invocations can be drastically reduced.

A variant of that solution is the use of single rules instead of one large rulec:

instance connector(?I,#Class1) ⇒ #Class1(?I)

instance connector(?I,#Class2) ⇒ #Class2(?I)

...

instance connector(?I,#ClassN) ⇒ #ClassN(?I) (7)

In that case, the connector is not always invoked when evaluating a statement of

type ?C(?I). Instead, each rule is only invoked for exactly one binding of ?C. In the

example of query (5), only the first rule’s body would be evaluated at all, invoking

the connector once with one bound variable. On the other hand, the number of

rules the reasoner has to evaluate for answering a query is increased.

The above example rules show how to invoke the instance connector wrapper,

which returns statements about category membership of instances. The other im-

portant is relation connector(?X, ?R, ?Y ), which has three variables. It returns the

set of all triples where object ?X is in relation ?R with object ?Y . As for the

instance connector wrapper, the corresponding types of invocation rules exist.

We have analyzed the performance impact of all three rule types: the generic

rule (4), the use of an extended rule (6), and the use of single rules (7).

To speed up the answer of our connectors, partly caching instance data in the

connector is a good strategy [Wiederhold and Genesereth, 1997], although it slightly

contradicts to the idea of avoiding double bookkeeping – it is the classic trade-off

of redundancy vs. performance. We have analyzed three different variants: using no

caches at all, i.e., each query for instance data is directly passed to the underlying

objects, and statements are assembled at query time (see Fig. 6(a)); and using eager

and lazy caching. While the eager cache updates the required statements for each

object when that object changes (see Fig. 6(b)), the lazy cache flags statements as

invalid upon change of the represented object, and re-creates them only if they are

requested (see Fig. 6(c)).

The variables in our evaluation are the number of software components (5, 10,

and 20), the number of object instances maintained by each component (250 and

cIn rule languages that do not support disjunctive rules, this variant is in fact the only way to

implement rule 6.

20 Heiko Paulheim

A-box

Connector

Component

AdapterO5

O4O3

O2O1

Queries are passed

through to the

original component

query query

(a) Without cache

A-box

Connector

Component

AdapterO5

O4O3

O2O1

Cache entries are replaced

when updates occur

updatequery

(b) Eager cache

A-box

Connector

Component

AdapterO5

O4O3

O2O1

Cache entries are invalidated

when updates occur

query

query on cache

miss

update

(c) Lazy cache

Figure 6. Different variants for using caches

500, randomly distributed over 10 classes per component), and the average update

frequency (25 and 50 updates per second). Each instance has been given 5 relations

to other instances. Therefore, our maximum test set has 10000 object instances with

50000 relations.

In Figs. 7 to 10, we show the results of selected typical queries, which illustrate

the main findings of our analysisd. While the figure depicts the results for the a+ b

flavor of each query type (see table 2), the results for the a and b flavor are similar.

Generally, the query times using eager caching are faster than those using lazy

caching. The actual factor between the two ranges from double speed (e.g., in case

of type 4 queries) to only marginal improvements (e.g., in case of type 3 queries).

Since lazy caches have to re-create the invalidated triples to answer a query, eager

caches can always serve the requested triples directly. Therefore, the latter can

answer queries faster.

dType 1 queries are not shown; they are generally answered very quickly, and there are no signif-

icant differences between the approaches.


1000

1500

2000

2500

3000

3500

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

0

500

1000

1500

2000

2500

3000

3500

5 10 15 20

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

Single Rules,

Eager Cache

Single Rules,

Lazy Cache

Figure 7. Query time for type 2 queries, performed with 500 object instances per component.The x axis shows the number of components (there have been no explicit measurements for 15

components), and the y axis shows the query time in seconds.

When looking at scalability, it can be observed that doubling the number of

integrated components (which also doubles the number of A-box instances) about

doubles the query answer time in most cases, thus, there is a linear growth of

complexity in most cases.

Multiple observations can be made when looking at the individual results regard-

ing different queries. For type 3 queries, it is single rules which produce significant

outliers (see Fig. 8), while for type 5 queries, it is generic rules (see Fig. 10). Thus,

only only extended rules guarantee reasonable response times in all cases with-

out any outliers, although they are outperformed by generic rules in type 2 and 4

queries.

In case of type 1, 2 and 4 queries, the relation in which the objects sought is

already fixed (e.g., “find all persons which are married to another person”), while

the case of type 3 and 5 queries, the relation is variable (e.g., “find all persons which

have any relation to another person”). The first type of query is rather target-

oriented, while the latter is rather explorative. The key finding of the results is

that target-oriented queries do not pose any significant problems, while explorative

queries do.

The bad behavior of single rules in the case of explorative queries can be ex-

plained by the fact that when an explorative query is answered, the various single

rules fire, thus causing many potentially expensive invocations of the connector.

The generic and extended rules, on the other hand, invoke the connector less of-

ten. For a similar reason, the generic rule variant behaves badly for the explorative

query types: here, the reasoner determines the possible relation types by invoking

the wrapper multiple times, each time trying another relation type. Extended and

22 Heiko Paulheim

3000

4000

5000

6000

7000

8000

9000

10000

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

0

1000

2000

3000

4000

5000

6000

7000

8000

9000

10000

5 10 15 20

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

Single Rules,

Eager Cache

Single Rules,

Lazy Cache



1000

1500

2000

2500

3000

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

0

500

1000

1500

2000

2500

3000

5 10 15 20

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

Single Rules,

Eager Cache

Single Rules,

Lazy Cache

Figure 9. Query time for type 4 queries, performed with 500 object instances per component.

The x axis shows the number of components (there have been no explicit measurements for 15components), and the y axis shows the query time in seconds.

single rules, on the other hand, already restrict the relation types in the rule body,

thus requiring less invocations of the wrapper.

Implementing a visualization such as the Semantic Data Explorer results in

issuing explorative queries of type 5: when expanding a node, all incoming and

outgoing relations are supposed to be shown, without an a priori restriction of the

type of such queries. Thus, for providing good performance in the semantic data


30000

40000

50000

60000

70000

80000

90000

100000

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

0

10000

20000

30000

40000

50000

60000

70000

80000

90000

100000

5 10 15 20

Generic Rule,

Eager Cache

Generic Rule,

Lazy Cache

Extended Rule,

Eager Cache

Extended Rule,

Lazy Cache

Single Rules,

Eager Cache

Single Rules,

Lazy Cache



explorer, only single or extended rules may be used, but generic rules would result

in too bad performance.

4. User Study

To show that the Semantic Data Explorer provides a valuable extension to inte-

grated information systems, we have conducted a user study with the integrated

emergency management system SoKNOS e [Braune et al., 2011; Doweling et al.,

2009; Paulheim et al., 2009], to which we have added the Semantic Data Explorer.

That system was built as a prototype in a research project conducted with several

software development companies, universities and other research institutions, as well

as experts from the emergency management domain, such as firefighters and police

officers. It uses a ontology of the emergency management domain which has been

developed together with domain experts [Babitski et al., 2009], and which is thus a

good candidate for a common conceptual model for creating the visualization.

4.1. Scenario

The SoKNOS prototype is based on the framework introduced in section 3.1 and

consists of 20 different integrated applications. It shows integrated information on

emergency situations in maps, tables, and timelines, where external information

eService-orientierte ArchiteKturen zur Unterstutzung von Netzwerken im Rahmen OeffentlicherSicherheit, German for service oriented architectures for supporting networks in the area of public

security.

24 Heiko Paulheim

sources, such as web services or data gathered by web crawlers, can also be inte-

grated [Fritz et al., 2010]. Furthermore, simulations (e.g., of the spreading of fires

or floodings) can be executed, messages from and to the operational resources (such

as fire brigade cars or helicopters) in the field can be handled, and information can

be shared across different organizations involved in larger disasters.

For the evaluation, we used two particular applications in SoKNOS: a mission

account application which is used for viewing problems and measures, as well as

assigned tactical units (such as fire brigade cars), and a resource management ap-

plication used for browsing available tactical units, both from the operator’s own

organization as well as from other supporting organizations. Figure 12 shows the

two applications. Assignments of units and measures can be made by dragging and

dropping a unit from the resource management application and dropping it onto a

measure in the mission account application. Technically, this creates a link between

the data managed by the two applications. The link can be removed by dragging

and dropping an assigned unit back to the resource management application.

The two applications used in the evaluation are developed on different techno-

logical platforms (Flex and Java). Details on the coupling of those heterogeneous

applications can be found in [Paulheim and Erdogan, 2010].

The scenario of the evaluation deals with the assignment of operational resources

to measures, e.g. sending helicopters to evacuate people from a roof top, or assigning

fire brigade cars to individual areas of fire. Planning such an assignment is an

important task in emergency management – an optimal assignment is needed for

avoiding overload of units as well unnecessary idle times. To this end, the person

doing the planning needs a good overview on the current assignments.

4.2. Evaluation Setup

In the course of the SoKNOS project, we have conducted interviews with domain

experts who deal with emergency management systems. From those interviews,

the requirements for the prototype have been derived. The tasks the users had to

perform in our evaluation are also based on those interviews, i.e., they are realistic

tasks that the end users need support for. From the field of managing assignments

of tactical units to measures, the following three types of tasks have been chosen

for the evaluation:

Type 1 Find out how many units are assigned to measure M .

Type 2 Find out how many measures a unit U is assigned to.

Type 3 Find out how many of the units assigned to measure M are also assigned

to at least one other measure.

The answer for tasks of type 1 can be obtained by looking it up in the mission

account application only. The answer for tasks of type 2 can be solved with one

interaction between the resource management application and the mission account

application (e.g., by first selecting the tactical unit and then counting the number


Male

Female

(a) Gender

<25

25-34

35-44

45+

(b) Age

None

Low

Medium

High

Expert

(c) Experience with Ontologies

None

Low

Medium

High

Expert

(d) Experience with Semantic Networks

Figure 11. Participants of the user study by age, gender, and self-assessment of prior knowledge

about ontologies and semantic networks.

of highlighted related measures). The answer for tasks of type 3 requires multiple

interactions between the two applications (e.g., first finding the relevant tactical

units in the mission account application, and then repeating task 2 for each of

those units).

Our hypotheses were that at least the more complex tasks of type 2 and 3 are

performed faster with the use of the SDE, that the error rate is lower for tasks of

type 2 and 3 when using the SDE, and that the use of the SDE increases the users’

satisfaction.

The evaluation was performed with 22 participants between 22 and 52 years, 3

of which were female and 19 of which were male. When asked to self-assess their

experience with ontologies and semantic networks, the majority of the participants

ranked their experience below average (see figure 11).

To test our hypotheses, each user had to perform two blocks of six tasks, each

block consisting of two tasks of each type. One block had to be performed using

the SDE, the other without using the SDE. The test persons were split into two

groups: One group started with the block of tasks using the SDE, the other with

the block of tasks without using the SDE. The assignment of the individual tasks

to the blocks was varied as well. When using the SDE, the users were advised to

use it for all tasks, even if they felt they could perform those tasks without the SDE

26 Heiko Paulheim

Figure 12. Screenshot of the evaluation setup. The setup consists of two applications – a mission

account application (top) and a ressource application (bottom left) as well as the Semantic Data

Explorer (bottom right). Items are parallely highlighted in different applications. The SDE hasbeen presented to the users for only half of the tasks.

as well (and maybe even better). Furthermore, users were offered to use pen and

paper if needed.

At the beginning of the evaluation, users were shown how to operate the system,

in a way that an instructor showed them how to find the kind of information that

was asked for later on the tasks. The group that started with the SDE was presented

the whole system including the SDE at once, while the other group was presented

the system without the SDE first, and got the introduction to the SDE at the

beginning of the second block of tasks.

After each block of six tasks, the users were handed out a questionnaire for eval-

uating their user experience, using the questionnaire described in [Laugwitz et al.,

2008]. It consists of 20 questions which are used to quantify user experience accord-

ing to five factors: attractiveness, perspicuity, efficiency, stimulation, and novelty.

When the users performed the tasks, the system recorded the times needed to

perform the task and the number of errors. The instructor additionally recorded for

which tasks the users made use of the offered pen and paper to take notes. For each


0

20

40

60

80

100

120

140

Type 1* Type 2** Type 3**

Tim

e in

Se

con

ds

Task Type

without SDE

with SDE

Figure 13. Average task completion times in seconds (*: p<0.05, **: p<0.01).

user, the evaluation, including filling out the questionnaires, took between 20 and

30 minutes.

4.3. Evaluation Results

Figure 13 shows the average task completion times for the different types of tasks,

each with and without SDE. It can be observed that the task completion time for

tasks of type 2 and 3 are highly significantly reduced (p<0.01 using a two-tailed

t-test). Especially for the type 3 tasks, the task completion time is reduced by more

than 50% when using the SDE. For type 1 tasks, the non-SDE variant is faster

(p<0.05).

For solving the tasks of type 3 without the SDE, 17 out of 22 participants made

use of pen and paper for taking down intermediate results, as opposed to none of the

participants using the SDE. This shows that those tasks are particular difficult to

solve, and that there is a need for additional support which is provided by the SDE.

For the other tasks, pen and paper was used by almost none of the participants.

Figure 14 shows the error rates (i.e., the percentage of tasks of each type that

have been solved incorrectly). For type 1 tasks, there are more errors with the SDE,

while the error rate is lower for type 2 and 3 tasks. However, none of those results

are statistically significant using a χ2 test.

Figure 15 shows the results from the user experience questionnaires [Laugwitz

et al., 2008]. We have compared the results of both times the users filled the ques-

tionnaire, once with and once without the SDE. It can be observed that the users

rated the application with the SDE significantly more attractive, perspicuous, effi-

cient, stimulating, and novel (all p¡0.01 using a two-tailed t-test).

28 Heiko Paulheim

0%

1%

2%

3%

4%

5%

6%

7%

8%

9%

10%

Type 1 Type 2 Type 3

Erro

r R

ate

Task Type

without SDE

with SDE

Figure 14. Average error rates. None of the results are statistically significant.

Attractiveness** Perspicuity** Efficiency** Stimulation** Novelty**-1.000

-0.500

0.000

0.500

1.000

1.500

without SDEwith SDE

Figure 15. Results of the questionnaires on user experience for all users. All differences are statis-tically significant with p<0.01. The value space for each criterion ranges from −3 to +3.

To examine how much the Semantic Data Explorer helps users that are not

familiar with ontologies and semantic web, we created a subset of our evaluation

results containing only those 11 users that assessed their knowledge on ontologies

and semantic networks less than medium. We have analyzed all parameters of the

user study on that subset. The task completion times between experts and non-

experts did not differ much, and the reduction of task completion time for type 2

and type 3 tasks when using the SDE was still significant (p<0.01).

The evaluation of the user experience questionnaires for the group of non-experts

proved improvements in attractiveness, efficiency, and novelty (all p<0.01), while

the improvements in perspicuity and stimulation could still be observed, but only

on a non-statistically significant level, as shown in figure 16. The latter can either be


Attractiveness** Perspicuity Efficiency** Stimulation Novelty**-1.000

-0.500

0.000

0.500

1.000

1.500

without SDEwith SDE

Figure 16. Results of the questionnaires on user experience for non-expert users. Differences markedwith ** are statistically significant with p<0.01. The value space for each criterion ranges from

−3 to +3.

a statistical effect because of the small set size of non experts (11 users), or ontology

experts experience the work with linked data visualizations more perspicuous and

stimulating.

In summary, our original hypotheses on task completion times and on user sat-

isfaction were supported by the evaluation. Our hypotheses on task error rates was

not supported. A possible explanation is that the overall number of errors is very

low, both with and without the SDE – less than 10% of all tasks were solved incor-

rectly in total. The participants were neither asked to perform the tasks as quickly

nor as correct as possible, and most of them obviously favored correct answers to

quick task completion and took their time to answer the questions very thoroughly,

which leads to a significant difference in task completion time, as discussed above,

at a constant error rate.

The participants were asked for additional comments on possible improvements

of the Semantic Data Explorer. One of the most often mentioned criteria was to use

meaningful colors and symbols in the SDE – in the prototype, only the currently

active node is highlighted in color, and all nodes, regardless of the type of object

they represent, are drawn as ellipses, and data values are shown as rectangles. Other

users opted for better labels to edges (which at the moment are marked with the

rdfs:label of the corresponding relation), and a better arrangement of objects

when the graph grows larger.

5. Conclusion and Outlook

In this paper, we have introduced the vision of improving integrated user interfaces

with graphical visualizations of linked data. The prototype shown in this paper uses

a hybrid view that combines legacy applications’ user interfaces with the Semantic

Data Explorer (SDE), which shows a semantic network view on the underlying

data. With this prototype, users can browse the information contained in integrated

information systems using those systems’ original user interfaces and the graphical

visualization in parallel, where the views are coordinated so that related information

30 Heiko Paulheim

is highlighted in all views. As a reasoner is used to create the semantic network

view, the graphical visualization can make implicit information contained in the

applications explicit and show non-obvious relations to the user.

We have shown that our approach is able to cope with different types of het-

erogeneity. Using one common ontology as a conceptual model underlying the visu-

alization, it is necessary to map different implementation models to that ontology.

We have shown that our approach is capable of dealing with technologically as well

as conceptually different models. By employing a rule-based mapping from imple-

mentation models to the common ontology, an ontology can provide an integrated

view on the different underlying implementation models.

Since we use a reasoner as the central instance coordinating the integrated user

interface as well as producing the visualization, performance is an essential issue to

address when implementing our approach, as reasoning can be very time consuming.

In this paper, we have shown how different implementation strategies influence

performance, and discussed an implementation that allows for high-performance,

interactive visualization of linked data.

We have evaluated our approach using a scenario from the emergency manage-

ment domain with a group of users, many of which assessed themselves to have

no or only little knowledge about ontologies and semantic networks. Our evalua-

tion has shown that using semantic networks for browsing information can lead to

substantial improvements both in task completion time and in the users’ satisfac-

tion. Other than user studies with comparable tools [de Araujo and Schwabe, 2009;

Kobilarov and Dickinson, 2008; Weiss et al., 2008], we have involved non-expert

users (w.r.t. RDF and ontologies) and shown that the observed improvements

are still significant for those users. Unlike claimed by, e.g., schraefel and Karger

[mc schraefel and Karger, 2006], we have shown that a simple graph-based visual-

ization of RDF does provide additional value for users.

As the evaluation suggests, using linked data and hybrid visualization can add

extra value to existing software applications with comparatively little effort. As dis-

cussed by [North and Shneiderman, 2000], the interface an application has to im-

plement to be used in such a setting is not too large, and linked data endpoints may

also be added to existing applications with little efforts [Auer et al., 2009]. There-

fore, the approach presented in this paper is a valid approach for building integrated

information systems with valuable support for information workers. Compared to

developing a whole new user interface, the development efforts of integrating exist-

ing user interfaces and combining them with a graph-based view of the underlying

linked data, is rather small.

The prototype developed for the evaluation uses desktop applications, but the

concept can be carried over to web applications as well when coupling the semantic

data explorer with a portal or mashup farmework. It may also be beneficial to en-

rich linked data provided by information systems internal to an organization (which

is actually linked closed data) with additional information from linked open data.


Furthermore, with the use of ontologies providing multi-lingual labels, the seman-

tic data explorer can be internationalized with little additional effort. Mappings

to other ontologies could help providing personalized visualizations using different

vocabularies and conceptualizations.

At the moment, links between information objects in the integrated applications

are either created explicitly by the user, e.g. by dragging one object to the other for

creating the link, or by the developer ensuring that information objects referring to

the same real world object, such as a customer, have the same URI in the different

information systems. A more versatile approach could run an instance matcher

[Ferrara et al., 2008] on the different data sources upfront to create useful links.

Although the evaluation in this paper has shown that significant improvements

regarding task completion time and user satisfaction can be achieved with our ap-

proach, we could not validate our hypothesis that the error rate could also be

reduced by using the Semantic Data Explorer. As the users were in a non-stressful

situation, they solved each task carefully, so the overall error rate both with and

without the SDE was rather low. We believe that conducting a second user study

including stress factors, such as a fixed time limit for each task, would provide

additional valuable insights.

Among the informal user feedback gathered, the suggestion to use color coding

and symbols for distinguishing different types of objects in the semantic network

was one of the improvements which has been asked for most often. As the cur-

rent prototype only uses a very basic visualization which makes hardly any use of

different symbols and colors, more sophisticated and domain-specific visualizations

are possible. As the literature suggests many different visualization strategies for

semantic networks [Katifori et al., 2007], we aim at developing and evaluating differ-

ent visualizations. Another request articulated by the participants aimed at more

understandable labels for the edges. Using methods from ontology verbalization

[Kaljurand and Fuchs, 2007] could provide improvements at that point.

The performance of our semantic data explorer has been experienced sufficiently

fast by our test persons; in fact, it takes less than a second to expand or display a

node. However, for even more fluent interactions and for more anticipatory layouting

of the resulting graph, look-ahead mechanisms could be employed.

In summary, we believe that integrated user interfaces and linked data are a

perfect match to build future information systems. The evaluation results discussed

in this paper show that this combination is a valuable strategy even for end users

who have no particular experience in the semantic web area.

Acknowledgements

The work presented in this paper has been partly funded by the German Federal

Ministry of Education and Research under grant no. 01ISO7009 and 01IA08006.

The author would like to thank Lars Meyer for his support in prototyping and

32 Heiko Paulheim

conducting the user study, as well as everyone who took their time to participate

in the experiments.

Bibliography

Angele, J. and Lausen, G. (2009). Ontologies in F-Logic. In Staab, S. and Studer, R.,editors, Handbook on Ontologies, International Handbooks on Information Systems,chapter 3, pages 45–70. Springer, 2nd edition edition.

Anicic, D. and Stojanovic, N. (2008). Towards Creation of Logical Framework for Event-Driven Information Systems. In Cordeiro, J. and Filipe, J., editors, ICEIS 2008 -Proceedings of the Tenth International Conference on Enterprise Information Systems,Volume ISAS-2, Barcelona, Spain, June 12-16, 2008, pages 394–401.

Apache Software Foundation (2010). Welcome to Pluto. http://portals.apache.org/

pluto/. Accessed April 12th, 2011.Auer, S., Dietzold, S., Lehmann, J., Hellmann, S., and Aumueller, D. (2009). Triplify:

Light-Weight Linked Data Publication from Relational Databases. In WWW ’09: Pro-ceedings of the 18th international conference on World wide web, pages 621–630, NewYork, NY, USA. ACM.

Babitski, G., Probst, F., Hoffmann, J., and Oberle, D. (2009). Ontology Design for Informa-tion Integration in Catastrophy Management. In Proceedings of the 4th InternationalWorkshop on Applications of Semantic Technologies (AST’09).

Becker, C. and Bizer, C. (2008). DBpedia Mobile - A Location-Aware Semantic WebClient. In Proceedings of the Semantic Web Challenge at ISWC 2008.

Berners-Lee, T., Chen, Y., Chilton, L., Connolly, D., Dhanaraj, R., Hollenbach, J., Lerer,A., and Sheets, D. (2006). Tabulator: Exploring and Analyzing linked data on theSemantic Web. In [Rutledge et al., 2006].

Berners-Lee, T., Cyganiak, R., Hausenblas, M., Presbrey, J., Seneviratne, O., , and Ureche,O.-E. (2009). Realising A Read-Write Web of Data. http://web.mit.edu/presbrey/Public/rw-wod.pdf. Accessed September 30th, 2010.

Birsan, D. (2005). On plug-ins and extensible architectures. ACM Queue, 3(2):40–46.Bizer, C. and Gauß, T. (2007). Disco - Hyperdata Browser. http://www4.wiwiss.

fu-berlin.de/bizer/ng4j/disco/. Accessed September 30th, 2010.Bizer, C., Heath, T., and Berners-Lee, T. (2009a). Linked Data - The Story So Far.

International Journal on Semantic Web and Information Systems, 5(3):1–22.Bizer, C., Heath, T., Berners-Lee, T., and Idehen, K., editors (2009b). Proceedings of the

WWW2009 Workshop on Linked Data on the Web, volume 538 of CEUR-WS.Bizer, C., Heath, T., Idehen, K., and Berners-Lee, T., editors (2008). Proceedings of the

WWW2008 Workshop on Linked Data on the Web, volume 369 of CEUR-WS.Bizer, C., Lehmann, J., Kobilarov, G., Auer, S., Becker, C., Cyganiak, R., and Hellmann,

S. (2009c). DBpedia - A Crystallization Point for the Web of Data. Journal of WebSemantics, 7(3):154–165.

Braune, S., Brucker, A. D., Kleser, G., Li, K., Meijler, T. D., Paulheim, H., and Probst,F. (2011). A Service-oriented Architecture for Emergency Management Systems. InSoftware Engineering 2011 - Workshops, volume 184 of LNI.

Calvary, G., Graham, T. C. N., and Gray, P., editors (2009). Proceedings of the 1st ACMSIGCHI Symposium on Engineering Interactive Computing Systems (EICS 2010).ACM.

Cardoso, J. (2007). The Semantic Web Vision: Where Are We? IEEE Intelligent Systems,22(5):84–88.


Cheyer, A., Park, J., and Giuli, R. (2005). IRIS: Integrate. Relate. Infer. Share. In [Deckeret al., 2005].

Cohen, M. and Schwabe, D. (2010). RExplorator - supporting reusable explorations ofSemantic Web Linked Data. In [Polleres and Chen, 2010].

Daniel, F., Casati, F., Benatallah, B., and Shan, M.-C. (2009). Hosted Universal Com-position: Models, Languages and Infrastructure in mashArt. In ER ’09: Proceedingsof the 28th International Conference on Conceptual Modeling, pages 428–443, Berlin,Heidelberg. Springer.

Daniel, F. and Matera, M. (2008). Mashing Up Context-Aware Web Applications: AComponent-Based Development Approach. In WISE ’08: Proceedings of the 9th inter-national conference on Web Information Systems Engineering, volume 5175 of LNCS,pages 250–263, Berlin, Heidelberg. Springer-Verlag.

Daniel, F., Yu, J., Benatallah, B., Casati, F., Matera, M., and Saint-Paul, R. (2007).Understanding UI Integration: A Survey of Problems, Technologies, and Opportunities.IEEE Internet Computing, 11(3):59–66.

Davies, S., Hatfield, J., Donaher, C., and Zeitz, J. (2010). User Interface Design Consider-ations for Linked Data Authoring Environments. In Bizer, C., Heath, T., Berners-Lee,T., and Hausenblas, M., editors, Proceedings of the WWW2010 Workshop on LinkedData on the Web, volume 628 of CEUR-WS.

de Araujo, S. F. C., Houben, G.-J., Schwabe, D., and Hidders, J. (2010). Fusion – VisuallyExploring and Eliciting Relationships in Linked Data. In Patel-Schneider, P. F., Pan,Y., Hitzler, P., Mika, P., Zhang, L., Pan, J. Z., Horrocks, I., and Glimm, B., editors,ISWC 2010, volume 6496 of LNCS. Springer.

de Araujo, S. F. C. and Schwabe, D. (2009). Explorator: a tool for exploring RDF datathrough direct manipulation. In [Bizer et al., 2009b].

Decker, S., Erdmann, M., Fensel, D., and Studer, R. (1999). Ontobroker: Ontology BasedAccess to Distributed and Semi-Structured Information. In Meersman, R., Tari, Z.,and Stevens, S. M., editors, Database Semantics - Semantic Issues in Multimedia Sys-tems, IFIP TC2/WG2.6 Eighth Working Conference on Database Semantics (DS-8),Rotorua, New Zealand, January 4-8, 1999, volume 138 of IFIP Conference Proceedings,pages 351–369. Kluwer.

Decker, S., Park, J., Quan, D., and Sauermann, L., editors (2005). Proceedings of the ISWC2005 Workshop on The Semantic Desktop - Next Generation Information Management& Collaboration Infrastructure, volume 175 of CEUR-WS.

Doweling, S., Probst, F., Ziegert, T., and Manske, K. (2009). SoKNOS - An InteractiveVisual Emergency Management Framework. In Amicis, R. D., Stojanovic, R., andConti, G., editors, GeoSpatial Visual Analytics, NATO Science for Peace and SecuritySeries C: Environmental Security, pages 251–262. Springer.

Eick, S. G. and Wills, G. J. (1995). High Interaction Graphics. European Journal of Op-erational Research, 84:445–459.

Ennals, R. (2010). Intel Mash Maker: Mashups for the Masses. http://software.intel.com/en-us/articles/intel-mash-maker-mashups-for-the-masses/. Accessed April12th, 2011.

Ferrara, A., Lorusso, D., Montanelli, S., and Varese, G. (2008). Towards a Benchmark forInstance Matching. In Shvaiko, P., Euzenat, J., Giunchiglia, F., and Stuckenschmidt,H., editors, Proceedings of the 3rd International Workshop on Ontology Matching (OM-2008), volume 431 of CEUR-WS, pages 37–48.

Fowler, M. (2003). Patterns of Enterprise Application Architecture. Addison Wesley,Boston, MA.

34 Heiko Paulheim

Fritz, C., Kirschner, C., Reker, D., Wisplinghoff, A., Paulheim, H., and Probst, F. (2010).Geospatial Web Mining for Emergency Management. In GIScience 2010 - ExtendedAbstracts.

Google Inc. (2010). Google Mashup Editor. http://code.google.com/gme/. AccessedApril 12th, 2011.

Goyal, S. and Westenthaler, R. (2004). RDF Gravity (RDF Graph VisualizationTool). http://semweb.salzburgresearch.at/apps/rdf-gravity/. Accessed April12th, 2011.

Groza, T., Dragan, L., Handschuh, S., and Decker, S. (2009). Bridging the Gap betweenLinked Data and the Semantic Desktop. In Bernstein, A., Karger, D. R., Heath, T.,Feigenbaum, L., Maynard, D., Motta, E., and Thirunarayan, K., editors, The SemanticWeb - ISWC 2009, volume 5823 of LNCS, pages 827–842. Springer.

Hardman, L., van Ossenbruggen, J., Troncy, R., Amin, A., and Hildebrand, M. (2009).Interactive Information Access on the Web of Data. In Proceedings of the WebSci’09:Society On-Line.

Hastrup, T., Cyganiak, R., and Bojars, U. (2008). Browsing Linked Data with Fenfire. In[Bizer et al., 2008].

Heppner, S. (2008). JSR 286: Portlet Specification 2.0. http://www.jcp.org/en/jsr/

detail?id=286. Accessed April 12th, 2011.Hillairet, G., Bertrand, F., and Lafaye, J. Y. (2008). Bridging EMF applications and RDF

data sources. In Kendall, E. F., Pan, J. Z., Sabbouh, M., Stojanovic, L., and Bontcheva,K., editors, Proceedings of the 4th International Workshop on Semantic Web EnabledSoftware Engineering (SWESE).

Hirsch, C., Hosking, J., and Grundy, J. (2009). Interactive Visualization Tools for Explor-ing the Semantic Graph of Large Knowledge Spaces. In Handschuh, S., Heath, T., andThai, V., editors, Workshop on Visual Interfaces to the Social and the Semantic Web(VISSW2009), volume 443 of CEUR-WS.

IBM Corporation (2008). IBM Web Portal software from WebSphere. http://www.ibm.com/websphere/portal. Accessed April 12th, 2011.

IBM Corporation (2010). IBM Enterprise Mashups - IBM Mashup Center. http://www.ibm.com/software/info/mashup-center/. Accessed April 12th, 2011.

JackBe Corporation (2011). Presto: The Real-Time Intelligence Solution. http://www.

jackbe.com/products/. Accessed April 12th, 2011.JBoss Community (2011). GateIn Portal. http://www.jboss.org/gatein/. Accessed April

12th, 2011.Kaljurand, K. and Fuchs, N. E. (2007). Verbalizing OWL in Attempto Controlled English.

In Golbreich, C., Kalyanpur, A., and Parsia, B., editors, Proceedings of the OWLED2007 Workshop on OWL: Experiences and Directions, Innsbruck, Austria, June 6-7,2007, volume 258 of CEUR Workshop Proceedings. CEUR-WS.org.

Katifori, A., Halatsis, C., Lepouras, G., Vassilakis, C., and Giannopoulou, E. G. (2007).Ontology Visualization Methods - A Survey. ACM Comput. Surv., 39(4).

Kobilarov, G. and Dickinson, I. (2008). Humboldt: Exploring Linked Data. In [Bizer et al.,2008].

Kotsalis, D. (2009). Managing Non-Native Widgets in Model-Based UI Engineering. In[Calvary et al., 2009], pages 313–316.

Lanzenberger, M., Sampson, J., and Rester, M. (2009). Visualization in Ontology Tools. InComplex, Intelligent and Software Intensive Systems, International Conference, pages705–711, Los Alamitos, CA, USA. IEEE Computer Society.

Laugwitz, B., Held, T., and Schrepp, M. (2008). Construction and Evaluation of a UserExperience Questionnaire. In Holzinger, A., editor, HCI and Usability for Education


and Work, 4th Symposium of the Workgroup Human-Computer Interaction and Us-ability Engineering of the Austrian Computer Society (USAB 2008), volume 5298 ofLecture Notes in Computer Science, pages 63–76. Springer.

Lawson, J.-Y. (2008). OpenInterface Platform - Description Languages Specifica-tion. https://forge.openinterface.org/frs/download.php/75/DL_spec.pdf. Ac-cessed April 12th, 2011.

Lawson, J.-Y. L., Al-Akkad, A.-A., Vanderdonckt, J., and Macq, B. (2009). An OpenSource Workbench for Prototyping Multimodal Interactions Based on Off-The-ShelfHeterogeneous Components. In [Calvary et al., 2009], pages 245–254.

Lohmann, S., Heim, P., Stegemann, T., and Ziegler, J. (2010). The RelFinder User Inter-face: Interactive Exploration of Relationships between Objects of Interest. In IUI ’10:Proceeding of the 14th international conference on Intelligent user interfaces, pages421–422, New York, NY, USA. ACM.

Luczak-Rosch, M. and Heese, R. (2009). Linked Data Authoring for NonExperts. In [Bizeret al., 2009b].

Masolo, C., Borgo, S., Gangemi, A., Guarino, N., and Oltramari, A. (2003). Wonder-Web Deliverable D18 – Ontology Library (final). http://wonderweb.semanticweb.

org/deliverables/documents/D18.pdf. Accessed April 12th, 2011.mc schraefel and Karger, D. (2006). The Pathetic Fallacy of RDF. In [Rutledge et al.,

2006].Microsoft Corporation (2005). Smart Client - Composite UI Application Block. http:

//msdn.microsoft.com/en-us/library/ff648747.aspx. Accessed April 12th, 2011.Microsoft Corporation (2010). Prism (Composite Client Application Guidance). http:

//msdn.microsoft.com/en-us/library/ff648465.aspx. Accessed April 12th, 2011.Mirizzi, R., Ragone, A., Noia, T. D., and Sciascio, E. D. (2010). Semantic Wonder Cloud:

Exploratory Search in DBpedia. In Daniel, F. and Facca, F. M., editors, Current Trendsin Web Engineering - 10th International Conference on Web Engineering ICWE 2010Workshops, volume 6385 of LNCS, pages 138–149. Springer.

North, C. and Shneiderman, B. (2000). Snap-together visualization: a user interface forcoordinating visualizations via relational schemata. In AVI ’00: Proceedings of theworking conference on Advanced visual interfaces, pages 128–135, New York, NY, USA.ACM.

Open Linked Software (2009). Zitgist DataViewer. http://zitgist.com/products/

dataviewer/dataviewer.html. Accessed September 30th, 2010.Paulheim, H. (2010a). Efficient Semantic Event Processing: Lessons Learned in User In-

terface Integration. In Aroyo, L., Antoniou, G., Hyvonen, E., ten Teije, A., Stucken-schmidt, H., Cabral, L., and Tudorache, T., editors, The Semantic Web: Research andApplications (ESWC 2010), Part II, volume 6089 of LNCS, pages 60–74. Springer.

Paulheim, H. (2010b). Seamlessly Integrated, but Loosely Coupled - Building UIs fromHeterogeneous Components. In ASE ’10: Proceedings of the IEEE/ACM InternationalConference on Automated Software Engineering, pages 123–126, New York, NY, USA.ACM.

Paulheim, H. (2011). Ontology-based Application Integration. Springer.Paulheim, H., Doweling, S., Tso-Sutter, K., Probst, F., and Ziegert, T. (2009). Improving

Usability of Integrated Emergency Response Systems: The SoKNOS Approach. InProceedings ”39. Jahrestagung der Gesellschaft fur Informatik e.V. (GI) - Informatik2009”, volume 154 of LNI, pages 1435–1449.

Paulheim, H. and Erdogan, A. (2010). Seamless Integration of Heterogeneous UI Com-ponents. In Sukaviriya, N., Vanderdonckt, J., and Harrison, M., editors, Proceedingsof the 2nd ACM SIGCHI Symposium on Engineering Interactive Computing Systems

36 Heiko Paulheim

(EICS 2010), pages 303–308. ACM.Paulheim, H. and Meyer, L. (2011). Developing Efficient Ontology-based Systems Using

A-box Data from Running Applications. In 7th International Workshop on SemanticWeb Enabled Software Engineering (SWESE 2011).

Paulheim, H., Plendl, R., Probst, F., and Oberle, D. (2011). Mapping Pragmatic ClassModels to Reference Ontologies. In The 2011 IEEE 27th International Conferenceon Data Engineering Workshops - 2nd International Workshop on Data Engineeringmeets the Semantic Web (DESWeb), pages 200–205.

Paulheim, H. and Probst, F. (2010a). Application Integration on the User Interface Level:an Ontology-Based Approach. Data & Knowledge Engineering Journal, 69(11):1103–1116.

Paulheim, H. and Probst, F. (2010b). Ontology-Enhanced User Interfaces: A Survey. In-ternational Journal on Semantic Web and Information Systems, 6(2):36–59.

Paulheim, H. and Probst, F. (2011). A Formal Ontology on User Interfaces – Yet An-other User Interface Description Language? In Hussein, T., Lukosch, S., Paulheim, H.,Ziegler, J., and Calvary, G., editors, Proceedings of the Second Workshop on SemanticModels for Adaptive Interactive Systems (SEMAIS).

Pietschmann, S., Voigt, M., and Meißner, K. (2009a). Dynamic Composition of Service-Oriented Web User Interfaces. In Proceedings of the 4th International Confer-ence on Internet and Web Applications and Services (ICIW 2009), pages 217–222,Mestre/Venice, Italy. IEEE CPS.

Pietschmann, S., Voigt, M., Rumpel, A., and Meißner, K. (2009b). CRUISe: Composition ofRich User Interface Services. In Gaedke, M., Grossniklaus, M., and Dıaz, O., editors,Proceedings of the 9th International Conference on Web Engineering (ICWE 2009),Edition 5648, pages 473–476, San Sebastian, Spain. Springer.

Polleres, A. and Chen, H., editors (2010). Proceedings of the ISWC 2010 Posters & Demon-strations Track: Collected Abstracts, volume 658 of CEUR-WS.

Quan, D., Huynh, D., and Karger, D. (2003). Haystack: A Platform for Authoring End UserSemantic Web Applications. In Fensel, D., Sycara, K. P., and Mylopoulos, J., editors,The SemanticWeb - ISWC 2003, number 2870 in LNCS, pages 738–753. Springer.

Rauschmayer, A. (2005). Semantic-Web-Backed GUI Applications. In Proceedings of theISWC 2005 Workshop on End User Semantic Web Interaction.

Rubel, D. (2006). The Heart of Eclipse. ACM Queue, 4(8):36–44.Rutledge, L., m.c. schraefel, Bernstein, A., and Degler, D., editors (2006). Procedings of the

The 3rd International Semantic Web User Interaction Workshop (SWUI06) Workshop.SAP AG (2011). SAP - Components & Tools of SAP Netweaver: SAP Netweaver Por-

tal. http://www.sap.com/platform/netweaver/components/portal/index.epx. Ac-cessed April 12th, 2011.

Sauermann, L., Bernardi, A., and Dengel, A. (2005). Overview and Outlook on the Se-mantic Desktop. In [Decker et al., 2005].

Schmitt, N., Niepert, M., and Stuckenschmidt, H. (2010). BRAMBLE: A Web-basedFramework for Interactive RDF-Graph Visualisation. In [Polleres and Chen, 2010].

Tummarello, G., Cyganiak, R., Catasta, M., Danielczyk, S., Delbru, R., and Decker, S.(2010). Sig.ma: Live views on the Web of Data. Web Semantics: Science, Services andAgents on the World Wide Web, 8(4):355 – 364. Semantic Web Challenge 2009; UserInteraction in Semantic Web research.

Vanderdonckt, J. (2005). A MDA-Compliant Environment for Developing User Interfacesof Information Systems. In Proceedings of the 17th Conference on Advanced Informa-tion Systems Engineering (CAiSE’05), pages 13–17. Springer.


Volkel, M. and Sure, Y. (2005). RDFReactor - From Ontologies to Programmatic DataAccess. In Posters and Demos at International Semantic Web Conference (ISWC)2005, Galway, Ireland.

W3C (2004). RDF Primer. http://www.w3.org/TR/rdf-primer/. Accessed April 12th,2011.

W3C (2007). RDF Validation Service. http://www.w3.org/RDF/Validator/. AccessedApril 12th, 2011.

W3C (2008). SPARQL Query Language for RDF.http://www.w3.org/TR/rdf-sparql-query/. Accessed April 12th, 2011.

Wege, C. (2002). Portal Server Technology. IEEE Internet Computing, 6(3):73–77.Weiss, W., Hausenblas, M., and Sprung, G. (2008). Visual Exploration, Query, and De-

bugging of RDF Graphs. In Semantic Web User Interaction at CHI 2008.Wiederhold, G. and Genesereth, M. (1997). The Conceptual Basis for Mediation Services.

IEEE Expert, 12(5):38 –47.Yahoo! Inc. (2011). Pipes: Rewire the web. http://pipes.yahoo.com/pipes/. Accessed

April 12th, 2011.Yu, J., Benatallah, B., Casati, F., and Daniel, F. (2008). Understanding Mashup Devel-

opment. IEEE Internet Computing, 12(5):44–52.

Date post:	22-May-2020
Category:	Documents
Upload:	others
View:	3 times
Download:	0 times

IMPROVING THE USABILITY OF INTEGRATED APPLICATIONS … · Improving Integrated Applications by...

Documents