Data-Fu: A Language and an Interpreter for Interaction

with Read/Write Linked Data

Steffen Stadtmüller Sebastian Speiser

Institutes AIFB, KSRI Institutes AIFB, KSRI
Karlsruhe Institute of Karlsruhe Institute of
Technology (KIT), Germany Technology (KIT), Germany
[email protected] [email protected]
Andreas Harth Rudi Studer
Institute AIFB Institutes AIFB, KSRI
Karlsruhe Institute of Karlsruhe Institute of
Technology (KIT), Germany Technology (KIT), Germany
[email protected] [email protected]

ABSTRACT sources and functionality from multiple providers. The im-

An increasing amount of applications build their function- portance of such compositions is reflected in the constant
ality on the utilisation and manipulation of web resources. growth of mashups – small programs that combine multiple
Consequently REST gains popularity with a resource-centric web APIs [33]. There is a strong movement in the web com-
interaction architecture that draws its flexibility from links munity toward a resource-oriented model of services based
between resources. Linked Data offers a uniform data model on Representational State Transfer (REST [11]). Flexibil-
for REST with self-descriptive resources that can be lever- ity, adaptivity and robustness are the major objectives of
aged to avoid a manual ad-hoc development of web-based REST and are particularly useful for software architectures
applications. For declaratively specifying interactions be- in distributed data-driven environments such as the web [22].
tween web resources we introduce Data-Fu, a lightweight However, data sources and APIs are published according to
declarative rule language with state transition systems as different interaction models and with interfaces using non-
formal grounding. Data-Fu enables the development of data- aligned vocabularies, which makes writing programs that
driven applications that facilitate the RESTful manipulation integrate offers from multiple providers a tedious task.
of read/write Linked Data resources. Furthermore, we de- The goal of our work is to provide a declarative means
scribe an interpreter for Data-Fu as a general purpose engine to specify interactions between data and functionality from
that allows to perform described interactions with web re- multiple providers. Such declarative specifications provide
sources by orders of magnitude faster than a comparable a modular way of composing the functionality of multiple
Linked Data processor. APIs. Also, declarative methods allow for automatically
optimising a program and parallelising the execution.
In a REST architecture, client and server are supposed to
Categories and Subject Descriptors form a contract with content negotiation, not only on the
H.5.4 [Hypertext/Hypermedia]: Architectures data format but implicitly also on the semantics of the com-
municated data, i.e., an agreement on how the data have
to be interpreted [32]. Since the agreement on the seman-
General Terms tics is only implicit, programmers developing client appli-
Languages, Performance cations have to manually gain a deep understanding of the
provided data, often based on natural text descriptions. The
Keywords combination of RESTful resources originating from differ-
ent providers suffers particularly from the necessary manual
REST; Linked Data; Web Interaction; Rule Language; In- effort to use and combine them. The reliance on natural
terpreter language descriptions of APIs has led to mashup designs in
which programmers are forced to write glue code with little
1. INTRODUCTION or no automation and to manually consolidate and integrate
There is a growing offer of functionality via web APIs1 . the exchanged data.
Increased value comes from combining data from multiple Linked Data unifies a standardised interaction model with
the possibility to align vocabularies using RDF, RDFS and
1
Alone http://programmableweb.com/ lists 7,991 APIs on OWL. However, the interactions are currently constrained to
November 24th 2012, which is almost twice the number from simple data retrieval. Following the motivation to look be-
one year earlier. yond the exposure of fixed datasets, the extension of Linked
Data with REST technologies has been explored [5, 34] and
Copyright is held by the International World Wide Web Conference
Committee (IW3C2). IW3C2 reserves the right to provide a hyperlink
to the author’s site if the Material is used in electronic media.
WWW 2013, May 13–17, 2013, Rio de Janeiro, Brazil.
ACM 978-1-4503-2035-1/13/05.

1225
led recently to the establishment of the Linked Data Plat-
form 2 W3C working group. Table 1: URI prefixes used throughout this paper
Several existing approaches recognise the value of combin-
ing RESTful services and Linked Data [17, 26, 30]. In this Prefix IRI
paper, we go one step further and propose Data-Fu, a data- acme: http://acme.example.org/company/
and resource-driven programming approach leveraging the p: http://acme.example.org/vocabulary/
combination of REST with Linked Data. Data-Fu enables sna: http://sna.example.org/lapi/
the development of applications built on semantic web re- snb: http://snb.example.org/rest/
sources with a declarative rule language. The main goal of mb: http://mb.example.org/interface/
Data-Fu is to minimise the manual effort to develop web-
based applications and the preservation of loose coupling by
• leveraging links between resources provided by Linked The marketing department orders a system from Acme’s
Data, and IT that manages the dissemination channels and automati-
• specifying desired interactions dependent on resource cally disseminates a post to all available channels either as
states, which is enabled by a uniform state description a micro blog entry or as a personal message. Initially the
format, i.e., RDF. micro blog service MB and the social network SNA have
A further requirement for our programming approach in to be supported. Marketing will supply their posts in an
a web-based environment is a fast and scalable execution Acme-specific vocabulary as so-called InfoItems.
of the applications. While there has been recent work on After a while, the marketing department decides to add
extending the Map/Reduce model for data-driven process- the new social network SNB as a dissemination channel,
ing [15, 4], these approaches are geared towards deployment which requires two steps: (i) the IT department extends the
in data centers. In contrast, our approach operates on the dissemination system to support the interface of SNB; and
networked open web. (ii) the marketing department adds Acme’s identity in SNB
This paper is based on a previous publication on a data- to the dissemination channels.
driven programming model for the web [27] and describes Throughout the paper, we will illustrate our technical con-
• how self-descriptive resources can be designed to en- tributions by realising bits and pieces of the proposed sce-
able loosely coupled clients (Section 4.1); nario. When modeling services and interactions, we will use
• a service model for REST based on state transition a number of URI prefixes for brevity that are either com-
systems as formal grounding (Section 4.2); mon4 or listed in Table 1.
• the Data-Fu language, a declarative rule-based exe-
cution language to allow an intuitive specification of
the interaction with resources from different providers 3. BACKGROUND
(Section 5);
According to the Richardson maturity model [24] REST
• an execution engine as an artefact to perform the de-
is identified as the interaction between a client and a server
fined interactions in a scalable manner (Section 6).
based on three principles:
We provide a motivating scenario in Section 2. We eval-
• The use of URI-identified resources.
uate our approach in two ways: (i) we describe throughout
• The use of a constrained set of operations, i.e., the
the paper how our motivating scenario can be realised with
HTTP methods, to access and manipulate resource
Data-Fu; and (ii) we conduct performance experiments with
states.
the Data-Fu interpreter in Section 7. Section 8 covers exist-
• The application of hypermedia controls, i.e., the data
ing work. We conclude in Section 9.
representing a resource contains links to other resources.
Links allow a client to navigate from one resource to
another during his interaction.
2. MOTIVATING SCENARIO The idea behind REST is that applications, i.e., clients, us-
In our scenario, we consider the Acme corporation, a con- ing functionalities provided on the web, i.e., APIs, are not
sumer goods producer, that aims at extending their social based on the call of API-specific operations or procedures
media activities to a broader range of dissemination channels but rather on the direct manipulation of exposed resource
(for more on multi-channel communication see [7]). Acme’s representations or the creation of new resource representa-
marketing department observes that while the number of po- tions. A resource can be a real world object or a data object
tential channels is constantly increasing, the channels can be on the web. The representation of a resource details the
broadly categorised into micro blog services and social net- current state of the resource. A manipulation of the state
works. Information about new products, special offers, and representation implies that the represented resource is ma-
other news should be disseminated in the following ways: nipulated accordingly. For brevity in this paper we often
(i) posts on the company’s micro blogs; and (ii) messages to talk about ”the manipulation of a resource”, when we actu-
social network users who are followers of the company. ally mean ”the manipulation of the state representation of a
We assume that the dissemination channels offer Linked resource and the subsequent change of the resource itself”.
APIs, i.e., resources are exposed that offer read/write Linked The flexibility of REST results from the idea that client
Data functionality.3 applications do not have to know about all necessary re-
sources. The retrievable representations of some known re-
2
http://www.w3.org/2012/ldp/charter sources contain links to other resources, that the client can
3
If there is no Linked API available, the conventional APIs
4
can be easily wrapped to consume and produce RDF, see, See http://prefix.cc/ for their full URIs, accessed on
e.g., [29, 17]. Wrapping APIs is out of scope of this paper. November 22nd 2012.

