Overview of Collaborative Computing and
Some NPAC Experience

 

Geoffrey Fox (fox@csit.fsu.edu)

Jianxiang Jin

NPAC

111 College Place

Syracuse University 13244-4100

 

1.Introduction

We survey the status and opportunities in collaborative computing with a focus on collaborative visualization. As usual we define collaboration as sharing of (digital) objects and describe some of the different architecture choices and the corresponding trade-offs between functionality and ease of use. We discuss general characteristics of both computing and collaboration. These we follow with more detailed sections on collaborative visualization and collaborative program invocation where the latter focuses on NPAC experience with shared invocation of the Biology Workbench. Section 5 describes several projects briefly and there is a complete reference list of which hard copies can be made available.

 

2. Choices in Collaborative Computing
2.1 Relevant Computing Characteristics

The design and functionality of any collaborative computing environment naturally depends on features of the computing tasks. The data to be shared can come a single or several sources; it can be local or geographically distributed; it can be needed in real-time or batch-mode. The geographical distribution of the data can be “just” a performance issue or affect the architecture. For visualization, one can split the processing in many ways between client and server; this is a tradeoff between power of client, network bandwidth available between client and server; power of server and number of users of it. A related point is the distinction between “data” and “information” – after producing data from an instrument or a computer, one typically performs one or more filters to enhance the information content and make it more intelligible to the user. These filters chew up computer time but reduce the bandwidth needed to transmit the visualization stream. Collaboration is sensitive to the position of these filters as one can (see fig. 1 later) share at any stage of the visualization pipeline, and the details of the implementation are quite sensitive to whether sharing is between replicated programs on clients or between naturally shared servers running central data sources or filters.

Many functions are involved in computing

1)       Producing and analyzing data from a program

2)       Controlling invocation of a program and “steering” of it (real-time interactions with running program)

3)       Debugging and other functions involving either multiple computer users or users and consultants discussing program and its execution in real-time

4)       Designing and writing software used in program

5)       Brainstorming and other discussions of science (knowledge) where computing was (partially) involved

6)       Writing and revising technical papers and proposals associated with a computation

 

The activities 4) to 6) are very important but will not be covered here. They are variants of collaborative scenarios that are more general than computing. For instance 4) (Designing and building software collaboratively) is a specialized version of general shared document preparation as also is 6). 5) is a highly unstructured (and therefore difficult to implement) version of the “general programming problem”. A special and easier version of 5) is support of briefings of formal discussions between distant participants. 1) 2) and 3) are related and we will essentially only discuss in any detail two cases – collaborative visualization and the much simpler collaborative program invocation. 3) is sort of half way between these examples (as one is sharing computer control and output) and the shared document editing problem. One could be discussing the shared (flawed) output of a computer program while the geographically separated participants (in this case often 2 – puzzled user and consultant) jointly edit the mistaken program and its control. Collaborative steering is also some sort of combination between invocation and visualization. Here we find multiple researchers sharing and discussing the output of a program (collaborative visualization) and then controlling its evolution by changing parameters (a variant of collaborative program invocation). An example suggested by Joe Thompson which is related to 2) and 3) is a “remote collaborative mesh generation facility”. It is well known to be quite difficult to generate appropriate meshes to support the solution of partial differential equations in complex geometries. The combination of a user, some interactive meshing program and if necessary a (remote) consultant seems an attractive approach. Here the human in the loop is necessary as currently no fully automatic mesh generator is reliable. The human support is likely to be remote because mesh generation expertise is only present in a few organizations. Again the considerations of collaborative visualization and program invocation can be combined to address this interesting application.

We have used the phrase collaborative visualization loosely above; more completely we can consider collaborative visualization and data analysis. In a typical large-scale application, one would produce data with a back-end (supercomputer) simulation and then analyse the implications of this computation. This analysis would include visualization but more generally it is “data-mining”; extraction of information from data produced by the simulation. This datamining could involve invocation of statistics package; matrix routines etc. In general datamining – just like visualization – can be performed server side, client side or any combination of these. As discussion below, this can lead to many different collaborative schemes. The server-side application is usually invoked just once; the client-side programs would be replicated for each user. This replicated code can run independently, in lock step or in any collaborative mode between these extremes. Note that independent client programs accessing the same back-end simulation data is a very reasonable collaboration model.

 

2.2 Some Collaboration Characteristics

As indicated above, one has many choices as to what to share – “the original program producing output”; “the data stream multicast at some point along route from program to client or at its simplest, the pixels displaying one or more of the client windows associated with the application. A key problem in building collaborative systems is deciding which properties of an application to share. Let us consider a given application as having an “input” and “output” window”. This distinction is only “logical”; one could have of course have a single window integrating both input or output functions – alternatively the application could be rendered as several separate windows. Then in the simplest mode (master/slave), one client controls the application and the collaborating clients receive identical copies of the output window. This is the natural consequence of the shared display collaboration model as implemented by VNC (Virtual Network Computing) system [51,52] from AT&T. NetMeeting from Microsoft has a similar functionality although VNC has the advantage of supporting both UNIX and PC clients. Such systems can also share basic user actions (keyboard and mouse clicks) even from the “slave” clients. This is excellent when the “slave” is a single remote access machine to an application on the “master”. It produces a very confusing (and uncontrolled) collaboration environment with many participating clients, which does not seem very popular. Thus the VNC/NetMeeting model is typically used (in our experiments) with only the master able to control the application.

