Abstract. Normal class-based code inheritance across component boundaries creates a dependency between the involved components. To avoid this, a speci cation of the inherited class must be part of the respective component's contract and the inheriting class must be speci ed with reference to this speci cation only. With this, inheritance can be replaced by object composition without sacri cing the possibility of static analysis, yet being more exible. 1

We present a new software system architecture for the implementation of hard real-time applications. The core of the system is a microkernel whose reactivity (interrupt handling as in synchronous reactive programs) and proactivity (task scheduling as in traditional RTOSs) are fully programmable. The microkernel, which we implemented on a Strong-ARM processor, consists of two interacting domain-specific virtual machines, a reactive E (Embedded) machine and a proactive S (Scheduling) machine. The microkernel code (or microcode) that runs on the microkernel is partitioned into E and S code. E code manages the interaction of the system with the physical environment: the execution of E code is triggered by environment interrupts, which signal external events such as the arrival of a message or sensor value, and it releases application tasks to the S machine. S code manages the interaction of the system with the processor: the execution of S code is triggered by hardware interrupts, which signal internal events such as the completion of a task or time slice, and it dispatches application tasks to the CPU, possibly preempting a running task. This partition of the system orthogonalizes the two main concerns of real-time implementations: E code refers to environment time and thus defines the reactivity of the system in a hardware- and scheduler-independent fashion; S code refers to CPU time and defines a system scheduler. If both time lines can be reconciled, then the code is called time safe; violations of time safety are handled again in a programmable way, by run-time exceptions. The separation of E from S code permits the independent programming, verification, optimization, composition, dynamic adaptation, and reuse of both reaction and scheduling mechanisms. Our measurements show that the system overhead is very acceptable even for large sets of task, generally in the 0.2–0.3 % range.

. The Gardens language, Mianjin, supports task based parallel computation, which utilises Active Messages style asynchronous communication. Unlike raw Active Messages, which is a library, this is achieved safely and without degrading performance by enforcing all necessary restrictions statically at the language level. Also supported is the definition of communication abstractions. To do this Mianjin utilises a partitioned address space where local objects are distinguished from those made globally accessible; this is achieved via type annotations. Type annotations are also used to distinguish those routines which may perform communications from those which will not; a distinction important for the static safety of an Active Message implementation. A special parameter mechanism is used to implement and enforce the conditions necessary for safe reply (read) operations. 1 Introduction This paper describes the Gardens programming language, Mianjin 1 , and its support for global objects....

Sather iters are a powerful new way to encapsulate iteration. We argue that such iteration abstractions belong in a class' interface on an equal footing with its routines. Sather iters were derived from CLU iterators but are much more flexible and better suited for object-oriented programming. We motivate and describe the construct along with several simple examples. We compare it with iteration based on CLU iterators, cursors, riders, streams, series, generators, coroutines, blocks, closures, and lambda expressions. Finally, we describe how to implement them in terms of coroutines and then show how to transform this implementation into efficient code.

. A machine_independent abstract program representation is presented that is twice as compact as machine code for a CISC processor. It forms the basis of an implementation, in which the process of code generation is deferred until the time of loading. Separate compilation of program modules with type_safe interfaces, and dynamic loading (with code generation) on a per_module basis are both supported. To users of the implemented system, working with modules in the abstract representation is as convenient as working with native object_files, although it leads to several new capabilities. The combination of portability with practicality denotes a step toward a software component industry. 1. Introduction The rapid evolution of hardware technology is constantly influencing software development, for better as well as for worse. On the downside, faster hardware can conceal the complexity and cost of badly_designed programs; Reiser [Rei89] is not far off the mark in observing that s...

One of the main problems of standards (e.g., DIN 66234, ISO 9241) in the context of usability of software quality is, that they can not be measured in product features. We present a new approach to measure user-interface quality in a quantitative way. First, we developed a concept to describe user-interfaces on a granularity level, that is detailed enough to preserve important interface characteristics, and is general enough to cover most of known interface types. We distinguish between different types of 'interaction-points'. With these kinds of interactionpoints we can describe several types of interfaces (CUI: command, menu, form-fillin; GUI: desktop, direct manipulation, multimedia, etc.). We carried out two different comparative usability studies to validate our quantitative measures. The results of one other published comparative usability study can be predicted. Results of six different interfaces are presented and discussed. Keywords: user-interfaces, utility functions, testability, quantification 1

We show how an object-oriented system-and in particular the Oberon System-can be used to write software that is extensible by end users even while the software is running. Extensibility instead of completeness may be a way out of the unpleasant situation in software industry where applications still tend to become bigger every year. Oberon is both an object-oriented programming language and an operating system with new concepts such as commands and dynamic loading. The language and the system make up an environment that is similar to Smalltalk in its flexibility but offers static type-checking and is much more efficient.

. The Oberon system, developed by Niklaus Wirth and J¨urg Gutknecht is unusual in that, although it has a "single process multitasking " window user interface, it does not support concurrent execution of programs. This approach yields a simple design and works surprisingly well, but it does have limitations of practical importance. In this report we describe a project, Concurrent Oberon, which introduces concurrency into the Oberon system while maintaining the simplicity and spirit of the original system. 1 Introduction Oberon is the name of both a programming language designed by Niklaus Wirth [RW92], and an operating system [WG92] for the Ceres workstation [Ebe87] designed by Wirth and J¨urg Gutknecht. 2 Both the language, which supports object oriented programming, and the system are notable for the elegance of their designs and significant functionality with a very small use of resources. In contrast to window systems that associate a process and a separate address space with ea...

Many modern systems, including web servers, database engines, and operating system kernels, are using language-based protection mechanisms to provide the safety and integrity traditionally supplied by hardware. As these language-based systems become used in more demanding situations, they are faced with the same problems that traditional operating systems have solved|namely shared resource management, process separation, and per-process resource accounting. While many incremental changes to language-based, extensible systems have been proposed, this thesis demonstrates that comprehensive solutions used in traditional operating systems are applicable and appropriate. This thesis describes Alta, an implementation of the Fluke operating system's nested process model in a Java virtual machine. The nested process model is a hierarchical operating system process model designed to provide a consistent approach to user-level, per-process resource accounting and control. This model accounts fo...

. In this paper we present an implementation of action notation based on a formal and modular speci cation of its semantics. This specication allows an automatic generation of an environment consisting of an interpreter and a debugger which allows the visualization of an action notation program execution and relates it to the given formal specication. The semantic description presented here is based on Montages, which is a semi-visual formalism for the speci cation of the syntax and semantics of programming languages. The tool support for Montages, called GemMex is used to execute the action notation specication and thereby generate an environment for executing action notation programs. Moreover, the specication maintains and renes the structuring of actions in terms of facets and thus ensures that the modularity present in action notation is retained in its semantic description. 1 Introduction Action semantics [30,34,52] is a specication formalism for the semantics of program...