Multiuser collaborative work in virtual environment based CASE tool

Multiuser collaborative work in virtual environment based CASE tool

Qingping Lin*, Chor Ping Low, Jim Mee Ng, Juan Bu, Xiaohua Liu

Information Communication Institute of Singapore, School of Electrical and Electronic Engineering, Naynang Technological University,

Naynang 639798, Singapore

Received 4 June 2002; revised 8 January 2003; accepted 9 January 2003

Abstract

VRCASE is a virtual environment based Computer Aided Software Engineering (CASE) tool. It provides a 3D multiuser collaborative

software modeling environment with automatic object-class abstraction, class diagram generation, and Cþþ skeleton generation facilities

for assisting Object-Oriented software development. It allows multiple concurrent users to model software system collaboratively. To

achieve efficient collaborative software development in VRCASE, we have proposed and implemented a Fine-grained locking and

notification mechanism together with visual indicators to maintain system consistency among multiple concurrent users. The system

evaluation shows that our approach can effectively support multiuser collaborative software design in VRCASE.

q 2003 Elsevier Science B.V. All rights reserved.

Keywords: Concurrency control; Collaborative virtual environment; Computer aided software engineering tool; Software modeling; Database design

1. Introduction

There exist a wide range of Computer Aided Software

Engineering (CASE) tools to support different methods and

different stages of the software development lifecycle

[1–3]. CASE tools make the software architecture and

design clearer and easier to be understood and modified

because users are enabled to abstract away from the

entanglement of the source codes. The graphic notation

makes the communication among the software development

teams easier and the skeleton code generation motivates

development teams to construct a good design before

coding. Some CASE tools may also support roundtrip

engineering with the ability of keeping model and code

consistent and the ability of deriving class diagrams or

database models from source codes. However, a funda-

mental characteristic of many software systems is that they

are very large and far beyond the ability of any individual to

create or even understand in detail. Developing a complex

software system requires the collaboration of software team

members, thus software engineering is no longer the

preserve of individuals but essentially a team-based activity

involving a wide variety of software engineers. Actually, it

has been estimated that system developers typically spend

70% of their time in working with others and these activities

account for 85% of the cost of the large software system [4].

Unfortunately, traditional software engineering environ-

ments provide limited support to permit concurrent software

engineering.

In this research work, a multiuser collaborative environ-

ment is proposed and developed to support the collaborative

software development in Virtual Reality based CASE tool.

An effective concurrency control mechanism is proposed to

address the system consistency issue. In the following

sections, we will discuss the VRCASE system architecture

in Section 2, followed by the proposed concurrency control

mechanism and its implementation in Section 3 before

presenting the system evaluation results in Section 4.

Finally, the conclusions are drawn in Section 5.

2. System architecture of VRCASE

The architecture of multiuser collaborative VRCASE

system is shown in Fig. 1. The system is designed based on

client–server architecture. A client communicates with

VACASE server via TCP/IP over the Internet. The server is

the core part of the whole system that keeps track of the

system state information and acts as a router transmitting

0950-5849/03/$ - see front matter q 2003 Elsevier Science B.V. All rights reserved.

doi:10.1016/S0950-5849(03)00017-X

Information and Software Technology 45 (2003) 253–267

www.elsevier.com/locate/infsof

* Corresponding author. Tel: þ65-67904688; fax: þ65-67922971.

E-mail address: [email protected] (Q. Lin).

http://www.elsevier.com/locate/infsof

the events of user interactions. It maintains all of the data of

the VRCASE system, manages the communication among

its clients and guarantees the consistency of the whole

system. All communication between client users goes via

the server. The client program undertakes most of the users’

software modeling and design work. It provides a 3D editor

to enable users to visualize their software development in a

VR environment. Some other services including object-

class abstraction, skeleton code generation, and serialization

are also provided in the client program. The client

communicates with the server to load initial project

information. It also sends/receives modification requests

and notification messages to/from the server.

The components designed to support multiuser colla-

borative work in VRCASE include Central Database,

Communication Manager (CM), Consistency Control,

Security Control, Administrator Tool, Object-Class

Abstraction, and Code Generation. The Central Database

is used as a system data repository for the VRCASE system.

The system administrator sets up a central Object-Oriented

database for a whole software project. All members of a

software project are able to share the information stored in

the database. They have reading and writing permissions to

certain parts of the project model depending on their roles.

CM is responsible for communications between the clients

and the server. It routes data units to higher layer and also

performs packaging of data units to and from TCP socket.

Connection oriented TCP sockets guarantee that the

messages preserve their order in the communication

medium. A major challenge of a multiuser collaborative

system is maintaining a consistent state among the team

members. Whenever any client modifies the shared

environment, an appropriate update will be reflected to the

other clients in order to maintain consistent state. Shared

objects will appear to be in the same state to all of the

sharing users. There are three main aspects need to be

considered: system persistent maintenance, concurrency

