Groupware toolkits let developers build applications for synchronous and distributed computer-based conferencing. This chapter describes four components that we believe toolkits must provide. A run-time architecture automatically manages the creation, interconnection, and communications of both centralized and distributed processes that comprise conference sessions. A set of groupware programming abstractions allows developers to control the behavior of distributed processes, to take action on state changes, and to share relevant data. Groupware widgets let interface features of value to conference participants be added easily to groupware applications. Session managers let people create and manage their meetings and are built by developers to accommodate the group’s working style. We illustrate the many ways these components can be designed by drawing on our own experiences with GroupKit, and by reviewing approaches taken by other toolkit developers.

Synchronous groupware systems allow physically separated users to interact with one another and with shared computational objects in real time. Such systems are problematic to build since their user interfaces must support multiple, concurrent users, and both their application logic and their user interfaces must be distributed across multiple platforms. This survey explores the range of software architectures that have been proposed to solve this problem. The presentation includes three distinct architectural views: reference models, which divide complete systems into named functional elements and specify data flow between those elements; architectural styles, which prescribe component and connector types and their allowed patterns of interaction; and distribution architectures, which represent the distribution of system functionality across connected computing platforms. The distribution architectures are presented using a new descriptive framework called Interlace. The architectural presentation is complemented by a brief overview of consistency maintenance

This thesis presents an architectural model for synchronous groupware called the Workspace Model, which provides a clean separation of conceptual structure from distributed implementation. The model includes a formally-defined, distribution transparent, conceptual level architectural model with appropriate abstractions for the development of groupware; a formally-defined implementation level architec-tural model that exposes the distributed system issues abstracted at the conceptual level; a formal relation between the two levels that allows a range of implementa-tions to be automatically computed for any conceptual level architecture; and an explicit representation of runtime change. We argue that this combination of properties allows the model to satisfy needs arising from three communities: end-users, application programmers, and toolkit developers. End users require that their groupware systems support fluid collab-oration, perform efficiently, and behave in a predictable manner. Application pro-grammers need an environment that is appropriately expressive and that doesn’t

The User Action Notation (UAN) is a notation for specifying how a user performs tasks using a given interactive software system. An accurate and complete UAN specification provides a clear description of what tasks the user needs to perform to accomplish his goals, and how the user will interact with the system to accomplish those tasks. This provides the software developer with a clear direction for implementing the system's behaviour, and a reference against which the success of the system design and implementation can be measured. However, it is the exception, rather than the rule, that a thorough and accurate specification of the tasks the user needs to perform is completed before implementation work begins. The reality of interactive software development is that specification and implementation are not chronologically distinct stages. Rather, they are interleaved, as the developer moves back and forth between them, incrementally refining both the system implementation and the sys...

Adaptive groupware systems support changes in users’ locations, devices, roles and collaborative structure. Developing such systems is difficult due to the complex distributed systems programming involved. In this paper, we introduce Fiia, a novel architectural style for groupware. Fiia is user-centered, in that it allows easy specification of groupware structured around users’ settings, devices and applications, and where adaptations are specified at a high level similar to scenarios. The Fiia.Net toolkit automatically maps Fiia architectures to a wide range of possible distributed systems, under control of an annotation language. Together, these allow developers to work at a high level, while retaining control over distribution choices.

ClockWorks is a programming environment supporting the visual programming of object-oriented software architectures. In developing ClockWorks, we used user interface evaluation techniques, including heuristic evaluation, cognitive walkthrough and user evaluation. The development of ClockWorks was based on a task analysis of ClockWorks programmers. This task analysis revealed that programmers work incrementally. Incremental development implies the need for good support for information filtering and for easy refinement and restructuring of programs. ClockWorks has been implemented, and runs on Sun workstations. All examples shown in this paper were programmed with ClockWorks. Keywords: Visual Programming, User Interface Architectures. 2 1 Introduction In 1991, we began a project to develop tool support for programming component-based software architectures, with the particular application domain of software architectures for graphical user interfaces. Four years later, we hav...

The use of a variety of software viewpoints is helpful in the usercentered development of interactive software. Viewpoints of interactive software include paper and pencil mockups, task-oriented specifications, architecture views, and code views. In our experience, however, programmers prefer to develop user interfaces using prototyping tools that emphasize the code view only, potentially resulting in both a lower quality of user interface and a poor quality of delivered code. This paper surveys the role of different software viewpoints in a user-centered development process. The paper argues that to be successful, such a process must support incremental development, easy movement between viewpoints, and good tool support for manipulating different viewpoints.

Abstract. We present a novel technique for applying two-level runtime models to distributed systems. Our approach uses graph rewriting rules to transform a high-level source model into one of many possible target models. When either model is changed at runtime, the transformation is incrementally updated. We describe the theory underlying our approach, and show restrictions sufficient for a simple and efficient implementation. We demonstrate this implementation in Fiia.Net, our model-based toolkit for developing adaptive groupware. Developers using Fiia.Net control components and connections through a high-level conceptual runtime model. Meanwhile, the toolkit transparently maintains the underlying distributed system, and propagates failures back into the conceptual model. This approach provides high stability, and performance that is sufficiently fast for interactive applications. 1

The development of complex, multi-user, interactive systems is a difficult process that requires both a rapid iterative approach, and the ability to reason carefully about system designs. This thesis argues that a combination of declarative prototyping and formal specification provides a suitable way of satisfying these requirements. The focus of this thesis is on the development of software tools for prototyping interactive systems. In particular, it uses a declarative approach, based on the functional programming paradigm. This thesis makes two contributions. The most significant contribution is the presentation of FranTk, a new Graphical User Interface language, embedded in the functional language Haskell. It is suitable for prototyping complex, concurrent, multi-user systems. It allows systems to be built in a high level, structured manner. In particular, it provides good support for specifying real-time properties of such systems. The second contribution is a mechanism that allows a formal specification to be derived from a high level FranTk prototype. The approach allows this to be done automatically. This specification can then be checked, with tool support, to verify some safety properties about a system. To avoid the state space explosion problem that would be faced when verifying an entire system, we focus on partial verification. This concentrates on key areas of a design: in particular this means that we only derive a specification from parts of a prototype. To demonstrate the scalability of both the prototyping and verification approaches, this thesis uses a series of case studies including a multi-user design rationale editor and a prototype data-link

Synchronous groupware applications let users collaborate over distance through their computers. Since these applications are difficult to build, groupware toolkits have been constructed to help developers with their tasks. Some of the building blocks supplied by these toolkits are a set of abstractions for sharing data between sites. Yet different toolkits use different strategies to share the data: some replicate the data at all sites, while others store it at a central site. The correct choice of data sharing strategy is not obvious, as different strategies affect data consistency as well as the performance of applications built using the toolkit. We argue that data sharing should be flexible and that the developer should be able control the data sharing by selecting from default strategies or creating new ones to meet the requirements of their application. We use a technique called open implementations to provide this control. We have built a prototype groupware toolkit called GEN that demonstrates the feasibility of flexible data sharing. Using GEN, six different forms of data sharing have been constructed, more than any other toolkit currently available.