Concurrent Object-oriented Programming Languages Research Articles

Dynamic structural operational semantics

We introduce Dynamic Structural Operational Semantics (DSOS or Dynamic SOS) as a framework for describing semantics of programming languages that include dynamic software upgrades, i.e., for upgrading software code during run-time. DSOS is built on top of the Modular SOS of P. Mosses, with an underlying category theory formalization. The idea of Dynamic SOS is to bring out the essential differences between dynamic upgrade constructs and program execution constructs. The important feature of Modular SOS (MSOS) that we exploit in DSOS is the sharp separation of the program execution code from the additional (data) structures needed at run-time. In DSOS we aim to achieve the same modularity and decoupling for dynamic software upgrades. This is partly motivated by the long term goal of having machine-checkable proofs for general results like type safety.We exemplify Dynamic SOS on two languages supporting dynamic software upgrades, namely the C-like Proteus, which supports updating of variables, functions, records, or types at specific program points, and Creol, which supports dynamic class upgrades in the setting of concurrent objects. Existing type analyses for software upgrades can be done on top of DSOS too, as we illustrate for Proteus.As a side contribution we define a general encapsulating construction on Modular SOS useful in situations where a form of encapsulation of the execution is needed. We use encapsulation to give modular semantics to the concurrent object-oriented programming language Creol with active objects and asynchronous method invocations.

Concurrent Object-Oriented Programming: The MP-Eiffel Approach.

In this article a new concurrent object-oriented programming language is presented. This language ‐ named MP-Eiffel (Multi-Processor Eiffel) ‐ is developed as an extension to the sequential object-oriented language Eiffel. This choice is not accidental. Eiffel’s powerful, safe, and simple object-oriented semantics proved to be an excellent framework to introduce concurrency mechanisms. The choices made for the language concurrent mechanisms, and their semantics, resulted from an attempt to provide a safe and simple integration of the essential properties of both worlds: concurrent and sequential object-oriented programming. In section 2 the essential characteristics, requirements, problems, and elementary solutions of concurrent programming are briefly reviewed. Object-oriented sequential programming is then briefly introduced, giving emphasis to its fundamental and useful properties. Since this work is about creating programming language mechanisms, some important language design rules are enumerated and succinctly justified. Those rules will be used to justify the choices made in MP-Eiffel. Several existing possibilities for integrating concurrency in an object-oriented language are presented and evaluated in section 4. A special care is taken to study the conditions under which unsafe interference may arise from the joint use of some mechanisms, such as the well known problem of “inheritance anomalies”. It is shown that such problems can be prevented without compromising neither of the essential properties of both worlds.

BCOOPL: A Language for Controlling Component Interactions

This paper introduces BCOOPL, which stands for Basic Concurrent Object-Oriented Programming Language. BCOOPL was designed to support component-based development. In particular, it focuses on the specification of weakly-coupled components and the specification of interaction sequences between them. BCOOPL supports two design patterns directly. The built-in observer design pattern encourages the construction of weakly-coupled components. Its support for the mediator design pattern allows to govern the interactions between those components. These language features cater for the design and implementation of flexible systems in which specifications of individual component behavior is separated from specifications of component interactions. A high level overview of BCOOPL's key concepts is given, which are exemplified by means of a process control example.

Support for Implementation of Evolutionary Concurrent Systems

Concurrent programs that embed specifications of synchronizations in the body of their component are difficult to extend and modify. Small changes in a concurrent program, particularly changes in the interactions among components, may require re-implementation of a large number of components. Even specifications of components cannot be reused easily. This paper presents a concurrent program composition mechanism in which both specification and implementation of computations and interactions are completely separated. Separation of specifications and implementations facilitates extensions and modifications of programs by allowing one to separately change the implementations of computations and interactions. It also supports their reusability. The paper also describes the design and implementation of a concurrent object-oriented programming language based on this model, including a compiler for the language, and reports on the execution behavior of programs written in the language.

BCOOPL: Basic concurrent object-oriented programming language

A small, object-oriented language is introduced: BCOOPL (Basic Concurrent Object-Oriented Programming Language). This language is specifically targeted to support component-oriented programming. The main design goal of BCOOPL was to provide a small, but powerful set of language features that supports the construction of high-quality components through well-established software engineering practices, which include the separation of interfaces and implementations, weakly-coupled objects, and abstraction. A number of design patterns based on these principles is actually built in the language. In particular, the observer, the mediator and the bridge are supported directly. This provides a strong foundation on which higher level component specification languages can be built. BCOOPL has a long research history. Its roots can be traced back to path expressions, and the concurrent object-oriented programming languages Procol and Talktalk. As a result, BCOOPL only integrates essential language features that blend well and have proven their value in practice. Copyright © 2000 John Wiley & Sons, Ltd.

Partial confluence of processes and systems of objects

A process calculus extending the π-calculus with higher-order agent abstractions as in the Higher-Order π-calculus and first-order data other than names but with only first-order interaction is used to give a natural and direct semantic definition for a concurrent object-oriented programming language. A notion of partial confluence of agents is introduced and its theory developed, first in the setting of CCS and then in the mobile-process calculus. It is shown how the semantic definition can be used as a basis for reasoning about systems prescribed by programs of the language: the theory of partial confluence is used to prove the indistinguishability in an arbitrary program context of two classes whose instances combine to form data structures only one of which supports concurrent operations.