There are other important collaboration models with TangoInteractive [54] and Habanero [53] supporting the powerful shared event model. This divides into collaboration aware systems (like TangoInteractive) and those where the sharing is transparent. The latter typically involves modifying the event handling in the application and the “transparent nature” of the collaboration destroys some of the point of the shared event model; one wanted to be able to customize the event sharing on a per-event and per-client basis. This in principle allows every property of an application to be separately defined on each client. One shares the application and then each change in property generates an event; this event can be multicast to each participating client. Each client can make either the same or different decisions as to what to do with each event. Further as “this is just software”, one can choose to only send events by one (e.g. master), some or all participants. In the simplest case, one reproduces the simplest master-slave model, with the master's events sent to all other clients who implement the implied object property changes. This gives you the lockstep model supported by VNC directly with little additional benefit except for the efficiency of low network traffic. Sending a change in a single parameter typically requires much lower network bandwidth than sending the change in the display pixels implied by this parameter change. However this gain is at substantial cost in development effort as each (master) event must be trapped in the program (object) to be shared and appropriately sent as a message and interpreted in other clients. In one of the educational activities this semester, we worked on the sharing of a simple Java applet designed to simulate planetary motion. Here the pixel sharing approach was not tried and maybe would have difficulty in keeping up with rapid change in pixels from the rotating planet. However the shared event model was not so easy to implement as this case involved replicated clients running on machines of different speeds and hence sharing the natural simple events (start motion of planets with such and such parameters) did not guarantee similar views on each client. We had to work hard (sending planet position information and causing faster machines to wait) to ensure clients were in essential lockstep. On the other hand we have built some sophisticated collaborative applications such as the shared Biology workbench [56] described later, which need and exploit the shared event model. This is a type of collaborative invocation allowing different clients versions of a common set of invocation parameters. The simplest collaborative invocation can be implemented using shared display. Support of brainstorming (category 6) in Sec. 2.1 where we designed and partially implemented a TangoInteractive application TextCube for this, also needs the richness of the shared event model to allow one to switch control and function between participating clients. In the case of collaborative visualization, one can clearly use shared display but more natural is a restricted shared event model where the basic filtered information is shared identically between the clients and the different users make different choices as to nature of zooming and details of the rendering. We deduce from this discussion that:

·         One needs to support multiple models of sharing. These include shared display as well as shared event supporting both the full collaboration aware and as much of the collaboration transparent model that is feasible. We need to make it easier to ”collaboratize” applications.

·         A major problem in building any collaborative capability is deciding on how relative freedom to allow each user. Too little flexibility and the users will not have a creative environment and just a lockstep view of the “master”. Too much flexibility and the users will get confused and there will so much divergence between the different clients that one will loose its collaborative nature.

 


3 Collaborative Visualization

In the references and quick summaries in sec. 5, we have listed a few of the many projects that have studied and produced collaborative visualization applications. We found two sources particularly useful as they described general architectures used by many systems. These references are the Leeds University thesis of Jason Woods [45] and a student paper from Roussev at North Carolina [46]. They analyze the general single-user visualization and study the general ways in which it can be made collaborative. This is in particular includes the collaborative model used in TangoInteractive where we built a prototype collaborative visualization system described in Sec 5.2.

                There are two types of collaboration issues: firstly one has the general services controlling sessions and users (authentication and keeping track of user roles and privileges etc.). These issues are applicable to any type of collaborative application and for instance built in to the basic TangoInteractive or Habanero infrastructure. More important here is the distinctive structure of remote visualization which determines the different ways one can make it collaborative. This is shown in fig. 1 with three users A, B and C . B is the master and in the case C is using the clean shared display model to interact in lock-step with client C. One significant advantage of this model is its clarity of execution -–it is sort of obvious what to implement. Most of the software (like VNC) in this arena is designed for a rather different problem – remote display of windows as needed for managing clusters from a single host or remote consulting of problems on a remote computing. Thus they do not scale well to many shared clients and do not have the natural interface needed by collaborating clients. We suggest that a well designed shared display system for scientific users could have significant value.

The more powerful sharing model is shown between users A and B in fig. 1. Critical is the “visualization pipeline” showing a variety of transformations being applied as data flows from the server. In the usual case where the original server source is shared, one can still invoke the collaboration at any point down the chain. The earlier the sharing occurs, the more flexible is the resultant model as the functions after sharing are replicated and hence can be customized separately by each client. The shared display model corresponds of course to “sharing at the last moment”.

