We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in “tangled” code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they crosscut the system’s basic functionality. We present the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming.

Flexible and adaptive quality of service (QoS) is desirable for real-time multimedia applications. Suppose a multimedia system is supporting a 30 frame/second video stream which is using a network bandwidth of 2 Mbps, and due to network congestion the network bandwidth is reduced to 1 Mbps. It is desirable that the system supports graceful adaptation of quality of the video stream, for example, by reducing the frame rate to 15 frame/second. The focus of this dissertation is to investigate the design of an adaptive multimedia system (AMS) with multiple concurrent sessions, where the quality of individual sessions is dynamically adapted to the available resources and to the run-time user preferences. We propose the Utility Model -- a mathematical model to capture the issues of resource management within multisession AMSs. In this model, each session provides a quality profile, which is a set of operating qualities arranged from the minimum acceptable quality to the maximum desired qualit...

Modern multimedia applications place ever-growing performance and flexibility demands on operating systems. Unfortunately, many existing operating systems are inflexible; because of their monolithic nature, they cannot be easily changed to accommodate these demands. Some flexibility can be gained by decomposing such monolithic systems into microkernels and user-level components. Creating and modifying these components, however, remains complicated, and the performance overhead is often high. Alternatively, flexibility can be gained by linking extensions directly into the kernel. This usually preserves performance, but much ingenuity is required to prevent new code from corrupting existing components, and to remove old code when it is no longer needed. Incorporation of meta-objects, metaspaces, and meta-interfaces into flexible operating systems offers promising solutions to these problems. 1. Introduction Modern multimedia applications place ever-growing performance and flexibility d...

The lifetime of an operating system is long compared with that of its many varied applications and uses. General purpose or flexible systems design are solutions that address such lifetime differences. General purpose systems suffer from size and inefficiency. Flexible operating systems suffer from the overhead introduced by the mechanisms permitting flexibility. Structured dynamic customization facilities are required in order for the system to remain manageable and memory efficient. However, if such overheads can be ameliorated by performance improvements obtained by tuning the system to application behavior, flexibility has little cost. In this paper, we describe a meta-level architecture for dynamically modifying the resource management policies of a micro-kernel operating system. The architecture supports reflective computation through a flexible scripting language embedded in the micro-kernel. Kernel interpreters ensure a safe environment for script execution, allowing user proce...

The last decade has seen the emergence and popularisation of middleware technologies, such as the OMG’s Common Object Request Broker Architecture (CORBA), Microsoft’s Distributed Component Object Model (DCOM) and Sun’s Java RMI. These technologies have profoundly changed the way distributed applications are developed. In particular, they enable the large-scale deployment of applications in distributed heterogeneous environments, by making transparent the distribution aspects and enabling the developers to focus on application concerns. Importantly, the dissemination of distributed systems technology has also stimulated the emergence of new application areas, such as distributed multimedia and mobile applications. However, due to the dynamic nature of these new applications, current middleware technologies have proven inadequate. The major reason for this is the currently dominating “black-box ” philosophy for middleware design, which precludes the flexible configuration and adaptation of a platform in order to suit the particular and evolving requirements of different applications. This thesis

A run-time system is the glue between the compiler-generated code and the underlying platform. In addition to having a significant impact on performance, run-time systems are also largely responsible for the degree of portability of a language implementation. Concurrent programming languages are particularly dependent on threads and communication, both of which can vary greatly from platform to platform. This paper presents our current work in developing a portable run-time system for the SR programming language. We argue that portability must be addressed at multiple layers in a run-time system, and not just in a single virtual machine layer. We also present detailed design issues of our run-time system, especially with respect to the thread interface. Performance results are presented for three Linux-based thread packages. Although our work focused on the SR implementation, our overall approach and general observations should also be applicable to implementations of other concurrent ...

Abstract A run-time system is the glue between the compiler-generated code and the underlying platform. In addition to having a significant impact on performance, run-time systems are also largely responsible for the degree of portability of a language implementation. Concurrent programming languages are particularly dependent on threads and communication, both of which can vary greatly from platform to platform. This paper presents our current work in developing a portable run-time system for the SR programming language. We argue that portability must be addressed at multiple layers in a run-time system, and not just in a single virtual machine layer. We also present detailed design issues of our run-time system, especially with respect to the thread interface. Performance results are presented for three Linux-based thread packages. Although our work focused on the SR implementation, our overall approach and general observations should also be applicable to implementations of other concurrent programming languages. 1 Introduction The implementation of a concurrent programming language (parallel or distributed) often consists of a run-time system (RTS)1 in addition to a compiler. Run-time systems are used to simplify code generation, to implement the dynamic aspects of complex language elements, and to interface with the underlying operating system and/or architecture. Often the gap between the semantics of the language and the underlying platform is too large to accommodate direct translation from source code to object code. As such, a run-time system provides interfaces for manipulating the internal representation of language elements. The compiler's code generator is then responsible for producing code that properly invokes the run-time system interfaces. Indeed, many sequential languages require run-time systems for all of these reasons, but concurrent languages typically require extensive support for threads and communication.

In this paper we investigate the implications of Java's dynamic proxies for supporting open architectures to implement reusable code. Dynamic proxies are interpreted as meta-objects, which define the behaviour of other objects and allow the implementation of meta-objects protocols.