REASONING ON DATA STREAMS FOR SITUATION AWARENESS
Norbert Baumgartner
1
, Wolfgang Gottesheim
2
, Stefan Mitsch
2
, Werner Retschitzegger
2
and Wieland Schwinger
2
1
Team Communication Tech. Mgt. GmbH, Goethegasse 3, 1010 Vienna, Austria
2
Johannes Kepler University Linz, Altenbergerstr. 69, 4040 Linz, Austria
Keywords:
Stream reasoning, Situation awareness.
Abstract:
Information overload is a severe problem for human operators of large-scale control systems, for instance,
in road traffic management. In order to determine a complete and coherent view of the overall situation
(i. e., gain situation awareness), an operator of such a system must consider various heterogeneous sources
providing streams of information about a large number of real-world objects. Since the usage of ontologies has
been regarded to be beneficial for achieving situation awareness, various ontology-driven situation awareness
systems have been proposed. Coping with evolving and volatile individuals in ontologies, however, has not
been their focus up to now. In this paper, we describe how concepts from data stream management systems and
stream reasoning, such as sliding windows, continuous queries, and incremental reasoning, can be adjusted
to support reasoning over highly dynamic ontologies for situation awareness. We conclude our paper with a
prototypical implementation and a discussion of lessons learned, pointing to directions of future work.
1 INTRODUCTION
Gaining Situation Awareness in Data Streams. In-
formation overload is a severe problem for operators
of large-scale control systems, such as encountered
in the domain of road traffic management (RTM). In
order to determine a complete and coherent view of
the overall (traffic) situation, an operator of such a
system must consider heterogeneous sources, such as
traffic jam detectors and traffic incident reports, pro-
viding information streams about a large number of
objects. In order to reduce information overload, sit-
uation awareness (SAW) systems, according to End-
sley (Endsley, 2000), support operators by pointing
them to relevant information during (i) perception of
objects (e. g., a traffic jam), (ii) comprehension of cur-
rent situations (e. g., a wrong-way driver approaches a
traffic jam), and (iii) projection of situation evolution
(e. g., a wrong-way driver may cause an accident).
Ontology-driven Situation Awareness Systems.
Since the usage of ontologies is beneficial for SAW
(Llinas et al., 2004), various ontology-driven SAW
systems representing data streams in ontologies, for
This work has been funded by the Austrian Fed-
eral Ministry of Transport, Innovation and Technology
(BMVIT) under grant FIT-IT 829598.
instance (Baumgartner et al., 2010), (Kokar et al.,
2009) have been proposed. In contrast to tradi-
tional ontology-driven information systems focusing
on query answering (cf. (Buccella et al., 2009) for
a recent survey), SAW systems often operate on data
streams resulting from constantly monitoring the en-
vironment under control. This entails, that reason-
ing components, such as a situation assessor deter-
mining the current situation, must process a highly
dynamic ontology comprising evolving (e. g., a grow-
ing traffic jam) and volatile individuals (e. g., an ac-
cident). Although ontology-driven approaches in the
area of situation awareness exist, coping with evolv-
ing and volatile individuals in ontologies has not been
the focus up to now
1
. In this paper, we describe how
concepts from data stream management systems and
stream reasoning, such as sliding windows, contin-
uous queries, and incremental reasoning, can be ad-
justed to support reasoning for SAW.
Challenges of Highly Dynamic Ontologies. In or-
der to establish a basis for describing the challenges
of highly dynamic ontologies in situation awareness,
1
Note, that the research field of ontology evolution (Har-
tung et al., 2011) focuses on a different problem, namely the
evolution of the schema level of ontologies.
407
Baumgartner N., Gottesheim W., Mitsch S., Retschitzegger W. and Schwinger W..
REASONING ON DATA STREAMS FOR SITUATION AWARENESS.
DOI: 10.5220/0003656704070412
In Proceedings of the International Conference on Knowledge Engineering and Ontology Development (KEOD-2011), pages 407-412
ISBN: 978-989-8425-80-5
Copyright
c
2011 SCITEPRESS (Science and Technology Publications, Lda.)
in the following a brief overview of major reason-
ing components of an SAW framework (Baumgartner
et al., 2010) is given. As part of applying this frame-
work to a particular domain, adaptors and domain
mappers resolve structural and semantic heterogene-
ity by representing information from a data stream
first as individuals of a domain ontology, which is
then mapped into a core ontology. This core ontol-
ogy characterizes objects by attributes (e. g., loca-
tion). The history of an object is described in terms
of changes to their attributes, assigning to each at-
tribute value a temporal validity and a direct prede-
cessor. Due to frequent updates in the underlying data
streams, the core ontology comprises highly dynamic
individuals. Framework components must cope with
these dynamic individuals as detailed below.
First, on the perception level a chronologically
consistent ordering of attribute values in the face
of arbitrary update sequences across multiple data
streams must be established. For example, a traffic
jam detector may report a traffic jam without delay,
possibly resulting in a radio station report arriving
later in time, but actually describing the jam’s state
that was valid before. During this ordering, a change
collector avoids propagating undeterministic update
frequencies of underlying data streams to components
on higher levels by collecting updates into batches.
Second, on the comprehension level attribute values
determine relations between objects, which are fur-
ther aggregated to situations (task of a situation as-
sessor, cf. (Baumgartner et al., 2010) for details).
Hence, the challenge in data streams is to handle rea-
soning complexity by appropriately chosing the size
of sliding windows providing a view on data streams.
Structure of the Paper. Section 2 discusses related
work from data stream management and stream rea-
soning, as a basis for Sect. 3 and Sect. 4 applying con-
cepts from these research communities to SAW. Sec-
tion 5 describes a prototypical implementation, and
Sect. 6 lessons learned and further research directions.
2 RELATED WORK
In this section, we discuss concepts from data stream
management systems forming the basis for closely re-
lated work from the area of stream reasoning. In data
stream management systems (DSMS), various con-
cepts for handling the dynamic nature of data streams
have been described (cf. (Golab and Ozsu, 2003) for
a comprehensive overview of these concepts): Fixed,
landmark, and sliding windows
2
constrain the size of
an ever increasing data stream to those elements being
relevant for query execution. Common practice is to
define the size either in terms of time or information
item count (Golab and Ozsu, 2003). DSMS either sup-
port continuous queries over such sliding windows in
a monotonic fashion (i. e., assume that newly arrived
information do not affect previous query results), or
in a non-monotonic manner (i. e., may need to re-
evaluate previous results). Such concepts are success-
fully applied, e. g., in context aware systems for con-
tinuous spatial queries (Farrell et al., 2011). Focusing,
however, on information processing without consider-
ing rich background knowledge, DSMS are utilized for
querying rather than reasoning. In constrast, existing
semantic technologies supporting reasoning assume
static knowledge (Stuckenschmidt et al., 2010). The
exploitation of concepts from both worlds is the focus
in stream reasoning (Stuckenschmidt et al., 2010).
In stream reasoning, as part of the LarKC project,
various concepts have been proposed on the basis of
DSMS (Barbieri et al., 2010), (Stuckenschmidt et al.,
2010), (Valle et al., 2009). Della Valle et al. (Valle
et al., 2009) describe two complementary stream rea-
soning frameworks: (i) combining data stream man-
agement systems with standard reasoners and (ii) ex-
tending existing query languages, such as SPARQL.
In our work, we follow the first approach by using
adaptors for resolving structural heterogeneity be-
tween data streams and applying standard reasoners
in SAW reasoning components. In the terminology
of Della Valle et al, these adaptors and SAW rea-
soning components are called transcoders and pre-
reasoners, respectively. Besides the basic task of at-
taching timestamps to RDF triples (Barbieri et al.,
2010), (Valle et al., 2009), these approaches, however,
do not focus on sorting those triples describing object
attributes into a chronologically consistent manner.
Concerning comprehension-level challenges, Barbi-
eri et al. (Barbieri et al., 2010) handle updates to ma-
terialized deductions whenever new information en-
ters the sliding window. Exceeding their fixed win-
dow sizes, we additionally present concepts for dy-
namically adjusting windows. For non-monotonic
continuous queries, which are necessary in the pres-
ence of deleted and changed facts, we utilize prove-
nance information in our ontology for tracking deduc-
tions back to the facts they base upon and re-evaluate
deductions only when necessary.
In summary, current stream reasoning approaches,
although taking a first step by utilizing general DSMS
2
Fixed windows have two fixed ends, landmark win-
dows have one fixed and one sliding end, and sliding win-
dows have two sliding ends (Golab and Ozsu, 2003).
KEOD 2011 - International Conference on Knowledge Engineering and Ontology Development
408
concepts, have not yet focused on major challenges
in situation awareness, in particular, (i) handling of
arbitrary update sequences, and (ii) adjusting sliding
window sizes. In the following sections, we describe
stream approaches to SAW, focusing these challenges
on the perception and comprehension level.
3 STREAM PERCEPTION
Adjusting Update Frequency. Since the underly-
ing data streams in road traffic management are inde-
pendently maintained and highly dynamic, frequent
data updates at arbitrary times can occur. Each of
these updates may cause subsequent processing steps
of further components on the perception, comprehen-
sion, and projection level. In order to avoid high
performance overhead caused by consecutive, tem-
porally close updates, a change collector aggregrates
incoming updates from the underlying data streams
(in a similar manner as, for instance, context aggre-
gators (Dey, 2000)). Thereby, the change collector
moves forward a sliding window at configurable time
intervals, allowing the execution of subsequent com-
ponents on batch updates. As an additional task, the
change collector marks updated objects, thus enabling
subsequent components to work incrementally.
Chronologically Sorting Attribute Value Changes.
As a result of arbitrary update sequences, the temporal
intervals describing validity of attribute values may be
in arbitrary order as well. To achieve a chronologi-
cally correct ordering of attribute values, the topolog-
ical relationship between such temporal intervals is of
major importance. We utilize Allen’s interval algebra
(Allen, 1983), being perhaps the most established top-
logical temporal calculus, in order to describe topo-
logical relations between attribute valid time inter-
vals. Following Allen’s interval algebra, the data
source update sequences of the valid time of a previ-
ous and a current attribute value result in 13 possible
update cases (e. g., attribute valid times may overlap,
or one may be contained in another). In case multiple
attribute values are in conflict, strategies developed
in the data integration community can be used to re-
solve such conflicts. A detailed discussion of possible
strategies can be found in (Bleiholder and Naumann,
2008), two sample strategies are depicted in Table 1.
In this example those cases making fusion necessary
are shown (i. e., the valid time of previous informa-
tion and that of an update start or finish at the same
time, one is during the other, or both are equal to each
other). By applying the strategy Take the Information
(Bleiholder and Naumann, 2008), information newly
Table 1: Comparison of sample fusion strategies.
Relation Illustration Take the Information Trust your Friends
Starts |------| |------|
|------------| |------| |------------|
During |------| |------|
|------------| |---| |--| |------------|
Finishes |------| |------|
|------------| |------| |------------|
Equal |------| |------|
|------| |------|
added to the sliding window (top bar) is preferred over
previously added information (bottom bar), whereas
by applying the strategy Trust your Friends (Blei-
holder and Naumann, 2008), information of a partic-
ular data stream (bottom bar) is preferred over infor-
mation of another stream (top bar).
After consolidating incremental information from
data streams into an integrated ontology, comprehen-
sion of current situations can take place.
4 STREAM COMPREHENSION
In order to support human operators in their com-
prehension of current situations, especially relevant
is the description of relations between objects (e. g.,
close to) (Barwise and Perry, 1983). In SAW sys-
tems, this task is the responsibility of situation as-
sessment algorithms, which derive relations between
objects from object attributes and aggregate these re-
lations to situations (cf. (Baumgartner et al., 2010)
for details). In order to restrict situation assessment
to the most relevant types of situations only, many
SAW systems (e. g., (Kokar et al., 2009)) use rules for
defining which types of relations must be derived be-
tween which types of objects. For example, the sit-
uation type AccidentNearTrafficJam could be de-
fined as a rule stating that such a situation should be
reported, if an object of type Accident is in a rela-
tion of type Near with an object of type TrafficJam,
but only when the accident occurred During the life-
time of the traffic jam. Such rules in an SAW system
represent reasoning goals for continuous processing
(Barbieri et al., 2010). Since satisfying these rules
involves pairwise comparison of objects for each pos-
sible relation (Baumgartner et al., 2010), sliding win-
dow size is of crucial importance to reduce compu-
tational effort. Sliding window size can be adjusted
either statically on the basis of situation and object
types or dynamically on the basis of current instances
thereof, as described in the following paragraphs.
Statically Adjusting Sliding Windows on the basis
of Situation Rules. A central question in reasoning
REASONING ON DATA STREAMS FOR SITUATION AWARENESS
409
Table 2: Relation types and relevant information about valid
time intervals.
1
st
Valid Time 2
nd
Valid Time Relation Illustration
?------| |-----? Before |------|
|------|
|------? ?-----| After |------|
|------|
?------| |-----? Meets |------|
|------|
?------| |-----? Meets |------|
Inverse |------|
|------| |-----| Starts |------|
|------------|
|------| |-----| During |------|
|------------|
|------| |-----| Finishes |------|
|------------|
|------| |-----| Equal |-------|
|-------|
over data streams is concerned with finding the ap-
propriate size of the sliding window. A large window
size results in a large number of objects contained in
the sliding window, thereby lowering situation assess-
ment performance, whereas choosing a small win-
dow size results in the risk of missing relevant situ-
ations. The types of these situations, and in partic-
ular the rules defining how such a situation can be
detected, however, provide valuable clues for defin-
ing an appropriate window size. As a first hint, types
of relations describing temporal distance between ob-
jects define upper bounds for the size of sliding win-
dows. Temporal relation types concerning the topol-
ogy of intervals (e. g., the relation type During used
above), however, do not define such clear-cut bound-
aries. Rather, they depend on valid times of the in-
volved objects. For adjusting sliding windows to fit
such relation types, we can only provide experience-
based boundaries observed from real-world object
evolution (e. g., accidents are typically cleared within
two hours). Such experience-based boundaries, how-
ever, bear the risk of missing relevant situations. In
order to find all relevant situations, we must dynami-
cally adjust sliding windows on the basis of both, sit-
uation rules and current objects, as discussed below.
Dynamically Adjusting Sliding Windows depend-
ing on Current Objects. Temporal relation types
without clear boundaries, such as topological rela-
tions between time intervals, make it necessary to de-
fine sliding windows not in terms of statically fixed
boundaries, but in terms of the objects contained in
them. Table 2 lists the information about valid time
intervals being relevant for defining sliding window
sizes that are sufficiently large to satisfy Allen’s inter-
val algebra (Allen, 1983).
From this table showing Allen’s interval relations,
we see that the relation After should only be used in
combination with temporal distance relations. Other-
wise, objects can never be removed from the sliding
window, since at any time other objects occurring af-
ter them may be added to the sliding window.
5 PROTOTYPICAL
IMPLEMENTATION
In this section, we describe the software infrastructure
of our prototypical implementation and its application
in RTM on real-world information from the Austrian
highways agency
3
.
Software Infrastructure. Our infrastructure is
largely based on Java and the Jena Semantic Web
Framework
4
. For OWL reasoning within Jena, we use
the Pellet OWL Reasoner
5
offering reasonable perfor-
mance. For situation assessment, which accesses ob-
ject information extensively, we additionally use the
RDF triple store AllegroGraph
6
for its in-server rea-
soning capabilities (Baumgartner et al., 2010). Alle-
groGraph is a client-server system that integrates with
Jena and Pellet on the client side. On the server side,
AllegroGraph provides a Prolog and Common Lisp
environment which both are employed for developing
the algorithms of our SAW framework.
Arrange Reasoning Components in a Pipeline.
Employing the described software infrastructure, in
this paragraph we discuss the application of the well-
known software architectural style pipes-and-filters
(Buschmann et al., 1998) with respect to data stream
processing. In this architectural style (cf. Fig. 1),
processing components—filters implementing parts
of the three levels of SAW, e. g., a situation asses-
sor supporting comprehension—are arranged in a
consecutive manner by connecting them with pipes
(e. g., implemented using plain method calls or Java
RMI communication), forming altogether a process-
ing pipeline. In such a pipeline, filters depend only
on the results of their direct predecessors, and hence,
processing of elements in a data stream can be paral-
lelized. Let us discuss the design of these filters mak-
ing them pluggable components in detail. Each filter
contains its own volatile, A-box and a pipe connect-
ing the filter to the A-box(es) of the succeeding fil-
ters(s) (cf. (Baumgartner et al., 2008)). A filter listens
for updates to this input A-box, computes inferences
upon these updates using a local OWL DL and rule
reasoner, and writes the results into its output A-box
3
http://www.asfinag.at
4
http://jena.sourceforge.net
5
http://pellet.owldl.com
6
http://agraph.franz.com
KEOD 2011 - International Conference on Knowledge Engineering and Ontology Development
410
Situation Assessor
Local A-box
Input Output
OWL-DL
Reasoner
Rule
Reasoner
Core Situation T-box
Situation
Relation
DisrelatedEquals
Domain Mapper
Rule Reasoner
Local A-box
Input
Output
Local A-box
Custom Data
Source Access
Adaptor
Road Maintenance T-box
Roadworks
BridgeWork Mowing
Core Object T-box
Object
Attribute
Lifespan
Location
Pipe
Filter
Data Flow
Legend
subClassOf
object
property
instanceOf
Business Logic Layer
Persistence Layer
Presentation Layer
Figure 1: Components in a pipes-and-filters architectural
style.
and the referenced succeeding A-box(es). Thereby,
just the A-box statements that are relevant for the fol-
lowing filter(s) are handed over via pipes, resulting in
mutually shared A-box(es). The individuals in these
shared A-boxes are consistent with the concepts in
a shared T-box: Each filter defines the expected in-
put vocabulary (i. e., individuals written to its input
A-box must be consistent with respect to the input
T-box), as well as the output vocabulary it complies
with (i. e., each filter guarantees to produce only indi-
viduals that are consistent with respect to the output
T-box). As a result, filters in a processing pipeline can
be arranged in an arbitrary manner, as long as neigh-
boring filters agree on a shared T-box. In case such an
agreement cannot be established, additional domain
mappers must be inserted between them, which medi-
ate between filters by mapping the concepts of a pre-
ceding filter to concepts understood by a succeeding
one.
Preliminary Performance Results. We obtained
preliminary performance test results describing the
performance of the situation assessor component,
since this component is the slowest filter in our pro-
cessing pipe due to pairwise object comparisons be-
ing performed between all objects in its sliding win-
dow. Note, that in our current prototypical imple-
mentation, sliding windows are only adjusted stati-
cally, while the implementation and evaluation of dy-
namically adjusting sliding windows is part of our
future work. The performance tests were run upon
real-world traffic data recorded centrally for Austrian
highways over a period of four weeks. These data
are reported by multiple heterogeneous sources, com-
prising (i) a roadworks management system that pro-
vides information about scheduled roadworks, traffic
restrictions, and expected traffic jams, (ii) a traffic jam
detection system that reports traffic jams which are
automatically detected, (iii) an incident management
system that provides manually entered traffic-related
incident data, and (iv) a nation-wide broadcasting sta-
tion that provides diverse traffic information, ranging
from incidents and traffic jams to poor driving condi-
tions. The recorded data set used for this evaluation
consists of 28,616 distinct traffic objects, comprising
25,269 traffic jams, 820 road works, 1,803 other ob-
structions, 614 accidents, 46 wrong-way drivers, and
64 severe environmental conditions, such as snow or
ice on the road. Currently, a rather small number of
approximately 250 traffic objects and their associated
information are active at the same time (i. e., should
be part of the statically adjusted sliding window).
The test case design is influenced mainly by (i)
the number of objects to be compared, i. e., the size
of the sliding window, ranging from 10 to 500 objects
(N10, N50, N100, N500), and (ii) the focus of situa-
tion types: a low focus means that a situation type is
rather general and therefore results in many matches,
whereas a high focus means that a situation type is
very specific (F1: low focus, F2: high focus). We
measured two performance indicators, being indepen-
dent of the execution environment: (i) the number of
direct object comparisons (CMP), and (ii) the number
of derived relations (REL). Fig. 2 summarizes the test
results. Unsurprisingly, the size of the sliding window
Ch t Titl
100000
Ch
ar
t
Titl
e
1000
10000
100
1000
CMP
1
10
REL
1
N50 N100 N500 N50 N100 N500
F1 F2
Figure 2: Evaluation test results.
dramatically influences the performance of the situa-
tion assessor, since it compares objects within its slid-
ing window in a pairwise manner. However, the effect
on runtime performance can be counteracted with cor-
rectly focused situation types (i. e., by configuration
of the situation assessor): low-focused situation types
(cf. F1) lead to a more than tenfold increase of pair-
wise object comparisons compared to F2 (just to give
a runtime estimation, the 184 comparisons of N50 in
F1 take up 16.8 seconds on our test machine—AMD
Athlon 64 3500+ with 1.8 GB RAM).
6 CONCLUSIONS
In this section, we present lessons learned from im-
plementing and evaluating the framework in RTM and
indicate directions for future work.
REASONING ON DATA STREAMS FOR SITUATION AWARENESS
411
Knowledge about Window Size Boundaries makes
issuing Warnings Possible. In order to comply
with real-time constraints for situation assessment
(e. g., report critical situations to human operators
within one minute), during intervals of extensive traf-
fic, such as beginnings of holidays or periods of heavy
snow fall, it may be necessary to reduce the sliding
window size. With knowledge from relation types
used in particular situation rules, however, in such a
case we are at least able to issue warnings to human
operators, bringing to their attentation that particular
types of situations will potentially be missed.
Pipes mediate between Filters with Different Push-
pull Processing Characteristics. Reasoning com-
ponents in an SAW system may exhibit different data
stream processing characteristics, such as pro-actively
pulling information from a pipe (e. g., upon execution
of a user query) or re-actively waiting for the pipe to
push new information into the component (e. g., when
new information is reported by an automated system).
Different kinds of pipes, such as pipes buffering the
results of a preceding filter for being pulled from it
later, are therefore necessary to bridge between adja-
cent reasoning components with different processing
characteristics. Such buffering pipes may also flatten
data stream peaks, allowing a slower filter to catch up
with a faster one during intervals of reduced load.
REFERENCES
Allen, J. F. (1983). Maintaining knowledge about temporal
intervals. Communications of the ACM, 26(11):832–
843.
Barbieri, D., Braga, D., Ceri, S., Valle, E. D., and Gross-
niklaus, M. (2010). Stream reasoning: Where we got
so far. In Proc. of 4th Int. Workshop on New Forms
of Reasoning for the Semantic Web: Scalable and Dy-
namic.
Barwise, J. and Perry, J. (1983). Situations and Attitudes.
MIT Press.
Baumgartner, N., Gottesheim, W., Mitsch, S., Retschitzeg-
ger, W., and Schwinger, W. (2010). BeAware!—
situation awareness, the ontology-driven way. Inter-
national Journal of Data and Knowledge Engineer-
ing, 69(11):1181–1193.
Baumgartner, N., Retschitzegger, W., and Schwinger, W.
(2008). A software architecture for ontology-driven
situation awareness. In Proc. of 23rd Annual Symp.
on Applied Computing. ACM.
Bleiholder, J. and Naumann, F. (2008). Data fusion. ACM
Comp. Surveys, 41(1).
Buccella, A., Cechich, A., and Fillottrani, P. (2009).
Ontology-driven geographic information integration:
A survey of current approaches. Computers and Geo-
sciences, 35(4):710–723.
Buschmann, F., Meunier, R., Rohnert, H., Sommerlad,
P., and Stal, M. (1998). Pattern-Oriented Software
Architecture—A System of Patterns. Addison-Wesley.
Dey, A. K. (2000). Providing Architectural Support for
Building Context-Aware Applications. PhD thesis,
Georgia Institute of Technology.
Endsley, M. (2000). Situation Awareness Analysis and Mea-
surement, chapter Theoretical Underpinnings of Sit-
uation Awareness: A Critical Review, pages 3–33.
Lawrence Erlbaum Associates, New Jersey, USA.
Farrell, T., Rothermel, K., and Cheng, R. (2011). Process-
ing Continuous Range Queries with Spatiotemporal
Tolerance. IEEE Transactions on Mobile Computing,
10(3):320–334.
Golab, L. and Ozsu, M. (2003). Issues in data stream man-
agement. SIGMOD Rec., 32(2):5–14.
Hartung, M., Terwilliger, J., and Rahm, E. (2011). Schema
Matching and Mapping, chapter Recent advances in
schema and ontology evolution. Springer.
Kokar, M. M., Matheusb, C. J., and Baclawski, K. (2009).
Ontology-based situation awareness. International
Journal of Information Fusion, 10(1):83–98.
Llinas, J., Bowman, C., Rogova, G., and Steinberg, A.
(2004). Revisiting the JDL data fusion model II. In
Proc. of 7th Int. Conf. on Information Fusion.
Stuckenschmidt, H., Ceri, S., Valle, E. D., and van Harme-
len, F. (2010). Towards Expressive Stream Reasoning.
In Semantic Challenges in Sensor Networks, Dagstuhl
Seminar Proceedings.
Valle, E., Ceri, S., Barbieri, D. F., Braga, D., and Campi,
A. (2009). A first step towards stream reasoning. In
Domingue, J., Fensel, D., and Traverso, P., editors,
Future Internet—FIS 2008: Revised Selected Papers.
Springer.
KEOD 2011 - International Conference on Knowledge Engineering and Ontology Development
412