In fig. 1, we separate “input” and “output” windows although as described in above in sec. 2.2 we understand this only describes the logical function of GUI elements – these functions can be and often are integrated into a single window. User A can share user B’s input window and so identify the visualization that A wishes to join. Then A can be allowed (with additional GUI elements dedicated to specifying collaboration) to specify where in the pipeline, A’s sharing should be invoked. As remarked in Sec. 2.1, the resultant sharing can occur either at the server or between replicated client applications. Any intermediate scenario is of course also allowed. One extreme case corresponds to replicated back-end server access which is in fact default in shared JavaScript browser described in Sec. 4. The sharing of input windows could be done in many ways. One possibility is the shared frame-buffer for the parts copied to A from B with A’s GUI elements for choosing collaborative mode supported as replicated elements that can be freely set by A. The other cases correspond to some version of the shared event model. Most systems just program the visualization subsystem to replicate any settings specified by B. Another model is to modify the environment on B’s client computer to trap “raw” events and transmit these. This is well illustrated by the JavaScript Shared Browser described in sec. 4. Several groups have achieved this with modifications to the GUI environment, which could come from several sources including Java (see sections 5.4 5.5 and 5.7), X [57] or the web page used in Sec. 4. The automatic trapping of client events has the important advantage of minimizing (and perhaps removing all together) any need to modify the visualization subsystem. Unless one is careful the transparent event trapping approach leads to unnecessary replication of service on the server side. However building the server to support caching so that the visualization is invoked once by the original user (B in fig. 1) but cached for later collaborating clients can minimize the impact of this. Thus caching servers are in this sense automatically collaboration aware. As shown in fig. 1, one can also use a  shared event model where one traps not the raw event (mouse click on such and such a button), but rather the interpreted version of the event in terms of some visualization capability. This keeps the server collaboration unaware but adds intelligence (collaboration awareness) to the client.

We have already remarked on perhaps the most serious implication of fig. 1 – namely there are an incredible number of choices in collaborative systems. We do not know which choice has the correct trade-off between increasing user confusion with two many options as opposed to offering too little cutomizable functionality.

 


4 Collaborative Invocation

This corresponds to the shared running of programs (distributed objects) and is an area that has been studied less than the visualization case. We have noted the important relevance to computational steering. In this paper, we will discuss some prototypes we built for TangoInteractive – the Shared Biology Workbench and the shared compilation tool TextCube.

In figure 2, we show the architecture of a shared browser that we built to support both distance education and collaborative computing. It uses the TangoInteractive JavaScript interface that was in fact the methodology used in our first lectures to Jackson State starting in fall 1997. We later replaced the first JavaScript system by a more reliable Java based shared browser.


We returned to the JavaScript approach in fall 1998 because it could support a collaborative version of the Biology Workbench [56]. As shown in fig. 3 below, this innovative and popular program uses a set of web pages to allow the user access to a wide variety of biology databases and programs. The web pages only use basic HTML GUI elements such as buttons, lists, text fields/areas, check-boxes, file uploads and links. These are implemented in HTML and not Java and hence they can all be trapped in the Browser using JavaScript capabilities. W3C has published standards for the structure of Web pages and their associated events [58]. Unfortunately uniform support for this is only just becoming available (summer 2000) with Internet Explorer 5 and Netscape 6. We did build our system compatibly between Microsoft and Netscape browsers wherever possible using the ideas of Goodman [59]. However linking to TangoInteractive required us to specialize to Netscape in the areas of security and event capturing. When this collaborative workbench was constructed Netscape 4 was the only available platform compatible with TangoInteractive. This browser has a reasonably complete and documented DOM (document object model) [59] and we were able to trap and share all the form elements used in the Biology Workbench. We were also able to add many customization capabilities. The master could choose which type of events to share and could force clients to accept values defining key operational procedures. Any user can save and restore the contents of the (Biology Workbench) form at any time. This allows one to have a collaborative session where the invocation parameters are shared, saved, and modified on each client. This particular application was aimed at an education setting where a remote individual could be tutoring others on how to use the Biology Workbench; the participants could exchange and discuss possible invocation settings and individually experiment. Note that this particular implementation of collaborative invocation implies replicated back-end actions. As discussed at the end of sec. 3, this is the natural consequence of technique used. As the Biology Workbench is not necessarily a major computation and we were aiming at educational applications, this feature was appropriate. It would not be difficult to avoid this replication but would require modification on the server side; our approach implied no changes at all to the Biology Workbench. We briefed this technology to members of the Biology Workbench team but in spite of their original request for this capability, we do not think it was seriously evaluated. This could be due to changes in interests of the team but maybe it was also due to the clumsy user interface and inevitable (due to bugs in Netscape 4) fragility of our system.

The technology for sharing of Form elements in the case of the Biology Workbench was used to share mouse motion in distance education and is illustrated in fig. 4. This was an early lesson from our very first distance education experiments in 1997. Just sharing a web page can be limiting if the teacher which to reference a particular part of the page by highlighting or mouse motion.


 


Detailed capabilities of the shared browser are recorded in the appendix. Unfortunately we were never able to deploy the new JavaScript shared browser in any real NPAC activity. Although we identified and removed implementation features that caused crashes on PC’s, we could never get the system to work reliably across platforms. The browser was built using some 10,000 lines of JavaScript and this was too much for fragile UNIX browsers. Interestingly the most difficult problems in this system stemmed from undefined behavior of JavaScript on pages or page elements that had not completed loading. Note that given differences between machine and client-server networks, pages on different machines can complete loading at different times – one has to queue page update events as a given client may or may not be ready to process them. Unfortunately no events identify either page loading or page updating directly and we had to resort to arcane phenomenological approaches such as counting the number of loaded components and seeing if they have asymptoted! This illustrated that at least art the end of 1998, the browser was not a reliable computing environment. Further JavaScript is a difficult language to use, as many of its actions are ill defined. This is part of the motivation of our current suggestion (see fig. 5 later) to minimize our use of JavaScript and put critical code in a “personal server”. Security is a serious problem as it is different between Netscape and Internet Explorer and has certain peculiar features. Netscape laudably tries to protect you from extracting certain properties from foreign pages coming from different sources than the server from which original collaborative system was downloaded. Using signed scripts can circumvent this but on Netscape 4, this process appeared to have bugs necessitating a rather clumsy architecture shown in fig. 2. The difficulties with security appear to be equally severe with Internet Explorer and it was not clear to us how to write a shared browser for the Microsoft browser.