Synchronisation, concurrent object-oriented programming and the inheritance anomaly

There have been a number of models proposed for integrating concurrency and object-oriented programming. Unfortunately, there have been few criteria proposed for evaluating them. In focusing on issues of inheritance, designers of new concurrent object-oriented programming languages appear to have forgotten the experiences learned from over two decades of concurrent programming. In this paper we review Bloom's criteria for evaluating the expressive power of synchronisation primitives, and apply it in an object-oriented framework. We show that most of the available concurrent object-oriented programming languages lack expressive power, and that this contributes to the so-called inheritance anomaly. We then propose a new model which does address all of Bloom's criteria.

Temporal modelling of real-time communication protocols based on a process/channel approach

The design of temporally-predictable real-time software is a major issue in a wide range of computer applications. This paper focuses on the temporal modelling of communication protocols in real-time OSI-based computer networks, and discusses a method which can form the foundation of a tool which gives true temporal representations of such systems. The proposed approach, implemented using the power of a concurrent object-oriented programming language (STRAND), utilises a modelling methodology based on an advanced process/channel model. The paper suggests that the techniques can be applied to a range of problems, illustrated here by an example of an OSI protocol.

Rendez-vous with metric semantics

A comparative semantic study is made of an element of the family of concurrent object-oriented programming languages. Particular attention is paid to two notions: (i) dynamically evolving process structures, including a mechanism to name and refer to processes and a means to create new processes, and (ii) rendez-vous between processes involving the sending and answering of messages and the induced execution of method calls. The methodology of metric semantics is applied in the design of operational and denotational semantics, as well as in the proof of their equivalence. Both semantics employ domains which are determined as fixed points of a contracting functor in the category of complete metric spaces. Moreover, fruitful use is made of the technique of defining semantic meaning functions as fixed points of contracting higher-order mappings. Finally. syntactic and semantic continuations play a pervasive role.

AN ARCHITECTURAL SURVEY OF OBJECT MANAGEMENT SYSTEMS

Much work has been done in the last decade in the related areas of object-oriented programming languages and object-oriented databases. Researchers from both areas now seem to be working toward a common end, that of an object management system, or OMS. An OMS is constructed similarly to an OODB but provides a general purpose concurrent object-oriented programming language as well, complementing the OODB query facilities. In this paper, we will define several different types of object systems (object servers, persistent OOPL’s, OODB’s and OMS’s) in terms of their interfaces and capabilities from the viewpoint of how these support the requirements of cooperative information systems. We will examine the distinguishing features and general architecture of systems of each type in the light of a general model of OMS architecture.

Concurrent object-oriented programming in Classic-Ada

Although Ada supports concurrency and can thus be used as a concurrent programming language, it is not generally considered to be an object-oriented programming language. Classic-Ada is a preprocessor which adds the concepts of classes, inheritance, and dynamic binding to the Ada language. Classic-Ada is not billed as a concurrent object-oriented programming language, but it is possible to do anything in Classic-Ada that can be done in Ada. Thus, Classic-Ada can also serve as a concurrent object-oriented programming language. In this paper, we review the use of Classic-Ada in both concurrent and distributed environments.

Reflection facilities and realistic programming

We propose a new reflection model called 2-dimensional hierarchical reflection . The model naturally describes reflective facilities which enable us to change the language semantics as well as the underlying environment, i.e., memory management and cpu scheduling. The concurrent object-oriented programming language called AL-1 has been designed based on the model. The language is an adaptable/extensible system in the sense that the system's bevavior is dynamically changed by the way of reflection. In order to demonstrate how the language is adapted in user's demand, the typical reflective programming in the language is presented.

Rosette: An object-oriented concurrent systems architecture

A number of concurrent computers have been designed, such as [Ametek 1988] and [NCUBE 1986]. Taking advantage of concurrency on these computers will require new languages, operating systems, and en...

Concurrent object-oriented real-times systems research

This research investigates how to build real-time systems using a concurrent object-oriented programming language based on the actor model [Agha86]. The close parallels between the characteristics of concurrent object oriented languages and real-time systems motivates this investigation. Successful use of the actor model in closely related problem domains [Bake78, Barr87, Atha87, Yone87, Dela88] also suggests that this a fruitful line of inquiry. The research is composed of three interrelated projects:• designing a concurrent object-oriented programming language, named ACT++, for real-time system applications.• using ACT++ in representative real-time applications.• constructing a distributed real-time kernel, named REACT, to support the execution of ACT++ applications.The language and the kernel are distinctive because they (1) use fine-medium grained concurrency, termed ultralight processes, (2) support the combination of inheritance with the actor model of computation, and (3) are based on automatic, distributed, incremental real-time garbage collection of concurrent objects - removing error-prone management concerns from developers and unifying process (time) and memory management. An extended "white paper" describing these projects is available from the author on request.