1226
discover during runtime. Clients can use such discovered
resources to perform further interaction steps. Table 2: Overview of HTTP methods
Method Safe Input Intuition
The Linked Data design principles5 also address the use required
of URI-identified resources and their interlinkage. However
GET x Retrieve the current
Linked Data is so far only concerned with the provision-
state of a resource.
ing and retrieval of data. In contrast to REST, Linked
OPTIONS x Retrieve a descrip-
Data does distinguish explicitly between URI-identified ob-
tion of possible inter-
jects (i.e., non-information resources) and their data repre-
actions.
sentation (information resources). An extension of Linked
DELETE Delete a resource
Data with REST to allow for resource manipulation leads to
read/write Linked Data, i.e., information resources can be PUT x Create or overwrite
accessed and manipulated. REST furthermore implies that a resource with the
a change of an information resource implies a change in the submitted input.
corresponding non-information resource. POST x Send input as subor-
The development of applications in a REST framework dinate to a resource
is especially challenging, since the links between resources or submit input to
and the resource states can only be determined during run- a data-handling pro-
time, however, programmers have to specify their desired cess.
interactions at design time.
Traditional service composition approaches that aim to
decrease the manual effort to use web-offered functional- safe method on the state of an addressed resource can de-
ity lead to a tight coupling between client and server, i.e., pend on the input data. The dependency between commu-
they sacrifice flexibility and are prone to failures due to nicated input and the resulting state of resources also needs
server-side changes. Traditional composition approaches of- to be described. Therefore, only the non-safe HTTP meth-
ten fail to leverage links between resources and do not pro- ods that require input data need further description mecha-
vide straightforward mechanisms to dynamically react to nisms. Note, the POST method can also influence the states
state changes of resources. The reaction on state changes of not directly addressed resources. The precise effect of a
becomes especially important in a distributed programming POST depends on the resource, since POST allows to send
environment, since a client cannot ex ante predict the influ- input data to a data-handling process of a resource.
ence of other clients on the resources, i.e., REST does not The state of a Linked Data resource is expressed with
allow a client to make assumptions on resource states. RDF. It is sensible to serialise the input data in RDF as well,
i.e., data that is submitted to resources to manipulate their
state. To convey the resulting state change after application
4. READ/WRITE LINKED DATA of a HTTP method we use RDF output messages. In previ-
In this section, we describe our approach for modelling of ous work [20] we analysed the potential of graph patterns,
RESTful services based on Linked Data. Our approach has based on the syntax of SPARQL7 , to describe required input
two layers: as well as their relation to output messages. The resulting
• Individual Read/Write Linked Data Resources with graph pattern descriptions are attached to the resource and
descriptions that allow predicting the effect of the exe- can be retrieved via the OPTIONS method on the respec-
cution of a functionality before invocation (Section 4.1); tive resource. Therefore the resources stay self-descriptive,
• A formal REST Service Model. A single REST ser- i.e., their current state can be retrieved with GET, the pos-
vice can consist of several resources, potentially spread sibilities to influence their state with OPTIONS.
over different servers. The service model is the ground- Example. Acme’s IT creates the resource acme:Acme rep-
ing for describing the interactions that are offered by resenting Acme. A GET on acme:Acme returns the following
the individual RESTful Linked Data resources and the initial description: acme:Acme rdf:type p:Company .
overall service (Section 4.2). The marketing department updates the acme:Acme resource
with the dissemination channels SNA and MB by perform-
4.1 Read/Write Linked Data Resources ing a PUT with the following input data:
In a RESTful interaction with Linked Data resources only acme:Acme rdf:type p:Company .
the HTTP methods can be applied to the resources. The se- acme:Acme p:dissChannel sna:Acme, mb:Acme .
mantics of the HTTP methods itself is defined by the IETF6 sna:Acme rdf:type p:SocialNetworkID .
and do not need to be explicitly described. mb:Acme rdf:type p:MicroBlogTimeline .
Table 2 shows an overview of the most important HTTP A subsequent GET on acme:Acme would result in exactly the
methods. We can distinguish between safe and non-safe description that marketing supplied with their PUT request.
methods, where safe methods guarantee not to affect the A GET on sna:Acme, Acme’s identifier in the social net-
current states of resources. Further, some of the methods work SNA, would result in a description of Acme in SNA’s
require additional input data to be provided for their in- vocabulary including its fans:
vocation. The communicated input data can be subject to sna:Acme rdf:type sna:CommercialOrganisation .
requirements that need to be described to allow an auto- sna:Acme sna:founded "11/20/2012" .
mated interaction, e.g., the input data can be required to sna:Acme sna:hasFan sna:User1, sna:User2, . . . .
use a specific vocabulary. Furthermore, the effect of a non- The resources representing users in the SNA network provide
5 7
http://www.w3.org/DesignIssues/LinkedData.html http://www.w3.org/TR/rdf-sparql-query/
6
http://www.ietf.org/rfc/rfc2616.txt #GraphPattern

