View
212
Download
0
Category
Preview:
Citation preview
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: iqplin@ntu.edu.sg (Q. Lin).
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267256
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 257
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
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267258
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 259
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267260
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 261
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267262
Fig. 11. The procedure of updating operation.
Fig. 12. The procedure of deleting operation.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 263
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267264
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 265
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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267266
[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.
Q. Lin et al. / Information and Software Technology 45 (2003) 253–267 267
Recommended