Dr. Gabb from ERDC expressed interest in a variant of collaborative computing – namely teaching programming at a distance. This is support that we could have used in out Java Academy taught spring 1999 to middle and high school students at Syracuse, Boston, Houston and Starkville. Here we imagine all participants developing and running modest size programs separately on remote machines. The teacher needs to exchange information either with all or a subset (perhaps one person) of the class. This information is programs, outputs, invocation parameters etc. We generalized this a system that shared general text fragments where each participant could have their own version – we termed this system TextCube as each file was labeled by filename, username and version number. Here we imagined users developing new versions in the collaborative framework. The system was also aimed at a type of meeting where one is discussing ideas and how best to put them in writing. The system allowed one to display the cube of files projected on any dimension – e,g. the latest version of files with a given name from all users. Unfortunately this project was caught up in the demise of NPAC and as only about 70% completed.

 

5 Case Studies

5.1 Introduction

                In the references, we list some papers that were studied to generate this report. Not all discuss collaboration directly but rather some of the key building block technologies. All of these papers are available in hard-copy which is fortunate as some of the work (especially that of students) is no longer available on the Web.


There are many (distributed system) technologies that are needed or can be used in building collaborative systems. On the client side, one can use applets or stand alone applications (in Java or C/C++) with well known trade-offs between convenience, performance, portability and reliability. The collaborative system would typically use a raw socket connection or perhaps a CORBA middleware request for the communications between client and server. There is still ongoing interest in thin clients (especially for hand-held) clients when technologies like servlets and Java Server pages are important. In the new collaborative portal model [55] proposed by Fox and shown in fig. 5, the “personal server” drives the thin clients and it is here that collaboration is implemented by sharing events. For Java based systems, JOS(Java Object Serialization) will be useful for applet or application migration; RMI is the way to send local data to remote machine and get result back. Of course dynamic class loading and applet downloading allows programs on remote machine to be used to process local data. XML is critical in defining all interfaces [55].

In the following, we discuss briefly some of the projects that we studied in greater depth. We do not repeat the discussion in section 3 of the important collaborative visualization architecture work in ref. [45] [46].

 

5.2 NPAC’s SV2 Java Visualization System[50]

SV2 is a collaborative data visualization and sharing system developed in Northeast Parallel Architecture Center. It was originally designed by Scott Klasky and extensively used as the Java visualization system SciVis. It had a built in collaborative system and was also linked experimentally to Tango Interactive. SV2 allows 1D, 2D and 3D graphic objects can be collaborative visualized with synchronized views. At the same time, private views are also supported for these situations that clients do not want to share their operations on data set. SV2 uses a single server, which imported data from a simulation and supported multiple clients.

                Recently SV2 was extended to share both scientific visualizations and the output of general applets. The latter is an interesting mode which is in between transparent and collaborative aware models and gives limited functionality supporting non lock step mode. One can share the basic applet output but have different views on each client.

 

5.3 Indiana(Purdue)’s Collaborative Environment for Visualization CEV [47]

CEV is a collaborative environment for visualization using Java RMI, emphasizing centralized server controlling thin clients.  It operates using only high-end workstation along with many inexpensive machines that need only the capability of running a web browser. The components of CEV are:

1)       VisClient :  VisClient is applet code embedded in a browser. It invokes remote method on VisServer while receiving invocations from BroadcastManager and UpdateImage.

2)       VisServer :   The VisServer object runs an application and is only invoked by a VisClient object.

3)       BroadcastManager: BroadcastManager resides within the server machine and is responsible for sending synchronization information to all connected clients.             

4)       UpdateImage: it extends the Thread class. It’s created from VisServer and is responsible for calling a native method, which perform the image generation.

 

5.4 Virginia Tech’s Java Applets Made Multiuser JAMM[5,25,27,48]

Display sharing is simplest way to make single user applications collaboratively available. JAMM provides sharing functionality for Java applets (and application). It is based on replicated architecture with event interception and broadcasting.. In JAMM, Event Interception and Broadcasting are implemented by modifying JDK 1.1. Features of JAMM include:

1)       Applet Migration: JAMM uses a modified JOS (Java Object Serialization) package to implement this.

2)       Event Interception and Broadcasting: JAMM modified the Java AWT to support event interception.

3)       Proxied Externalities: Externality is an object that is not truly platform independent. It represents state external to the portable Java environment, such as : socket, filestream, iostream. JAMM use a semi-replicated solution where externality objects are NOT replicated but rather reside at a single location and are accessible from proxies.               

               

5.5 Virginia Tech’s Sieve[31]

Sieve introduces a technique that enhances the standard JavaBeans mechanisms to support use of “Collaboration-unaware” software components. With the technique, components need only conform to basic JavaBeans conventions. Sieve was produced as the master’s thesis of Isenhour.

Sieve also allows component developers to provide custom mechanism for sharing components in a more flexible way. These capabilities include:

