Traditional con gurable operating systems typically provide a xed and limited set of functionality. W e propose a metalevel architecture, where application-de ned objects can choose from a rich selection of possible con gurations and are therefore able to dynamically change the way in which they are executed to the con guration that suits best. This allows applications to adapt operating system behaviour to even unanticipated requirements during run-time. A distributed application processing multimedia data serves as an example to illustrate the concepts described.

The following paper describes a security scheme for a distributed multimedia environment called Switchboard. After a brief introduction to the philosophy of the Switchboard and the underlying system model, the main building blocks of the concept are described. These are: an authentication mechanism preventing intruder attacks and a protection scheme based on an extended access control matrix approach. This protection scheme covers both static and dynamic aspects of access protection for multimedia devices. Some remarks on the implementation of the mechanisms and a discussion conclude this paper.

No abstract

Traditional object-oriented r eal-time systems are often limited in that they provide only one approach to real-time object support. Taking the increasing demand for exible and extensible object support environments into account, we discuss the design and implementation of a small object-oriented r eal-time executive based on a sub-framework which we call Roo. Roo is a component of the Tigger framework (our proposal for an extensible object support operating system) and is intended to support di erent object models providing soft real-time behaviour. Roo p r ovides support for di erent mechanisms and policies for real-time thread management, scheduling and synchronization. In this it serves as a basis for other components of the Tigger framework.

With the advent of object-oriented metalevel architectures, a new programming paradigm in the shape of before and after metamethods has arrived. This paradigm allows the hidden execution of additional functionality that previously had to be inserted explicitly into the source code of a program. Typically, this was implemented as a pair of invocations to some initialisation and finalisation routines. This paper provides the formal proof that before and after metamethods have the same expressive power as the explicit invocation of functionality, resulting in the equivalence of both paradigms.