control, and client display consistency maintenance. Each

multiuser collaborative system needs a security mechanism

to ensure system safety and avoid the system data loss. In

our VRCASE system, the security mechanism is responsible

for preventing illegal users from entering VRCASE system,

blocking illegal users to access system data, and backing up

the system data. Project manager manages the system

through Administrator Tool. Project managers can add or

delete projects, recover database, monitor system activities

and project information etc. Actually, the server graphic

user interface acts as the system administrator tool in

VRCASE. Once the software modeling is completed in

VRCASE, users can use its two other modules: Object-Class

Abstraction and Code Generation, to generate Unified

Modeling Language (UML) class diagram and correspond-

ing Cþþ skeleton codes. Since these two modules are not

the focus of this paper, please refer to Refs. [3,12] for their

detailed discussions, algorithms and implementations.

2.1. 3D collaborative virtual environment

Collaborative virtual environment techniques have been

actively developed in the past ten years [22,23] and applied

Fig. 1. VRCASE architecture.

Q. Lin et al. / Information and Software Technology 45 (2003) 253–267254

in various collaborative engineering systems [24]. 3D

virtual environments offer several advantages for infor-

mation visualization as pointed by Young [13]:

† A greater working volume for information presentation

with focus, context and point of interest managed

dynamically by the viewpoint. Additionally, the 3D

perspective view means that while investigating items of

interest, the remainder of the information in the world is

still apparent thus maintaining context and location

within the visualization.

† 3D graphics offer a greater level of flexibility for

representing, organizing and presenting information.

† Human experience in interacting and exploring within

3D environments is exploited.

Although the full potential of using 3D views and

interaction techniques has not yet been realized, a number of

software systems have been developed to investigate its

worth. The majority of software visualization systems to

date have concentrated on producing 2D representations and

animations of various aspects of a software system.

However, a growing area of research is the investigation

of the application of 3D graphics and virtual environment

technology to software visualization. Research into 3D

software visualization attempts to address the problem both

in terms of the data to represent and the users’ ability to

navigate through this data. Representing the data comes

from a growing need for more expressive powers to

represent the inherently multidimensional data, facts and

relationships that constitute a software system. Navigating

the data plays upon the naturally developed capabilities of

humans for navigating and interacting within 3D environ-

ments. A number of software systems have been developed

to investigate the potential of 3D techniques: GraphVisua-

lizer3D [14], VisualLinda [15], VOGUE [16], Vineta [17],

etc.

Visual editing support provided by current CASE tools

suffers from the problem of scalability. Actually, we believe

that much of the problem associated with visual editing

support is because the current approach is still restricted to

by traditional two-dimension paper drawing approach and

CASE is basically acting as a 2D drawing tool, and the

potentials of the computer are not fully utilized. While with

the arrival of VR, people have begun to question whether it

is possible to utilize another spatial dimension to model

software.

Gil and Kent [18] presented a series of 3D graphical

notations demonstrating effective use of the third dimension

in modeling. This is done by e.g. connecting several graphs

together. Each notation combines several familiar 2D

diagrams, which can be reproduced from 2D projections

of the 3D model. They find out that 3D models are useful

even in the absence of a powerful graphical workstation;

even 2D stereoscopic projections can reveal more

information than a plain planar diagram. They also expected

the CASE tool to support 3D diagram layout and navigation.

Gogolla [19] studied object diagrams, sequence diagrams

and the animation of sequence diagrams, respectively, to

show that 3D diagram layout and animation may improve

comprehension of complex UML diagrams significantly.

Gogolla’s work also reaffirm the usefulness of 3D

representation in CASE tools discussed above. Using 3D

virtual environment in CASE would require more powerful

computing resources and more complex CASE software

design. However, as the computing power increase rapidly

with the advance of computer chip technologies, the benefits

of using 3D virtual environment in CASE tools far

outweighs its costs.

To fully take advantages of 3D techniques, VRCASE

provides a collaborative 3D virtual environment to team

workers and the user interface helps the user view his

own and other group member’s work with the WYSIWIS

(What You See Is What I See) style [2]. The multiuser

virtual environment enables users to communicate

and interact with each other more naturally.

The VRCASE collaborative virtual environment is

shown in Fig. 2.

VRCASE adopts a WYSIWIS policy, which refers to the

presentation of a consistent display of shared information to

all participants, recognizing the importance of being able to

see all the work in progress. If each user sees a slightly

different or out-of-date version then the session’s cohesive-

ness will soon be lost. VRCASE system has the capability to

allow users to see what work other members have done and

what work is in progress. With the WYSIWIS strategy, all

of the actions that change the VRCASE system elements are

reflected instantly on the displays of other users who are

working collaboratively in the same project. Users see

updates from other users, as they are committed. VRCASE

supports the WYSIWIS strategy by maintaining synchro-

nized graphical data across client workstations.

To enhance collaboration among users in software

modeling processes, a viewpoint-sharing mechanism is

