Collaborative editing systems (CES) are central to distributed, collaborative software engineering. Without the ability to collaborate on documents, the system cannot function. Central to the ability to collaborate on documents is the ability to work within a group and coordinate group effort. In a traditional software engineering setting, these activities entail project task scheduling, status reporting (and meetings), and inter-group communication.
Borghoff and Teege  present a model for collaborative editing that “mediates coordination and cooperation” and make the case that such a system can be used in the software engineering domain. They define the multi-user distributed system titled “IRIS” that consists of a data layer an operations layer. Static user information (such as phone numbers, email addresses, etc.) is stored in the data layer so communication is facilitated. Explicit and implicit coordination is provided by the operation layer, where implicit takes care of mutual exclusion for collaborative editing, and explicit allows users to soft and hard lock and communicate their activities to others in the collaborative space. The model also allows users to defined new parts, remove existing parts, and move parts in a structured edit (assumes that the documents in use have structure – SGML, ODA, etc.).
Borghoff and Teege  also have an interesting view in the systems applicability to software engineering. The authors make the case that software engineering consists of document manipulation and coordination of collaborative development. The code of the software system being built can be coordinated using their explicit and implicit coordination structure; versioned automatically because the model contains “history information;” report current activities because the system tracks dynamic user profiles (who has recently done what and is currently doing what); and can extract the latest build/version of the system [Borghoff and Teege, 1993].
What is most novel about the “IRIS” model is that it explicitly separates the structural information of the document from the content information of the document. This allows the transformation operations on the document to be more easily achieved. Of course, the system has the advantage of working only with highly-structured documents, which is often not the case in general-purpose document editing. Fortunately, software engineering documents and source code are most often highly structured; therefore, this model is very applicable to the field of distributed software engineering.
Distributed software development by its nature involves four essential problems: evolution (changes must be tracked among many different versions of the software), scale (increased software systems involve more interactions among methods and developers), multiple platforms on which the system will be deployed (coupling the methods and subsystems of the software), and distribution of knowledge (in that many people all are working on the system and each contain a set of the working knowledge of the system) [Perry et al. 1998]. The central question to ask in parallel development is one of managing the scope of changes within the system over time. Certainly we can employ process (as has been done for decades) to manage the software development activities, but more and more, CASE tools are being utilized to help manage the growing complexity and tightly-coupled activities within software development.
In the more general sense (transcending beyond software engineering), emergent models of organizational theory suggest that there is a movement away from hierarchical forms of group coordination to utilizing information technology in facilitating more adaptive, flexible structures. Such structures are often termed “network organizations” or “adhocracies” [Hellenbrand, 1995] and offer the possibility for more productive and efficient groups and organizations. By utilizing collaborative computing environments, transaction costs are reduced and coordination of tasks is improved.
Certainly there is a need for coordinating the collaborative nature of software development [Chu-Carroll]. This problem is beyond the scope of version control systems and must address the very human side of software development through coordination policies and processes central to distributed software engineering.