Specification of multi-object coordination schemes using coordinating environments

This dissertation proposes a coordination model for concurrent object-oriented programming languages (COOPLs). The model, termed Coordinating Environments (CEs), prescribes coordination among concurrently executing objects that compute as a group to achieve a common task or goal. The model represents coordination constraints and coordinating actions in a structured manner by grouping them into syntactic entities called Coordinating Behaviors (CBs). A group coordinator, termed a Coordinating Environment object (CE object), reduces the intrusive effects of coordination by transparently observing message-acceptance and method-termination events in components and triggering one or more coordinating actions on them. The conflict between the issues of information hiding (for better encapsulation) and information externalization (to enable coordination) is partially resolved by requiring components to provide state-interrogation methods. This allows a CE object to obtain and use local state information of components for the purpose of coordination.

A method for developing reusable coordination specifications in C++ is described. The method consists of two major steps: defining an abstract Coordinating Environment class (CE class) to capture the coordination problem in an abstract manner and then defining a concrete CE class (a subclass of the abstract CE class) to map the coordination effect embodied in the abstract CE class to a specific coordination problem. The method makes extensive use of the inheritance, polymorphism, and dynamic binding mechanisms of C++. Seven coordination problems, ranging from the coordination of a panel of buttons to the coordination of a multi-car elevator system, are specified to illustrate the method. A detailed design of the major components of the CEs model is also described.

The issues involved in using formal abstractions for coordinating process-agents specified in the Calculus of Communicating Systems (CCS) are also investigated. Using CCS directly to specify coordination has two weaknesses. First, coordination is modeled at a very low level in CCS by making agents engage in explicit communications. Such low-level specifications are poor candidates for specifying designs of software components that must satisfy software engineering criteria such as separation of concerns and reusability. Second, when the computation steps of the composition of agents are determined using the Expansion Law of CCS, many terms are generated that represent incorrect coordination sequences among the agents. Thus, the need for a calculus that addresses both the issue of concurrency and communication and the issue of effectively managing the communication among concurrent agents (that is, coordination) is identified, and the Calculus of Coordinating Environments (CCE) is proposed as a first step towards satisfying that need.