implemented in VRCASE. Users can make their viewpoint

position available to each other. Server is notified whenever

any user’s viewpoint was changed and server informs other

users about the changes. The viewpoint of users are

transparent to each other, so a user can always know what

other’s are doing very easily by looking at their viewpoint in

the 3D world. Thus they can discuss with each other

naturally and easily if necessary. A leading viewpoint can be

set up in a group discussion. When one user controls the

leading viewpoint, other users can set up their navigation

mode to follow the leading viewpoint. Thus when the leader

moves his viewpoint and navigate in the 3D model, other

users can follow the movement on their local machine. As

shown in Fig. 2, Kathy, Jane, Frank and Tom are working

collaboratively in a project. The figure is the display view of

Kathy. After Kathy chooses to show other users, the avatars

of the three users are shown on her screen.

Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 255

2.2. Synchronous communication

Real-time synchronous communication is an important

requirement of multiuser collaborative VRCASE system.

Since real time cooperative design of a 3D virtual world

usually involves a great amount of data to be manipulated

and visualized, minimizing the response time and the

network traffic load becomes vital. It will affect the

feasibility of such a real time design system. WYSIWIS

interface requires high responsiveness to ensure the

system consistency. The time taken to access data, modify

data, or notify users of changes must be as short as

possible. One can image that if one participant modifies

an object and takes long time for other participants to

visualize it, or even worse, the change never appears on

another participant’s screen, the cooperative design will

become impossible. Failure to provide good responsive-

ness is likely to limit the practical usability of the system.

Thus an efficient concurrency control mechanism is

needed to support the concurrent software modeling

work in VRCASE. Detailed discussions on the current

consistency control mechanisms used in CASE tools and

our solutions on concurrency control will be presented in

Sections 3.1 and 3.2.

2.3. Communication facilities

VRCASE provides its users with a built-in chat

communication tool to support group members to

communicate with each other explicitly rather than

communicate through work products implicitly. As

shown in Fig. 3, the VRCASE server GUI furnishes a

talk window that allows a member to communicate with

other members. The chat tool is used to facilitate user

conversation by exchanging textual information. It

employs free-for-all policy that allows multiple users to

send text information to each other freely. A member can

select from the group member list for interaction partners.

If the other member doesn’t have the talk window opened

when a talk request arrives, a request confirmation

message is signalled. When the user enters messages at

the text input area, this array of bytes is shared and

displayed at the text output area of other users. Group

members may utilize this channel to discuss topics related

to the file contents and structure, application group

arrangement and others. The window contains two parts:

the first part displays messages from other members while

the second part allows a member to type messages.

VRCASE system can track the users’ activities and all

information of a project. As shown in Fig. 4, the message

monitor can track the user’s information such as Log in/

off time, project name, last action and action time. Icons

with different colors are used to indicate different states.

VRCASE uses a tree view structure as the project

information monitor to track useful information of

projects such as project name, predefined password and

user list. Our work in live audio and video communication

implemented in NATIVE CVE system [25] may also be

incorporated into VRCASE to support the collaborative

work.

Fig. 2. 3D Collaborative virtual environment.


3. Concurrency control in VRCASE

3.1. Concurrency control in CSCW systems

Concurrency control has been most actively studied

within the domain of CSCW systems and database systems.

Traditional concurrency control techniques for database

systems have been successful in many multiuser setting, but

these techniques are inadequate in open, extensible and

CSCW systems supporting collaborating users.

Locking mechanism is a standard technique in traditional

distributed computing and CSCW systems to ensure data

Fig. 3. Server graphic user interface with built-in chat tool.

Fig. 4. Property sheet in two states.


integrity by prohibiting concurrent conflicting updates on

shared data objects. Locking has also been applied in

various groupware systems for consistency maintenance

[20]. It is also a common concurrency control method for

database systems. But there is an overhead in requesting and

obtaining the lock, this may include waiting if the data is

already locked. In any case there will be degradation in

response time.

Transactions in collaborative applications have several

characteristics that distinguish them from transactions in

database systems requiring concurrency control. Colla-

borative applications are typically interactive, for

example, they may be of long duration; they are often

unstructured and more sensitive to response time

performance than total system throughput. Thus, con-

currency control’s role of preventing inconsistent con-

current actions must compete with the need of users to

share their partial results with each other. Hence,

collaborative applications have their own peculiar con-

currency control requirements such as support for long

transactions, user control over transaction execution,

relaxed consistency criteria, and integration with access

control.

Traditional database concurrency control is generally

restrictive for collaborative applications. The semantics

of the shared data object of collaborative application is

usually much more complex than the read/write seman-

tics of the database data model. As a result, the

concurrency control it supports is more conservative

than necessary. A database using read/write semantics

will not allow concurrent insertions but will block one to

let the other proceed. Traditional database systems do not

allow concurrent transactions to mutually depend on each

other, whereas in collaborative systems users whose