1)       Radar views, which is a small window to display other’s view, makes collaboration  not so tight

2)       “push” event and “pull” data in dataflow model.

 

5.6 Shastra Collaborative Computing Environment (Texas/Purdue) [1]

Shastra provides a flexible infrastructure for sophisticated WAN based collaborative computing using the shared event model. It is built around a network of servers supporting thin clients. The servers exchange network events in a fashion similar to the personal servers.

The components for Shastra are:

1)       Kernels: a set of cooperating servers which are used to manage network resources.

2)       Sessions: are the servers responsible for controlling shared access to network services.

3)       Brokers: act as distributed task schedulers.

4)       Thin Clients: are viewing browsers

 

5.7 Relay for Java Applications from Duke[39]

This collaboration-unaware system supports replicated Java application with event interception and broadcasting. Relay is a Master’s thesis of Carmine Greco from Duke University.

The usage of caching mechanism in collaborative computing is a major contribution of this paper. Features Include:

1)       Caching: improves performance

2)       Unsynchronized access: more flexible

3)       Eventual consistency: user can tolerate short-lived inconsistencies as long as they are guaranteed eventual consistency.  This technique could be very useful for improving the system performance of collaborative system.

 

5.8 CAVE6D from EVL (Electronic Visualization Laboratory) Chicago [6]

CAVE6D is a system to collaboratively visualize multidimensional, time-varying, environmental data. It supports multiple data sources, which can either be global or local.

The key components of CAVE6D are:

1)       Information Request Broker(IRB), which provides a unified interface to all the networking and database needs of the collaborative environment to support the distribution of data across the clients. CAVE6D  basically is CAVE5D(a non-collaborative application) with the IRB added.

2)       Channel, is a facility of communication between IRB.

3)       Key, acts as a soft of a handle to the storage location in the IRB’s database. Each key can be assigned to a specific data to be transmitted across the network. These can then be set to trigger a callback whenever they get filled by some data, which can then transmit the data to the remote key through the link. This way the IRB transparently manages data sharing with the remote subscribers.

 

This work brings another aspect of collaborative visualization. Thus one views the visualization as the shared 3D virtual environment and the key issue is the interaction of the avatars representing scientists exploring this world.

 

 

5.9 NICE and CALVIN – The Prototypes of CAVE6D [7]

A important issue within any networking computing environment is the methodology for controling the networking flow to disparate collaborating clients. Both CALVIN and NICE are collaborative environments which preceded CAVERN (The CAVE Research Network) and its software CAVERNsoft. Many issues about virtual reality are discussed in this paper. The following points are directly related to collaborative computing:

1)       Both NICE and CALVIN use a central server to maintain consistency

2)       CALVIN employs DSM(distributed shared memory) to eliminate the need of developing network communication protocol.

3)       For multicast, “smart repeaters” are used for slower clients in NICE. Smart-repeaters perform dynamic filtering depending on the client’s throughput capabilities.

4)       Supported collaboration models include replicated homogeneous; shared centralized; shared distributed with peer-to-peer updates; shared distributed using client-server subgroup

 

5.10 POPCORN from Hebrew University Jerusalem [8,43]

POPCORN is a globally distributed computation system and forms the master’s thesis of Shmulik London.

One concept in POPCORN is particularly interesting. This is a Computelet, which contains data and piece of code to process the data.

 

5.11 Dynamic Architecture for Remote Visualization from Vienna [2]

This paper does not discuss collaboration but rather remote visualization over a network of variable quality Implementing Data visualization system over Internet is very difficult because of the variation in the quality of network.

In this system, data visualization has been divided into some stages which composite the visualization pipeline. In order to get the best configuration for the visualization pipeline, a dynamic configuration is calculated as a result of calculation of resource estimation based on capacity of server and client, and the bandwidth of network.

 

5.12 Adaptive Architecture from Sweden [40]

An important issue within any networked computing environment is control of the networking flow. This paper presented a framework allowing applications to distribute data in a scalable way, with regard to both the numbers of applications and the available control bandwidth.

The real time remote flow control is implemented using an agent-based architecture. The technology in this paper could be very useful when we talking about the collaborative computing in a network which is not so ideal.

 

5.13 XSIL from Caltech[3,4,17]

XML is a flexible and way to exchange metadata between computers. In our three-tier system seen in fig. 5 and ref. [54], XML play an important role in defining the interfaces between the tiers. XSIL is designed by Williams at Caltech and is part of ScienceML in that it supports scientific data. It has been applied in several cases including the gravitational wave detector LIGO.

An impressive feature of XSIL’s application at Caltech is the support of client customized interfaces to a given data stream.

 

6 Conclusions and Future Work

The architecture of collaborative systems will continue to be hotly debated over the next few years as it is one of the hardest problems in distributed software architectures

As for collaboration system, “personalization” will get more attention in the future, because:

1)       ”Everyone keeps everything in the exactly same at every time” is NOT necessary for most collaborative applications, and technically it’s very hard to achieve this except by the rather primitive shared display approach.

2)       We need to improve the concept of a “user group” to allow hierarchical definitions

3)       We need to do more experiments to find out exactly what to share and to see how much flexibility really is required.

 

References

1)       Web Based Thin-Client Architecture for Collaborative Visualization; C. Bajaj; Department of Computer Sciences and TICAM, University of Texas, Austin; S. Cutchin; Department of Computer Sciences, Purdue University; This and other Shastra project papers are at http://king.ticam.utexas.edu/CCV/projects/collabweb/papers/

