Abstract The Java programming language has a low‐level concurrency model which is hard to use and does not blend well with inheritance. JACis an extension of Java that introduces a higher level of concurrency, hiding threads and separating thread synchronization from application logic in a declarative fashion. The emphasis is on limiting the differences between sequential and concurrent code, thus furthering code reuse, and on avoiding inheritance anomalies. This is achieved by taking a middle road between concurrent code on the one hand and complete separation of sequential application logic from concurrency mechanisms on the other. An extensive comparison with related approaches is given for motivating our design decisions. Copyright © 2005 John Wiley & Sons, Ltd.

HERON is a platform for object-oriented distributed computing in an open systems environment. We try to achieve a degree of distribution transparency previously known only from special distributed programming systems, while at the same time accommodating heterogeneous, autonomous computer systems. Distributed programs are written in Eiffel. The Eiffel language system is not modified: HERON employs proxies for remote object invocation and a flexible configuration procedure for building servers and distributed programs. In addition to regular objects, two kinds of distributed objects are supported by the proxy generator: dispersed objects and objects fragmented by remote inheritance. They contribute to distribution transparency both for distributed programs and for client/server systems.>

Widespread acceptance of concurrent objectoriented programming in the field can only be expected if smooth integration with sequential programming is achieved.This means that a common language base has to be used, where the concurrent syntax differs as little as possible from the sequential one but is associated with a "natural" concurrent semantics that makes library support for concurrency superfluous.In addition, not only should sequential classes be reusable in a concurrent context, but concurrent classes should also be reusable in a sequential context.It is suggested that cmcurrcmy nnnofutions be inserted into otherwise sequential code.They are ignored by a sequential compiler, but a compiler for the extended concurrent language will recognize them and generate the appropriate concurrent code, The concurrent version of the language supports active and concurrent objects and favours a declarative approach to synchronization and locking which solves typical concurrency problems in an easier and more readable way than previous approaches.Concurrency annotations are introduced using E@ieZ as the sequential base.

A description is given of DAPHNE, a system of tools and run-time support routines that allow programs to be broken into parts for distributed execution on different nodes of a heterogeneous computer network. This approach serves as a natural basis for classical network services such as remote file access or remote login while at the same time allowing arbitrary distributed applications to be written in a standard programming language. The pivot of DAPHNE is a remote procedure call mechanism that is specifically adapted to a heterogeneous environment, notably heterogeneous systems software. The current language context of DAPHNE is Modula-2. Prototype software exists for a local area network including Unix and MS-DOS systems.>

Abstract The programming language Concurrent Pascal can be used for the construction not only of small memory‐resident operating systems but also of moderate size swapping systems. If a few amendments are made to the kernel, it is possible to provide a virtual memory management as a part of the CPASCAL program. This approach was taken in the construction of a small time‐sharing system called MUSIC (Multi‐User System In Concurrent Pascal), the design of which is briefly sketched, along with some considerations about the language.

A well-structured system can easily be understood and modified. Moreover, it may lend itself even to dynamic modification: under special conditions, the possibility of changing system parts while the system is running can be provided at little additional cost. Our approach to the design of dynamically modifiable systems is based on the principle of data abstraction applied to types and modules. It allows for dynamic replacement or restructuring of a module's implementation if this does not affect its specification (or if it leads to some kdnd of compatible specification). The fundamental principles of such "replugging" are exhibited, and the implementation of a replugging facility for an experimental operating system on a PDP-11/40E is described.

We take the view that operating systems should not be written in assembly language. Alternatives are machine oriented high-level languages and “safe” languages in the style of Concurrent Pascal and MODULA. A serious drawback of the Concurrent Pascal approach is the fact that those very language features that pertain to operating systems must be implemented separately, using some other language. A technique is presented which solves this problem. This technique is based on user-defined trap handling. It is exhibited by demonstrating how virtual memory systems can be constructed using Concurrent Pascal and how process management can be moved from the kernel to the Concurrent Pascal program. We demonstrate that a fundamental solution of the difficulties with Concurrent Pascal, MODULA, and similar languages cannot be found in going back to classical implementation languages, but in designing languages that are not rich with special features, but powerful with respect to extension and shrinkage.