By a user-interface generator, we mean a UIMS that automatically generates views of abstract data from high-level descriptions of these views.
Examples of user-interface generators include ADE [Row85], which supports form-filling interfaces; and single-user Suite [Dew90a], which supports generalized editing interfaces [Dew90c]. Multiuser Suite [Dew92], which is an extension of single-user Suite, illustrates the benefits of extending a single-user user-interface generator to support multiuser applications.
Single-user Suite offers near automatic generation of single-user editing interfaces. It supports the abstraction of active variables and interaction variables. An active variable is an application variable whose value is displayed to the user and can be changed by him via an interaction variable. An interaction variable is a user's local version of an active variable of an object, which is automatically created by the system when the user connects to the object. It can be updated by the client to show a result, edited by the user to input a new value, and committed by the user to update the value of the corresponding active variable. An interaction variable is associated with interaction attributes, which determine interaction properties of the variable such as the format used to display it. The system invokes validate callbacks in a client to ask it to validate user changes to interaction variables and update callbacks to inform it of committed changes to these variables.
Multiuser Suite extends single-user Suite by displaying active variables to multiple, possibly distributed users, and allowing multiple users to manipulate the displays and the underlying variables. It provides a default collaboration scheme including a default sharing, communication, and concurrency control scheme, which can be used to create multiuser interfaces to collaboration-transparent Suite clients. It also defines a variety of high-level collaboration attributes, which are based on the editing model of interaction and can be used by application programs and users to dynamically specify alternate collaboration schemes. These attributes include sharing attributes, communication attributes, access attributes, and concurrency-control attributes.
Sharing attributes [Dew91] support the semantic, image, and complete sharing schemes discussed above. In addition, they support other kinds of sharing such as sharing of selected regions and cursor positions.
Communication attributes [Dew91] determine when changes made by a user are communicated to other users. They support, for instance, communication of changes as they are made or when they are explicitly committed. Both the sharing and communication attributes can refer to arbitrary groups of users, thereby allowing a user to share and communicate differently with different sets of users.
Access attributes [She92] are used to specify access rights and concurrency control attributes determine the granularity of locking.
The system also defines collaboration calls and collaboration callbacks, which can used by clients to implement their own collaboration schemes. In particular, it provides primitives to multicast a call to a variety of groups of users.
Figure 8.16 shows the main components of a Suite multiuser program.
Figure: Components of a Suite Multiuser Program
Figure 8.17 shows the architecture of Suite. It creates a single copy of the application, and for each user of the application, it automatically creates a system-defined dialogue manager which manages the user's interaction with the object. An application and its dialogue managers communicate with each other to keep their states consistent. They execute in separate address spaces and can reside on different computers. In particular, a user's dialogue manager can execute on the local workstation.
Figure: The Suite Hybrid Architecture
Implementing the example user-interface: The application program specifies the parse tree and other data structures displayed to users, callbacks for receiving changes to these data structures and implementing queries, and collaboration attributes that specify, for instance, that the complete state of test windows should be shared between users A and B, these changes should be communicated incrementally, only the semantic state of edit windows should be shared between these users, and only user A should be allowed to edit the madd procedure (Figure 8.1).
Multiuser Suite combines the benefits of a variety of tools. It offers collaboration-transparent programs,
fine-grained concurrency and access control, high-level support for specifying semantic, image, and complete sharing,
and collaboration calls and callbacks for implementing application-specific collaboration schemes. In addition, it provides high-level support for other kinds of sharing methods, specifying the communication scheme, dynamically changing the collaboration scheme, and allowing selected groups of users to share parts of the application state.
Moreover, its architecture is designed to keep network traffic low while executing semantic operations once. The architecture can be regarded as a combination of the centralized and replicated architectures since it supports a central semantic component (application) and local user-interface components (dialogue managers). Under this architecture, semantic actions are executed once in the central application component and user-interface tasks are performed locally. Since the semantic tasks are performed remotely, a user has to wait for communication delays involved in receiving results but not their displays, which are formatted locally by dialogue managers. Preliminary experience shows that these delays are not perceptible since (a) the size of a result is typically small in comparison to its display and, more important, (b) results are produced infrequently since users execute long transactions before they commit their input values.
Multiuser Suite has two important drawbacks. First, it is tied to single-user Suite and thus cannot offer multiuser versions of single-user interfaces that cannot be supported by single-user Suite. Second, unlike a database system, it does not address efficient access of large data structures or a relational query language, since the shared data structures it supports are defined and managed by a conventional programming language.