Abstract
Several software engineering methods have been implemented using the tool, and experience with the process of method design has been valuable in refining our approach (Nuseibeh, Finkelstein, & Kramer, 1994). For each of the issues raised by the scenario in this paper, we have sketched out the approach and tested it on small examples. We have devised further experiments for each of the issues described, and are currently investigating the applicability of the approach using larger examples.
Introduction
In large-scale software engineering, maintaining perfect global consistency across distributed teams is often a bottleneck. Traditional development environments rely on a "single source of truth"—a centralized repository that enforces strict consistency. However, this approach stifles design freedom and creates communication overhead. This paper proposes a decentralized framework that treats inconsistency not as an error to be avoided at all costs, but as a manageable state that can be resolved incrementally.
The Problem of Global Consistency
Concurrent engineering involves multiple actors working on different parts of a system simultaneously. These experts often use diverse notations (e.g., dataflow diagrams vs. state charts) and have distinct goals. Forcing these perspectives to be perfectly consistent throughout the development lifecycle is an unnecessary burden. The real challenge lies in managing the "multiple perspectives problem"—allowing developers to work independently while providing formal mechanisms to identify and resolve conflicts when they impact the project's integrity.
The ViewPoints Framework
The authors introduce ViewPoints, which are loosely coupled, locally managed objects that encapsulate specific perspectives. Each ViewPoint consists of:
- Slots: These define the representation style (notation), domain (area of concern), specification, work plan, and a historical work record.
- Templates: Blueprints that define the methodology (e.g., how to construct a Dataflow Diagram).
- Inter-ViewPoint Rules: Formalized relationships that define how different perspectives should relate. These include Existence rules (e.g., "If a process is decomposed, a child diagram must exist") and Agreement rules (e.g., "Inputs in a parent diagram must match those in the child diagram").
- Process Models: Pre- and post-conditions that guide owners on when to check for consistency and how to handle failures.
Managing Inconsistency in Practice
To demonstrate the framework, the authors utilize a scenario involving two engineers, Anne and Bob, working on hierarchical Dataflow Diagrams (DFDs). Anne owns the top-level domain, while Bob is responsible for decomposing a specific process within that domain.
In this scenario, the framework allows Anne to define a process (Y) and delegate its decomposition to Bob. Bob can then build his sub-diagram (Y.1, Y.2) asynchronously. The system uses inter-ViewPoint rules to ensure that the data flows (d2, d3, d4) defined by Anne match the inputs and outputs in Bob's detailed view. If Bob renames a flow or adds an unauthorized output, the system flags an inconsistency without immediately blocking his work.
Key Insights
- Inconsistency as a Feature: Tolerating temporary "messiness" allows for design freedom during early phases, preventing premature commitment to rigid structures.
- Inconsistency vs. Conflict: The paper distinguishes between a broken formal rule (inconsistency) and an interference in goals (conflict). One can exist without the other, and the framework focuses on the formal management of the former to facilitate the resolution of the latter.
- Decoupling Actions: By separating the identification of a need from its fulfillment, the framework enables truly asynchronous collaboration.
- History-Aware Resolution: By maintaining a work record, the system can suggest repairs based on past successful states, such as identifying that a recent deletion caused a rule failure.
Conclusion and Future Work
The ViewPoints framework provides a qualitative proof-of-concept for a decentralized development environment that supports multi-language specifications and incremental resolution. While the current prototype, "The Viewer," successfully manages local responsibility, future work is needed to support human negotiation within the tool and to scale the management of thousands of inter-ViewPoint rules in massive industrial projects.
Summary updated