2)       Bringing your visualization Application to the Internet; Lukas Mroz, Helwig Loffelmann, Eduard Groller; Vienna University of Technology, Institute of Computer Graphics; http://www.cg.tuwien.ac.at/research/TR/detailed_index.html

3)       XSIL: Extensible Scientific Interchange Language; Kent Blackburn, Albert Lazzarini, Tom Prince,Roy Williams; Caltech; http://www.cacr.caltech.edu/SDA/xsil/

4)       An XML Architecture for High-Performance Web-Based Analysis of Remote Sensing Archives; G. Aloisio, G. Milillo, R.D. Williams; California Institute of Technology ; http://www.ccsf.caltech.edu/SDA/publications.html

5)       Transparent Sharing of Java Applets: A Replicated Approach; James "Bo" Begole, Craig A. Struble, Clifford A. Shaffer, Randall B. Smith; http://www.acm.org/pubs/citations/proceedings/uist/263407/p55-begole/

6)       Cave6D: A Tool for Collaborative , Interactive Immersive Visualization of Environmental Data; Abhinav Kapoor , Jason Leigh, Glen Wheless, Cathy Lascara, Andrew E. Johnson, Kyoung S. Park, Thomas A Defanti; http://www.evl.uic.edu/akapoor/cave6d/

7)       Issues in the Design of a Flexible Distributed Architecture for Supporting Persistence and Interoperability in Collaborative Virtual Environments; Jason Leigh, Andrew E. Johnson, Thomas A.DeFanti; http://www.supercomp.org/sc97/proceedings/TECH/LEIGH/INDEX.HTM

8)       Globally Distributed Computation over the Internet - The POPCORN Project; Noam Nisan, Shmulik London, Ori Regev, Noam Camiel; http://dlib.computer.org/conferen/icdcs/8292/pdf/82920592.pdf

9)       DOVE: distributed objects based scientific visualization environment; Lalit Kumar Jain,Mark Abbott; Concurrency: Practice and Experience 10, 1087-1095(1998) http://www.cs.ucsb.edu/conferences/java98/program.html

10)    An Investigation of Multi-user Design Tools for Collaborative 3D Modelling; Tek-Jin Nam; http://des-sgi-02.brunel.ac.uk/~dtpgtjn/research.html

11)    Collaborative Augmented Reality: Exploring Dynamical Systems; Anton Fuhrmann, Helwig Loffelmann, Dieter Schmalstieg; http://www.acm.org/pubs/citations/proceedings/graph/266989/p459-fuhrmann/

12)    An Externed Data-Flow Architecture for Data Analysis and Visualization; Greg Abram, Lloyd A. Treinish

13)    Interoperability of Concurrency Control Schemes in Collaborative Systems; Anshu Sharma(sharma@cs.unc.edu); http://www.cs.unc.edu/~munson/DARPA/

14)    Latecomer Accommodation via Generic Logging Facility; Goopeel Chung(chungg@cs.unc.edu)

15)    Hector: Distributed Objects in Python: A Framework for distributed environments; David Arnold, Andy Bond, Martin Chilvers; http://www.ddj.com/articles/1997/9713/9713b/9713bf1.htm

16)    Group Communication Support for Distributed Collaboration System; Injong Rhee, Shun Yan Cheung, Phillip W. Hutto, Vaidy S. Sunderam

17)    The Ligo Lightweight Data Format; An XML-based Language for Representing Scientific Data Objects; Kent Blackburn, Albert Lazzarini, Tom Prince, Roy Williams; http://www.ligo.caltech.edu/~sanders/111798.htm

18)    Improving Visualization Through collaboration; Jason Wood, Helen Wright , Ken Brodlie

19)    Collaborative 3D Visualization with CSpray; Alex Pang; http://www.computer.muni.cz/cga/cg1997/g2032abs.htm

20)    The CAG Multi-Agent Framework an introduction; Rob Kremer; http://sern.ucalgary.ca/cag/information/introduction.html

21)    An Architecture for Collaborative Virtual Environment With Enhanced Awareness; Dennis Brown (brownde@cs.unc.edu)

22)    Orbit: A Next Generation Collaboration Environment; James Milligan , Carla Burns

23)    The WebMe Data Visualization Tool; Roseanne Tesoriero, Marvin V. Zelkowitz

24)    COCA: Collaborative Objects Coordination Architecture; Du Li , Richard Muntz; http://www.acm.org/pubs/citations/proceedings/cscw/289444/p179-li/

25)    Sluice: A Java-Based Framework for Collaborative Interactive Modular Visualization; Environments; Philip Isenhour,Clifford A. Shaffer,James "Bo" Begole,Jeff Nielsen; http://vtopus.cs.vt.edu/~csrc/connection/CCFW97/TechReports.html

26)    JTransport: Collaborative Mobile Java Applications; Jason Hong; UC Berkeley CS294 Fall 97 report; http://www.cs.berkeley.edu/~jasonh/classes/cs294-7/

27)    Can You Share JavaBeans?; James Begole,Philip L. Isenhour, and Clifford A. Shaffer; Dr. Dobb’s Journal, June 1999; http://www.ddj.com/articles/1999/9906/9906m/9906m.htm

