Software Abstractions for Event-Intensive Systems (SAFE-IS)
This project is situated in the domain of the Internet of Things, where computing power is introduced into everyday objects (which we will refer to as Things) that will enable them to communicate with one another and with the more classical computing elements such as PDAs, PCs and servers. Many Things will have very limited or no processing power at all (e.g. RFID-tags) while others are full-fledged mobile computers (e.g. PDAs). Some Things will request services from other Things. Others will autonomously produce events even though there was no prior explicit request by another Thing. For example, a rack in a supermarket could broadcast a continuous stream of events to notify potential passers-by for publicity purposes.
From a software engineering point of view, it is virtually impossible to represent the Things (and the events they produce) as simple collections (e.g. arrays) over which the application logic is to iterate. Because of Thing mobility, the collection constantly grows and shrinks as Things appear, disappear and reappear. The collection changes shape and size while we are iterating over it and designating its constituents. This project focuses on such event-intensive software systems where the crux of the problem lies in the volatility and massiveness of the information produced.
Recently, event-based programming has attracted a lot of attention. However, it is still too early to speak of mature methodologies that enable a systematic engineering of event-based systems [Müh06]. Furthermore, existing approaches have not been designed to deal with the aforementioned volatility of the connections and the massiveness of the produced events.
Objectives and expected results of the project
In distributed systems research, programming language and middleware research are often considered as competing approaches to tackle similar problems. SAFE-IS envisions that one single approach will not cover all aspects of the problem described above. On the one hand, we believe that the scale and volatility of the information produced results in a computational model that is irreconcilable with the traditional thread-based models in order to mould a complete solution in middleware libraries. On the other hand, we believe that the technical properties of the underlying machinery are too diverse in order to hide all aspects in a pre-designed programming language. SAFE-IS will therefore use an integrated approach that consists of an innovative open programming language in which language embedding is used to access an underlying middleware layer. Both will be supported by the appropriate implementation technology.
The three objectives of SAFE-IS are:
- We will conceive a suite of linguistic abstractions that allow us to collect, represent and manipulatelarge volatile ?clouds? of events in an atomic way. Operators working on such clouds operate ?in one shot? (similar to array-programming operators). This will allow us to reason about such volatilecollections in an expressive way even if those collections constantly change due to mobility of Things.
- We will conceive a middleware layer that is capable of routing, gathering and delivering massive amounts of events in the context of mobile Things that exhibit various semantic and spatiotemporalproperties. Language embedding techniques will take care of the integration of the language layer and the middleware layer.
- We will study and develop an implementation technology to support both the language as well as the middleware layer. First, we will develop technology that keeps the software layers causally connected tothe real world by keeping track of appearing, disappearing and reappearing Things. Second, we will develop the notion of an ?automaton-based composite event? that allows a cloud of events to be ?frozen? for subsequent processing by a normal sequential application.