http://www.ronpub.com/index.php/journals/OJDB/issues?volume=6&issue=ALL All papers of this volume en-us https://www.ronpub.com/ojdb/OJDB_2019v6i1n01e_HiDeSt2018.html http://nbn-resolving.de/urn:nbn:de:101:1-2018122318332165752519 Stream processing as an information processing paradigm has been investigated by various research communities within computer science and appears in various applications: realtime analytics, online machine learning, continuous computation, ETL operations, and more. The special issue on "High-Level Declarative Stream Processing" investigates the declarative aspects of stream processing, a topic of undergoing intense study. It is published in the Open Journal of Web Technologies (OJWT) (www.ronpub.com/ojwt). This editorial provides an overview over the aims and the scope of the special issue and the accepted papers. https://www.ronpub.com/ojdb/OJDB_2019v6i1n02_QianLiu.html http://nbn-resolving.de/urn:nbn:de:101:1-2018122318333313711079 Provenance describes how results are produced starting from data sources, curation, recovery, intermediate processing, to the final results. Provenance has been applied to solve many problems and in particular to understand how errors are propagated in large-scale environments such as Internet of Things, Smart Cities. In fact, in such environments operations on data are often performed by multiple uncoordinated parties, each potentially introducing or propagating errors. These errors cause uncertainty of the overall data analytics process that is further amplified when many data sources are combined and errors get propagated across multiple parties. The ability to properly identify how such errors influence the results is crucial to assess the quality of the results. This problem becomes even more challenging in the case of Linked Data Streams, where data is dynamic and often incomplete. In this paper, we introduce methods to compute provenance over Linked Data Streams. More specifically, we propose provenance management techniques to compute provenance of continuous queries executed over complete Linked Data streams. Unlike traditional provenance management techniques, which are applied on static data, we focus strictly on the dynamicity and heterogeneity of Linked Data streams. Specifically, in this paper we describe: i) means to deliver a dynamic provenance trace of the results to the user, ii) a system capable to execute queries over dynamic Linked Data and compute provenance of these queries, and iii) an empirical evaluation of our approach using real-world datasets. https://www.ronpub.com/ojdb/OJDB_2019v6i1n03_Schiff.html http://nbn-resolving.de/urn:nbn:de:101:1-2018122318334350985847 Recent approaches to ontology-based data access (OBDA) have extended the focus from relational database systems to other types of backends such as cluster frameworks in order to cope with the four Vs associated with big data: volume, veracity, variety and velocity (stream processing). The abstraction that an ontology provides is a benefit from the enduser point of view, but it represents a challenge for developers because high-level queries must be transformed into queries executable on the backend level. In this paper, we discuss and evaluate an OBDA system that uses STARQL (Streaming and Temporal ontology Access with a Reasoning-based Query Language), as a high-level query language to access data stored in a SPARK cluster framework. The development of the STARQL-SPARK engine show that there is a need to provide a homogeneous interface to access both static and temporal as well as streaming data because cluster frameworks usually lack such an interface. The experimental evaluation shows that building a scalable OBDA system that runs with SPARK is more than plug-and-play as one needs to know quite well the data formats and the data organisation in the cluster framework. https://www.ronpub.com/ojdb/OJDB_2019v6i1n04_Obermeier.html http://nbn-resolving.de/urn:nbn:de:101:1-2018122318335923776377 In the past, we presented a first approach for stream reasoning using Answer Set Programming (ASP). At the time, we implemented an exhaustive wrapper for our underlying ASP system, clingo, to enable reasoning over continuous data streams. Nowadays, clingo natively supports multi-shot solving: a technique for processing continuously changing logic programs. In the context of stream reasoning, this allows us to directly implement seamless sliding-window-based reasoning over emerging data. In this paper, we hence present an exhaustive update to our stream reasoning approach that leverages multi-shot solving. We describe the implementation of the stream reasoner's architecture, and illustrate its workflow via job shop scheduling as a running example.