Abstract: We discuss a number of open issues within object-oriented programming. The central mechanisms of object-oriented programming appeared with Simula, developed more than 30 years ago; these include class, subclass, virtual function, active object and the first application framework, Class Simulation. The core parts of object-oriented programming should be well understood, but there are still a large number of issues where there is no consensus. The term object-orientation has been applied to many subjects, such as analysis, design implementation, data modeling in databases, and distribution. In this paper the term object-oriented programming is meant to cover all these subjects, since one of the advantages of object-orientation is that it provides a unified approach to these subjects. The issues being discussed in this paper are the following: modeling versus reuse as the main benefit of object-orientation; the need for a language independent conceptual framework; abstraction mechanisms for supporting object-oriented programming, including classification and composition, single and multiple inheritance, inner versus super, genericity versus virtual classes and issues related to typing; class-based versus prototype-based languages; and concurrency. The points of view presented in this paper reflect the author's background in the Scandinavian tradition as manifested in the BETA language and the Mjolner project.

Abstract: Cooperative, process-oriented environments (CPEs) are systems whose behavior is defined in terms of process models. We show how CPEs are realized through brokers, which are a special form of software agents used to model participating entities in CPEs. A broker can represent a human participant, an existing software tool, or a part of the environment infrastructure. In our approach, we implement brokers on top of the active object-oriented database management system (ADBMS) SAMOS. Particularly, we use the facilities of SAMOS for implementing communication/cooperation between and control of brokers in CPEs. Our approach allows the construction of flexible, extensible systems and the definition of the behavior of participating entities local to brokers, avoiding the need for a centralized process engine.

Abstract: We present the multi-paradigm architecture TriGSflO, for a workflow management system. TriGS ’, is based on an active extension of the commercial object-oriented database system GemStoneTM. TriGSp,,,, takesfill advantage of the capabilities of the underlying database system such as reliability, recovery, transaction management, ana ’ authorization. At the current stage of implementation the novel features of TriGSpow are the seamless integration of ECA rules into an object-oriented model, theflexibility of worwow specification due to rule modeling, and the integration of external applications as part of workflow processing.

Abstract: The architecture and the implementation of the active, object- oriented database management system SAMOS are described. SAMOS is a research prototype extending a commercial object-oriented database management system with reactive behavior specified in the form of event- condition rules. This paper describes the various components of SAMOS for event detection, rule management, rule execution, and transaction management, and explains how they work and interact upon rule definition and execution. The current architecture of SAMOS is evaluated, experiences with the layered approach are described, and drawbacks are identified.

Abstract: Designing system software for large scale shared memory multiprocessors is challenging because of the level of performance demanded by the application workload and the distributed nature of the system. Adopting an object oriented approach for our system, we have developed a framework for de clustering objects, where each object may migrate, replicate, and distribute all or part of its data across the system memory using the policies that will best meet the locality requirements for that data. The mechanism for object invocation hides the internal structure of an object, allowing a request to be made directly to the most suitable part of the object on a per processor basis without any knowledge of how the object is de clustered. Method invocation is very efficient, both within and across address spaces, involving no remote memory accesses in the common case. We describe the design and implementation of this framework in Tornado, our multiprocessor operating system. >

Abstract: The objects accessible by a user at a particular time in an object-oriented system form a working environment. The invocation language via which this environment is viewed and manipulated can be regarded as semantically flexible since the set of operations available to the user is the union of the methods of all currently visible classes. In this paper we present a language system in which class definitions are extended to include appropriate syntax rules for the methods and which is consequently also syntactically flexible. The requirements for such a system both from the point of view of a user and with regard to efficient implementation are discussed. An implementation of such a flexible invocation language within a persistent object-based operating system is then presented.

Abstract: This paper describes a model for developing applications of active object-oriented databases based on three orthogonal concepts; methods, guards and actions and a tool which implements these ideas called MGA. MGA objects are active; they have guards which constrain the object's state, actions which maintain database integrity when the object's state changes, and methods through which the object provides other services. These active components are implemented as (collections of) rules and rules are in turn modelled as objects.

Abstract: This paper addresses efficient object invocation in distributed systems. Such systems include support for transparent object migration between computers connected by a network, delegation and revocation of access to objects in a system, and very high speed communication between objects, whether they are located in the same machine or across the network from each other. Asynchronous Transfer Mode (ATM) networks can be effectively utilized to implement many of the necessary features of secure, location transparent object invocation. By using the switch controller in an ATM network as a repository for location information, and by mapping virtual circuits to pairwise object interactions with explicitly declared rights of each object, we are able to provide a high performance system that is both secure and simple. >

