An Architecture for Multi-User Software Development Environments

Israel Ben-Shaul, Gail E. Kaiser, George T. Heineman

Abstract

This paper presents a landmark approach to building software development environments (SDEs) tailored for collaborative team environments. By moving away from rigid, "one-size-fits-all" database models, the authors propose a modular architecture that allows developers to swap out synchronization policies with ease. The core innovation lies in a componentized architecture for Multi-User Software Development Environments (MUSDEs) that decouples synchronization from task and data management, enabling the use of diverse "cooperative" transaction models.

Introduction

In the early 1990s, SDEs were transitioning from single-user tools to multi-user systems. The prevailing approach was to adopt "atomic transactions" from database management systems. However, software development is inherently collaborative and involves long-duration activities—fixing a bug might take days, not milliseconds. Traditional locking models, where one user's access blocks all others, severely hinder productivity in this context.

While various "cooperative" transaction models were emerging, no single standard existed. The challenge was to build an environment stable enough for production work yet flexible enough to experiment with evolving coordination policies. This paper proposes an architecture designed to bridge this gap through modularity and the separation of mechanism from policy.

Architectural Design

The authors advocate for two core design principles: componentization and the separation of mechanism from policy. The architecture is structured into independent, loosely coupled layers to ensure horizontal adaptability.

Figure 1: The modular architecture for Multi-User Software Development Environments (MUSDEs), showing the separation of Task Management, Synchronization, and Data Management.

Core Components

The system is divided into three primary functional areas as shown in Figure 1:

  1. Task Management: Handles the execution and sequencing of development activities.
  2. Synchronization: Manages concurrent access and conflict resolution.
  3. Data Management: Oversees the storage and retrieval of project artifacts.

A key innovation within the synchronization layer is the split between the Lock Manager (LM) and the Transaction Manager (TM). The LM acts as a "mechanical" conflict detector using a table-driven compatibility matrix. In contrast, the TM serves as the "intelligent" conflict resolver, determining the appropriate action (e.g., aborting, suspending, or allowing a "dirty" read) when a conflict is detected.

Client-Server Hybrid Model

To prevent the server from becoming a performance bottleneck, the architecture employs a hybrid model. Long-duration activities, such as running compilers or editors, are offloaded to the client. The server remains focused on maintaining "control data"—the state, status, and relationships of the project objects.

Implementation and Evaluation: The MARVEL System

The architecture was realized in MARVEL 3.x, a rule-based, process-centered SDE. MARVEL 3.1, consisting of over 150,000 lines of C code, served as the primary testbed for evaluating the architecture's flexibility over a two-year period.

Key Insights

  • Mechanism vs. Policy: By utilizing a table-driven Lock Manager, the system's locking behavior could be modified by editing an external table, requiring no recompilation.
  • Coordination Manager (CM): A "mediator" component between task management and synchronization allows the system to apply semantic knowledge to conflict resolution (e.g., allowing members of the same sub-team to share files).
  • Visualization: Recognizing the need for situational awareness, the system allows clients to cache the structure of the project "objectbase," providing a graphical view of team activities without the overhead of caching full file contents.

Results

The "pluggability" of the architecture was demonstrated through several major system iterations:

  • Transaction Model Flexibility: The authors successfully replaced a "flat" transaction model with a "nested" one. Due to the modular design, this significant change had no impact on the Lock Manager and required only minimal changes to the Rule Processor.
  • Extensibility: The integration of the "Field" broadcast message server into the MARVEL client required only 950 lines of new code.
  • Real-World Robustness: MARVEL 3.1 was licensed to 25 educational and industrial sites, proving that a modular, experimental architecture could support real-world development.

Conclusion and Future Work

While the architecture successfully decoupled policy from mechanism, several challenges remain. The centralized server model faces scalability limits for very large teams, suggesting a need for distributed server architectures. Furthermore, while swapping components is straightforward, defining the complex rules for cooperative work remains a difficult task. Future research will focus on addressing these scaling issues and optimizing data transfer between clients and servers.

Summary updated

BibTeX
@inproceedings{benshaul1992architecture,
  author = {Israel Ben-Shaul and Gail E. Kaiser and George T. Heineman},
  title = {{An Architecture for Multi-User Software Development Environments}},
  booktitle = {SDE},
  year = {1992},
  doi = {10.1145/142868.143765},
}
Figure