Issues

Collaborative applications raise several design and implementation issues. The former address the user-interface of the application and correspond to the collaboration functions provided by the application to end user. The latter address how the application is programmed and its performance.

The design issues include:

• Session Management: How do distributed users create, destroy, join, and leave collaborative sessions?

• Single-user interface: What is the single-user interface presented to a user, that is, what are the application semantics if there is a single user in the session?

• Coupling: In a multiuser session, what feedback does a user receive in response to the input of another user?

• Access Control: How do we ensure that users do not execute unauthorized commands?

• Concurrency Control: How do we ensure that concurrent users do not enter inconsistent commands?

• Merging: How do we merge concurrent commands entered by different users?

• Undo/Redo: What are the semantics of undo/redo in a collaborative session?

• User Awareness: How are users made aware of ``out of band'' activities of their collaborators, that is, activities not deducible from the application feedback they receive from coupling?

• Fault Tolerance: How does the application react to faults?

The implementation issues include:

• Objects: What kind of objects are used to program a collaborative application?

• Collaboration Awareness: Which of these objects are collaboration aware and how are these objects integrated with existing, collaboration-unaware objects?

• Layers: How are these objects arranged in layers?

• Concurrency: How is the application decomposed into concurrent threads?

• Distribution: How are the application objects placed in different address spaces and hosts?

• Replication/Migration: Which of these objects are centralized and which are replicated? Which of the centralized objects can migrate?

• Real-Time Support: What kind of services are provided to ensure real-time interaction with tolerable jitter and latency?

• Collaboration Awareness: Which of the application objects are collaboration aware and how are these objects integrated with existing, collaboration-unaware objects?

• Infrastructure Support: Which of the application objects are implemented by the application programmer and which are provided by an infrastructure.

• Interoperability: How are objects of a collaborative application integrated with objects of other (collaborative and non-collaborative) applications?

• Algorithms: What are the algorithms used to implement the various collaboration functions of the object?

These views are overlapping since, for instance, good approaches to resolving collaboration issues can be found in existing collaboration systems. Thus, these views define a network of related concepts (Figure 2).

 
Figure 2: Different Views of a Concept.

In this course, we will traverse the network using first the systems view and then the issue view. Even though the other views will not be primary top-level views used to traverse this network, we will, nonetheless use them as secondary views. That is, for each construct we introduce as part of a system or as a resolution to an issue, we will consider the problems it solves and the relevant research in related disciplines. Since we will be looking at overlapping sets of concepts from two different views, there will be some repetition. The systems view will give us the broad context for many of the collaboration constructs we will discuss in-depth when we take the issue view later. We will not cover all of the problems, issues, disciplines, and systems because of since we do not have sufficient time and some of these issues, such as fault-tolerance in collaborative applications, have not been addressed in-depth.