workspaces are coupled may be expected to influence

each other in mid-transaction. Before adding a new item,

a user would observe the actions of the other user to

ensure that duplicate items are not inserted in the

database. In collaborative systems users may wish to

temporarily allow conflicting actions and delay their

resolution until some later time. Conventional database

systems, however, do not allow the database to remain in

an inconsistent state for indefinite periods. The action

that a conventional database system will take when

conflict is identified is to throw away all work that led to

the conflict and return the database to a prior consistent

state. For a user about to commit a large number of

changes to a document, this would not only be very

unpleasant, but is probably unnecessary; the user may

only need to discard changes to one paragraph [21].

To support concurrent engineering in a multiuser

collaborative software development environment, most of

existing multiuser collaborative CASE tools adopt the

object-level locking mechanism [6,8,9], file-level locking

mechanism [7,10] and the floor control mechanism [5] for

concurrency control. Some tools constrain the edit right

only to one person (for example, the object owner) strictly to

reduce the opportunities of concurrent conflict [9]. These

mechanisms tend to cause long blocking and thus cannot

provide the high level of responsiveness required for

collaborative software design as discussed in Section 2.2.

The following sections discuss our approach to address the

issue.

3.2. VRCASE concurrency control mechanism

Real-time multiuser VRCASE allows two or more

geographically separated people to work together at the

same time through a common system environment. The

system typically supports a group’s ability to manipulate

their artifacts through a shared working space. It is often

possible for many clients to attempt to manipulate the same

element almost at the same time. If concurrency control is

not established, users may invoke conflicting actions. As a

result, the group may become confused because displays are

inconsistent, and the VRCASE system may be corrupted

due to events being handled out of order. So the concurrency

control is the core issue in multiuser collaborative VRCASE

system. Concurrent access with guaranteed consistency is a

strict requirement for VRCASE. Concurrency control

mechanism is based on avoidance or resolution of

collisions. Issues to address when developing mechanisms

for concurrent access to the shared workspace include

notification, responsiveness, and the impact of different

access control mechanisms on the group. Notification

should be maximized when the group members are working

together closely, and can be relaxed otherwise. Respon-

siveness should also generally be maximized.

In VRCASE, we propose a new concurrency control

strategy that is synthesized from mechanisms used in

traditional database management and approaches used for

concurrency control in CSCW systems. Fine-grained lock-

ing and notification, and Visual Indicator mechanism are

proposed to work together as the concurrency control

mechanism in VRCASE system. VRCASE provides con-

tention resolution at the level of attributes in nodes or links.

The system allows any number of users simultaneously to

read and display the data field of a given node in a separate

window on the screen. However, permissions to make

modifications to the data field are restricted to one user at a

time.

3.2.1. Fine-grained locking mechanism

Most of the existing multiuser collaborative CASE

tools use the traditional object-level locking mechanism to

control the concurrent conflicts. This object-level locking

only allows one person to operate on an object at a time.

If one group member is updating the data field of a node,

object-level locking will not allow other group members

to annotate or create new attribute in the node. Thus it is

easy to cause long blocking. A Fine-grained locking

mechanism is proposed in VRCASE to guarantee system


consistency. The essence of this mechanism is to mitigate

the problems with traditional locking method. The Fine-

grained locking mechanism moves the contention from the

level of object to the level of single attribute in object,

thus changes the nature of access contentions. In this way,

the smallest sharing unit changing from an object to a

single attribute of object is obtained. Then the potentials

of lock blocking and the access conflict are reduced to a

low level.

Using Fine-grained locking mechanism, permission to

make modifications to data field is only restricted to one

user at a time while others can read the same data at the

same time. The Fine-grained locking mechanism enables

several persons to share data and attributes within a node (or

link), instead of sharing a whole node or link which only

allows one person to operate on a node or a link at a time.

Different users can operate on different attributes of nodes at

the same time. For example, users can create new attributes

or operations to the same object simultaneously under the

Fine-grained locking mechanism while only one user is

permitted to create a new attribute or operation at one time

under the object-level locking mechanism because the

whole object can be locked by only one user. Fine-grained

locking enables a fine granularity of sharing between group

members in collaborative working sessions. Users can

freeze a part of the element to protect it from changes by

other users. Before any items are updated or deleted from

the data source, the tool checks if the items are in use by

anyone else.

In VRCASE, the information of a whole object is divided

into several small units, thus when a user wants to modify

one object, he only needs to lock the relatively small unit,

other sharing user still can lock and modify other parts. The

clients only need to send the newly modified data part to

server. There is no need to send the message of the whole

object to the server, which will only replace the old data

from the data cache. Since only the new data parts are sent to

server and propagated to other sharing users, the workload

of the network transmission is reduced and thus the working

efficiency is improved.

As shown in Fig. 4, the property of the model element is

divided into four separate parts ‘General’, ‘Attributelinks’,

‘Operations’ and ‘Relations’. Different model element

