=Paper=
{{Paper
|id=Vol-2073/article-05
|storemode=property
|title=None
|pdfUrl=https://ceur-ws.org/Vol-2073/article-05.pdf
|volume=Vol-2073
|dblpUrl=https://dblp.org/rec/conf/www/KaferH18
}}
==None==
https://ceur-ws.org/Vol-2073/article-05.pdf
Rule-based Programming of User Agents for Linked Data
Tobias Käfer Andreas Harth
Karlsruhe Institute of Technology (KIT) Karlsruhe Institute of Technology (KIT)
Institute AIFB Institute AIFB
Karlsruhe, Germany Karlsruhe, Germany
tobias.kaefer@kit.edu harth@kit.edu
ABSTRACT with read-write capabilities (HTTP PUT, POST, and DELETE oper-
While current Semantic Web languages and technologies are well- ations) for the interface to writeable resources, most systems that
suited for accessing and integrating static data, methods and tech- interact with LDP servers are still programmed in imperative code.
nologies for the handling of dynamic aspects – required in many We would like to specify the behaviour of user agents in a language
modern web environments – are largely missing. We propose to use grounded in mathematical logic.
Abstract State Machines (ASMs) as the formal basis for dealing with A high-level language for the specification of the behaviour
changes in Linked Data, which is the combination of the Resource of user agents would allow expressing executable specifications,
Description Framework (RDF) with the Hypertext Transfer Proto- which are shorter and cheaper to create than imperative code, and
col (HTTP). We provide a synthesis of ASMs and Linked Data and which are easier to validate (e. g. with subject matter experts) and
show how the combination aligns with the relevant specifications to analyse (e. g. using formal methods). The language could also
such as the Request/Response communication in HTTP, the guide- serve as execution substrate for agent specifications created using
lines for updating resource state in the Linked Data Platform (LDP) planning approaches from Artificial Intelligence.
specification, and the formal grounding of RDF in model theory. Several approaches exist for specifying user agents on read-only
Based on the formalisation of Linked Data resources that change Linked Data. These user agents process queries and have the ability
state over time, we present the syntax and operational semantics of to follow links, which can lead to the discovery of additional data
a small rule-based language to specify user agents that use HTTP during query processing [5], [16], [12], [38], [17]. An extension
to interact with Linked Data as the interface to the environment. to read and write capabilities in addition to the following of links,
We show the feasibility of the approach in an evaluation involving which is core to web architecture [9], [30], would allow for user
the specification of automation in a Smart Building scenario, where agents that are able to not only query data but also to effect change.
the presented approach serves as a theoretical foundation. The choice of a formalism for dynamical aspects on the web should
respect these standards, specifications, and practices as foundations.
1 INTRODUCTION How to beneficially combine current technologies around Linked
Data and REST into a unified formalism of dynamics is an open
Data in languages such as RDF (Resource Description Framework)1 ,
research problem [18], [43], [31], [13].
RDFS (RDF Schema)2 , and OWL (Web Ontology Language)3 is
We present an approach for programming user agents for Linked
widely deployed on the web4 and allow for data representation
Data. Following a hypermedia architectural style, the approach
and integration. The technologies around Linked Data [3] facilitate
operates on a set of resources, with a resource’s state described in
the publication of and access to such data: data publishers make
RDF. The resource state descriptions contain references to other
RDF files available on web servers; user agents can then access the
resources (links). Resource state can be manipulated via HTTP
published RDF files using HTTP (Hypertext Transfer Protocol)5 .
operations. To formalise the user agent specifications, which cause
On such read-only web data, developers can build data integration
an evolution of Linked Data over time, we build on Abstract State
systems based on queries and ontologies, i. e. approaches grounded
Machines (ASMs) [11] rooted in mathematical logic. We believe
in mathematical logic, where most of the operations are carried
that ASMs are the right starting point: ASMs encode state in first-
out by query processors and reasoners. However, to integrate such
order logic, which is a superset of the RDF-family of languages; on
data from read-only sources is only a first step; many scenarios, for
top, ASMs require only rules to represent state change, and rules
example on the Web of Things, require to change data. With HTTP-
have been proposed for RDF data processing7 ,8 In our operational
based write access to Linked Data, we have a uniform interface on
semantics derived from ASM semantics, the execution of rule-based
both the data and the interaction level, easing system integration.
programs (user agents) leads to a series of HTTP requests.
But while the W3C’s LDP (Linked Data Platform) specification6
Our contributions are as follows:
combines read-only Linked Data (via the HTTP GET operation)
1 http://www.w3.org/TR/rdf11-concepts/
• We provide a formal account of the standards around Linked
2 http://www.w3.org/TR/rdf-schema/ Data in combination with Abstract State Machines (ASMs).
3 http://www.w3.org/TR/owl2-overview/ With the synthesis between Linked Data, which provides a
4 See e.g. the datasets in the Linking Open Data cloud at http://lod-cloud.net/
5 http://www.ietf.org/rfc/rfc7230.txt
way to represent and manipulate resource state, and ASMs,
6 http://www.w3.org/TR/ldp/ which provides operational semantics based on rules and
stepwise execution of these rules, we are able to specify user
TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France
© 2018 The authors, published under the Creative Commons Attribution 4.0 Interna-
7 http://www.w3.org/TeamSubmission/n3/
tional (CC BY 4.0) license.
8 http://www.w3.org/Submission/SWRL/
TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France Tobias Käfer and Andreas Harth
agent behaviour with the entire user agent state maintained building 3. In RDF, we can link resources to each other, thus form-
in RDF on web-accessible resources. ing a graph. For instance, we link said lights to the ssn:Property
• We present a syntax for a rule language (based on Notation37 , http://localhost/Lighting_1F_M59#it (cf. (1) in Figure 1). To
a superset of the RDF Turtle language) to define conditions form rules, we use N3’s graph quoting (curly brackets) and vari-
that trigger updates based on HTTP state manipulation op- ables (terms starting with question marks). Note that in contrast to
erations. We give an operational semantics of the language RESTdesc [43], which also uses the N3 syntax, we do not interpret
based on the ASM execution semantics. the rules as input and output descriptions of HTTP interactions,
• We conduct an evaluation of a prototype rule processing sys- but as executable specifications.
tem in a Smart Buildings scenario and show the applicability We distinguish derivation and request rules. In both types of
of the approach. rules, the body consists of a set of triple patterns (triples with vari-
The paper is structured as follows: we start in Section 2 with ables, cf. basic graph patterns (BGPs) in SPARQL14 ). In a derivation
an introduction to a Smart Building scenario, in which we set the rule, the head also consists of a set of triple patterns (cf. (2) in Fig-
examples and the evaluation. We continue in Section 3 with basic ure 1, which defines the inverse to ssn:hasProperty). Derivation
definitions of Linked Data and ASMs. In Section 4, we propose a rules are not in the focus of the paper, but are important when lay-
synthesis on the level of state representation (interpretations) in ering higher-level entailment regimes on top of the work presented
ASMs and RDF model theory. In Section 5, we present an evaluation in this paper. Here, we use the Simple Interpretation. In a request
using a benchmark and point to successful applications of our rule, the head specifies an HTTP request. The request specifica-
approach. In Section 6, we relate our work to the state of the art tion includes an HTTP method, a request URI, and optionally a set
and in Section 7 we conclude with a summary and an outlook. of triple patterns to form the HTTP body (cf. Figure 1, where (3)
dereferences an end of ssn:isPropertyOf links, and (4) changes
2 EXAMPLE SCENARIO: RULE-BASED the state of ssn:Properties that fulfil a certain condition).
CONTROL FOR BUILDING AUTOMATION
@prefix IBM_B3: .
Throughout the paper, we use examples from the Smart Building @prefix brick: .
domain, inspired by recent work in Building Management Systems:
# (1) Language feature: RDF:
NIST identified interoperability as a major challenge for the building IBM_B3:Lighting_1F_M59 a brick:Lighting ;
industry [10]. To raise interoperability in Building Management ssn:hasProperty .
Systems, Balaji et al. developed Brick [2], an ontology to model
# (2) Language feature: Derivations:
buildings and corresponding building management systems. { ?thing ssn:hasProperty ?property . }
We use a description of building 3 at IBM Research Dublin in => { ?property ssn:isPropertyOf ?thing . } .
Ireland. Balaji et al. provide a static description of this building
# Language feature: Conditional requests:
using the Brick ontology9 . The description covers the building ## (3) Defining how to retrieve world state (GET requests):
and the building’s parts (e. g. rooms) and the different parts of the { ?y ssn:isPropertyOf ?x . }
=> { [] http:mthd httpm:GET ; http:requestURI ?y . } .
building’s systems (e. g. lights and switches). As there is nothing to
automate in the static description, we introduce dynamics by adding ## (4) Defining the logic (PUT, POST, DELETE requests):
information about the state of these system parts (e. g. on/off) in { ?light a brick:Lighting .
?property a ssn:Property ; foaf:primaryTopicOf ?ir ;
the form of properties from the SSN ontology10 . We serve those ssn:isPropertyOf ?light ; rdf:value "off" . }
properties as writeable Linked Data on localhost. => { [] http:mthd httpm:PUT ; http:requestURI ?ir ;
In the examples, we use our approach to program an user agent http:body
{ ?property a ssn:Property ; rdf:value "on" . } . } .
that controls one light in the building in a straight-forward fashion
(turn the light off if the light is on). In the evaluation, we use more Figure 1: An example for a simple rule program that turns
complex control schemes with up to 30 rules and control the lights on the lights (in N3 syntax13 ).
of the entire building.
2.1 Intuition of the Syntax of a Rule Language 2.2 Intuition of the Semantics of the Rule
We express rule programs in a subset of the Notation3 (N3) syntax7 , Language
for an example see Figure 1. N3 is a superset of the RDF Turtle We informally give the operational semantics for the rule language
syntax11 , hence we can express RDF in N3: In RDF, we use URIs by describing how an interpreter would execute the program in
(Uniform Resource Identifiers12 ) as names for resources, for in- Figure 1: An interpreter evaluates the triple patterns of the body of
stance we use the abbreviated13 URI IBM_B3:Lighting_1F_M59 the rules on RDF data that is either given initially (1) or downloaded
to identify the lights in room 21 on the first floor in wing 42 of as mandated by request rules with GET requests (3). Meanwhile,
9 https://github.com/BuildSysUniformMetadata/GroundTruth/blob/2e48662/ the interpreter adds data as mandated by derivation rules (2). The
building_instances/IBM_B3.ttl interpreter executes derivations and GET requests until it calculated
10 http://www.w3.org/TR/vocab-ssn/
11 http://www.w3.org/TR/turtle/
the fixpoint. Last, the interpreter executes the PUT, POST, DELETE
12 http://www.ietf.org/rfc/rfc3986.txt requests of all request rules whose body holds in the data (4). The
13 We assume the usual definitions for the prefixes from standardised vocabularies
14 http://www.w3.org/TR/sparql11-query/
such as RDF, HTTP, and SSN, which can be found on http://prefix.cc/
Rule-based Programming of User Agents for Linked Data TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France
interpreter operates in a looped fashion. The rationale behind this • We also consider the responses to successful HTTP PUT, POST,
operational semantics is the subject of the paper. DELETE requests as empty, as they may be empty or carry
no information about the state of resources6 ,16 .
3 PRELIMINARIES We now turn to the individual HTTP request methods and sum-
In this section, we give foundational definitions of the technologies marise their semantics16 . For legibility, we neglect redirects in this
around Linked Data with a special focus on the aspects relevant to paper. We sketch in Section 4.2 how they can be re-introduced.
our proposed synthesis with Abstract State Machines, whose basic The GET request is a means to retrieve state information about
definitions form the rest of this section. the request target. For instance, we can find out whether the lights
We assume a basic knowledge of the technologies Linked Data are on or not in said room 21 using a GET request to http://
is built on: Uniform Resource Identifiers (URIs)12 for identifying localhost/Lighting_1F_M59#it. By contract, the GET request is
things, the Hypertext Transfer Protocol (HTTP)5 for interacting considered safe, i. e. a GET request must not change state.
with things, and the Resource Description Framework (RDF)1 for The PUT request is a means to overwrite the state information at
static descriptions of things. As the technologies are about the the request target. For instance, we can set the lights to be on in said
transfer and the description of state information, we first discuss room 21 using a PUT request to http://localhost/Lighting_
the relations of different kinds of state (e. g. world and resource 1F_M59#it. For the formalisation in this paper, we assume all tar-
state). Next, we go beyond the basics of HTTP and refresh the gets that we want to write to, to be writeable.
reader’s knowledge of the semantics of different HTTP requests The POST request is a means to e. g. append a resource described
and responses. The HTTP semantics are an important building in the body to a collection or to send data to a data handling process.
block in our formalisation. Next, we refresh the reader’s knowledge In this paper, we restrict ourselves to the former.
of basic RDF model theory. We use model-theoretic semantics to The DELETE request is a means to delete the request target. For
describe static aspects in our formalisation. Subsequently, we out- our considerations, we regard a DELETE request as a PUT request
line a relation between Linked Data and the semantics of an RDF with an empty message body.
Dataset, which we need for our formalisation when it comes to
the relation between a source of data and the data itself. Last, we 3.3 RDF Model-Theoretic Semantics
introduce Abstract State Machines (ASMs), on which we base our We use the graph-based data model Resource Description Frame-
formalisation of dynamic aspects. If two approaches use the same work (RDF) to describe things and their relations1 . In an RDF Graph,
term, we introduce subscripts for the origin (·rdf vs. ·asm ). typed connections between resources are stated in the form of
triples, e. g. (1) in Figure 1, which relates a light to a ssn:Property.
3.1 State An RDF Graph is defined follows:
We distinguish different kinds of state: When successfully retriev-
ing state using HTTP GET from a URI, we obtain a description the Definition 1 (RDF Graph, Triple). Let U, B, L be the respec-
resource’s state, e. g. the light in a room. The corresponding HTTP tive sets of all URIs, Blank Nodes and Literals. The set of all RDF triples
request’s state can e. g. be “successful”. We call the union of the state T is then defined as follows: T = U ∪ B × U × U ∪ B ∪ L. An RDF
information about all resources world state, i. e. all resources in Graph G is a set of triples: G = {t |t ∈ T }.
the world. An application (e. g. implemented as rule program) can The RDF standard uses model theory to specify the meaning of
maintain state (e. g. in writeable resources), which then represents an RDF Graph (e. g. that the URI for the light is interpreted as the
the application’s state, e. g. a note that something just happened. resource that represents the light). We paraphrase the definitions
The application state is a subset of the world state. ASM termi- as they are given in the corresponding W3C Recommendation17 .
nology uses the term system state, which can be translated to our
terminology as the subset of the world state that is relevant for an Definition 2 (InterpretationRDF , name, vocabularyRDF , uni-
application, e. g. the building description and the weather report. verse). An interpretation is defined as a mapping from U and L
into some set called the universe. Both the mapping and the set can
3.2 HTTP Semantics be constrained. A name is an element from the union U ∪ L. A set
The Hypertext Transfer Protocol (HTTP) is a protocol to interact of names is also called vocabulary.
with a resource (called the target) in a request/response fashion5 . The basic interpretation for an RDF Graph is the simple interpre-
In the spirit of Read-Write Linked Data, we consider the request tation. The simple interpretation defines the following mappings
methods that implement CRUD15 : GET, PUT, POST, DELETE. and constraints:
As our formalisation is based on world state, we only consider
(of the responses to HTTP requests with different methods) the Definition 3 (Simple interpretation, extension). A simple
responses to successful HTTP GET requests: interpretation is defined using the following sets and mappings: IR
and IP denote the subsets of the universe that contain all resources and
• We assume the responses to unsuccessful HTTP requests to
properties respectively. IEXT(p), called the extension of a property
be empty: The response to an unsuccessful HTTP request
p, is a mapping IP → 2IR×IR that maps p to all pairs in IR that are
against a target does not contain information about the tar-
connected by p. IS is a mapping U → IR ∪ IP. IL is a partial mapping
get, but on the request16 .
L → IR.
15 The basic operations of persistent storage: Create, Read, Update, Delete
16 http://www.ietf.org/rfc/rfc7231.txt 17 http://www.w3.org/TR/rdf11-mt/
TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France Tobias Käfer and Andreas Harth
To not to have to specifically address Blank Nodes, we assume Definition 5 (Super-universe, function, relation, charac-
ground RDF Graphs in this paper. The extension to Blank Nodes teristic function). The super-universe X is a non-empty set. X
should be straight-forward. contains e. g. all functions X n → X , true, false, and undef. The
boolean functions behave the usual way on {true, false}. Relations
3.4 RDF Dataset Semantics and Linked Data are functions that map X n → {true, false}. A characteristic func-
To talk about RDF data from different sources, we use the notion tion for a set is a function X → {true, false} that maps to true iff
of an RDF Dataset. An RDF Dataset1 is a collection of RDF Graphs. the operand belongs to the set.
Each RDF Graph in an RDF Dataset is identified using a name, Definition 6 (InterpretationASM , transition rule, func-
which can be a URI, a Blank Node, or empty. The RDF Graph with tion update, static and dynamic function). An interpretation
the empty name is called the default graph. For legibility, we denote I : ϒ → X maps the terms from an ASM vocabulary to a super-
the default graph with default in this paper. universe. A transition rule R is a function update, e. g. f (t 1 , . . . , tn ) :=
While the RDF specification does not impose restrictions on t 0 , or a guarded function update, which has a boolean condition, e. g.
the relation between the graph name and the RDF Graph in the if condition then function update(s). A function update changes
RDF Dataset, we use the semantics defined in Section 3.5 of18 as the interpretation of a function name at given arguments. A static
abstraction of Linked Data: The graph names are URIs and the RDF function is not subject to change by the function updates of an ASM,
Graph with a given name in the RDF Dataset is the graph that can as opposed to a dynamic function.
be obtained using an HTTP GET request with the graph name as
target. If the request to a graph name fails or returns no RDF data, Definition 7 (Value and evaluated form). The value of a term
the RDF Graph is empty. In the evaluation, we contrast two ways from the vocabulary ϒ is the term’s referent in the super-universe X
of constructing the RDF Dataset about the current system state: under the current interpretation I. We denote the referent of a term
Using download of a dump (D1), or following links (D2). t under an interpretation I using eval(t, I). If t is a tuple, we have:
eval(t, I) := (eval(t 1 , I), . . . , eval(tn , I)). If t is a function, we have:
3.5 Abstract State Machine (ASM) eval(f (t 1 , . . . , tn ), I) := eval(f , I)(eval(t 1 , I), . . . , eval(tn , I))).A
For the dynamic aspects of our approach, we use Abstract State function update in its so-called evaluated form is eval(f (t 1 , . . . , tn ) :=
Machines (ASMs). Concretely, ASMs help us to define how to evolve t 0 , I) = f (eval(t 1 , I), . . . , eval(tn , I))) := eval(t 0 , I).
Linked Data, which we interpret as RDF Dataset. Here, we give the Definition 8 (Algebra, state, run, step). A (static) algebra or
standard definitions for ASMs to make the paper self-contained. The state is a triple of a vocabulary, a super-universe, and an interpretation.
approach of ASMs has been developed towards the end of the 1980s A step is a transition from one state to the next by the means of firing
with the aim to bridge between the specification and computation transition rules. A run is a sequence of steps.
of programs [11]. ASMs are meant to improve on Turing’s thesis.
Turing Machines have proven too low-level to specify algorithms The transition rules to be fired in one step are composed in an
larger than toy examples. In ASMs however, the level of abstraction update set.
can be adapted to the requirements of the use-case. ASMs have been Definition 9 (Update set). The update set to be fired in an
extensively used to give operational semantics to programming interpretation I under the transition rule set T can be defined as
languages including C, Prolog, and Java19 . updates(I,T ) := {eval(u, I)|u ∈ T ∧(the condition of u holds in I∨
An ASM consists of an algebraic first-order structure and a set u has no condition)}
of transition rules on how to modify the structure. In the following,
we give the basic definitions for ASMs. In ASM, we assume discrete time. Time progresses from one state
to the next, i. e. in a run, there is an ordered sequence of system
Definition 4 (VocabularyASM , function name, relation states. There may be multiple transition rules that fire in one state.
name, characteristic function name, variable, term). The If multiple transition rules want to update the interpretation of
vocabulary ϒ be defined as a finite set of function names and their a function name for the same arguments, then the system halts
arity n ≥ 0. The vocabulary also contains the nullary function names because of the conflict.
undef, and the boolean constants true and false. Moreover, the
vocabulary contains the usual boolean operators as functions. Relation Definition 10 (Abstract State Machine). An Abstract State
names and characteristic function names are special function names. Machine (ASM) can be defined as a quadruple of a vocabulary, a
Terms can be defined recursively: Variables are terms. If f is an r -ary super-universe, an interpretation for time t 0 , and a set of transition
function and t 1 , . . . , tn are terms, then f (t 1 , . . . , tn ) is a term. rules: ASM := (ϒ, X , I0 ,T )
For the presentation in this paper, we characterise a function We now introduce variables to be able to range over names in
name with arity > 0 with their correctly sized argument list, e. g. to conditions and updates. In ASM, we have to state from which set
talk about an RDF Dataset for Linked Data, we define quad(·, ·, ·, ·), of individuals those individuals are to take that are to be bound to
which defines the function name quad with an arity of 4. We omit variables. Therefore, a variable declaration is of the following form:
the argument list for nullary function names. Variable(s) ?varname range(s) over set
18 http://www.w3.org/TR/rdf11-datasets/
End variable scope
19 See the annotated ASM bibliography at http://web.eecs.umich.edu/gasm/ Formally, the variables can be covered by the help of an auxiliary vo-
index.html cabulary that contains the variables as nullary function names [11].
Rule-based Programming of User Agents for Linked Data TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France
4 ABSTRACT STATE MACHINES AND L in our definitions, in contrast to the fixed vocabulary used by
LINKED DATA + RULES the Linked Data sources under consideration. Correspondingly, IS
and IL interpret all U and L, and IR has corresponding elements.
This section is about our proposed synthesis of ASM, and Linked
We point to17 for how to amend the definitions to finite vocabu-
Data + Rules with the help of RDF model theory and HTTP seman-
laries. To further ease the presentation, we assume ground graphs.
tics. We first describe on a high level the commonalities between
Moreover, be IP = IR, such that we only need to address IEXT
ASM and RDF model theory, which motivate our synthesis, and
in our considerations. When working with RDF Datasets, we as-
then the different foci of both approaches. After that, we provide a
sume that the same elements of the vocabularies of the different
synthesis of ASM and Linked Data + Rules. While the formalisa-
graphs have the same referent when interpreted using IS and IL.
tion has the user agent in the focus, which regards Linked Data as
We do not consider redirects in the definitions, although they can
external functions, we next sketch how a server fits into the pic-
be layered on top by defining a function for the correspondence
ture. Then, we sketch how the synthesis can be used for specifying
between a non-information resource and an information resource.
computation. Subsequently, we use the synthesis to give seman-
In the definitions, we also assume all Linked Data sources to be
tics to a rule language and discuss our findings. Last, we derive
in N , the named graphs of our RDF Dataset, i. e. we assume web-
requirements for a Linked Data user agent specification language.
completeness in the terminology of [15]. By restricting N , we can
implement other completeness classes.
4.1 Overview Of the W3C RDF WG Note on RDF Dataset semantics18 , two
While both, ASMs and RDF are defined in terms of interpretations of sections are of particular use for our considerations:
vocabularies into a (super-)universe, the focus of both approaches is 3.5 “Named graph are in a particular relationship with what
different: RDF model theory is about whether different RDF Graphs the graph name dereferences to” defines an interpretation
entail each other or whether models can exist for an RDF Graph. for each graph in the RDF Dataset, hence we can define an
Therefore, conditions on the universe are in the focus. The inter- extension function per dereferenceable source
pretation is static in RDF model theory. ASMs are all about the
evolution of system state, which manifests itself in the evolution of IEXT c := Extension function of the graph available at c
the interpretation of a vocabulary into a super-universe. Therefore, 3.2 “Default graph as union or as merge” defines the default
the transition function T is in the focus, in which updates to the in- graph of an RDF Dataset as RDF union or merge of all named
terpretation are stated and the conditions under which the updates graphs in the RDF Dataset. As we assume ground graphs,
happen. Linked Data is about the publication and the updating of there is no difference in RDF union or merge. Hence, we can
RDF data on the web using HTTP, where the RDF describes the define the extension function of the union as:
state of a resource. Ø
IEXT union (p) := IEXT c (p)
The high-level idea of the synthesis, which is described in the sub-
c ∈N
sections of Section 4.2, is to (1) define RDF model theory for Linked
Data using RDF Datasets, (2) define ASM functions statement(·, ·, ·) The default graph can be regarded as knowledge of the client, e. g.
and quad(·, ·, ·, ·) for Linked Data/RDF Datasets and the functions’ knowledge that is not available at any n ∈ N . The default graph
interpretations, (3) define an ASM transition function for Linked can also be used in the case of higher-level entailment regimes for
Data/RDF Datasets using rules with HTTP requests in the head stating axiomatic triples in case they cannot be dereferenced from
(4) define how the ASM evaluation of the statement(·, ·, ·) function a Linked Data source.
and the ASM updates to the quad(·, ·, ·, ·) function can be done in 4.2.2 Define ASM functions quad(·, ·, ·, ·) and statement(·, ·, ·) for
accordance with the semantics of HTTP requests, and (5) use above Linked Data/RDF Datasets and the functions’ interpretations. We
definitions in the definition of an ASM. define
quad(s, p, o, c) : IR × IR × IR × N → {true, undef}
4.2 Synthesis
as the characteristic ASM function for IEXT c . Moreover, be
In this section, we take the definitions from the simple interpreta-
tion from RDF model theory and use them, slightly amended for statement(s, p, o) : IR × IR × IR → {true, undef}
RDF Datasets, in the definition of an ASM. The synthesis allows us the characteristic ASM function for IEXT union . The statement func-
to specify the evolution of an RDF Dataset using ASM semantics. tion has also been used in [36] to process RDF using Prolog.
Note that the terms vocabulary and interpretation used in ASM and So far, we have defined Linked Data as static ASM functions.
RDF model theory mean the same. The term universe in RDF maps Now, we proceed by introducing dynamics.
to the term super-universe in ASM.
4.2.3 Define how the ASM transition function for Linked Data/RDF
4.2.1 Define RDF model theory for Linked Data using RDF Datasets. Datasets can be stated. The rules can be given as usual in ASM
We base our considerations on two semantics for RDF Datasets that in rules of the form if condition then update(s) modifying the
have been discussed in Sections 3.2 and 3.5 of a note of the W3C interpretations of function names. We use conjunctions of the
RDF Working Group18 . statement(·, ·, ·) function for the conditions (reflecting BGP queries
We start out with definitions to simplify our presentation: Like from SPARQL14 ) and the conjunctions of the quad(·, ·, ·, ·) func-
the W3C Recommendation on model-theoretic semantics for RDF17 , tion for the updates. Both the conditions and updates can contain
we use as vocabulary the infinite sets of all URIs U and Literals variables.
TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France Tobias Käfer and Andreas Harth
4.2.4 Define how the ASM evaluation of the statement(·, ·, ·) func- sets
tion and the ASM updates to the quad(·, ·, ·, ·) function can be done in
quad(·, ·, ·, http://localhost/Lighting_1F_M59)
accordance with the semantics of HTTP requests. For the evaluation
of the conditions, we consider the statement(·, ·, ·) function as mak- to true for the argument
ing HTTP GET requests to all n ∈ N and to evaluate statement(·, ·, ·)
(, rdf:value, "on")
like an external function in ASM. For the default graph, no request
needs to be made. The updates are done using the quad(·, ·, ·, ·) and undef for all other triples. A server processing a POST request
function, which takes an additional c as parameter. The updates with the target of a LDP container, e. g. http://localhost/ldbbc/
correspond to HTTP PUT, POST, DELETE requests. and the RDF payload payl first determines a new URI sub that is
We perform the requests ordered in accordance with ASM steps, subordinate to the container resource, then defines a new graph
i. e. we first evaluate all HTTP GET requests, and collect the updates by relativising all URIs in the payl against sub and PUTs the new
that are mandated by the transition functions. After we collected the graph at sub into the RDF Dataset. Moreover, a membership triple
updates to be performed, we carry out the corresponding requests for sub is added to the representation of the container resource.
in bulk, i. e. multiple HTTP PUT, POST, DELETE requests at a time.
After all updates in the form of HTTP PUT, POST, DELETE requests 4.4 Operational Semantics for the
have been performed, we continue with the next ASM step. The Condition-Action Rule Language
result of the HTTP PUT, POST, DELETE requests is dependent on
In this section, we give operational semantics to our condition-
server implementations, see Section 4.3.
action rule language using the synthesis. We use the program in
4.2.5 Define the ASM. We define the ASM for Linked Data as: Figure 1 as example: The program consists of RDF (1), derivations
ASM := (ϒ, X , I0 ,T ) (2), and requests (3+4), the latter to interact with the environment.
Remember that in an ASM step, updates are executed after the
The vocabulary ϒ contains all RDF names (all URIs and Literals), the update set has been constructed entirely. To construct the update
boolean operator ∧, and constant names. We omit (1) the boolean set, all rules have to be evaluated on the current state.
name false and the boolean operator ¬ because of the open world In our language, information about the current system state is
assumption, which is typically made on the Semantic Web20 , and given by RDF, by evaluating all derivations, and by evaluating all
(2) the operator ∨, because in a BGP, conditions are only connected GET requests on the Linked Data sources until the fixpoint has
using conjunctions. Disjunctions can be stated by using multiple been calculated. In our example, we know from the RDF (1) that
rules. We add the function names statement and quad: the light IBM_B3:Lighting_1F_M59 has the ssn:Property http:
ϒ := U ∪ L ∪ {true, undef} ∪ {∧} ∪ {quad, statement} //localhost/Lighting_1FM59#it. The derivation rule (2) adds
the inverse link to the knowledge. With the inverse information
The super-universe X is a set that contains elements for all RDF
available, the conditional GET request is triggered (3). The data
Graphs, and functions X n → X including the boolean and. To be
obtained using the GET request is added to the knowledge, e. g. that
able to visually tell the elements of ϒ and X from each other, we
the light is off. No further knowledge can be derived using rules,
use typewriter font for the nullary function names and small caps
so the fixpoint is calculated. The updates in our language are the
for their counterparts in the super-universe.
unsafe requests. The conditional PUT, POST, DELETE requests (4)
X := IR ∪ IP ∪ {true, undef} ∪ { f | f : X n → X } are collected during the information gathering about the current
The interpretation It of an element y of the vocabulary ϒ at time t, state, and are executed after the fixpoint calculation. Note that using
consists of IS(·) and IL(·) from RDF model-theoretic semantics for conditional requests, we can do hypermedia-style link following. In
the RDF names, mappings for the boolean true, and undef, and our example, the condition for the last rule holds in the knowledge
functions for quad(·, ·, ·, ·) and statement(·, ·, ·), and ∧: after the fixpoint calculation. Hence, the light is turned on.
To execute programs in our language along the ASM step se-
IS(y) if y ∈ U mantics, an interpreter operates in nested loops (see Figure 2 for its
if y ∈ L algorithm). The algorithm takes as input a rule program and emits
IL(y)
a sequence of sets of safe and unsafe requests, depending on the
It (y) := true if y = true
available state information. Note that ASM steps in combination
if y = undef
undef
with GET requests implement polling.
∈ { f | f : X n → X } if y ∈ {quad, statement, ∧}
4.5 Discussion: Computation, ASMs, Simple
4.3 Linked Data Servers
Reflex Agents, and Linked Data
Although our formalisation is made for the user agent, we show
for completeness the server behaviour, which reflects the update of ASMs are a model of computation, i. e. one can specify arbitrary
the quad(·, ·, ·, ·) function for PUT, POST, and DELETE requests: A computation using the model, e. g. algorithms and programs. In
server processing a PUT request to the target information resource the previous section, we defined an ASM view on Linked Data.
http://localhost/Lighting_1F_M59 with the body Hence, we now can specify arbitrary computation with the state
of the computation represented in Linked Data. Our ASM-based
rdf:value "on". formalisation of Linked Data is based on the assumption that we
20 http://www.w3.org/TR/owl2-primer/ have exclusive read and write access to all relevant URIs during
Rule-based Programming of User Agents for Linked Data TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France
Require: assertions ▷ Triples to be asserted in every ASM step 4.6 Requirements for a Linked Data User
Require: rules ▷ Derivation and request rules Agent Specification Language
var unsafeRequests: set
var data, oldData: set What current languages to specify queries and updates are missing
var fixpointReached: boolean is a way of expressing the transition function T . In ASM, T is given
while true do ▷ Loop of the ASM steps using rules in the form if condition then function update(s). T is
unsafeRequests.clear() then executed in ASM steps. Thus, we need a language
data.clear() (1) that allows to express conditions on state information
data.add(assertions) (2) that allows to define updates that send state information,
repeat ▷ Loop for determining the update set (3) whose semantics adhere to ASM steps, i. e. one repeatedly
fixpointReached <- true first evaluates all conditions of all rules and collects all up-
for rule : rules do dates, and then one evaluates all updates in bulk.
if rule.matches(data) then ▷ Also empty rule bodies
We chose N3 as rule language in the context of RDF data and gave
oldData = data.copy()
ASM-based semantics to N3. Other approaches including SPARQL
if rule.type==derivation then
updates22 or RUL [28] as very elaborate ways to address point 1.
data.add(rule.match(data).data)
They do not implement server interaction using exchange of state
else ▷ So the rule must be an interaction rule
representation, but RPC-style interaction (point 2). They also do
if rule.match(data).request.type==GET then
not implement bulk updates, as required by ASM steps (point 3).
data.add(rule.match(data).request.execute())
else
unsafeRequests.add(rule.match(data).request) 5 EVALUATION
end if To describe our evaluation, we start out with defining the data and
end if different scenarios for data access. Next, we present different work-
if ! data.copy().remove(oldData).isEmpty() then loads. Then, we describe experimental setup. Next, we present and
fixpointReached <- false discuss our results. Last, we showcase applications of our approach.
end if
end if 5.1 Data
end for We evaluate our approach in the building automation setting of
until fixpointReached Section 2. We use the building’s lighting subsystem, as lamps and
for request : unsafeRequests do ▷ Enacting the update set switches can be regarded as having a discrete state. We use building
request.execute() 39 , as the building’s description includes a lighting subsystem.
end for The core classes of the Brick ontology are depicted in Figure 3.
end while The first part of the ontology, Location and subclasses, allows for
Figure 2: The nested loops for the ASM-based operational describing a building in terms of the subdivisions provided by the
semantics for the rule language. brickwork, e. g. floors and rooms. The second part of the ontology,
Equipment and subclasses, allows for describing different systems
an ASM step. When generalising to a setting with multiple agents, that run the building, where we focus on the lighting system in this
ASMs typically assume circulating exclusive access to the system paper. Other systems include water, and HVAC (heating, ventilation,
state. As there is no central control in a web setting, we cannot and air conditioning). The third part of the ontology, Point and
circulate the access right. Thus, there is no general solution to the subclasses, allow to talk about sensors and actuators in the building.
problem of concurrent access, but a number of remedies: (1) in Building 3 is box-shaped with its long side oriented from north
a realistic setting, we do not have the entire Linked Data in our to south. In the RDF description, the building is subdivided into
system state (i. e. web-completeness in the terminology of [15]), floors and wings. The rooms are assigned to their corresponding
but a considerably smaller subset. (2) on the web, most access is floor and wing (also has-part relationships). The lights are directly
typically reading, and only little is writing [32]. (3) if the servers assigned to rooms or wings. A light system can consist in (1) an
use ETags21 , a client can send conditionally writing requests, which occupancy sensor that determines whether there are people in its
fail if a concurrent update has happened. (4) with sufficiently fast vicinity, (2) a luminance command, in other words, a switch to
data processing, the problem can be mitigated. control the lights, and (3) a luminance sensor that we consider to
Using our ASM view on Linked Data, we can also implement be triggered by daylight. We provide basic statistics in Table 1.
simple reflex agents for Linked Data, the simplest agent type in We bring the static building description “to life” by adding ssn:
Russell and Norvig [34]. Simple reflex agents perceive the environ- hasProperty links to dynamic Linked Data resources on localhost
ment and choose their action by matching condition-action rules on representing switches, occupancy sensors, luminance sensors, and
the perceived environment. Then, the agent carries out the action lights. The state of each resource relevant for the evaluation is
and repeats. This sense-act cycle aligns with an ASM step of first, on/off for the lights, and a numeric value for the luminance sensors.
matching rules and second, acting in the form of updates.
21 http://www.ietf.org/rfc/rfc7232.txt 22 http://www.w3.org/TR/sparql11-update/
TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France Tobias Käfer and Andreas Harth
:Location :Equipment :Point
:Building :Floor :HVAC_Zone :Lighting_Zone :Room :Fire_Safety_System :HVAC :Lighting_System :Water_System :Alarm :Command :Sensor :Setpoint :Status
Figure 3: Excerpts from the Brick Ontology as UML Class Diagram. UML class inheritance denotes RDFS sub class relations.
5.2 Workload high outliers in the 99 % percentile, which spoil mean and standard
In our evaluation, we implement different user agents that provide deviation. The median, however, is stable. The order of magnitude
automation. We run the rules on different parts of the buildings to of the measurements in varies in Table 3, in contrast to Table 2.
investigate how the approach scales. In terms of data access, i. e. This is owed to the fact that each ASM step, regardless of the data
the evaluation of the quad function, there are two extremes: that is actually needed, the whole building description has to be
transferred in D1, which is 2.3 MB per transfer. Compared to that,
D1 The whole building description is available as one file, which
the link following approach D2 can access the building data as
is loaded from one single Linked Data source on the network
required. This fine granularity comes at the price of additional
D2 The building description is available subdivided into one Linked
requests, which make the processing of the whole building more
Data source per resource in the building. The Linked Data
expensive. The drop in time between W2 and W3 can be explained
sources can thus be accessed as required following links.
by the reasoning that is employed in W2 to check whether the
We scale the scenario from one room to the whole building. current day and hour is a working hour, which is not needed in
In terms of automation workloads, we scale both the rule com- W3. The increase between W3 and W4 underestimates the real cost
plexity, and energy efficiency and comfort of the building. Accord- of the computations, as we go from all lights in W3 to only those
ing to UNEP [39], lighting is the second-highest energy consumer lights with sensors in W4, cf. Table 1. The drop between W4 to W5
in commercial buildings, optimised control can yield high savings. can be explained by the smaller number of lights with luminance
W1 Turn all light switches on (no conditions / baseline; 9 rules) sensors. The rise in time for the workloads in Table 2 is due to that
W2 Working hours (conditions and another source, a Linked Data different workloads need to access different amounts of data.
clock / clock-based straight-forward control; 46 rules): The
lights are on per default during working hours. 5.5 Applicability
W3 Weather API (more complex rules, another source / raising
In this section, we give examples of how we applied our approach.
energy efficiency; 20 rules): We turn the lights on only if a lack
Composition of RESTful services to VR systems We used
of sunlight indicates illumination.
our approach to connect different parts of Virtual Reality systems: In
W4 Luminance sensor (numerical computations / further raising
the i-VISION project, we connected a flight simulator to a workflow
efficiency; 34 rules): We consider luminance sensor values in
analysis software [22] (ca. 90 rules). In a demo [24], we connected a
the rooms to determine whether the lights should be on.
Microsoft Kinect sensor and APIs from the Web to a 3D engine (ca.
W5 Luminance sensor w/room-individual thresholds (more com-
60 rules), where the interpreter running the rules performed about
plex computation / raising individual comfort; 19 rules): We
30 ASM steps per second (i. e. the refresh rate of the Kinect sensor).
assign an individual light threshold per room.
Specification of Operational Semantics Similar to previous
applications of ASMs to define the operational semantics of pro-
5.3 Experimental Setup gramming languages, we currently work on defining the opera-
We use the engine Linked Data-Fu version 0.9.1223 to run the rule tional semantics of a workflow language using our approach (ca.
programs. We use LDBBC version 0.0.624 as LDP Container to 30 rules).
serve the static building data. We implement the following dynamic Turing-Completeness To show the expressiveness of our ap-
sources: (1) an RDF weather API built from a sample file from Open- proach, we implemented a Turing Machine using Linked Data and
WeatherMap25 , a JSON-LD context, and a sunset/sunrise simulation four rules. The rules together with instructions for the set-up can
for Dublin, and (2) luminance sensor readings according to time of be found online27 . While the Turing-completeness is, of course,
day and season. We run the experiments on a laptop with an Intel an inherent property of the ASM part of the approach, it persists
Core i7-5600U CPU, 12 GB of RAM, and Ubuntu Linux 17.04. After despite the restrictions we imposed to make ASM fit Linked Data.
the dynamic sources simulated one year, i. e. one minute in wall- All parts of our approach are necessary: Read-Write Linked Data for
clock time, we stop one experiment leading to repetition counts tape and machine state, and request rules executed in ASM steps.
of up to 7’500 depending on the runtime of one ASM step. The
evaluation system including data and rules can be found online26 . 6 RELATED WORK
In this section, we discuss related work subdivided by topic.
5.4 Results and Discussion One-step updates of semantic data In Semantic Data Man-
We present the results for D1 in Table 2 and for D2 in Table 3. agement, people studied updates to RDF Graphs, e. g. schema-
We report median values as due to firing many requests, there are preserving updates [28], and standardised updating the data in
23 http://linked-data-fu.github.io/ a triple store using SPARQL22 . To update Linked Data using HTTP
24 http://github.com/kaefer3000/ldbbc/
has been proposed in a Design Issues article [4] and detailed out in a
25 http://www.openweathermap.org/
26 http://github.com/kaefer3000/rwld-brick-benchmark/ 27 http://github.com/kaefer3000/ldf-turingmachine
Rule-based Programming of User Agents for Linked Data TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France
Table 1: Basic counts for building 3 Table 2: Median time [ms] for one Table 3: Median time [ms] for one ASM step
and the benchmark. ASM step in scenario D1, data access in scenario D2, data access via Linked Data +
from one single Linked Data source. link following.
Rooms 281
Floors 2 Rooms W1 W2 W3 W4 W5 Rooms W1 W2 W3 W4 W5
Wings 3
1 484 572 510 554 561 1 8 8 8 8 8
Lights w/occupancy sensors 156
5 480 582 501 574 582 5 40 38 38 40 40
Lights w/luminance commands 126
10 498 584 529 605 618 10 85 80 79 88 88
Lights w/luminance sensors 60
20 537 631 562 719 687 20 259 238 228 320 268
Triples in IBM_B3.ttl 24947 First Floor 563 629 590 750 728 First Floor 938 1690 891 1063 1048
Resources in the LDP Container 3281 Wing 42 527 595 550 651 604 Wing 42 1435 1427 1371 1664 1408
Dynamic resources 551 Building 3 605 734 613 794 788 Building 3 2442 2187 2192 2542 2497
W3C recommendation6 . In previous work, we proposed a language 7 CONCLUSION AND FUTURE WORK
and an interpreter for interacting with Read-Write Linked Data [37]. We have presented a formal approach for capturing the dynamics
Those works lack the notion of ASM steps. of Linked Data with the aim of specifying user agents. To this end,
Automation on the web Unlike automation systems such as we gave a synthesis of RDF model theory, ASMs, and HTTP, and
[42], IFTTT28 , and Arktik29 , we do not assume centralised informa- described requirements for implementing the synthesis. We applied
tion and event processing, but decentralised information and rule the approach to give semantics to a rule language such that we can
evaluation on state information. Ripple [35], and [27] allow for read- specify Linked Data user agents. We presented application scenarios
only scripting and programming with Linked Data. We also cover and showed our approach to be Turing complete (Section 5.5). We
writing. Unlike the multi-agent approach of [8], we work without evaluated our approach in a Smart Building setting.
a central platform for discovery and for distributing notifications. In the paper, we took the first step towards autonomous agents
Descriptive works We monitored [23], analysed [20], and for- that operate on Linked Data: We presented a formal basis for the
mally described [14] the dynamics of Linked Data. Those works execution of agents. Still, there are more steps to take, a formal
are insufficient to specify computation. notion of (1) internal state in the agent, and (2) a notion of goals
Web Service descriptions A focus of Semantic Web Services and capabilities, which we will address in future work.
are service descriptions and the processing of such descriptions, Yet, we believe our work can already be applied today: Although
with some work on operational semantics [1], [29], [6], [33], mainly experts built the applications in Section 5, the experiments of van
used for analysing composed services, instead of execution. Kleek et al. [42] or the success of IFTTT [40] show that rules are a
Descriptions/formalisations and HTTP Lately, descriptions way of programming that is highly relevant also for end-users.
in a Semantic Web Services fashion have gained traction again, es-
pecially on the Internet of Things [7], and even when working with ACKNOWLEDGMENTS
HTTP [26], [31], [18]. The descriptions express in a standardised
We thank Armin Haller for insights into ASMs in WSMO. This work
manner what you can do with a (server) API. Instead, we formally
is partially supported by the German federal ministry for education
address user agent specifications. Our approach can be extended
and research in AFAP, a Software Campus project (FKZ 01IS12051).
with planning (e. g. [43], [33]) if service descriptions are available.
Thus, our Linked Data-based formalisation (which respects the BIBLIOGRAPHY
HTTP message semantics) gives an alternative to BPEL-based ap-
proaches to service composition and execution. [1] A Ankolekar, F Huch, and KP Sycara. 2002. Concurrent se-
Application of ASMs in Semantic Technologies Before the mantics for the web services specification language DAML-S.
advent of RDF and Linked Data, the authors of [41] compared for- In Proc. of the 5th Intl. Conf. on Coordination Models and Lan-
malisms to specify dynamics for knowledge bases. Abstract State guages (Coordination).
Machines (ASMs) stood out for their simplicity and ease of opera- [2] B Balaji et al. 2016. Brick: towards a unified metadata schema
tionalisation. ASMs have also been used to describe the communi- for buildings. In Proc. of the 3rd Intl. Conf. on Systems for
cation of services in a choreography in WSMO [33]. Energy-Efficient Built Environments (BuildSys). ACM.
Combination of static and dynamic modelling The authors [3] T Berners-Lee. 2006. Linked Data. Design Issues. http://
of [19] executed queries in linear temporal logic (LTL) over evolving www.w3.org/DesignIssues/LinkedData.
ontologies, which is complementary to our approach. Similar to [4] T Berners-Lee. 2009. Read-write Linked Data. Design Issues.
our work, the author of [25] combined approaches for static and http://www.w3.org/DesignIssues/ReadWriteLinkedData.
dynamic modelling for object-oriented modelling. While Graph [5] P Bouquet, C Ghidini, and L Serafini. 2009. Querying the
Rewriting could serve as an alternative to ASM for the specification Web of Data: A formal approach. In Proc. of the 4th Asian
of the evolution of RDF Graphs, we think ASM is more compatible Semantic Web Conf. (ASWC).
to the Semantic Web stack, as both are based on first-order logic. [6] S Chandrasekaran, JA Miller, GA Silver, IB Arpinar, and AP
Sheth. 2003. Performance analysis and simulation of com-
28 http://ifttt.com/ posite web services. Electronic Markets, 13, 2.
29 http://arktik.io/
TheWebConf Workshop: Linked Data on the Web (LDOW), 2018, Lyon, France Tobias Käfer and Andreas Harth
[7] V Charpenay, S Käbisch, and H Kosch. 2016. Introducing [26] M Lanthaler and C Gütl. 2013. Hydra: A vocabulary for
thing descriptions and interactions. In Proc. of the 1st WS on hypermedia-driven web APIs. In Proc. of the 6th WS on Linked
SemanticWeb technologies for the Internet of Things (SWIT). Data on the Web (LDOW).
[8] A Ciortea, O Boissier, A Zimmermann, and AM Florea. 2016. [27] M Leinberger, R Lämmel, and S Staab. 2017. The essence of
Responsive decentralized composition of service mashups functional programming on semantic data. In Proc. of the
for the internet of things. In Proceedings of the 6th Interna- 26th European Symp. on Programming (ESOP).
tional Conference on the Internet of Things (IoT). [28] M Magiridou, S Sahtouris, V Christophides, and M Koubarakis.
[9] R Fielding. 2000. Architectural Styles and the Design of Network- 2005. RUL: A declarative update language for RDF. In Proc.
based Software Architectures. PhD thesis. University of Cali- of the 4th Intl. Semantic Web Conf. (ISWC).
fornia, Irvine, USA. [29] S Narayanan and SA McIlraith. 2002. Simulation, verification
[10] MP Gallaher, AC O’Connor, JL Dettbarn Jr., and LT Gilday. and automated composition of web services. In Proc. of the
2004. Cost analysis of inadequate interoperability in the us 11th Intl. Conf. on World Wide Web (WWW).
capital facilities industry. NIST, (2004). [30] KR Page, D de Roure, and K Martinez. 2011. REST and Linked
[11] Y Gurevich. 1995. Evolving algebras 1993: lipari guide. In Data: a match made for domain driven development? In Proc.
Specification and Validation Methods. E Börger, editor. OUP. of the 2nd Intl. WS on RESTful Design (WS-REST).
[12] A Harth, K Hose, M Karnstedt, A Polleres, K Sattler, and J [31] C Pautasso, A Ivanchikj, and S Schreier. 2016. A pattern lan-
Umbrich. 2010. Data summaries for on-demand queries over guage for RESTful conversations. In Proc. of the 21st European
Linked Data. In Proc. of the 19th Intl. Conf. on World Wide Conf. on Pattern Languages of Programs (EuroPLoP).
Web (WWW). [32] C Pautasso and O Zimmermann. 2018. The web as a software
[13] A Harth and T Käfer. 2017. Specifying and executing appli- connector. IEEE Software, 35, 1.
cation behaviour with condition-request rules. In Proc. of [33] D Roman et al. 2005. Web service modeling ontology. Applied
the WS on Decentralizing the Semantic Web at the 16th Intl. Ontology, 1, 1.
Semantic Web Conf. (ISWC). [34] SJ Russell and P Norvig. 1995. Artificial intelligence - a modern
[14] A Harth and T Käfer. 2016. Towards specification and exe- approach: the intelligent agent book. Prentice Hall.
cution of linked systems. In Proc. of the 28th WS Grundlagen [35] J Shinavier. 2007. Functional programs as Linked Data. In
von Datenbanken (GvD). GI. Proc. of the WS on Scripting for the Semantic Web (SFSW).
[15] A Harth and S Speiser. 2012. On completeness classes for [36] M Sintek and S Decker. 2002. TRIPLE – A query, inference,
query evaluation on linked data. In Proc. of the 26th Conf. on and transformation language for the semantic web. In Proc.
Artificial Intelligence (AAAI). of the 1st Intl. Semantic Web Conf. (ISWC).
[16] O Hartig, C Bizer, and JC Freytag. 2009. Executing SPARQL [37] S Stadtmüller, S Speiser, A Harth, and R Studer. 2013. Data-fu:
queries over the web of Linked Data. In Proc. of the 8th Intl. a language and an interpreter for interaction with Read/Write
Semantic Web Conf. (ISWC). Linked Data. In Proc. of the 22nd Intl. Conf. on World Wide
[17] O Hartig and J Pérez. 2016. LDQL: A query language for the Web (WWW).
web of Linked Data. Web Semantics, 41. [38] J Umbrich, A Hogan, A Polleres, and S Decker. 2015. Link
[18] AG Hernández and MNM García. 2010. A formal definition traversal querying for a diverse web of data. Semantic Web,
of RESTful semantic web services. In Proc. of the First Intl. 6, 6.
WS on RESTful Design (WS-REST). [39] UNEP and SKANSKA. 2009. Energy efficiency in buildings.
[19] Z Huang and H Stuckenschmidt. 2005. Reasoning with multi- [40] B Ur, MPY Ho, S Brawner, J Lee, S Mennicken, N Picard, D
version ontologies: A temporal logic approach. In Proc. of Schulze, and ML Littman. 2016. Trigger-action programming
the 4th Intl. Semantic Web Conf. (ISWC). in the wild: an analysis of 200,000 IFTTT recipes. In Proc. of
[20] T Käfer, A Abdelrahman, J Umbrich, P O’Byrne, and A Hogan. the 34th Conf. on Human Factors in Computing Systems (CHI).
2013. Observing Linked Data dynamics. In Proc. of the 10th [41] P van Eck, J Engelfriet, D Fensel, F van Harmelen, Y Venema,
European Semantic Web Conf. (ESWC). and M Willems. 2001. A survey of languages for specifying
[22] T Käfer, A Harth, and S Mamessier. 2016. Towards declar- dynamics: A knowledge engineering perspective. Transac-
ative programming and querying in a distributed CPS: the tions on Knowledge and Data Engineering (TKDE), 13, 3.
i-VISION case. In Proc. of the 2nd Intl. WS on modelling, anal- [42] M van Kleek, B Moore, DR Karger, P André, and m. c. schrae-
ysis, and control of complex CPS (CPSData). fel. 2010. Atomate it! end-user context-sensitive automation
[23] T Käfer, J Umbrich, A Hogan, and A Polleres. 2012. Towards using heterogeneous information sources on the web. In
a dynamic Linked Data observatory. In Proc. of the 5th WS Proc. of the 19th Intl. Conf. on World Wide Web (WWW).
on Linked Data on the Web (LDOW). [43] R Verborgh, T Steiner, D van Deursen, S Coppens, JG Vallés,
[24] FL Keppmann, T Käfer, S Stadtmüller, R Schubotz, and A and R van de Walle. 2012. Functional descriptions as the
Harth. 2014. High performance Linked Data processing for bridge between hypermedia APIs and the semantic web. In
Virtual Reality environments. In Proc. of Posters & Demos at Proc. of the 3rd Intl. WS on RESTful Design (WS-REST).
the 13th Intl. Semantic Web Conf. (ISWC).
[25] M Kifer. 1995. Deductive and object data languages: A quest
for integration. In Proc. of the 4th Intl. Conf. on Deductive and
Object-Oriented Databases (DOOD).