28)    Distribued Interactive Simulation for Synthetic Forces; P.Messina, S. Brunett, D. Davis, T. Gottschalk, D. Curkendall, L.Ekroot, H.Siegel

29)    Collaborative Computing and Integrated Decision Support Tools for Scientific Visualization; Theresa Marie Rhyne, Lockheed Martin; http://www.css.tayloru.edu/instrmat/graphics/hypervis/related.htm

30)    An Intelligent Visualization System for Earth Science Data Analysis; Zahid Ahmed , Peter Kochevar; http://www.sdsc.edu/Tecate/papers.html

31)    Sieve: A Java-Based Framework for Collaborative Component Composition; Philip L. Isenhour; http://borg.lib.vt.edu/theses/public/etd-21698-23121/etd-title.html; http://simon.cs.vt.edu/sieve/

32)    Microsoft TerraServer: A Spatial Data Warehouse; Tom Barclay, Jim Gray, Don Slutz

33)    A High-Performance Active Digital Library; Roy Williams, Bruce Sears; http://sunsite.informatik.rwth-aachen.de/dblp/db/indices/a-tree/s/Sears:Bruce.html

34)    Support for Implementing Scheduling Algorithms Using MESSIAHS; Steve J. Chapin, Eugene H. Spafford; http://www.cerias.purdue.edu/homes/spaf/messiahs.html

35)    Building Interactive Distributed Applications in C++ with The Programmers' Playground; Kenneth J. Goldman, Joe Hoffert, T. Paul McCartney, Jerome Plun, Todd Rodgers

36)    The Programmers' Playground: I/O Abstraction for Heterogeneous Distributed Systems; Kenneth J. Goldman, Michael D. Anderson, Bala Swaminathan; http://www.cs.wustl.edu/cs/playground/papers/wucs-93-29-abstract.html

37)    The Programmers' Playground: A Demonstration; Kenneth J. Goldman, T.Paul McCartney, Ram Sethuraman, Bala Swaminathan; http://www.acm.org/pubs/citations/proceedings/multimedia/217279/p317-goldman/

38)    The Globus Project: A Status Report; Ian Foster, Carl Kesselman; http://www-unix.mcs.anl.gov/metaneos/kickoff.html

39)    A Simple Shared Data Space for Web-based Distributed Collaborative Applications; Carmine F. Greco; Masters Thesis Duke University 1997; http://www.cs.duke.edu/ari/cisi/relay/html/paper/paper.html

40)    Real-Time Control and Management of Distributed Applications using IP-Multicast; P.Parnes, K.Synnes, D. Schefstrom; http://www.cdt.luth.se/~peppar/docs/

41)    Student 2000: Net-based Learning for the Next Millenium; Kare Synnes, Peter Parnes, Johnny Widen, Dick Schefstrom; http://www.cdt.luth.se/utbildning.direkt/

42)    Distributed Computing; John A. Stankovic; Encyclopedia of Telecommunications, Marcel Dekker, Inc. NY.

43)    A Paradigm for Global-Computing; Shmulik London; Masters Thesis in Computer Science at Hebrew University of Jerusaleam, June 1998.

44)    Data and Visualization Corridors Report on the 1998 DVC Workshop Series; Edited by Paul H. Smith and John van Rosendale; http://www.cacr.caltech.edu/Publications/DVC/

45)    Collaborative Visualization; Jason Wood; Leeds University PhD Thesis, February 1998. http://www.scs.leeds.ac.uk/kwb/publications95.htm#Love:98; http://cself27.leeds.ac.uk:8010/jason/Thesis/; http://cself27.leeds.ac.uk:8010/jason/html/books.html

46)    A Reference Architecture for Distributed Collaborative Applications; Vassil Roussev(roussev@cs.unc.edu); http://www.cs.unc.edu/~munson/DARPA/

47)    CEV: Collaborative Environment for Visualization using Java RMI; Rajeev R. Raje, Michael Boyles, and Shiaofen Fang; Concurrency: Practice and Experience 10, 1079-1085(1985).

48)    Flexible JAMM (Java Applets Made Multiuser); James Begole; Virginia Tech Department of Computer Science; http://geosim.cs.vt.edu/JAMM/

49)    Integrated Control of Distributed Volume Visualization Through the World Wide Web; Cheong S. Ang, David C. Martin, Michael D. Doyle; University of California, San Francisco Library and Center for Knowledge Management.

50)    SV2 Java Visualization System; http://www.new-npac.org/projects/sv2all/

51)    VNC or Virtual Network Computing at http://www.uk.research.att.com/vnc/.

52)    Virtual Network Computing, Tristan Richardson, Quentin Stafford-Fraser, Kenneth R. Wood & Andy Hopper, IEEE Internet Computing, Vol.2 No.1, Jan/Feb 1998 pp33-38.

53)    Habanero Home Page at NCSA - http://havefun.ncsa.uiuc.edu/habanero/

54)    TangoInteractive Collaboration System home page http://www.npac.syr.edu/tango

55)    Portals for Web-based Education and Computational Science, Geoffrey C. Fox, ERDC Technical Report May 2000, http://www.new-npac.org/users/fox/documents/generalportalmay00/erdcportal.html.

56)    The Biology Workbench Home Page from NCSA Illinois and the University of San Diego. http://biology.ncsa.uiuc.edu/.

