Classroom Anywhere: An Initiative of the United Nations University

Ng S. T. CHONG <>
United Nations University

University of Tokyo


This paper reports on the technical aspects of the Virtual University project launched by the United Nations University. Our vision is to promote the development of open, affordable, and ubiquitous learning environments that will provide users with increased opportunities for collaboration and easy access to the global knowledge pool. As a first step toward meeting this goal, we are developing a major software product, Classroom Anywhere (CA), a multi-user virtual learning environment and Java collaborative framework. Drawing on research into component-software and computer-supported cooperative work (CSCW) systems, CA enables runtime extensibility and flexible sharing of applications that may or may not be originally designed for collaboration. Under this framework, each feature can be recursively extensible, that is, the constituents of a feature can be again extensible. Furthermore, we will release the source code under certain conditions and license it for free distribution in developing countries. In this way, the system is open-ended in the true sense and encourages cooperative development. Two pilot subsystems of CA have been developed to verify the design feasibility. The first subsystem is a multi-user whiteboard with extensible authoring support for creating contents in real time. The second subsystem is a chat facility that provides users with a flexible group control and coordination mechanism.


1. Introduction

The Internet has become a viable platform for teaching and learning. The enormous capacity of the Internet for delivering information and the increasing support for interpersonal communication have fostered a worldwide movement across universities and organizations to reexamine and evolve the current learning and educational infrastructure. Many applications have been developed that demonstrate the potential of the Internet for learning. They all try to implement some form of the standard apparatuses of a university: lecture, library, and laboratory. Computer support for learning is centered around three base modes of learning and their variations [1]:

Despite the potential of the Internet to support different modes of learning, most of today's learning applications are targeted for teacher-led learning, using such options as broadcasting live or recorded scenes of the classroom and two-way video. By far this form of presentation-driven learning is among the most popular practices in distance learning because it is better understood than other forms of learning, and there are plenty of tools that can be used to produce electronic lectures of reasonable quality.

Recent research in the social and cognitive sciences begins to show the benefits of supporting learning at the group and individual level, especially in such domains as science and technology. However, there is still a remarkable scarcity of supports for inquiry-based activities and interpersonal collaboration and social knowledge construction that are important in learning processes. The shortage exists at the level of learning environments and at the level of tools that are needed for building such environments.

Regardless of the type of pedagogy modeled, commercial quality learning environments tend to have a high cost of ownership in terms of initial costs and subsequent upgrade costs. At the same time, there are concerns about the effectiveness of information technology (IT) in learning [2]. However, we believe that in the case of developing countries where education is under-served and under-developed, the question of effectiveness is probably not as important as the cost of not getting an education at all. Internet technologies have the potential to make education more accessible, scalable, and global.

To provide some relief to the above issues, we propose Classroom Anywhere (CA) -- an extensible multi-user learning environment and a toolkit for creating or leveraging legacy single-user applications into collaborative applications. CA is a part of the Virtual University project being developed at the United Nations University [3]. The main characteristics of CA are runtime support for extensibility and development support to simplify the construction of multi-user collaborative learning applications. In this sense CA is an open-ended, learning environment -- anybody from anywhere on the Internet can independently add new learning functionality to the system.

2. Aims for the system

The CA project is intended to address the limitations found in current distance-learning environments and provide tools to simplify the development of multi-user collaborative tools and applications in learning and education.

2.1 Limitations in tele-learning software

We have identified six major limitations in distance-learning software:

2.2 Target framework features

CA contributes to the above issues with an open framework and learning environment whose aim is to support the following features:

3. Status

We are currently engaged in a feasibility study investigating the requirements outlined above using the Java language. So far we have implemented two multi-user tools that successfully demonstrated feature extensibility and group coordination flexibility, respectively. Our experience in developing these tools lay down the foundation for the design of the experimental EEE architecture and model. These tools will eventually be part of the CA learning environment. Our immediate target is to rebuild these tools and other ones using the CA framework. In this way, we can effectively validate and assess the degree of simplification that the framework allows in the development of extensible collaborative learning tools.

4. Pilot subsystems

4.1 First-Class: an extensible enhanced whiteboard

First-Class serves as a shared collaboration space for distributed users and is itself a cooperative environment for both computing and integrating independently developed software components. First-Class is an extensible collection of servers executing services on behalf of remote clients, such as rendering math equations from their text representation, and developers around the world can add new services to the system.

The architecture is discussed in detail in [9]. Extensibility is realized through our own plug-in mechanism that allows First-Class to download the extra Java classes as it runs. This opens the possibility for launching a wide range of applications on the whiteboard, including such self-contained features as animations and simulations. At the same time, the extensible whiteboard lends itself as a real-time authoring tool that can be used during a lecture presentation. The architecture also supports whiteboard recording to facilitate the delivery of lectures in asynchronous mode. In our prototype, we implemented a modest set of sample downloadable plug-ins, including a Latex expression renderer, Japanese text input, real-time handwriting recognition, equation plotter, and Towers of Hanoi animation. Some of these plug-ins were ported directly from existing Java applications. Their adaptation into First-Class required very minimal modifications to the source code. Figure 1 shows a screenshot of a prototype implementation of First-Class.