properties are described in various property pages. In the

multiuser environment, while one user is changing a model

element’s property page, other users can modify other

property pages but can only view the same property page.

When a property sheet is opened, it is assumed that the user

wants to view the model element. As shown in Fig. 5, the

Object ‘Item’ has four Operations. Each Operation has a pop

up property page to describe the detailed property. When

user wants to modify certain Operation, he can double click

that Operation name and then lock the pop up property page

to get the writing right. Multiple users can modify different

Operations at the same time.

3.2.2. Fine-grained notification

Corresponding to Fine-grained locking mechanism,

Fine-grained notification is used to notify locking, unlock-

ing, deleting, writing and other operations. System can

distinguish among operations on different attributes in an

object. All related users are notified when one user signals

the intention to modify the data field of the node by

obtaining a lock. When the user finishes modifying the data

field of a node, other users who have subscribed to this event

will get notified that the data field of the node has been

unlocked and is writing accessible. When one user actually

modifies the shared object, all of the sharing users will

automatically get the newly modified data and the

corresponding graphical display. When a node is deleted,

the display of the node will be removed from the screens of

all clients who are working in the shared modeling

environment. Server is responsible for sending messages

to clients to notify them about the data changes. Server

sends messages out only to those who are interested in them

instead of sending out to all of the clients. In this method the

number of transmitted network messages is reduced and the

efficiency of the communication is increased.

3.2.3. Visual indicator mechanism

Besides the lock blocking, another problem in the

traditional lock mechanism is the lock overhead in

requesting and obtaining the lock. VRCASE system

provides users with visual indicators of lock resources to

give users explicit indications about the sharing status.

Whenever the server grants or releases a lock on an object to

one of the clients, it should notify relevant clients about the

change. The client side program has enough knowledge

Fig. 5. Operation page.


about the lock status of the object and this knowledge is

represented on the user interface by various visual

indicators. Thus user knows the lock status of the object

at the first sight from the user graphical interface. Once one

user locks an item, other users will not waste time and effort

on requesting the lock and do any modification on this item.

They can continue to work on other parts without this item.

Hence, the likelihood of unnecessary requests issued for

locked objects is reduced greatly.

As shown in Fig. 4(a), a ‘Lock’ button is provided in the

property page to enable users to express their intention of

writing. The enabled ‘Lock’ button indicates that the

element is not being selected and edited by anybody else.

Before the ‘Lock’ button is selected by the user, all the

editing controls are disabled to prevent users from editing

the model. Only the owner and sharers of the object have the

right to request the lock. Only when the object is not locked

by anyone else can the ‘Lock’ button on the property sheet

be enabled and user can press this button to require lock

permission from server. Locks are allocated when the user

invokes the editor lock command indicating a change in

mode from browsing to editing. The lock message will be

sent to server to ask for the lock right. The ‘Lock’ button

will then be changed into ‘Unlock’ button (Shown in

Fig. 4(b)) and all editing controls are changed to be

available once the lock is granted by the server. The lock is

released when the user clicks the ‘Unlock’ button.

Comparing Fig. 4(a) with Fig. 4(b), it can be seen that

different background colors are used to indicate different

sharing status. Background colors will change depending on

the current user’s identification and the object’s sharing

information recorded in the client side. The knowledge

about lock status of the object of client side is represented on

the user interface by various background colors and ‘Lock’/

’Unlock’ button. It can be seen from Fig. 4 that the

background color changes from gray to green to indicate

that the user already gets the lock from server and all of the

editing controls are available for the user.

3.2.4. Design of central database for concurrency control

The Central Database is crucial in making the entire

system work logically and consistently. It provides the

organization structures of the system data as well as a full

service for recording local and remote users’ work areas. Its

design is important in implementing the proposed con-

currency control approach. The Central Database organizes

both textual and graphical information according to their

structural relationship. There are two parts in the Central

Database: Information Database that is used to record

project and user information, and System Data Database

that is used to record system data.

(A) Information database. Information Database

includes Project Information table and User Information

table. Project Information table records all of the project

information such as ProjectID, ProjectName and predefined

Password etc. It is initialized and managed by project

managers. A project manager initializes the project name,

predefined password and username list through the admin-

istrator interface of server application. Server grants a user

the project access right and loads all initial data to the user

only if he can provide valid user name and password. All

users who will work in the same project collaboratively are

recorded in a name list in the project information table. User

Information table records the user information such as user

name, password and project name. User can change his

password periodically. The newest password is recorded in

this table.

(B) System data database. System Data Database is used

as the whole system data container. Every project has its

own database that includes multiple tables, which are used

to record different data structure of VRCASE system data.

Fig. 6 shows the overview of the structure of the system

database. System Data Database includes two kinds of

databases: Graph database and non-graph Database.

(C) Graph database. The Graph Database is used to

record the 3D graphic model data. FigNode and FigLink are

defined to represent 3D-node model and the relations

