Prasun Dewan

Access control for collaborative environments

In this dissertation, previous work on access control for both collaborative and non-collaborative systems is surveyed. New access control requirements for general collaborative environments are identified, and it is shown that existing models do not completely meet these requirements. A new access control model is developed for meeting the requirements. In particular, a set of collaboration rights are identified based on a general collaboration model; exception-based, multiple inheritance mechanisms are used to support both flexible and high-level access specification; and dynamic, multiple ownership rules are developed to support flexible access administration. The model can emulate a variety of existing systems and meets the new access requirements. It has been implemented in a generic, extensible collaborative system, which relieves individual applications from implementing the model.

A high-level and flexible framework for implementing multiuser user interfaces

We have developed a high-level and flexible framework for supporting the construction of multiuser interfaces. The framework is based on a generalized editing interaction model, which allows users to view programs as active data that can be concurrently edited by multiple users. It consists of several novel components including a refinement of both the Seeheim UIMS architecture and the distributed graphics architecture that explicitly addresses multiuser interaction; the abstractions of shared active variables and interaction variables, which allow users and applications to exchange information; a set of default collaboration rules designed to keep the collaboration-awareness low in multiuser programs; and a small but powerful set of primitives for overriding these rules. The framework allows users to be dynamically added and removed from a multiuser sesssion, different users to use different user interfaces to interact with an application, the modules interacting with a particular user to execute on the local workstation, and programmers to incrementally trade automation for flexibility. We have implemented the framework as part of a system called Suite. This paper motivates, describes, and illustrates the framework using the concrete example of Suite, discusses how it can be implemented in other kinds of systems, compares it with related work, discusses its shortcomings, and suggests directions for future work.

Flexible user interface coupling in a collaborative system

An important issue in collaborative systems is the kind of sharing or coupling among the various windows displaying a shared workspace. We have developed a flexible coupling model that allows users to control severat aspects of the coupling among shared windows including which values in these windows are coupled, when changes to these values are broadcast and received, how “correct” a value must be before it is broadcast or received, which users see the same view of a vatue, and whether a user can specify coupling parameters for other users. In this paper, we argue that a collaborative system must support flexible coupling, identify some of the issues in the design of SyStems supporting flexible coupling, describe and illustrate our approach to flexible coupling, and present conclusions and directions for future work.

A concurrency control framework for collaborative systems

We have developed a new framework for supporting concurrency control in collaborative applications. It supports multiple degrees of consistency and allows users to choose concurrency control policies based on the objects they are manipulating, the tasks they are performing, and the coupling and merge policies they are using. Concurrency control policies are embodied in hierarchical, constructor-based lock compatibility tables. Entries in these tables may be specified explicitly or derived automatically from coupling and merge policies. In this paper, we motivate and describe the framework, identify several useful concurrency control policies it can support, evaluate its flexibility, and give conclusions and directions for future work.

A flexible object merging framework

The need to merge different versions of an object to a common state arises in collaborative computing due to several reasons including optimistic concurrency control, asynchronous coupling, and absence of access control. We have developed a flexible object merging framework that allows definition of the merge policy based on the particular application and the context of the collaborative activity. It performs automatic, semi-automatic, and interactive merges, supports semantics-determined merges, operates on objects with arbitrary structure and semantics, and allows fine-grained specification of merge policies. It is based on an existing collaborative applications framework and consists of a merge matrix, which defines merge functions and their parameters and allows definition of multiple merge policies, and a merge algorithm, which performs the merge based on the results computed by the merge functions. In conjunction with our framework we introduce a set of merge policies for several useful kinds of merges we have identified. This paper motivates the need for a general approach to merging, identifies some important merging issues, surveys previous research in merging, identifies a list of merge requirements, describes our merging framework and illustrates it with examples, and evaluates the framework with respect to the requirements and other research efforts in merging objects.

Toward computer-supported concurrent software engineering