Figure 1. Sample features in First-Class.

4.2 GCC-IRC: a coordinated chat system

Chat tools are often used during a lecture broadcast to gain feedback from the remote audience. However, these tools are too generic to be useful in anything but the simplest meeting scenarios (e.g., in a small meeting where people are familiar with each other and everybody is free to speak without the need for any explicit floor control). They rely on social protocols to ensure that the coordination conventions are followed correctly. But, social protocols do not offer guarantees and therefore enforcement mechanisms are needed. The problem is manifested not only in chat tools; most of the existing collaboration support tools are and continue to be developed with coordination mechanisms hard-coded. As a result, to satisfy the evolving and unanticipated coordination requirements during the different phases of a meeting (e.g., role switching) it becomes necessary to produce a new version of the program each time. This severely limits reusability and complicates the development of collaborative tools and systems.

Group Control and Coordination-Internet Relay Chat (GCC-IRC) achieves flexible coordination support for collaboration through a programming model that encourages a triple separation of semantics in the design and implementation of collaboration systems [10]. In particular, the programming model supports independent development of the following: user-interface aspects of coordination (e.g., voting dialog box), processing logic of coordination (e.g., deciding whether a mouse-click needs to be shared and by whom), and application-specific semantics (e.g., behavior of a telepointer). The benefits of decoupling the various semantics are clearer delineation of responsibilities of the developers, simplification in the design and implementation of collaborative tools, and increased opportunities for code reuse and sharing. For example, to build a shared whiteboard we do not have to intermingle the coordination aspects (e.g., access and concurrency control) with the computational aspects of the whiteboard. The same tool can be reused under a different coordination policy without changes to the whiteboard, such as when switching from a turn-taking policy to a centralized control policy. Likewise, the different graphical user interface (GUI) dialog and control components supporting each coordination policy can also be developed separately.

In GCC-IRC, the coordination policies are modeled in a high-level language. Figure 2 shows the coordination policy for a chat session in a typical classroom scenario. The architecture is based on a coordination language interpreter that runs alongside the user application. The interpreter controls the behavior of the chat application by intercepting input events originating from the chat application. Upon interception of an event, it determines a course of action based on the current coordination policy. For example, this action could be to deny an event from reaching the target GUI object, which would result in a denial of access to the GUI object.

Figure 2. Specification of a teacher-led chat with floor control and message routing.

5. Design of EEE

EEE works as a runtime environment for dynamically loading, instantiating, and sharing collaboration-transparent (i.e., not originally designed for group usage) and collaboration-aware (i.e., originally designed for group usage) Java program components that conform to certain minimum requirements and are previously uploaded to our framework. For example, we require that the GUI objects in an application must be based on the increasingly popular JSwing toolkit.

5.1 Architecture

The architecture of EEE is still evolving. As of this writing, there are five main components on the client side and three main components on the server side. Figure 3 summarizes the architecture. The various services provided by the architecture are accessible programmatically in the form of an API and some are also available transparently once a program component is loaded into the framework (e.g., event distribution and user-level concurrency control). EEE is based on a replicated architecture. Each conferee site runs a separate instance of a shared application. Event propagation is used to synchronize the views of the conferee sites for either strict "what you see is what I see" (WYSIWIS; i.e., identical views: events are distributed to all participating sites) or relaxed WYSIWIS (i.e., different views: events are filtered to allow independent views and working). State data replication beyond user-interface level sharing is possible through the use of the EEE API.

Figure 3. Prototype architecture of the EEE system -- client and server system components.

5.1.1 Client-side components

The kernel on the client consists of the basic services it needs for self-initialization and bootstrapping:

The downloadable system components include the following:

5.1.2 Server-side components

There are three centralized servers in the architecture:

5.2 Programming model

The EEE programming model is designed to minimize the development cycle for collaborative applications and to encourage rapid prototyping. It is based on the integration of the concepts and mechanisms derived from programming by specifying coordination policies and (lazy) programming by loading components on demand into a multi-user collaboration-enabling framework as Figure 5 shows. This has implications for the legacy single-user applications, which are not intended for collaboration use. In particular, once they are loaded in our framework they are enabled to perform in a shared mode without reprogramming. Likewise, single-user applications can be easily extended to achieve collaboration-awareness through the EEE API. In particular, because most of the multi-user and coordination aspects can be delegated to the system and shifted to policy specifications, developers can concentrate on the single-user computational features of the application.

Figure 5. The EEE Programming Model.

With respect to other related computer-supported cooperative work (CSCW) frameworks [11,12], CA shares similar limitations in collaboration transparency, caused mainly by the limited knowledge of the system on the application semantics and difficulties in synchronizing all types of state transitions (e.g., events from multi-threaded applications). Table 2 shows the extent of support in our framework. In contrast to parallel works, our framework supports concurrency control based on an external coordination policy program without requiring users to reprogram their applications. The implicit supports also work for collaboration-aware applications; hence, users only need to customize them to suit their specific needs.

