Visibility as central abstraction in event-based systems

We introduce scopes as basic abstraction in event-based systems. While existing work disregarded the role of an administrator and simply focused on using pub and sub primitives in flat design spaces, we devise on top of the visibility concept abstractions that support bundling and composing of new components, refining delivery semantics in these bundles, and mappings in heterogeneous systems. 1 Engineering Event-based Systems ... Publish/subscribe or event notification services are used increasingly often in distributed systems. They offer the ability to easily compose varying sets of components, facilitating loose coupling and asynchronous operations. The existing notification services typically have simple APIs with plain semantics: pub() and sub() methods for publishing notifications and registering callbacks with subscriptions [2] that are called when matching notifications are published. The notification services implement simple distributed broadcast and filter mechanism, and they are used for asynchronous notification and exception handling purposes, often besides the ‘normal’ operation of request/reply-based distributed systems. However, event-based cooperation can also be used for designing general purpose, highly configurable distributed systems, although the inherent complexity increases drastically if no further abstractions are available. The engineering support is not adequate and nowhere near the support we know for systems based on remote method invocation (RMI). For coordinating and composing loosely coupled systems there exists lot of related work in the area of Linda-like coordination systems [6] and composition languages, e.g., [10], but the characteristics of event-based systems are not fully supported. We analyze the engineering requirements of event-based systems and propose a module construct for abstraction and encapsulation by applying the notion of scoping to event-based systems in [3]. The visibility of events and components is used as fundamental basis for designing and engineering these systems. From an engineering point of view, scopes offer a module construct for event-based systems, being an abstraction and encapsulation unit at the same time. As an abstraction unit, a scope provides the rest of the world with common higher-level input and output interfaces to the bundled subcomponents. As an encapsulation unit, a scope constrains the visibility of the notifications published by the grouped components. It hides the details of the composition implementation, such as the underlying data transmission mechanisms, the interface mappings that map between internal and external representations of notifications, security policies, transmission policies controlling the way notifications are forwarded, etc. The structure built thereby is orthogonal to the components’ implementation, separating concerns of implementation and interaction. As defined in our model, scopes have the flavor of component frameworks in the sense of Szyperski [13]: they encode the interactions between components and can themselves act as components in higher-level frameworks. In this position paper, the scoping concept is revaluated from the viewpoint of providing abstractions of communication between event-based components, reflecting the ongoing work on transforming a straightforward Java implementation of the basic features to a coordination and configuration language for event-based systems. 2 ... and the Role of Visibility Software engineering research early identified information hiding and abstraction [12] as basic principles that have influenced the development of structured programming, modules, classes, and compo-