An experimental software engineering environment called the flexible environment for collaborative software engineering (Flecse), which supports concurrent software engineering, is discussed. Flecse features tools designed to surmount collaboration problems that software engineers are increasingly encountering. The implementation of five important themes of concurrent software engineering in Flecse tools, concepts, life cycles, integration, and sharing, is examined.<<ETX>>

Semi-synchronous conflict detection and resolution in asynchronous software development

Previous work has found that (a) when software is developed collaboratively, concurrent accesses to related pieces of code are made, and (b) when these accesses are coordinated asynchronously through a version control system, they result in in- creased defects because of conflicting concurrent changes. Previous findings also show that distance collaboration aggravates software-development problems and radical co- location reduces them. These results motivate a semi-synchronous distributed computer- supported model that allows programmers creating code asynchronously to synchro- nously collaborate with each other to detect and resolve potentially conflicting tasks be- fore they have completed the tasks. We describe, illustrate, and evaluate a new model designed to meet these requirements. Our results show that the model can catch con- flicts at editing time that would be expensive to manage at later times.

Coupling the user interfaces of a multiuser program

We have developed a new model for coupling the user interfaces of a multiuser program. It is based on an interaction model and a user interface framework that allow users and programmers, respectively, to view applications as editors of data. It consists of a semantics model, a specification model, and an implementation model for coupling. The semantics model determines (1) which properties of interaction entities created for a user are shared with corresponding interaction entities created for other users and (2) when changes made by a user to a property of an interaction entity are communicated to other users sharing it. It divides the properties of an interaction entity into multiple coupling sets and allows users to share different coupling sets independently. It supports several criteria for choosing when a change made by a user to a shared property is communicated to other users. These criteria include how structurally complete the change is, how correct it is, and the time at which it was made. The specification model determines how users specify the desired semantics of coupling. It associates interaction entities with inheritable coupling attributes, allows multiple users to specify values of these attributes, and does a runtime matching of the coupling attributes specified by different users to derive the coupling among their user interfaces. The implementation model determines how multiuser programs implement user-customizable coupling. It divides the task of implementing the coupling between system-provided modules and application programs. The modules support automatically a predefined semantics and specification model that can be extended by the programs. We have implemented the coupling model as part of a system called Suite. This paper describes and motivates the model using the concrete example of Suite, discusses how aspects of it can be implemented in other systems, compares it with related work, discusses its shortcomings, and suggests directions for future work.

Controlling access in multiuser interfaces

Traditionally, access control has been studied in the areas of operating systems and database management systems. With the advent of multiuser interfaces, there is a need to provide access control in the user interface. We have developed a general framework for supporting access control in multiuser interfaces. It is based on the classical notion of an access matrix, a generalized editing-based model of user-application interaction, and a flexible model of user-user coupling. It has been designed to support flexible control of all significant shared operations, high-level specification of access control policies, and automatic and efficcent implementation of access control in a multiuser interface. It supports several new kinds of protected objects including sessions, windows, and hierarchical active variables; a large set of rights including not only the traditional semantic rights but also interaction and coupling rights; a set of inference rules for deriving default permissions; and a programming interface for implementing access control in multiuser interfaces. We have implemented the framework as part of a system called Suite. This article describes and motivates the framework using the concrete example of Suite, identifies some of the difficult issues we faced in its design, describes our preliminary experience with it, and suggests directions for future work.

A tour of suite user interface software

Suite offers high-level abstractions for developing both single-user and multi-user interfaces. An interactive application in Suite displays data structures to one or more users and asynchronously responds to user modifications to these data structures. Between each application and user is a dialogue manager, which offers the user an interface for manipulating displayed data. Dialogue managers and applications execute in separate address spaces, residing possibly on different computers, such as local workstations and remote hosts. Users and applications can customize several aspects of the user interface including how data are displayed, the kind of feedback given in response to user input, and how changes made by multiple users to a data structure are synchronized. An inheritance model offering both structural and type inheritance is provided for easing the task of customizing user interfaces. Typing is considered orthogonal to persistence, communication, and input/output, that is, a value of any type can be made persistent, communicated among applications, and input from and output to users. In this paper, we take the reader on a tour of the software, highlighting its distinguishing features.