Table 2. Limitations in collaboration-transparency
EEE Support Collaboration-Transparent Java Program Components
Extensibility Not available
Network Bus Implicit
Event Propagation Implicit
State Data Propagation Not available
GCC Engine Implicit
Inter-component Bus Not available

The concept of component and its relationship to the EEE architecture can be succinctly described in a grammar as follows:

Note that in the production rule for EEE_API, we use the non-conventional notation X[0..1] to denote the occurrence of at most one instance of X. A recursive component can contain nested levels of recursive components by applying the extensibility features in the EEE API. Figure 6 shows an example of a composition tree for a learning environment composed of three applications that are currently being developed. The whiteboard is a collaboration-aware application written in Java that makes extensive use of the EEE API. The Java-based IRC system is developed separately using tools not related to the framework. Although it is an inherently collaboration-aware application, it can work transparently with GCC. Moreover, the normal semantics of the IRC client dictates that the replication of user input events to peers should be disabled. This can be easily done in our framework. The Web co-navigation system launcher is a simple collaboration-transparent application written in Java that starts up a multi-user non-Java application. The Web co-navigation system itself explicitly interacts with the GCC engine by message passing. The EEE glues the disparate components together to form a multi-user collaborative application.

Figure 6. A component tree showing recursive extensibility.

6. Concluding remarks

This paper describes CA: a learning environment and a framework for building groupware applications. We have outlined the motivation, status, design, and evolving directions of CA. The foundation of CA is the EEE architecture. The main novel features of the EEE architecture are the simultaneous support for runtime extensibility and flexible collaboration in one framework as well as the ability to mix collaboration-transparent and collaboration-aware Java programs in one application. To facilitate system-level evolution, the mechanisms for runtime extensibility are self-applied in the design of the client architecture. Thus, although certain cooperative features are currently lacking in our system, such as group awareness support, they can be implemented separately as self-contained downloadable features.

Rewriting seems to be the common approach for achieving collaboration transparency. JAMM (Java Applets Made Multiuser)[11] replaces the system abstract windowing toolkit with its own. The problem with this approach is that the implementation is unstable, requiring modification with every new release of the system toolkit. DISCIPLE [12] modifies non-system Java classes during load time, and hence the dependencies are fewer. However, the overhead of load-time rewriting added to the already substantial delays in loading classes from disk or across the network raises concerns about performance. Our approach also tries to keep the dependencies to a minimum by rewriting at the source code level. Since the rewriting is done offline during upload, rewriting does not impose any penalty on class load time.

In a future release of EEE we plan to use a public-domain middleware that supports multicasting in place of our own Sync server. Finally, in the slightly longer term we plan to develop a UNL-based Internet search engine and add network-awareness support to EEE.


[1] Chong, Ng S. T., Internet Technologies: Towards Advanced Infrastructure and Learning Applications. In: Access to Knowledge: New Information Technologies and the Emergence of the Virtual University, edited by T. Tschang and T. Dellasenta, Elsevier Press/ International Association of Universities, forthcoming.

[2] Kadiyala, Madhavi, and Crynes, Billy, Where's the Proof? A Review of Literature on Effectiveness of Information Technology in Education, Proc. 28th ASEE/IEEE Frontiers in Education Conference, Tempe, Arizona, 1998.

[3] VU Media and Technology Lab., Virtual University Initiative - Project Abstract,

[4] Soloway, E., No One is Making Money in Educational Software, Communications of the ACM, February 1998.

[5] Manhart, Peter, and Ziegler, Heiko, Continuous Cooperative Learning in Organizations, Procs. IASTED Internet and Multimedia Systems and Applications, Nassau, Bahamas, October 1999, pp. 192-196.

[6] Dearle, A., Toward Ubiquitous Environments for Mobile Users, IEEE Internet Computing, January-February 1999, pp. 22-32.

[7] Peha, J.M., Alternative Paths to Internet Infrastructure: the Case in Haiti, "3f/3f_2.htm", INET'99.

[8] UNL Center, UNL-an Electronic Language for Communication Understanding and Collaboration, Technical Report, Institute of Advanced Studies/United Nations University, 1996.

[9] Chong, Ng S. T., and Sakauchi, Masao, Back to the Basics: a First Class Chalkboard and More, Proc. 2000 ACM Symposium on Applied Computing, Como, Italy, March 2000.

[10] Chong, Ng. S. T., and Sakauchi, Masao, GCC-IRC - a Multi-mode Chat for Coordinated Interaction, Technical Report, Institute of Advanced Studies/United Nations University, December 1999. Submitted to 2000 ACM Conference on Technology and Innovation in Computer Science.

[11] Begole, J.B., et al., Supporting Worker Independence in Collaboration Transparency, Proc. 1998 ACM Symposium on User Interface Software and Technology, San Francisco, California, November 1998, pp. 133-142.

[12] Li, Wen, et al., Collaboration Transparency in the Disciple Framework, Proc. 99 ACM Conference on Supporting Group Work, Phoenix, Arizona, November 1999.