1227
functionality to send messages to the corresponding users. state change function as
A POST can be employed to send a message to a user re- 
source (e.g., to sna:User1). The input data for the POST 
σk , if µ = GET

σ \ {r k },
contains its sna:sender and its sna:content, according to s k i if µ = DELETE
δ (σk , (ri , µ, g)) =
the description of the user resource that can be retrieved 
(σ k
k \ {ri }) ∪ g, if µ = PUT


with an OPTIONS request: posti (σk , g), if µ = POST,
INPUT: ?m rdf:type sna:Message .
?m sna:sender ?s . where the function posti encapsulates the resource spe-
?m sioc:content ?c . cific behaviour of a POST request, as described by its
OUTPUT: ?m sna:sender ?s . INPUT/OUTPUT patterns, which can be obtained via
?m sioc:content ?c . an OPTIONS request on the resource. Let σl be the
?m sna:receiver sna:User1 . new state as defined by δ s , we define the output func-
Acme’s timeline mb:Acme on the micro blogging service tion as
MB also supports the POST operation. Figure 1 illustrates 

 (c , rik ), if µ = GET
the timeline resource mb:Acme of our example, with a set 

of entries in the current state and the graph pattern that o (c , ∅), if µ = DELETE
δ (σk , (ri , µ, g)) =
describe how a new entry can be POSTed. 
 (c , σ l \σk ), if µ = PUT


Applying a DELETE on a blog post, e.g., one that ad- (c , σ l \σk ), if µ = POST.
vertises an expired sale, does not require input; its effect is
inherently defined by the method: the entry is erased. A client interacting with a service modelled by an RST S =
{R, Σ, I, O, δ} creates an input i = (ri , µ, g) for RST S by in-
voking the HTTP method µ on the resource ri and passing
4.2 REST Service Model the potentially empty RDF graph g in the request body. De-
pending on the current state σk of the service the following
A REST service can be identified with the resources it
happens:
exposes. An interaction within a REST architecture is based
1. The service transitions into the state δ s (σk , (ri , µ, g)).
on the manipulation of the states of the exposed resources.
2. The client gets an HTTP response with the HTTP
We develop a model, that allows to formalise the function-
code c and the RDF graph g " in the body, where (c, g " ) =
alities exposed by a REST API based on read/write Linked
δ o (σk , (ri , µ, g)).
Data resources. A formal service model serves as rigorous
Safe methods that do not change any resource states, de-
specification of how the use of individual HTTP methods
scribe self-transitions, i.e., transitions that start and end in
influences resource states and how these state changes are
the same state.
conveyed to interacting clients.
The output function in the case of PUT and POST report
We model a Linked Data-based RESTful service as a REST
to the client the effect the invocation of the method had on
state transition system (RSTS) similar to a state machine
the state of the RSTS (i.e. σl \σk ).
as defined by Lee and Varaiya [18]. The behavior of the
Resources do not necessarily allow the use of all HTTP
clients themselves is not in the scope of this model, it rather
methods. Note that all state change functions are defined
formalises all possible interaction paths of a client with the
for every resource, i.e., every resource can be addressed with
resources.
all methods: If a resource does not allow for the application
of a specific method, the state change function describes a
self-transition.
Definition 1. A REST state transition system (RSTS) The defined service model serves as formal grounding of
is defined as a 5-tuple RST S = {R, Σ, I, O, δ} with: the execution language described in Section 5. However, the
• A set of resources R = {r1 , r2 , ...}. self-descriptive resources provide sufficient information for
• A set of states Σ = {σ1 , ..., σm }. Each state σk ∈ Σ the interaction with the exposed resources.
of the RSTS is defined as the union of the states of • The current state of Linked Data resources – and there-
!
all resources: σk = ri ∈R rik . The state of a single fore the state of the RSTS – can be accessed as RDF.
resource ri ∈ R in a state σk is given by its RDF • The possible transitions and the state they result in are
representation rik ∈ G, where G is the set of all possible independent of the specific resource, except for POST
RDF graphs. transitions. The effect of POST transitions is declared
• An input alphabet I = {(r, µ, g) : R × M × G}, where with graph pattern descriptions (see Section 4.1).
M = {GET, DELETE, PUT, POST} is the set of the Example. Figure 2 illustrates a state transition in RSTS
supported HTTP methods8 . where an entry is POSTed to mb:Acme. Note, that a client
• An output alphabet O = {(c, o) : C × G}, where C is could derive the input for the POST method from the states
the set of all HTTP status codes. of other resources (e.g., from Acme InfoItems).
• An update function δ : Σ × I → Σ × O that returns
for a given state and input the resulting state and the 5. THE DATA-FU LANGUAGE
output. We decompose δ into a state change function
δ s : Σ × I → Σ and an output function δ o : Σ × I → O, In this section, we present Data-Fu9 , an execution lan-
such that δ(σ, i) = (δ s (σ, i), δ o (σ, i)). We define the guage to instantiate a concrete interaction between a client
9
We use the name Data-Fu in adaption of the term google-
fu, which adopts the suffi xFu of from Kung Fu, implying
8
For brevity we focus here on the four most important meth- great skill or mastery. Thus Data-Fu hints at the mastery
ods. Other methods can be added analougously. of data interaction that can be achieved with the language.

1228
Figure 1: Self-descriptive resource: current state can be accessed with GET, input/output description with
OPTIONS

Figure 2: State transition of a RSTS, with excerpts of two states.