between nodes, respectively. The position of 3D graphic

object in the 3D display is described using x; y; z

coordinates. The relationships need to be stored in the

Graphic Database are described as following:

1. The relationship between the graphic nodes and the

project that contains them. ParentID describe the ID of

the project.

2. The relationship between graphic model and software

model. RelatedElementID specifies which object the

FigNode represents.

3. The relationship among FigNodes. The SrcLinkEndID

and DesLinkID specify the source and destination 3D

FigNodes of the FigLink, thus the relationships between

the 3D nodes are described.

4. The enclosing relationship between 3D FigNodes. The

enclosing relationship is described by the EnclosingID

field that specifies the parent which encloses the 3D

node.

(D) Non-graph database. Non-graph Database is used to

record non-graphical type of system data. VRCASE

classifies the system data in several different data types

Fig. 6. System data database structure.


and different data types have different table structures. The

relationships stored in the Non-graph Database include:

1. The relationship between the system element and the

parent element or project. ParentID describes the parent

ID.

2. The relationship between the class and its instance. For

example, ClassIDdescribe the class from which the

object is instantiated.

3. The relationship between Objects. Objects relate to each

other via Links. Fig. 7 shows the link relationship

between two objects. SrcLinkEndID and DesLinkEndID

describe the source and destination of the Link,

respectively. In the LinkEnd table, the OwnerObjectID

and ConnectLinkID present the connected Object and

Link, respectively. Thus the relationship between Link

and LinkEnd is also presented. Fig. 8 shows the retrieval

procedures.

(E) Data retrieval. To allow concurrent data access,

VRCASE system uses ID as the global index. The server

grants an ID to system data item and manages the ID

numbers to work as a global index to retrieve data in the

central database. Each element ID includes three parts:

ParentID that indicates the parent of the new item,

ElementType that indicates the data type of the new item

and SequenceNumber. Whenever the user creates a new

system element, the client software will first send the new

data to the server, and the server will then grant a

corresponding ID to this new element through ID Generator.

ID Generator is responsible for generating the ID for a new

system item.

Fig. 9 shows the ID Index Tree that is used as the path to

retrieve VRCASE data using the ID number. Server

retrieves the data directly through the ID index tree. Client

applications also use the ID to identify system elements.

3.2.5. Consistency control procedure

Consistency Control Procedure ensures the system

consistency. When clients add new objects, update objects

or delete existing objects, all of the changes are sent to

the other clients immediately. Over the client side, the client

application reads received messages and changes the system

model based on new data to keep the results consistent.

Concurrency control mechanism described in Sections 3.1

and 3.2 are used to maintain the system consistency in

VRCASE.

When client creates a new element, the new data

is sent to server first. The Server generates a new

ID for this new item and records it to data source.

After that, server notifies other clients about the new

item. Fig. 10 describes the procedures of the Adding

operation.

When clients do the Updating operations, shared

elements must appear to be in the same state to all of

the sharing clients. Users must get the lock before they

change the system element. The procedure of the

Updating operation is shown in Fig. 11. There are four

parts in the concurrency control procedures. Server deals

with all of the lock transactions in part1 including accept

lock request, check lock state, grant lock and refuse lock.

After the user gets the lock, he will have the right to

manipulate the locked element and send the updated data

to the server in part2. In part3, the server records the

updated data into the consistent data source and notifies

all shared users simultaneously. Clients that share the

element recreate the remote event locally based on the

new data and update the shared view to keep the view

consistent with others.

When client deletes an existing system element, the

deleting operation sent to server. Server first checks whether

the element is being used by others (locked by others) or not.

Only when the element is not being used by other clients,

the deleting operation will succeed. Fig. 12 shows the

procedure of Deleting operation.

4. Evaluation of concurrency control in VRCASE

A full evaluation of VRCASE was conducted to test

its functionalities and performance. A group of post-

graduate research students were involved to cooperatively

design a software model named ‘Connie’s Convenience

Store’ based on the example by Coad et al. [11]. They

were required to design the ‘Connie’s Convenience

Store’ system which aims at helping cashiers work

more effectively during checkout, keeping good records

of each sale, and supporting more efficient business

operations. Its main features include: Log

important information, Conduct business, Analyze

business results, and Interact with other systems. The

collaborative software design process was used to

evaluate VRCASE.

An important step in assessing the multiuser collabora-

tive VRCASE system is to gather a set of generally

accepted rules for multiuser collaborative work analysis.

The evaluation metric to assess the effectiveness of

Fig. 7. Link between objects.

Fig. 8. Relationship retrieval procedures.


VRCASE in supporting multiuser collaborative software

development is presented according to the model of

multiuser collaborative environment as illustrated in

Fig. 13 and Vessey’s ideas that were used to evaluate

several CASE products [4]. This model is also potentially

applicable to variable other multiuser CASE tools. So the

evaluation instrument refined from the multiuser colla-

