ACM '97

If you arrived at this page from the ACM'97 Expo Exhibitors page, and would like infomation on our exhibit, ARC: Augmented Reality for Construction, please follow this link to its page.

The ARC system is implemented using COTERIE, the testbed described here.


The Columbia Object-oriented Testbed for Exploratory Research in Interactive Environments

Blair MacIntyre, Steven Feiner

The Computer Graphics and User Interfaces Laboratory

COTERIE is a testbed for fast prototyping of distributed virtual environment systems (MacIntyre and Feiner 1996). It is designed to support the creation of virtual environments with multiple simultaneous users interacting with many heterogeneous displays and input devices. The testbed is designed around a multi-threaded, modular, object-oriented programming model and supports fully transparent distributed communications via both client-server and replicated distributed objects. By building applications as groups of cooperating threads, a single programming model can be used for both single and multiprocess programs. Both interpreted (Obliq) and compiled (Modula-3) languages are simultaneously available to the application programmer.

Motivating Requirements

The requirements we set for our testbed reflect our desire to experiment with distributed, multi-user VEs that combine a variety of displays that are hand-held, head-worn, desk-top, and wall-sized, including both opaque and see-through. This means that it is essential that we be able to create robust prototypes quickly and easily to explore different design alternatives. We identified a number of core requirements for the infrastructure on which we would build our testbed.
  1. Uniform treatment of local and distributed data
  2. Embedded, interpreted language
  3. Object-oriented, multithreaded programming model
  4. Desirable distributed system characteristics (scalable, open, fault tolerant, network data transparency)
  5. Data replication for fast local access
  6. Asynchronous data propagation
  7. Asynchronous notification of updates to shared data


Our testbed is currently being written in the Modula-3 programming language. Our decision to use Modula-3 was based on the language itself and the availability of a set of packages that provide a solid foundation on which to build our infrastructure. Modula-3 is a descendent of Pascal that corrects many of its deficiencies. In particular, Modula-3 retains strong type safety, while adding facilities for exception handling, concurrency, object-oriented programming, and automatic garbage collection [*]. One of its most important features for our work is that it gives us uniform access to these facilities across all architectures we use (Solaris, SunOS, HP-UX, OSF/1, IRIX, NT and Windows 95). We also depend on some packages that are part of the standard Modula-3 distribution:
  1. Network Objects
    The Network Object package supports distributed data sharing by providing remote method call facilities that are virtually transparent to the programmer. These include distributed garbage collection, exception propagation back to the calling site, and automatic marshalling and unmarshalling of method arguments and return values of virtually any data type between heterogeneous machines.
  2. Obliq
    Obliq is a lexically-scoped untyped language for distributed object-oriented computation that is tightly integrated with Modula-3. Like Modula-3, it supports multiple threads of control within a single process. Obliq's distributed computation mechanism is based on Network Objects, allowing transparent support for multiple processes on heterogeneous machines. Objects are local to a site, while computation can roam over the network.
  3. Obliq-3D
    Obliq-3D is a high-level 3D animation system that consists of two parts: a Modula-3 library that provides a set of graphical objects and animation primitives, and those same primitives embedded in Obliq. Obliq-3D programs can be written in Modula-3, Obliq, or any combination of the two because all data structures are simultaneously available from both languages. The package's structure and interface also make it relatively easy to extend.
  4. HTTP
    The HTTP package is a Modula-3 library that support the creation of HTTP clients and servers. It was created as part of DEC SRC's Millicent project.
The implementation of COTERIE can be broken into a number of components:
  1. Shared Objects
    The Shared Object package, when combined with the Network Object package, provides a distributed language infrastructure geared toward the needs of VE applications by providing general purpose, asynchronously updated, replicated objects. It is based on two concepts: Distributed Shared Memory via the Shared Data-Object Model, and Callback Objects.
  2. Repo
    In Obliq, all objects are Network Objects: one copy exists in some process, and all other processes make remote method calls to access that object. In Repo, we round out the object model with the other two kinds of objects a programmer might need: Repo is our superset of Obliq. A manual will be available soon.
  3. Anim-VR
    The Anim-VR package is an rewrite of Anim-3D that aims to satisfy two important goals:
  4. Obliq/HTTP
    This package exposes the Modula-3 HTTP package into Obliq, allowing distributed HTTP servers to be written entirely in Obliq. This package was used to create our lab's Augmented Reality WebCam in less than 200 lines of code. This package also allows us to easily build applications with web-based interfaces.
  5. Trackers
    We have developed an object oriented tracker package with support for a variety of 2, 3 and 6DOF tracking systems, including

    More devices are being added (ie. Ascension Flock of Birds, Precision Navigation Orientation Tracker). The package is designed so that client software can operate on any tracker with appropriate capabilities (2D, 3D position or orientation, or some combination) interchangeably.

Using COTERIE, we are building a library of objects to support the various VE devices we use and an application framework that allows us to create prototype applications with the distributed system characteristics we desire.

Current Status

We currently have the basic system running on a variety of machines, including: The graphical components of the system currently run on: Other highlights of our current project status include:


All of the pictures on this page were generated with various applications built using COTERIE.

This research is supported in part by the Office of Naval Research under Contract N00014-97-1-0838, a gift from NYNEX Science & Technology, hardware and software gifts from Mitsubishi Electric Research Labs, Intel, and Microsoft, the New York State Center for Advanced Technology in Computers and Information Systems under Contract NYSSTF-CAT-92-053, the Columbia Center for Telecommunications Research under NSF Grant ECD-88-11111, and NSF Grant CDA-92-23009.


MacIntyre, B and S. Feiner. "[Language-level support for exploratory programming of distributed virtual environments." In Proc. UIST '96 (ACM Symp. on User Interface Software and Technology), Seattle, WA, November 6-8, 1996, 83-95.

[*] If this feature set sounds familiar to those acquainted with Java, that is because Modula-3 can be thought of as Java's closest relative. James Gosling, the designer of Java, pointed out in his UIST '96 keynote address that many of Java's ideas were borrowed from Modula-3. Unfortunately, important facilities such as the ability to do "unsafe" operations (required for such tasks as communicating with hardware devices) and language features designed to support large scale program design, are ommitted from Java. In any event, Java was not available in 1994 when we were selecting a language, and still does not offer the range of well designed, free, tightly integrated packages that are available for Modula-3.

Return to the
Columbia University Computer Graphics and User Interfaces Lab.

Please send comments to Blair MacIntyre at <bm AT>