and resources, which preserves the adaptability, robustness programmers can define an interaction pattern with a set of
and flexibility of REST. rules for their client applications.
In a resource-driven environment, applications retrieve The use of conjunctive queries is motivated by the idea
and manipulate resources exposed on the Web. Since the re- that clients have to maintain a knowledge space (KS) in
sources can potentially be accessed by a multitude of clients, which they store their knowledge about the states of the re-
applications have to react dynamically on the state of the re- sources they interact with [17, 25]. KS is filled with the RDF
sources. Therefore, an important factor in the development data the client receives after applying an HTTP method, as
of resource-driven applications is the dependency between defined by the output functions of the RSTS. The output
the invoked transitions and resource states. The dependency always informs the client about the current state after the
between the invoked state transitions (i.e., applied HTTP application of the method.
methods) and the states of resources is that Concretely N3 graph patterns are employed as queries q,
1. input data for the transition is derived from RDF de- which are evaluated over KS. If the evaluation of q is suc-
tailing the states of resources and/or cessful, i.e., matches are found in KS, the defined HTTP
2. the transition is only invoked, if resources are in a spec- method µ is applied to r with input g. The query q can also
ified state. be used to dynamically (i.e., during runtime)
Data-Fu, a declarative rule-based execution language, en- 1. derive input data from the states of other resources, as
ables programmers to define their desired state transitions. stored in KS and
Data-Fu rules specify the interaction of a client with REST- 2. identify the resource to which an HTTP method has
ful Linked Data resources and congruously a path through to be applied, i.e., leveraging hypermedia controls.
the RSTS. Further Data-Fu allows to specify the conditions Regarding 1: Instead of specifying the input data g explicitly
under which a specific transition is to be invoked as subject as RDF graph, a graph pattern can be used. If a match is
to the states of resources. found for q in KS, the identified bindings for q are used to
replace the variables in g to establish the input data for the
Definition 2. A rule ρ is of the form µ(r, g) ← q, interaction (with HTTP method µ at resource r). g as graph
where µ ∈ M is an HTTP method, r ∈ R ∪ V is a resource pattern and q act together similar to a SPARQL construct
or a variable with V the set of all variables, g ∈ G ∪ P is a query over KS, where the result of the query is used as input
(potentially empty) RDF graph or graph pattern, and q ∈ P data for the invocation of the method µ.
is a conjunctive query with P the set of all possible RDF Regarding 2: To preserve the flexibility provided by REST
graph patterns. If r is a variable, it must be bound in q. If our execution language has to be able to make use of links
g is a graph pattern, all its variables must be bound in q. in the resource states to other resources. Rather than spec-
The head of a rule corresponds to an update function of ifying the addressed resource r of a rule explicitly as URI,
the RSTS in that it describes an HTTP method that is to a variable can be used. If a match is found for q in KS, an
be applied to a resource. The rule bodies are conjunctive identified binding for a variable q is used for the variable r.
queries that allow programmers to express their intention r as variable and q act together as a SPARQL select query
under which condition a method is to be applied. Thus, to identify the targeted resources of method µ.

1229
 A Data-Fu program terminates when there are no active POST (?f, { []
rdf:type snb:PrivateMsg ;
transitions and no rules can be activated that could trig- snb:origin snb:ACME ;
ger new transitions. In general, termination of a program snb:text ?c . })
cannot be guaranteed, as every transition can result in data ← { snb:ACME snb:followedBy ?f .
that triggers new transitions. However, the termination of a ?x rdf:type p:InfoItem .
program is not necessarily intended by a programmer, in the ?x p:content ?c }.
case of applications that are supposed to continuously inter- The new dissemination channel is active when marketing
act with resources. Furthermore, the deletion and change of PUTs Acme’s identifier in SNB’s network to acme:Acme.
resources can lead to applications with a non-deterministic
execution behavior. For discussions about properties of rule 6. THE DATA-FU INTERPRETER
sets in related languages that guarantee termination and de- The Data-Fu interpreter is an execution engine for service
terminism, we refer the reader to [2]. interactions specified as a set of Data-Fu rules. The engine
Example. The IT department of Acme creates the dis- implements the KS as well as the functionality to invoke in-
semination system with four Data-Fu rules. The market- teractions with resources as defined in the rules. In practice,
ing department has simply to create new InfoItems and the we translate a Data-Fu program into a logical dataflow net-
system automatically distributes the information over the work, which is then optimised (e.g., re-using triple patterns
dissemination channels of Acme. The rules are defined as and joins). The optimised logical network is then trans-
follows: formed into an evaluator plan that actually implements the
1. Whenever a InfoItem is found, retrieve the resource dataflow network.
acme:Acme to get an up-to-date list of the current dis- We realise the evaluator plan for the Data-Fu engine as
semination channels. a streaming processor that can process several queries in
GET (acme:Acme, {}) ← { ?x rdf:type p:InfoItem } parallel. We implement the processor as a multi-threaded
component with one thread evaluating individual triple pat-
2. If a p:MicroBlogTimeline is found (from the retrieved terns, and separate threads for each join operator and for
dissemination channels), post a new entry to the time- each rule head, i.e., the component that performs the state
line using the content from the InfoItem. transitions by invoking the corresponding HTTP methods
POST (?mb, { [] rdf:type sioc:Post ; on resources. The joins are implemented as symmetric hash
sioc:content ?c . }) join operators [35]. The implemented dataflow network is
← { ?x rdf:type p:InfoItem . similar to a parallel version of the Rete algorithm [12].
?x p:content ?c . To enable a wide variety of applications the engine can
?mb rdf:type p:MicroBlogTimeline } . include an extension to support the interaction with REST
3. If a social network ID of Acme is found (from the re- resources that are not based on Linked Data. The engine can
trieved dissemination channels), retrieve the represen- store data entities (e.g., binaries, JSON documents) received
tation of Acme from the social network to get a list of from such services separately. A triple pointing to a received
Acme’s followers. non-RDF entity can be included in KS, thus the entities can
GET (?sid, {}) be used in the logic of the execution rules. However, an
← { ?sid rdf:type p:SocialNetworkID } . interaction with such non-RDF entities requires to fall back
to a more mashup-like programming approach.
4. Post to every found follower of Acme on SNA a mes- Example. The dataflow network shown in Figure 3 evalu-
sage with the content of the InfoItem. ates the plan generated for the Data-Fu program for Acme’s
POST (?f, { [] rdf:type sna:Message ; dissemination system. We can see that joins (e.g., the join
sna:sender sna:Acme ; on ?x) are re-used, i.e., have multiple outgoing edges. The
sna:content ?c . }) triple stream is initialised by the service input, which is sent
← { sna:Acme sna:hasFan ?f . by the client via a POST request. If the input data con-
?x rdf:type p:InfoItem . tains a description of an information item, it will trigger
?x p:content ?c }. the rule retrieving Acme’s description containing links to
The described rules disseminate new information items au- its dissemination channels. The social networks will fire a
tomatically to social network SNA and the micro blog MB. rule, which then retrieves the social network id’s of Acme
IT deploys the dissemination system itself as a read/write and thus retrieve the corresponding followers. Both social
Linked Data resource under acme:Dissemination. Market- network followers and micro blog timelines will then trigger
ing uses the dissemination service by POSTing a graph to the corresponding POST actions that will sent the informa-
the dissemination resource that corresponds to the following tion item in the appropriate vocabulary to the dissemination
input pattern: channels, i.e., as micro blog posts or personal messages to
{ ?x rdf:type p:InfoItem. ?x p:content ?c } . the followers.
Other dissemination channels can easily be added to the
system, simply by adding corresponding rules in the system. 7. EVALUATION
For example, we consider that IT adds support for social To evaluate the scalability of the Data-Fu engine we com-
network SNB by adding a rule that uses SNB’s vocabulary pared execution times for different numbers of interactions
for retrieving followers and sending a message: and rules with Cwm10 , a data-processor for the Semantic
Web. Cwm uses a local triple store that supports the full
N3 language to save data and intermediate results. The local
10
http://www.w3.org/2001/sw/wiki/CWM

