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.
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 :
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 . 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 . 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.
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.
We have identified six major limitations in distance-learning software:
High production cost. Quality distance-learning software is very
expensive to build . The cost can be attributed in part to
the complexity of the software itself and dearth of adequate support that could
help shorten the development cycle.
Consistently, educational research and students' testimonials have attested to the cognitive benefits of interactivity through group communication and collaboration, leading to a growing demand for multi- user collaborative features in learning applications. However, it is well recognized that development of multi-user collaborative features introduces many more degrees of complexity with respect to single-user applications. In addition, development tools often are designed for programmers only. As a result, content providers who often lack the necessary programming background cannot easily turn their ideas into software by themselves. Although there are authoring tools available that could make software development easier for non-programmers, these tools are often general, lacking domain-specific features and constrained by the targets set by the designer(s) of the tools. As a result, developers often find themselves building a full-featured application from scratch.
Monolithic design. Today's support in learning and teaching focuses primarily on a single mode of interaction that is often restricted to learning activities inside a typical classroom . Other learning scenarios that go beyond the presentation-oriented interaction mode (e.g., collaborative learning and information searching) are only scarcely supported.
Feature lock-up. Learning applications at large are not extensible, supporting only a prefabricated set of features. However, curricula and teaching styles vary across individuals and institutions: learning applications must be flexible if they are to meet the changing needs of educators and students and the wide range of pedagogical approaches. Generic human interaction tools such as email, mailing lists, and conferencing applications dominate in virtual learning infrastructures. But because they are not originally designed to support education activities they impose significant overhead on users.
Limited Internet-awareness. Learning technologies are just beginning to expand their capabilities to fit in an increasingly networked society, that is, to tap into the resources and human networking potential that the Internet offers.
Environment-unaware. Developments related to the Internet are shaping the way we learn. Table 1 shows the evolutionary path of learning on the Internet and projects into the future.
|Classroom Learning||Distributed Learning||Ubiquitous Learning|
Educational software assumes that the resources it needs from the underlying operating environment are always available. However, in the case of mobile users, the operating conditions such as the battery constraints on their mobile computers or bandwidth constraints in the network can change dynamically, resulting in intermittent operation and connectivity . It should be clear that developing countries could benefit from educational software that can operate in an environment of constrained resources, where the IT infrastructure is not as advanced as its counterpart in developed countries. Besides, the use of wireless technologies in developing countries is often the only choice due to the poor telephone infrastructure .
Monolingual. While there is a growing number of people who access the Internet in other languages besides English, educational contents continue to be produced and delivered in a single language. This greatly limits the global sharing of educational resources.
CA contributes to the above issues with an open framework and learning environment whose aim is to support the following features:
Extensibility. CA employs a component-oriented approach to support extensibility. A component can be a full-featured application or a building block for a composite application. A more precise definition of a component is given in section 5. Components permit rapid construction of complete learning features by visually interconnecting compatible components that can be used without modifications. Moreover, they can be developed independently by different people and can be exchanged between people. It draws people to support each other's efforts, rather than duplicating them. This leads to limitless learning application possibilities, increased opportunities for code reuse and sharing, and faster application development. It also helps catalyze the efforts of a wider community of course designers and developers.
Cooperative development is important because not a single institution can have all the expertise or resources needed to implement all the desired features. Further, it promotes specialization of components into domain-specific components. The idea is that end-users not familiar with programming can draw on an evolving library of domain-specific components developed by programmers. In this way, CA is extensible by both software consumers and component producers.
EEE and API (Extensible Execution Environment and Application Programming Interface). EEE is at the heart of CA. It provides a transparent migration mechanism to extend the existing large body of single-user components with groupware capabilities without reprogramming. In addition, the development of multi-user learning components can be simplified by using the EEE API, which provides high- level abstractions for sharing objects and coordinating user interactions.
Multi-mode learning. CA preserves the prevailing teacher- led learning mode that has been exemplified for decades. At the same time, it supports other informal forms of learning like independent inquiry-based learning, collaborative learning, and community learning. In such learning scenarios, roles can include educator, learner, and moderator, for example. In practice, a curriculum could be structured to use a different learning strategy during different stages of the course. In addition, the framework provides facilities to record the user's input and state information needed during playback in asynchronous learning.
Natural language-independent Internet search engine. Search engines are essential in the realization of independent inquiry- based learning. Language barriers hinder the exploration and discovery of resources on the Internet. To enable Web documents in any language to be searchable in the future, UNL (Universal Networking Language) framework  is being used to develop a new breed of Internet search engines. Briefly, the UNL is an electronic language that describes the semantics of sentence information in a hyper-graph . The nodes in the hyper-graph represent concepts and arcs represent relations. Further, concepts are represented as character-strings called Universal Words (or UWs). UWs can be annotated with attributes that provide further information about how the concept is being used in a specific sentence. They represent the meanings of a word in various languages. Once a document is converted into UNL, it can be converted into any of the participating languages of the project. It is expected that throughout the development of the UNL framework a huge amount of UWs will be defined. It is the rich knowledge information contained in the UWs that makes the UNL framework attractive for designing content-based search engines.
Network-aware. CA is adaptive to the changing network conditions in the operating environment. For example, before a picture file is sent to a student, the picture could be resized dynamically based on the availability of bandwidth. Moreover, a student should be able to resume his/her learning application gracefully in an intermittent connection.
Open sources and free distribution. Although our support for extensibility permits users to vary and augment the functionality of the system, the ultimate openness of the system is achieved with the disclosure of source code. Sources will be made available for academic and research institutions to facilitate the adaptation of CA into customized usage and future technologies.
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.
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 . 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.
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 . 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.
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.
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.
The kernel on the client consists of the basic services it needs for self-initialization and bootstrapping:
The downloadable system components include the following:
There are three centralized servers in the architecture:
Sync Server serves as a general-purpose communication bridge linking clients and servers with data and message services. In addition, it provides event coordination and event broadcasting services. Event coordination (e.g., ordered event delivery) is crucial in ensuring that people in the collaboration share a consistent view. To guarantee view consistency, we identify an event with an ownership and sequence number.
Directory Server maintains a repository of Java program components that users have uploaded. After the code is uploaded, the code is modified to include event handling, class loading, and GCC interface methods. Figure 4 shows how the original compiled code is modified at the source code level by first running it through a decompiler.
Figure 4. Code rewrite process during code uploading to the Directory Server.
Session Server is the central counterpart of the Distributed Session Manager. It pushes updated membership information to the clients and newly joined clients pull the latest peer status information from this server.
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.
|EEE Support||Collaboration-Transparent Java Program Components|
|State Data Propagation||Not available|
|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.
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) 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  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.
 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.
 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.
 VU Media and Technology Lab., Virtual University Initiative - Project Abstract, http://www.ias.unu.edu/project_99/viu.asp.
 Soloway, E., No One is Making Money in Educational Software, Communications of the ACM, February 1998.
 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.
 Dearle, A., Toward Ubiquitous Environments for Mobile Users, IEEE Internet Computing, January-February 1999, pp. 22-32.
 Peha, J.M., Alternative Paths to Internet Infrastructure: the Case in Haiti, "3f/3f_2.htm", INET'99.
 UNL Center, UNL-an Electronic Language for Communication Understanding and Collaboration, Technical Report, Institute of Advanced Studies/United Nations University, 1996.
 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.
 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.
 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.
 Li, Wen, et al., Collaboration Transparency in the Disciple Framework, Proc. 99 ACM Conference on Supporting Group Work, Phoenix, Arizona, November 1999.