אליאור מלול, הרצאה סמינריונית למגיסטר
יום שלישי, 29.1.2013, 13:30
Although event processing is considered an emerging technology,
empirical studies show that most enterprises ability to use such systems as ranging from poor to fair.
Moreover, many of them indicated the skill issue as a barrier to adoption.
One of the major contributors to this observation is the inherent difficulty in enforcing temporal correctness using current languages and tools.
This difficulty can lead to incorrect outcomes or to work being hacked around these issues for a particular event processing system.
Such workarounds create a substantial entry barrier in the development of event processing applications.
We propose a solution that uses high level programming constructs for defining and enforcing temporal correctness guards requirements.
We demonstrate this approach by defining three temporal correctness guards that correspond to frequently used correctness requirements.
One of the three guards we define is the fairness guard,
which guarantees that events are processed in a logical order,
regardless of their path. This is vital for applications in which fairness must be kept with respect to the order;
examples of such application include bids, stock purchases, and computerized games.
We present two scenarios that demonstrate these correctness guards and formally define each guard.
Since the correctness guards are model-independent,
we also define the extension needed for a specific event processing model to support these guards.
The scenarios include the run-time algorithm we use to enforce the guards within that model.
The proposed solution opens up the opportunity to develop correctness abstractions,
which have the potential to significantly reduce the skill barrier for developing event processing applications.
The main contribution of this thesis, is that it pinpoints potential correctness problems in event processing application,
that we think to be common. Further more, this thesis formalize these problems,
as well as offer solution to deal with those problems. We continue by generalizing the solutions into runtime artifacts we name guards.
Finally, we define a domain specific language, that allows one to define new guards.