1230
 GET(?sid, {}) ?sid rdf:type p:SocialNetworkID Service Input Data-Fu Rule Head

Triple Stream Input POSTed to Service

Dataow
GET(acme:Acme, {}) ?x rdf:type p:InfoItem ?x p:content ?c

pattern Triple pattern matcher

?x
POST(?f, { [] rdf:type sna:Message ;
POST(?f, { [] sna:sender sna:Acme ; X sna:Acme sna:hasFan ?f ?x Join on variable ?x
POST(?f, { [] sna:content ?c . })
X Cross-product
POST(?f, { [] rdf:type snb:PrivateMsg ;
POST(?f, { [] snb:origin snb:ACME ; X snb:ACME snb:followedBy ?f
POST(?f, { [] snb:text ?c . })

POST(?mb, { [] rdf:type sioc:Post ;

X ?mb rdf:type p:MicroBlogTimeline
POST(?mb, { [] sioc:content ?c . })

Figure 3: Dataflow network of Acme’s dissemination system

triple store of Cwm uses seven indices to allow for a rapid local:1 rdf:type local:number.
readout of the local data with almost every combination local:1 local:value "1".
of subject, predicate and object patterns. For inferencing local:1 local:successor local:2.
Cwm uses a forward chain reasoner for N3 rules. The pat- We chose this design to easily keep track of the number
tern matching for the rules is done by recursive search with of performed interactions.
optimisations, such as identifying an optimal ordering for For the evaluation we start with the resource number 0,
the evaluation of the rules and patterns. which we manually inject into the Data-Fu engine and Cwm.
Cwm is built as a general purpose tool to query, process, We identify and retrieve the successor of the number. The
filter and manipulate data from the Semantic Web. As such, successor of a number yields a new successor to retrieve,
the motivation behind Cwm is closest to the Data-Fu engine, and so on. The interactions of this set-up are illustrated in
compared with any other rule engines or reasoning systems, Figure 4.
to the best of our knowledge. However, Cwm is not tar-
geted on the direct RESTful manipulation of web resources,
but their retrieval and the local manipulation of the data.
Therefore to make the systems comparable we limit the eval-
uated interactions to GET transitions, i.e., we use only rules
that retrieve resources, if a match for the rule body is found.
Please note that the limitation to GET transitions does not Figure 4: Interactions of evaluation set-up with one
influence the validity of the evaluation: Since additional ex- rule
ecution time when using non-safe interactions (e.g., PUT,
POST) only results from time required to transmit data to We realise the interactions with the Data-Fu Engine and
resources and the subsequent time necessary to process this Cwm (for the latter in two different ways) as follows:
data by the server, where the resource resides. This time • Data-Fu: For the Data-Fu engine we use a rule:
overhead caused by non-safe transitions is neither influenced
by the Data-Fu engine, nor could it be avoided by any other GET (?suc, {}) ← {?n rdf:type local:number
system that we could use as comparison. ?n local:value ?v
We conducted the experiments on a 2.4 GHz Intel Core 2 ?n local:successor ?suc}
Duo with 4 GB of memory (2 GB assigned to Java virtual The rule body queries for a resource (variable ?n) that
machine on which the experiments run). Thus we evaluate is typed as number, has a value and a successor. If
the Data-Fu engine on commodity hardware with the intent a match is found, a GET transition is triggered at
to show the parallelisation-based scalability of the Data-Fu whatever URI is identified to be the successor of the
engine not only on high-end industrial machines. matched number. The Data-Fu engine adds the re-
We deploy Linked Data resources used for the interactions trieved representation of the successor to the data flow
locally on an Apache Tomcat11 server to further minimise network, which results in the identification of the next
execution time variations caused by establishing HTTP con- successor to retrieve. Thus, all numbers are iteratively
nections and retrieving data over the web. In the rules used found and retrieved.
by the Data-Fu engine and Cwm the resources are addressed • Cwm direct: Cwm offers built-in functions to perform
with their localhost address. Every deployed resource repre- web-aware queries in rules. The keyword log:semantics
sents a number. Every number resource is typed as number in a query of a rule allows to resolve a URI and bind
and contains its value as literal and a link to the successor the retrieved RDF data to a variable as formula. The
of the number: formula bound to a variable can then be used to con-
struct triples in the rule head. We used the following
rule to perform the desired interaction:
11
http://tomcat.apache.org/

1231
 {{ :n rdf:type local:number.
:n local:value :v.
:n local:successor :suc }
local:is local:known. }
:suc log:semantics :sem.
⇒
{ :sem local:is local:known. }
Like in the approach for the Data-Fu engine we query
for the successor of a number. The successor is re-
trieved and bound as formula in subject position to a
new triple that is written to the triple store. Since the
retrieved representation of the number appears only as
formula in triples we have to extend the query in the
rule body to search for the successor of a number in
a formula in subject position of a triple, thus making
the query slightly more complicated than in the case of
the Data-Fu engine. Cwm repeatedly applies the rule Figure 5: Average execution time from ten runs for
to the triple store, thus retrieving all numbers. different evaluation set-ups with one rule
• Cwm import: To compare the performance of Cwm
with the Data-Fu engine, where the queries of the rules
are equally complex, we implemented the desired re- The Data-Fu engine is able to execute the interaction by
trieval with another approach, with the following rule: orders of magnitude faster than the other two approaches
with Cwm. Also the growth-rate of the execution time with
{ :n rdf:type local:number.
the increasing size of number sets is much lower with Data-
:n local:value :v.
Fu compared to the Cwm approaches (note the log scale in
:n local:successor :suc }
Figure 5). The Data-Fu engine achieves this time saving by
⇒
leveraging the data flow network: Data-Fu has just to put
{ :n owl:imports :suc. }
the new results after an interaction through the data flow
We use the same query to identify the successor of network to find new bindings. Cwm on the other hand has
a number as for the Data-Fu engine. For every found to apply the rules repeatedly over the increasing dataset in
match we write a triple to the Cwm store, that marks its triple store.
the identified successor with owl:imports. Cwm of- To evaluate the capabilities of the Data-Fu engine with re-
fers a command to retrieve all resources marked with gard to parallelisation we run the same interaction of retriev-
owl:imports. This allows us to programmatically in- ing successors of numbers again, with ten different ”kinds”
struct Cwm to apply the rule and retrieve the suc- of numbers (A-J) in parallel. The numbers are distinguished
cessor, as many times as needed. Note, that this im- by different namespaces. Each of the three evaluation set-
plementation of the interaction does not deliver the ups requires ten rules for the interaction (each addressing
same functionality as with the Data-Fu engine: We another namespace), analog to the previously shown rules.
have to manually define how often the rule followed by Figure 6 illustrates this evaluation set-up.
the retrieve command is to be applied (once for every
number), rather then having the engine automatically
retrieve all the numbers.
We evaluate the execution time of the interaction with
all three setups for sets of 20, 40, 60, 80 and 100 numbers.
With the approaches Data-Fu and Cwm direct the interac-
tion ends when the last number in a set does not refer to a
next successor to retrieve. For Cwm import we had to decide
manually how often the rule is applied and thus how many
numbers are retrieved and when the interaction stops. The
results are shown in Table 3 and Figure 5. We provide the
average execution times from ten runs to reduce variations.

Table 3: Average execution time from ten runs for Figure 6: Interactions of evaluation set-up with one
different evaluation set-ups with one rule rule
number set size Data-Fu Cwm direct Cwm import
20 342 ms 1549 ms 468 ms The results for the different evaluation set-ups are shown
40 371 ms 5144 ms 976 ms in Table 4 and Figure 7 as average from ten runs. Again
60 500 ms 11272 ms 1595 ms Data-Fu executes the interaction significantly faster with a
80 555 ms 21005 ms 2309 ms lower growth rate than Cwm in the other set-ups: In the case
100 594 ms 32213 ms 3688 ms of the most interactions (10 x 100) Cwm direct requires over
17 minutes and Cwm import over 32 seconds, the Data-Fu
engine handles the same interactions in under 4 seconds.

1232
 engine with 20, 40, 60, 80 and 100 rules/number sets, thus
Table 4: Average execution time from ten runs for performing between 2 000 and 10 000 interactions. Addition-
different evaluation set-ups with ten rules in parallel ally we measure the time needed to calculate the evaluation
number set size Data-Fu Cwm direct Cwm import plan separately to compare it with the total execution time.
20 1833 ms 22513 ms 2836 ms The results are shown in Table 5 and Figure 8.
40 2421 ms 108421 ms 7067 ms
60 2916 ms 310498 ms 13518 ms
80 3889 ms 621798 ms 21729 ms Table 5: Average execution time from ten runs of
100 3944 ms 1038524 ms 32983 ms Data-Fu engine with number sets of size 100
rules/number sets execution time evaluation plan
20 8357 ms 4 ms
40 17195 ms 6 ms
60 30767 ms 7 ms
80 49430 ms 8 ms
100 75764 ms 9 ms

Figure 7: Average execution time from ten runs for

different evaluation set-ups with ten rules in parallel

Comparing the results of the interactions with a single rule

and the interactions with ten rules in parallel we note, that
the Data-Fu engine suffers less than Cwm from the ten times
increased workload when executing ten rules in parallel. On Figure 8: Average execution time from ten runs of
average for the individual sizes of number sets Data-Fu engine with number sets of size 100
• Data-Fu requires 6.2 times longer,
• Cwm direct requires 25 times longer, The results of the evaluation for large amounts of interac-
• Cwm import requires 8 times longer, tions show that the Data-Fu engine scales well up to thou-
when running with ten rules compared to one single rule. sands of interactions even on commodity hardware. The
The reason for this time advantage is the capability of the Data-Fu engine is capable of interacting with 10 000 web
Data-Fu engine to execute several components of the inter- resources in about 1:15 min. The necessary time required
action in parallel, e.g., the evaluation of the triple patterns to establish the evaluation plan increases with the number
of the queries and the communication with several web re- of rules, but remains a very small fraction of the overall
sources. Note, that the theoretically possible speedup due execution time and is therefore negligible.
to parallelisation on a dual core system implies that a 10 The evaluation shows the advantages of the parallel pro-
times increased workload results in a 5 times longer execu- cessing of queries and interactions and provides evidence
tion time. However, the Data-Fu engine cannot quite reach that the Data-Fu engine is capable of performing rapid inter-
this optimal speedup, since not all parts in the interaction actions with web resources as desired. We did not consider
can be completely parallelised, e.g., the management of the the necessary time to establish HTTP connections on the
individual threads. These parts of an interaction that can- web and the response time of the servers, where resources
not be completely parallelised result in a slightly diminished are deployed, since these additional time requirements would
speedup, as stated by Amdahl’s Law [3]. be the same for any employed interaction system. Note how-
Following the results of the evaluation in comparison with ever, that due to its parallel processing nature, the Data-Fu
Cwm, we devise a final evaluation setting to test the scala- engine could further benefit from longer response times of
bility of the Data-Fu engine when performing large amounts servers compared to other systems: At the same time as the
of interactions. Similar to the previous evaluation setting we Data-Fu engine performs the manipulations and retrieval of
retrieve number resources that are identified during runtime resources other rules can be evaluated, thus the overall exe-
as successor of an already found number. We fix the size cution time can be minimised.
of the number sets to 100, i.e., we deploy sets of 100 con- We provide the data used for the evaluation and an exe-
secutive number resources that are distinguished with their cutable jar online12 to re-run the experiments.
namespace. Then we retrieve the numbers of every set with
12
a respective rule. We evaluate the runtime of the Data-Fu http://people.aifb.kit.edu/sts/datafu/evaluation/

1233
8. RELATED WORK 9. CONCLUSION
Pautasso introduces an extension to BPEL [21] for a com- In this paper, we addressed the problem of creating value-
position of REST and traditional web services. REST ser- added compositions of data and functionalities. As a unify-
vices are wrapped in WSDL descriptions to allow for a BPEL ing model for both static data sources and dynamic services,
composition. Our approach focuses on a native composition we described how Linked Data Resources can be extended
of REST services, rather than relying on technologies of tra- with descriptions for RESTful manipulation. The natural
ditional web services. For a comparison between RESTful extension of Linked Data with RESTful manipulation of re-
services and “big” services see [23]. sources enables a framework with uniform semantic resource
There exist several approaches that extend the WS-* stack representations for REST architectures. We have proposed
with semantic capabilities by leveraging ontologies and rule- to exploit the advantages resulting from the combination of
based descriptions (e.g., [28, 10, 8]) to achieve an increased REST and Linked Data in a programming framework for the
degree of automation in high level tasks, such as service Semantic Web. We have introduced Data-Fu, a declarative
discovery, composition and mediation. Those approaches rule-based execution language with a state transition system
extending WS-* became known as Semantic Web Services as formal grounding, and the challenges we address with this
(SWS). An Approach to combine RESTful services with language, i.e., achieving scalability and performance while
SWS technologies in particular WSMO-Lite [31] was inves- preserving the flexibility and robustness of REST. Further-
tigated by Kopecky et al. [16]. In contrast to SWS, REST more, we described our implementation of an execution en-
architectures do not allow to define arbitrary functions, but gine for the Data-Fu language.
are constrained to a defined set of methods and are built For future work, we plan to extend our approach in the fol-
around another kind of abstraction: the resource. There- lowing directions. First, we will add capabilities to improve
fore our approach is more focused on resource/data centric handling of failures of resource interactions. Second, we will
scenarios in distributed environments (e.g., in the Web). extend our formal model of Data-Fu to provide clearly de-
Active XML introduces service calls as XML nodes that fined semantics in the presence of non-deterministic rules.
are placeholders for new XML documents that can be re- Third, we will integrate support for rule-based reasoning into
trieved from the service [1]. The service calls are compara- the execution engine. The rules bring useful expressivity for
ble to hypermedia links in resource descriptions and the ac- aligning different vocabularies and can be easily supported
tive XML document corresponds to the knowledge space. In in the engine by introducing triple-producing rule heads in
contrast to Active XML, our work discovers links to new re- addition to the current state transition handlers.
sources instead of links to function calls. The resource model
provides more flexibility, e.g., a Data-Fu program could per-
form a DELETE on a discovered resource, whereas the Ac-
Acknowledgments
tive XML equivalent would be constrained to the predefined This work was partially supported by the PlanetData NoE
operations in the original link. (FP7:ICT-2009.3.4, #257641) and by the German Ministry
The scripting language S [6] allows to develop Web re- of Education and Research (BMBF) within the Software-
sources with a focus on performance due to parallelisation Campus project framework.
of calculations. Resources can make use of other resources in
descriptions, thus also enabling a way of composing REST 10. REFERENCES
services. S does not explicitly address the flexibility of REST
and has no explicit facilities to leverage hypermedia controls [1] S. Abiteboul, O. Benjelloun, and T. Milo. Positive
or to infer required operations from resource states. Active XML. In Proceedings of the 23rd Symposium on
RESTdesc [30] is an approach in which RESTful Linked Principles of Database Systems (PODS’04), pages
Data resources are described in N3-Notation. The composi- 35–45. ACM, 2004.
tion of resources is based on an N3 reasoner and stipulates [2] A. Aiken, J. Widom, and J. M. Hellerstein. Behavior
manual interventions of users to decide which hypermedia of database production rules: Termination, confluence,
controls should be followed. and observable determinism. SIGMOD Record,
Hernandez et al. [14] proposes a model for semantically 21(2):59–68, 1992.
enabled REST services as a combination of pi-calculus [19] [3] G. M. Amdahl. Validity of the single processor
and approaches to triple space computing [9] pioneered by approach to achieving large scale computing
the Linda system [13]. They argue, that the resource states capabilities. In Proceedings of the 1967 Spring Joint
can be seen as triple spaces, where during an interaction Computer Conference (AFIPS’67), pages 483–485,
triple spaces can be created and destroyed as proposed in an Atlantic City, New Jersey, 1967. ACM.
extension of triple space computing by Simperl et al. [25]. [4] D. Battré, S. Ewen, F. Hueske, O. Kao, V. Markl, and
Our service model is in contrast to this approach more fo- D. Warneke. Nephele/PACTs: A programming model
cused on the composition of data driven interactions. and execution framework for web-scale analytical
Similar to the idea of triple spaces is the composition of processing. In Proceedings of the 1st ACM Symposium
RESTful resources in a process space, proposed by Krum- on Cloud Computing (SoCC’10), pages 119–130,
menacher et al. [17] based on resources described using Indianapolis, Indiana, USA, 2010. ACM.
graph patterns. Speiser and Harth [26] propose similar de- [5] T. Berners-Lee. Read-Write Linked Data. August
scriptions for RESTful Linked Data Services. Our approach 2009. Avaiable at http://www.w3.org/DesignIssues/
shares the idea that graph pattern described resources read ReadWriteLinkedData.html, accessed 26th November
input from and write output to a shared space. We improve 2012.
on this approach by providing a service model and a more [6] D. Bonetta, A. Peternier, C. Pautasso, and W. Binder.
explicit way of defining the interaction with resources. S: A scripting language for high-performance RESTful

1234
 web services. In Proceedings of the 17th ACM [22] C. Pautasso and E. Wilde. Why is the web loosely
SIGPLAN Symposium on Principles and Practice of coupled?: A multi-faceted metric for service design. In
Parallel Programming (PPoPP’12), 2012. Proceedings of the 18th International Conference on
[7] C. Brenner, A. Fensel, D. Fensel, A. Gagiu, World Wide Web (WWW’09), pages 911–920, Madrid,
I. Larizgoitia, B. Leiter, I. Stavrakantonakis, and Spain, 2009. ACM.
A. Thalhammer. How to domesticate the [23] C. Pautasso, O. Zimmermann, and F. Leymann.
multi-channel communication monster. Available at Restful web services vs. ”big”’ web services: making
http://oc.sti2.at/sites/default/files/oc_ the right architectural decision. In Proceedings of the
short_handouts.pdf. 17th International Conference on World Wide Web,
[8] J. Cardoso and A. Sheth. Semantic Web Services, WWW ’08, pages 805–814, New York, NY, USA,
Processes and Applications. Springer, 2006. 2008. ACM.
[9] D. Fensel. Triple-space computing: Semantic web [24] L. Richardson and S. Ruby. RESTful Web Services.
services based on persistent publication of O’Reilly Media, 2007.
information. In Proceedings of the IFIP International [25] E. Simperl, R. Krummenacher, and L. Nixon. A
Conference on Intelligence in Communication Systems coordination model for triplespace computing. In
(INTELLCOMM’04), number 3283 in Lecture Notes Proceedings of the 9th International Conference on
in Computer Science, pages 43–53, Bangkok, Coordination Models and Languages
Thailand, 2004. Springer. (COORDINATION’07), 2007.
[10] D. Fensel, H. Lausen, A. Polleres, J. de Bruijn, [26] S. Speiser and A. Harth. Integrating Linked Data and
M. Stollberg, D. Roman, and J. Domingue. Enabling services with Linked Data Services. In Proceedings of
Semantic Web Services: The Web Service Modeling the 8th Extended Semantic Web Conference
Ontology. Springer, 2006. (ESWC’11) Part I, volume 6643 of Lecture Notes in
[11] R. Fielding. Architectural Styles and the Design of Computer Science, pages 170–184, Heraklion, Crete,
Network-based Software Architectures. PhD thesis, Greece, 2011. Springer.
University of California, Irvine, 2000. [27] S. Stadtmüller and A. Harth. Towards data-driven
[12] C. Forgy. Rete: A fast algorithm for the many programming for RESTful Linked Data. In Workshop
pattern/many object pattern match problem. on Programming the Semantic Web (ISWC’12), 2012.
Artificial Intelligence, 19(1):17–37, 1982. [28] R. Studer, S. Grimm, and Abecker, A. (eds.).
[13] D. Gelernter. Generative communication in Linda. Semantic Web Services: Concepts, Technologies, and
ACM Transactions on Programming Languages and Applications. Springer, 2007.
Systems (TOPLAS), 7:80–112, 1985. [29] M. Taheriyan, C. A. Knoblock, P. A. Szekely, and
[14] A. G. Hernández and M. N. M. Garcı́a. A formal J. L. Ambite. Rapidly integrating services into the
definition of RESTful semantic web services. In Linked Data cloud. In Proceedings of the 11th
Proceedings of the First International Workshop on International Semantic Web Conference (ISWC’12),
RESTful Design (WS-REST’10), pages 39–45, 2010. volume 7649 of Lecture Notes in Computer Science,
[15] M. Isard, M. Budiu, Y. Yu, A. Birrell, and D. Fetterly. pages 559–574. Springer, 2012.
Dryad: Distributed data-parallel programs from [30] R. Verborgh, T. Steiner, D. V. Deursen, R. V.
sequential building blocks. In Proceedings of the 2nd de Walle, and J. G. Valls. Efficient runtime service
ACM SIGOPS/EuroSys European Conference on discovery and consumption with hyperlinked
Computer Systems (EuroSys’07), pages 59–72, Lisbon, RESTdesc. In Proceedings of the 7th International
Portugal, 2007. ACM. Conference on Next Generation Web Services
[16] J. Kopecky, T. Vitvar, and D. Fensel. MicroWSMO: Practices (NWeSP’11), Salamanca, Spain, 2011.
Semantic description of RESTful services. Technical [31] T. Vitvar, J. Kopecky, M. Zaremba, and D. Fensel.
report, WSMO Working Group, 2008. WSMO-Lite: Lightweight semantic descriptions for
[17] R. Krummenacher, B. Norton, and A. Marte. Towards services on the web. In Proceedings on the 5th
Linked Open Services. In Proceedings of the 3rd Future European Conference on Web Services (ECOWS’07),
Internet Symposium (FIS’10), volume 6369 of Lecture pages 77–86, 2007.
Notes in Computer Science, Berlin, Germany, 2010. [32] J. Webber. REST in Practice: Hypermedia and
Springer. Systems Architecture. O’Reilly, 2010.
[18] E. A. Lee and P. Varaiya. Structure and Interpretation [33] M. Weiss and G. R. Gangadharan. Modeling the
of Signals and Systems. Addison-Wesley, 2011. mashup ecosystem: Structure and growth. R&D
[19] R. Milner. Communicating and Mobile Systems: Management, 40(1):40–49, 2010.
π-calculus. Cambridge University Press, Cambridge, [34] E. Wilde. REST and RDF granularity, 2009. Available
UK, 1999. at http://dret.typepad.com/dretblog/2009/05/
[20] B. Norton and S. Stadtmüller. Scalable discovery of rest-and-rdf-granularity.html.
linked services. In Proceedings of the 4th International [35] A. N. Wilschut and P. M. G. Apers. Dataflow query
Workshop on REsource Discovery (RED’11), 2011. execution in a parallel main-memory environment. In
[21] C. Pautasso. RESTful web service composition with Proceedings of the 1st International Conference on
BPEL for REST. Journal of Data and Knowledge Parallel and Distributed Information Systems
Engineering, 68(9):851–866, 2009. (PDIS’91), pages 68–77, Miami Beach, FL, USA,
1991. IEEE Computer Society Press.

1235