author: George T. Heineman and Alok Mehta
The purpose of this paper is to gain experience in solving real problems faced by a company. We first specify the system architecture of the AFS Master System (r) using our Component Specification Language (CSL). We then identified various problems evident in the current architecture of the AFS Master System (r). Based on an analysis of the architecture and these problems, we proposed a modification to the software architecture that addressed five out of the seven main problems identified. The engineers made the appropriate changes to the software system (about one week of effort) and have noted a 25% improvement in efficiency as well as an improved system organization that can be more easily changed to meet future demands. We believe the type of architectural change described in this paper will prove useful to developers using similar technologies as described in this paper.
author: George T. Heineman
One of the many difficulties in making Component-Based Software Engineering (CBSE) a reality is the adaptation of software components that may be required when constructing applications from COTS components. We surveyed the literature to discover various approaches to component adaptation and evaluated these approaches against a set of requirements for component adaptation mechanisms. We also discuss differences between adaptation of software components and extension of object-oriented classes.
author: George T. Heineman
This paper focuses on the need to adapt software components and software architectures. Too often, examples from the literature avoid the difficult problem of constructing a software system from sets of (possibly independently constructed) software components. Consider the following example: given a set of components, an application builder attempts to construct a software system. Along the way, however, some components are adapted with new code to suit the requirements of the final application. If the components have architectural specifications, how are these adaptations reflected? In particular, changes in the component implementation (i.e., new classes, modified methods, new lines of code) must be reflected in the specification of the component (i.e., ports). This problem is more important than simply keeping documentation synchronized with software -- the architectural description of a software system is essential in understanding the interconnections between the various software components.
authors: Helgo Ohlenbusch and George T. Heineman
The Software Architecture community has developed a common vocabulary for describing software components and their interconnections. However, the structure of ports and roles have been too simplistic for capturing even simple examples. This paper explores the part that composition, inheritance, and interfaces play in defining ports and roles. We discuss these concepts within the context of the JavaBeans component model and show how to capture the complexity inherent in the interfaces of components and connectors.
author: George T. Heineman
The construction of software systems from pre-existing, independently developed software components will only occur when application builders can adapt software components to suit their needs. We propose that software components provide two interfaces -- one for behavior and one for adapting that behavior as needed. The ADAPT framework presented in this paper supports both component designers in creating components that can easily be adapted, and application builders in adapting software components. The motivating example, using JavaBeans, shows how adaptation, not customization, is the key to component-based software.
author: George T. Heineman
The construction of software systems from pre-existing, independently developed software components will only occur when application builders can adapt software components to suit their needs. Our ADAPT framework supports both component designers in creating components that can easily be adapted, and application builders in adapting software components. We propose that software components provide two interfaces -- one for behavior and one for adapting that behavior as needed. In this position paper, we outline some requirements for composing software systems from components and suggest that adaptation be recognized as a significant factor.
authors: Israel Z. Ben-Shaul and George T. Heineman
A workflow management systems (WFMS) employs a workflow manager (WM) to execute and automate the various activities within a workflow. To protect the consistency of data, the WM encapsulates each activity with a transaction; a transaction manager (TM) then guarantees the atomicity of activities. Since workflows often group several activities together, the TM is responsible for guaranteeing the atomicity of these units. There are scalability issues, however, with centralized WFMSs. Decentralized WFMSs provide an architecture for multiple autonomous WFMSs to interoperate, thus accommodating multiple workflows and geographically-dispersed teams. When atomic units are composed of activities spread across multiple WFMSs, however, there is a conflict between global atomicity and local autonomy of each WFMS. This paper describes a decentralized atomicity model that enables workflow administrators to specify the scope of multi-site atomicity based upon the desired semantics of multi-site tasks in the decentralized WFMS. We describe an architecture that realizes our model and execution paradigm.
authors: George T. Heineman and Gail E. Kaiser
Database management systems (DBMSs) have been increasingly used for advanced application domains, such as software development environments, network management, workflow management systems, computer-aided design and manufacturing, and managed healthcare. In these domains, the standard correctness model of serializability is often too restrictive. We introduce the notion of a Concurrency Control Language (CCL) that allows a database application designer to specify concurrency control policies to tailor the behavior of a transaction manager. A well-crafted set of policies defines an extended transaction model. The necessary semantic information required by the CCL run-time engine is extracted from a task manager, a (logical) module by definition included in all advanced applications. This module stores task models that encode the semantic information about the transactions submitted to the DBMS. We have designed a rule-based CCL, called CORD, and have implemented a run-time engine that can be hooked to a conventional transaction manager to implement the sophisticated concurrency control required by advanced database applications. We present an architecture for systems based on CORD and describe how we integrated the CORD engine with the Exodus Storage Manager to implement Altruistic Locking.
authors: Israel Z. Ben-Shaul and George T. Heineman
Decentralized process-centered software engineering environments (PSEEs) provide an architecture for interoperability between multiple PSEEs with heterogeneous processes. Atomicity is a standard correctness model for guaranteeing that a set of activities occurs as an atomic unit, or none of them occur at all. Within a single PSEE, atomicity is the concern of its database system. In a decentralized environment, however, the autonomous environments must find ways to cooperate if an atomic unit is split between multiple PSEEs. This paper describes a flexible atomicity model that enables process administrators to reconcile the conflict between local autonomy and global atomicity and cooperatively specify the scope of multi-site atomicity based upon the desired semantics of multi-site tasks in the decentralized PSEE.
authors: George T. Heineman and Gail E. Kaiser
Layered and componentized systems promise substantial benefits from dividing responsibilities, but it is still unresolved how to construct a system from pre-existing, independently developed pieces. Good solutions to this problem, in general or for specific classes of components, should reduce duplicate implementation efforts and promote reuse of large scale subsystems. We tackle the domain of software development environments and present an architecture for retrofitting external concurrency control components onto existing environment frameworks. We describe a sample ECC component, explain how we added concurrency control to a commercial product that had none, and briefly sketch how we replaced the concurrency control mechanism of a research system.
authors: Peter G. Selfridge and George T. Heineman
Understanding a software system is a prerequisite to any significant maintenance activity, and this understanding must intimately extend to the source code itself. This activity is difficult to support because of its highly interactive nature and the fact that code understanding is generally built up over time. This paper describes the Interactive Code Understanding Environment (ICUE, pronounced "IQ"), a graphical environment that supports the exploration of code and code relationships and allows the capture of significant relationships in the form of reusable graphical diagrams. ICUE provides a user with the ability to query a comprehensive code database generate from source code, view the results of queries in the form of graphs, interactively expand the graphs, hide unwanted information in several ways, and examine source code easily and directly from the graphs. ICUE also provides a mechanism for annotating, saving and manipulating these graphs to facilitate the capture of code-level software understanding as a library of such annotated graphs.
author: George T. Heineman
This paper demonstrates that the enaction of a software process can be separated from the formalism in which the process is modeled. To show this, we built a compiler capable of automatically translating a process model specified using StateMate into a Marvel environment which then supports the enaction of the process.
authors: George T. Heineman and Gail E. Kaiser
Reengineering a large code base can be a monumental task, and the situation becomes even worse if the code is concomitantly being modified. Since January 1992, we have been using the Marvel process-centered environment (PCE) for all of our software development and are currently using it to develop the Oz PCE (Marvel's successor). Towards this effort, we are reengineering Oz's code base to isolate the process engine, transaction manager, and object management system as separate components that can be used in arbitrary systems. In this paper, we show how a PCE can assist teams of users in carrying out code reengineering while allowing them to continue their normal code development. The key features to this approach are its incremental nature and the ability of the PCE to automate most of the tasks necessary to maintain the consistency of the code base.
author: George T. Heineman
Concurrency Control is the ability to allow concurrent access of multiple independent agents while still maintaining the overall consistency of the database. We discuss the notion of Cooperation Control, which gives a DBMS, the ability to allow cooperation of multiple cooperating agents, without corrupting the consistency of the database. Specifically, there is the need for allowing cooperating agents to cooperate while preventing independent agents from interfering with each other. In this paper, we use the Marvel system to construct and investigate cooperative scenarios.
author: George T. Heineman
The database community has produced extensive research on the concurrency control problem in the context of traditional databases. However, this traditional model is not suitable for some applications, such as software development environments and CAD/CAM systems. What is needed is an extended transaction model better suited for these newer applications. Unfortunately, there is no consensus as to which of the almost dozens of extended transaction models is appropriate. This paper posits that there is no single model which will be applicable to every application and seeks other ways to use existing database technology. Towards this end, we present Pern, a new transaction manager component which provides the flexible and tailorable support required by advanced database applications.
authors: Israel Z. Ben-Shaul, Gail E. Kaiser, and George T. Heineman
We present an architecture for multi-user software development environments, covering both general and process-centered MUSDEs. Our architecture is founded on componentization, with particular concern for the capability to replace the synchronization component -- to allow experimentation with novel concurrency control mechanisms that support collaborative work -- with minimal effects on other components while still supporting integration. The architecture has been implemented for the Marvel SDE, and we report our experience replacing and tailoring several parts of the synchronization component as part of Marvel.
authors: George T. Heineman, Gail E. Kaiser, Naser S. Barghouti, and Israel Z. Ben-Shaul
Marvel is a rule-based development environment (RBDE) that assists in the process of developing software projects. Marvel encapsulates each software development activity in a rule that specifies the condition for invoking the activity and its effects on the components of the project under development. These components are abstracted as objects and stored in a persistent objectbase. Each rule applies to a specific class of objects, which is specified as the parameter of the rule. Firing a rule entails binding its formal parameter to a specific object. If the rule changes the object in such a way that the conditions of other rules become satisfied, these other rules are automatically fired. A problem arises in this forward chaining model when the classes of the objects manipulated by the rules are different, because Marvel has to determine which object to bind to the parameter of each rule in the chain, based on the object manipulated by the original rule that initiated the chain. We describe both heuristic and algorithmic approaches for solving this problem.
author: George T. Heineman
This thesis proposal describes a transaction manager component, called Pern, with a tailorable concurrency control protocol. The database community has produced extensive research on the concurrency control problem in the context of traditional databases. However, this traditional model is not suitable for some applications, such as CAD/CAM systems and software development environments. What is needed is an extended transaction model better suited for these newer applications. Unfortunately, there is no consensus as to which of the almost dozens of extended transaction models is appropriate. This proposal posits that there is no single model which will be applicable to every application. To solve this problem, we propose Pern, a flexible and tailorable transaction manager component which provides the necessary support required by advanced database applications.