borative model can be used as general evaluation criteria

for multiuser collaborative CASE tools. The main

functionalities of multiuser support environment can be

categorized into four categories: User Communication,

Security Control, Information Sharing and Information

Monitoring. These are the key features that mainly affect

the effectiveness and productivity of the collaborative

software development. Thus they are used to evaluate

VRCASE in this research.

As the focus of this paper is on concurrent

collaborative work, we will only discuss the evaluation

of concurrent information sharing (Data Sharing, Con-

sistency Enforcement, and Concurrency Control) and

Fig. 9. ID index tree.

Fig. 10. The procedures of adding operation.


Fig. 11. The procedure of updating operation.

Fig. 12. The procedure of deleting operation.


the performance of system responsiveness using

our proposed concurrency control mechanism. Full

evaluation results on other aspects are reported in

reference [3].

4.1. Concurrency information sharing support

Concurrency information sharing strategy of VRCASE

is to provide a collaborative environment for software

engineers to work cooperatively under a WYSIWIS style.

Thus VRCASE system pays more attention to the

consistency control and maintenance features. Figs. 14

and 15 show sample screen captures of information

sharing of two users: Tom and Jane. The screen captures

show the sharing display of the user Tom, who is locking

‘Sale’ object, and another user Jane, respectively. Fig. 16

shows the zoom-in view of ‘Sale’ object and its editing

menu while Fig. 17 illustrates the information sharing

property window of the ‘Sale’ object. The concurrent

information sharing functionality evaluation results are as

follows:

(1) Data Sharing. The same graph model can be

displayed on different workstations at the same

Fig. 14. Sharing model display of a user ‘Tom’.

Fig. 13. Model of collaborative support environment.


time. Software engineers at different workstations are

able to share the same data dictionary.

(2) Consistency Enforcement. System enforces a certain

diagram/graphic standard. It has capability to handle

problems caused by naming conflict. The system

automatically notifies analysts whose work might be

affected due to changes in the data source. Software

developers can freeze parts of the design work to

protect it from changes. It also has the capability of

identifying redundancy in the data source. Data

source can store system data persistently.

(3) Concurrency Control. Software developers can

access data source concurrently. The system provides

a mechanism to control concurrent access to project

data. Before any item is deleted, the system can

check if the item is in use by anyone. If concurrent

access is controlled by locking, software developer

can query to find who has locked the item of interest.

Fig. 15. Sharing model display of Jane.

Fig. 16. Zoom in view of sale object and its editing menu.


4.2. System responsiveness

To evaluate the system responsiveness, we tested the

VRCASE in Local Area Network (LAN) environment

and measured the time lag between user action upon the

VRCASE client interface (e.g. change on a object

property, or add an object) and the corresponding system

information update at the client end. As shown in Fig. 18,

the time latency increases approximately linearly with the

size of the group. L1 shows the time lag when clients

work in the same project with system data shared by all

clients and L2 is the result when clients work in two

projects. The time latency varies within 135–155 ms and

latency differences varies within 20 ms. The results show

that the system responsiveness is sufficient

for collaborative work in VRCASE. Although our

experiment was conducted in a LAN environment, it

should also work well over the Internet since the size

of the data packet for maintaining the system consistency

is very small (about 61 bytes per message in our

approach).

5. Conclusion

In this paper, we presented a multiuser collaborative

environment based VRCASE tool. It supports multiuser

collaborative software development in VRCASE tool.

Multiple software engineers can collaboratively design a

software system in a 3D shared virtual environment.

Fine-grained locking and notification mechanisms, incor-

porating with Visual Indicator mechanism, have been

proposed to reduce concurrent conflicts and notifications

from the traditional object level to attribute level

and ensure the system consistency in multiuser colla-

borative VRCASE with good system responsiveness.

System evaluation demonstrates that the proposed

CSCW environment in VRCASE could

support multiuser collaborative software development

effectively.

Acknowledgements

This research work was carried out under the research

grant AcRF 20/98 provided by Ministry of Education,

Singapore. We would also like to thank those postgraduate

research students from Information Communication Insti-

tute of Singapore, School of Electrical and Electronics

Engineering, Nanyang Technological University, who had

participated and helped in evaluating VRCASE.

References

[1] R.J. Norman, M. Chen, Working together to integrate CASE, IEEE

Software 9 (3) (1992) 13–16.

[2] A. Fugetta, A classification of case technology, IEEE Computer 26

(12) (1993) 25–38.

[3] Q. Lin, C.P. Low, J.M. Ng, A Virtual Environment Based System for

Assisting Object-Oriented Software Development, Final Report for

AcRF project 20/98, Nanyang Technological University of Singapore,

2000.

[4] V. Iris, S.A. Paul, CASE tools as collaborative support technologies,

Communication of ACM 38 (1) (1995) 83–95.

[5] L. Brothers, V. Sembugamoorthy, M. Muller, ICICLE: groupware for