57)    XMX Shared X Windows Muliplexor, http://www.cs.brown.edu/software/xmx/.

58)    W3C Web Page Document Object Model, http://www.w3.org/DOM/.

59)    Dynamic HTML, The Definitive Reference by Danny Goodman (1st ed, O'Reilly, 1998)

 

<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd"><BASEFONT SIZE="5">

Appendix: JavaScript Shared Browser Features

 

·         This allows a rich sharing of Web Pages between a Master Browser and any number of other (called nonmaster) clients. The Sharing is implemented by sharing browser events and events are transmitted between browser windows using the largely Java TangoInteractive.

·         The dynamic HTML support is based on ideas published in Core capability is a Shared Web Page Controlled by Master where location of Page can be set from either

·         Explicit Entry of URL in text field

·         Choice of URL from list of "favorites" preset in configuration files stored in archival files or cookies

·         Clicking of links and such Browser invocations

·         Key properties of pages can be shared including

·         Frame locations

·         Dynamic HTML and layers

·         Scrolling Position

·         Form properties

·         Window Size

·         Note web page through form can specify access to a general server side object (such as a CGI Script, CORBA Broker, Servlet) Thus this shared web browser can in fact share any server side object accessed from HTML pages

·         One can save your personal pages of interest(called personal bookmarks) in pages which are conveniently controlled from central dialog box

·         Only the master can control the main shared page but subsidiary system bookmarks where only the URL is shared, can be distributed to all users by either master or if given permission, a non-master client. These pages can be used for general information of value during the session.

·         Location of System and Personal bookmarks can be set by same mechanisms allowed for main page.

·         All Properties of Forms can be shared such as

·         Text fields

·         Text areas

·         Multiple and Single Selection Lists

·         File Browsing

·         Passwords

·         Radio Buttons

·         Check Boxes

·         All types of Buttons

·         Further forms can be saved, read back and/or transmitted between master and non-master, This allows master to check and edit forms filled in by non masters

·         Behavior can be individually customized and saved either in named cookies or web pages. Configurations can be retrieved by name.

·         Possible Customization includes

·         Whether or not scrolling shared

·         Which windows saved at end of session

·         Whether non master clients can click on shared browser page

·         Sessions can be completely archived in terms of all events generated or received from TangoInteractive; URL's seen in Shared Browser; Personal and System Bookmarks; Configuration data.

·         Archived Sessions can be read back and replayed with original or accelerated timing.

·         As well as formal archives, all messages are saved in a console which is available for inspection and which also can be saved for debugging or other purposes.

·         Optimized support for PowerPoint Internet Export and WebWisdom Pages

·         This includes automatic registration of these pages through the onload handler. This makes sharing of pages more precise as Shared Browser otherwise uses a heuristic to decide if page is loaded and it is safe to manipulate it.

·         Shared Pointer package exploiting dynamic HTML Support

·         Network Performance package allows one to

·         Measure ping from a "netmaster" node to any or all of participants

·         Examine processing status of any client and download times for all pages received. This can be compared to download time of Netmaster or other nodes

·         Measure and display average download times of selected Images

·         Performance can be invoked or displayed locally or requested remotely by a netmaster

·         Netmaster status is gotten by granting or requesting Tango Master Status

·         One cannot change master of main browser window

·         You can get response from non masters using System Bookmarks which can be controlled by any client

·         One can open up any number of simultaneous Shared Browsers, which run without Interference. This allows anybody to control their own session

·         Any nonmaster can map URL's by changing stem. This enables support of mirror sites.

·         Heuristic Algorithm with user customization is used to predict Next and Previous Pages in a set and to guess image location of thumbnail for a page

·         Thumbnail can be used to provide a preview (master) or review (nonmaster) of coming or past pages.

·         Control Bar forced above other windows and includes key access to parameters and files as well as a JavaScript Clock recording time of events in last minute with 2 second resolution.

·         Here and with bookmarks one can force "focus" on particular windows and so manage a cluttered desktop

·         Control Bar can be positioned in any corner of screen and allows you to move other windows around.

·         Dynamic HTML can be used in two ways

·         Direct Sharing of mouse and keyboard events (clicks, mouse up/down, mouse over/out)

·         A custom interface used by shared pointers and games where for instance mouse clicks are directly linked to TangoInteractive in the event handler

·         The game interface is defined and enables multi-player JavaScript Games to be developed

·         Two simple card games -- Concentration and Internet Snap are provided as Examples

·         There is a heartbeat that operates every 30 seconds and keeps non-masters “on track” in spite of deliberate or accidental deviations. This heartbeat and all events are recorded in a clock that was built using JavaScript (see fig. 2) and was meant to give the user a warm fuzzy feeling that all was well in this fragile world created by the shared browser.

·         Using TangoInteractive notification mechanism, new clients joining are immediately updated.

·         Using a nifty set of heuristics to determine page loading, the shared browser delays subsequent events on nonmasters until page is ready

·         This copes with delays due to filling in passwords on protected pages or just greater delays on nonmasters than master for a particular page

·         The Shared Browser is built around the concept of events covering all actions from form content or URL change to pinging of clients and window resizing. These events have in total some 100 distinct properties, which can be displayed from "History Page". There is a general serialization package for JavaScript events used to pack internally, send over TangoInteractive channels, and save in archive pages or cookies.