Abstract: Chimera i? a novel database language integrating an object-oriented data model, a declarative query language based on deductive rules, and an active rule language for reactive processing. In most active object-oriented databases, active rules are associated with objects through methods—rules are triggered by method activations, and are used as devices for testing preand post-conditions for method applications to individual object instances. The Chimera approach is substantially different: it uses set-orzented active rules, activated as the effect of several, logically indistinguishable events affecting multiple object instances. This approach is consistent with the rest of Chimera, which supports a set-oriented, declarative query and update language. Object-orientation in Chimera guarantees important advantages over relational active rules, due to the use of object tdenttjiers. In object-oriented databases, object identifiers are uniquely associated with each object instance. In rules of Chimera: object-valued variables (i.e., variables ranging over obJect identifiers) provide a powerful bzndtng passing mechanism for linking events to conditions and conditions to actions, thus bridging the three syntactic components of active rules. Active rules in Chimera have several innovative features:

Abstract: A technique for software fault-tolerance on a distributed object-oriented system is presented. It provides software fault tolerance as well as resilience to the object failures. The technique is an extension of the active object replication schemes. Using the property of encapsulation, a group of objects with multiple implementations sharing a common interface can be treated as if they are a group of replicated objects. The resilience from hardware failures is achieved by the replication of computation. The software fault tolerance is attained by the design diversity. The application layer implementation of the technique is discussed.

Abstract: We develop a model for active entities in software systems. An active entity or simply an entity is an active object with a private state and one or more independent threads of control. Entities communicate with each other by message passing. A collection of communicating entities constitute a concurrent and distributed systems. We present a language for describing entities. The semantics and implementation of the language are also discussed.

Abstract: This paper describes a parallel object-oriented approach to dynamic 3-D visualization. We specify 3D objects and pixels as active objects. It employs a set of ECA rules to describe the behavior of active objects which are are compiled into a state network. A state network consists of a set of processes each of which corresponds to a state of an active object. Our analysis shows that the management cost for the state network is smaller than the pure object-oriented approach.

Abstract: A visual programming system is presented in which an object-based framework is imposed on a strongly typed object-oriented language. Active objects in this framework are viewed as a network of cooperating agents subject to mechanisms of behaviour replacement and delegation. Since these mechanisms are effective in a structured organization they tend to increase the active object’s responsibilities and push delegation to a higher level in the design process. The framework is intended to provide, at a coarser level, the flexibility and dynamic characteristic of delegation-based languages without sacrificing the structural design and the efficiency enabled by strongly typed languages.

Abstract: We discuss the implementation of GOAD (Gemstone Object-oriented Active Database), an active object-oriented database built on top of GemStone. This system has been developed with the specific aim of supporting interface tools for the creation and maintenance of rule bases, and we give particular attention to explaining how GOAD is designed to meet this aim. We show how objects, classes and metaclasses can support a three level event model which integrates with the underlying system in an ‘open’ manner. Moreover, by providing a uniform interface to these different objects, we are providing support for the implementation of more generic tools. We discuss the design of the system and how we gather inherited rules at run-time in an efficient manner. We explain the problems that arise as a result of our desired mode of implementation and how they were circumvented. Finally we discuss our future work and specifically how we plan to implement tools for the easier creation of rule bases.

Abstract: Rule-based object coordination.- Sender-initiated and receiver-initiated coordination in a global object space.- Correctness-preserving transformations for the design of parallel programs.- Distributed conflicts in communicating systems.- Bauhaus Linda.- On the operational semantics of a coordination language.- Abstracting interactions based on message sets.- Law-governed linda as a coordination model.- Requirements for a composition language.- A model for active object coordination and its use for distributed multimedia applications.- A machine for uncoupled coordination and its concurrent behavior.

Abstract: Many attempts have been made to add concurrency to C++, often by extensive compiler extensions, but much of the work has not exploited the power of C++. This paper shows how the object-oriented facilities of C++ are powerful enough to encapsulate concurrency creation and control. We have developed a concurrent C++-based prototype system (ABC++) and describe how we can provide, with a standard compiler, almost all of the functionality offered by a new or extended language. Active objects, object distribution, selective method acceptance, and synchronous and asynchronous object interaction are supported. Concurrency control and synchronization are encapsulated at the active object level. The goal of ABC++ is to allow users to write concurrent programs without dealing with explicit synchronization and mutual exclusion constructs, with as few restrictions on the use of C++ as possible. ABC++ can be implemented on either a shared memory multiprocessor or a cluster of homogeneous workstations. It is presently implemented on a network of RISC System/6000® processors and on the IBM Scalable POWERparallel™ System 1 (SP1™).