code inspection, Proceedings of the ACM 1990 Conference on

Computer-Supported Cooperative Work (1990) 169–181.

[6] Sterling Software, ObjectTeam (Now the COOL:Jex) product

document, Cayanne, 2000.

[7] Rational Rose online document, 2001, Rational software, http://www.

rational.com/.

[8] Advanced Software Technology, 2001, GDPro on line document,

http://www.advancedsw.com.

[9] T.-H. Kim, W.-C. Shin, G.-D. Park, T.-H. Lee, T.-G. Kim, Y.G. Shin,

C.-S. Wu, DOOD distributed object-oriented software development

environment, Proceedings of APSEC’97 and ICSC’97, IEEE (1997)

427–434.

[10] J.W. Gintell, M.B. Houde, R.F. McKenney, Lessons learned by

building and using scrutiny, a collaborative software inspection

system, Proceedings of Seventh International Workshop on Compu-

ter-Aided Software Engineering, IEEE (1995) 350–357.Fig. 18. System responsiveness test results.

Fig. 17. Information sharing property window of sale object.


http://www.rational.com/

http://www.rational.com/

http://www.advancedsw.com

[11] P. Coad, D. North, M. Mayfield, Object Models: Strategies, Patterns,

and Applications, Second ed., Prentice Hall, 1997.

[12] J. Bu, Q. Lin, J. Ng, C.P. Low, VRCASE: A Virtual Reality Based

Collaborative CASE Tool, IASTED International Conference,

Applied Informatics (AI 2001), February 19–22, 2001, Innsbruck,

Austria, pp. 202–209.

[13] P. Young, M. Munro, Visualising software in virtual reality,

Proceedings of the Sixth IEEE International Workshop on

Program Comprehension (IWPC’98), Ischia, Italy June (1998)

19–26.

[14] University of New Brunswick, The GraphVisualizer3D Project Online

Documentation, http://www.omg.unb.ca/hci/projects/hci-gv3d.html

or the Nested Vision3D User Guide, http://www.nvss.nb.ca/

products/nv3d/documentation, 1995.

[15] H. KoiKe Labs, VisualLinda: 3D Visualization of Parallel Linda

Programs, On-Line Project Abstract, Koike Labs, University of

Electro-Communications in Tokyo, http://www.vogue.is.uec.ac.jp/

public/html/en/research/vlinda.htm, 1997.

[16] H. Koike, Three Dimensional Software Visualization: A Framework

and its Application, in: T.L. Kunii (Ed.), Visual Computing:

Proceeding of International Conference on Computer Graphics

(CG’92), Springer, Tokyo, 1992, pp. 151–170.

[17] U. Krohn, VINETA: Navigation through Virtual Information Spaces,

Proceedings of the ACM International Workshop on Advanced Visual

Interfaces (AVI’96), ACM Press, New York, 1996.

[18] J. Gil, S. Kent, Three dimensional software modeling, Proceedings of

the 20th IEEE/ACM International Conference on Software Engineer-

ing (ICSE’98), Kyoto Japan April (1998) 105–114.

[19] M. Gogolla, Towards three-dimensional representation and animation

of UML diagrams, Proceedings of UML’99—the Unified Modeling

Language: Beyond the Standard Second International Conference,

Fort Collins, CO, USA October (1999) 489–502.

[20] C.A. Ellis, S.J. Gibbs, Concurrency control in groupware system,

Proceedings of the ACM SIGMOD International Conference on

Management of Data (1989) 399–407.

[21] J. Munson, P. Dewan, A concurrency control framework

for collaborative systems, Proceedings of the ACM 1996

Conference on Computer Supported Cooperative Work (1996)

278–287.

[22] M. Macedonia, M.J. Zyda, D.R. Pratt, P.T. Barham, S. Zeswitz,

NPSNET: a network software architecture for large-scale virtual

environments, Presence 3 (4) (1993) 265–287. Fall.

[23] T.A. Funkhouser, A RING: a client-server system for multi-user

virtual environments, ACM SIGGRATH, Special Issues on sym-

posium on 1995 Interactive 3D Graphics (1995) 85–92.

[24] J. Maxfield, A distributed virtual environment for collaborative

engineering, Presence 7 (3) (1998) 241–261.

[25] W. Wang, Q. Lin, C.P. Low, J.M. Ng, VRML based collaborative

virtual environment design in NATIVE system, Proceedings of

EUROMEDIA’2000, Antwerp, Belgium May (2000) 74–80.


http://www.omg.unb.ca/hci/projects/hci-gv3d.html

http://www.nvss.nb.ca/products/nv3d/documentation

http://www.nvss.nb.ca/products/nv3d/documentation

http://www.vogue.is.uec.ac.jp/public/html/en/research/vlinda.htm

http://www.vogue.is.uec.ac.jp/public/html/en/research/vlinda.htm

Documents

Multiuser collaborative work in virtual environment based CASE tool