Physical widgets or phidgets are to physical user interfaces what widgets are to graphical user interfaces. Similar to widgets, phidgets abstract and package input and output devices: they hide implementation and construction details, they expose functionality through a well-defined API, and they have an (optional) on-screen interactive interface for displaying and controlling device state. Unlike widgets, phidgets also require: a connection manager to track how devices appear on-line; a way to link a software phidget with its physical counterpart; and a simulation mode to allow the programmer to develop, debug and test a physical interface even when no physical device is present. Our evaluation shows that everyday programmers using phidgets can rapidly develop physical interfaces.

The Notification Collage (NC) is a groupware system where distributed and co-located colleagues comprising a small community post media elements onto a real-time collaborative surface that all members can see. Akin to collages of information found on public bulletin boards, NC randomly places incoming elements onto this surface. People can post assorted media: live video from desktop cameras; editable sticky notes; activity indicators; slide shows displaying a series of digital photos, snapshots of a person's digital desktop, and web page thumbnails. User experiences show that NC becomes a rich resource for awareness and collaboration. Community members use it to indicate their presence to others by posting live video onto it. They regularly act on this information by engaging in text and video conversations. Because others can overhear these conversations, these become opportunities to join in. They also post items they believe will be interesting to others, such as vacation photos. People also use NC somewhat differently when it is displayed on a large public screen than when it appears on a personal computer. Under the covers, the system works by propagating and storing information through a combined shared dictionary / notification server architecture.

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

Abstract not found

This paper focuses on the distributed architecture of the collaborative augmented reality system Studierstube. The system allows multiple users to experience a shared 3D workspace populated by multiple applications using seethrough head mounted displays or other presentation media such as projection systems. The system design is based on a distributed shared scene graph that alleviates the application programmer from explicitly considering distribution, and avoids a separation of graphical and application data. The idea of unifying all system data in the scene graph is taken to its logical consequence by implementing application instances as nodes in the scene graph. Through the distributed shared scene graph mechanism, consistency of scene graph replicas and the contained application nodes is assured. Multi-user 3D widgets allow concurrent interaction with minimal coordination effort from the application. Special interest is paid to migration of application nodes from host to host allowing dynamic workgroup management, such as load balancing, late joining and early exit of hosts, and some forms of ubiquitous computing.

Design-level architectures allow developers to concentrate on the functionality of their groupware application without exposing its detailed implementation as a distributed system. Because they abstract issues of distribution, networking and concurrency control, design-level architectures can be implemented using a range of distributed implementation architectures. This paper shows how the implementation of groupware applications can be guided by the use of semantics-preserving architectural annotations. This approach leads to a development cycle that involves first developing the functionality of the application in a local-area context, then tuning its performance by setting architecture annotations. The paper concludes with timing results showing that architectural annotations can dramatically improve the performance of groupware applications. 1 Introduction In recent years, a number of software architecture styles have been proposed to support the development of synchro...

Many object-oriented toolkits and frameworks for group-ware development provide shared objects as a basic service. This relieves developers of a lot of problems originating from the field of distributed systems. However, there is little support on how to use shared objects to actually build col-laborative applications. In this paper we propose an object-oriented model for applications using shared objects. The model is discussed with respect to object-oriented reusabil-ity aspects and its applicability is tested against CSCW-specific aspects like the provision of group-awareness and coupling control. Furthermore, concrete model examples derived from an example application are shown for illustra-tion.

This paper presents the DISCIPLE framework, a novel architecture for synchronous groupware, which enables sharing of software applications by conferees that participate in collaborative knowledge work. The particular class of applications dealt with is Java components (Applets and Beans). The central part of DISCIPLE is conceptualized as a collaboration bus. It spans network fabrics and provides a virtual interconnect for geographically distributed clients. Collaborating users import Java components by drag-and-drop manipulation into their virtual workspaces. The imported component becomes a part of a multi-user application and all conferees can collaboratively interact with it. The bus achieves synchronous collaboration through real-time event delivery, event ordering and concurrency control. In addition, importing various Beans also allows user tailoring of the human-computer interface. Interface customization can be achieved with multimodal human-machine interfaces and the collaboration components (such as group awareness widgets, concurrency controllers, etc.). The system has been implemented and tested on a variety of Java applications.

To effectively collaborate in Internet environments, it is critical to efficiently manage the shared state of collaboration. However, the management of shared state is highly situational; different collaboration semantics require different measures tailored to their specific needs. Hence, providing a general set of services that meet the management requirements of varying collaboration situations is challenging. In this paper, we discuss our approach to providing such services. The services are made flexible by allowing collaborators to choose appropriate services based on the needs of their collaboration tools and specific characteristics of their shared state. We present the shared state management services provided by our Corona server that embodies our approach and report experience with its use.