role-play virtual worlds for teaching object-oriented design: the virplay development experience

19
SOFTWARE – PRACTICE AND EXPERIENCE Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience Guillermo Jimenez-Diaz , , Pedro A. Gonzalez-Calero and Mercedes Gomez-Albarran Dept. Ingenier´ ıa del Software e Inteligencia Artificial, Complutense University of Madrid, Spain SUMMARY The use of game technology for building virtual learning environments is intended to improve the motivation and engagement of the student, borrowing such properties from their entertaining counterparts. Nevertheless, wrapping pedagogical contents in a virtual environment is no simple achievement, and requires a rigorous process of designing and validating the metaphors and mechanics included in the virtual learning system. In this paper we describe such design process exemplified in the construction of consecutive versions of ViRPlay, a 3D role play virtual environment for teaching object-oriented design. We show how main mechanics were transferred from experiments in the real world and how such mechanics were evolved based on empirical evaluations. Copyright 2011 John Wiley & Sons, Ltd. Received 2 August 2010; Revised 24 January 2011; Accepted 29 January 2011 KEY WORDS: virtual learning environments; role-play; software usability; object-oriented design 1. INTRODUCTION Role-play is a kind of active learning where participants learn complex concepts—hard to under- stand by means of abstract explanations—while they simulate a scenario. In this scenario each participant plays a predefined role. Role-play has been used for software design tasks [1]. It has been also used in software design understanding to explore the pros and cons of a software design in a particular execution scenario. When applied to the object-oriented (OO) design field, each actor in the role-play session plays the role of an object. The participants enact how a software application works in a hypothetical but concrete situation of system usage, i.e. an execution scenario. During the role-play, participants interact with each other, learning from themselves, the other participants and the assigned roles [2]. The role of each participant in OO role-play activities is detailed using CRC Cards, a technique widely used in responsibility-driven design [1]. A CRC card represents a Class and it contains information about class responsibilities and collaborators. A responsibility is what a class knows and what it can do, i.e. the class properties and methods. A collaborator is a class that helps to carry out a responsibility. CRC cards provide valuable support for discussing and evaluating an OO design in a collaborative way. It is worth highlighting the existence of proposals about the use of role-play to teach OO basic aspects: what an object is and how it interacts with other objects in order to complete a responsibility. In [3] the authors propose the use of case studies—complete software applications Correspondence to: Guillermo Jimenez-Diaz, Dept. Ingenier´ ıa del Software e Inteligencia Artificial, Facultad de Inform´ atica, Universidad Complutense de Madrid, C/ Prof. Jos´ e Garc´ ıa Santesmases s/n, 28040 Madrid, Spain. E-mail: [email protected] Copyright 2011 John Wiley & Sons, Ltd. Softw. Pract. Exper. Published online 13 April 2011 in Wiley Online Library (wileyonlinelibrary.com). DOI: 10.1002/spe.1071 2012; :23542 253

Upload: guillermo-jimenez-diaz

Post on 06-Jul-2016

217 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

SOFTWARE – PRACTICE AND EXPERIENCE

Role-play virtual worlds for teaching object-oriented design: theViRPlay development experience

Guillermo Jimenez-Diaz∗,†, Pedro A. Gonzalez-Calero and Mercedes Gomez-Albarran

Dept. Ingenierıa del Software e Inteligencia Artificial, Complutense University of Madrid, Spain

SUMMARY

The use of game technology for building virtual learning environments is intended to improve themotivation and engagement of the student, borrowing such properties from their entertaining counterparts.Nevertheless, wrapping pedagogical contents in a virtual environment is no simple achievement, andrequires a rigorous process of designing and validating the metaphors and mechanics included in thevirtual learning system. In this paper we describe such design process exemplified in the constructionof consecutive versions of ViRPlay, a 3D role play virtual environment for teaching object-orienteddesign. We show how main mechanics were transferred from experiments in the real world and how suchmechanics were evolved based on empirical evaluations. Copyright q 2011 John Wiley & Sons, Ltd.

Received 2 August 2010; Revised 24 January 2011; Accepted 29 January 2011

KEY WORDS: virtual learning environments; role-play; software usability; object-oriented design

1. INTRODUCTION

Role-play is a kind of active learning where participants learn complex concepts—hard to under-stand by means of abstract explanations—while they simulate a scenario. In this scenario eachparticipant plays a predefined role. Role-play has been used for software design tasks [1]. It hasbeen also used in software design understanding to explore the pros and cons of a software designin a particular execution scenario.

When applied to the object-oriented (OO) design field, each actor in the role-play session playsthe role of an object. The participants enact how a software application works in a hypothetical butconcrete situation of system usage, i.e. an execution scenario. During the role-play, participantsinteract with each other, learning from themselves, the other participants and the assigned roles [2].The role of each participant in OO role-play activities is detailed using CRC Cards, a techniquewidely used in responsibility-driven design [1]. A CRC card represents a Class and it containsinformation about class responsibilities and collaborators. A responsibility is what a class knowsand what it can do, i.e. the class properties and methods. A collaborator is a class that helps tocarry out a responsibility. CRC cards provide valuable support for discussing and evaluating anOO design in a collaborative way.

It is worth highlighting the existence of proposals about the use of role-play to teach OObasic aspects: what an object is and how it interacts with other objects in order to complete aresponsibility. In [3] the authors propose the use of case studies—complete software applications

∗Correspondence to: Guillermo Jimenez-Diaz, Dept. Ingenierıa del Software e Inteligencia Artificial, Facultad deInformatica, Universidad Complutense de Madrid, C/ Prof. Jose Garcıa Santesmases s/n, 28040 Madrid, Spain.

†E-mail: [email protected]

Copyright q 2011 John Wiley & Sons, Ltd.

Softw. Pract. Exper.Published online 13 April 2011 in Wiley Online Library (wileyonlinelibrary.com). DOI: 10.1002/spe.1071

2012; :235–42 253

Page 2: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

that include information about their development and questions to engage students to analyze,judge and evaluate their design [4]—as the foundations of the different role-play sessions.

After studying the use of role-play in teaching OO basics we applied role-playing techniquesto teach more complex concepts: OO design patterns. We defined an innovative approach thatpromotes active learning and student participation during the analysis and comprehension ofalternative designs through role-play sessions: each student performs the role of an object within asoftware application case study in order to better understand the collaborations among the objectsby simulating the execution of a use case.

This approach was applied in two courses in Design Patterns in the Computer Science Schoolat the Complutense University of Madrid. We collected the students’ opinion about using role-play sessions in the classroom and estimated the pedagogical efficiency of our approach andthe importance of participating in the role-play sessions instead of observing them. An in-depthdescription of the pedagogical approach, the experiments and the detailed results are related in [5].In brief, the students judged the experience as very motivating and they preferred the role-play-based sessions rather than the lecture-based ones. Additionally, the analysis of the students’ gradesduring the courses revealed significant differences between the students who actively participatedin the role-play sessions and the ones who merely observed the simulation.

These promising results motivated us to transfer the role-play sessions into a Role-play VirtualEnvironment (RPVE), a virtual environment rich in design information where students mimic theinteractions produced in a role-play session in order to simulate an execution scenario from a casestudy. We have not found in the literature any tool for learning OO design following role-playactivities. Works such as [6–8] describe systems that mimic role-play activities to other fields,such as web-based application courses, writing stories and mathematics, respectively.

The transfer of the role-play activities into an RPVE has been conceived as a methodicaldevelopment process that does not only include design and implementation but also evaluationsthat verify the progress of the pedagogical tool. The development of pedagogical software requiresa thorough work. On the one hand, developers have to consider different design alternatives andthey have to evaluate them formatively with the educational final users: instructors and students. Onthe other hand, educators involved in the project have to evaluate summatively the final product interms of its effectiveness in the learning process, providing other instructors with enough evidenceto warrant the effort involved in using it. We agree with Navarro and van der Hoek [9, 10] thatthere is a widespread tendency to overlook these long evaluation processes.

The first prototype of the RPVE, ViRPlay3D (VIrtual Role-PLAY 3D), deployed a scriptedsingle-user mode. ViRPlay3D (Figure 1) defined our first attempt in providing a visual metaphorto the basic concepts defined in the OO paradigm, such as objects, classes and message passing.Furthermore, ViRPlay3D Sketched the central interaction mechanics in the RPVE. After finishingthe development of this prototype, ViRPlay3D was undergoing an evaluation process to assess thedefined mechanics and metaphors and the usefulness of the contained design information. Studentsand instructors participated in this evaluation, providing us with invaluable information that, onthe one hand, confirmed us that the main design decisions taken were in the right direction and,on the other hand, gave us ideas about new improvements to enhance the virtual environment.

ViRPlay3D evolved into ViRPlay3D2 (Figure 1) [11, 12] with the enhancement of the visualappearance and the interaction mechanics, the inclusion of a new free-mode in single-user runningand the definition of the multi-user running mode. As its predecessor, ViRPlay3D2 suffered aformative evaluation that was aimed to compile information feedback about the features enhancedwith respect to the previous version, the new features included some future extensions of theenvironment.

In the implementation of ViRPlay3D2 we have used an extensible architecture based on theones employed extensively in videogame development [13]. This architecture has allowed us toenhance easily the first prototype developed for a single-user to a multi-user application based ona client–server architecture.

Finally, ViRPlay3D2 has been used in a blended-learning approach that combines the traditionallectures with a set of activities performed in the virtual environment. The experience allowed us

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

236

Softw. Pract. Exper. 2012; :235–42 253

Page 3: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

Figure 1. Screenshots from the RPVE ViRPlay3D: (a) VirPlay3D and (b) VirPlay3D2.

to evaluate the RPVE from two different points of view. On the one hand, a formative evaluationprovides us with the subjective opinion of the instructors and students about the developed tool.On the other hand, a summative evaluation assesses the impact of introducing this novel tool as ahelp to learn the basic concepts in OO programming courses.

The remainder of the paper runs as follows. The next section reviews related work on learningenvironments for object-orientation in microworlds and virtual worlds. Section 3 gives a generaloverview of the interaction supported by ViRPlay3D2, while Section 4 details its mechanics alongwith the requirements that led us to choose such an interaction. Section 5 describes ViRPlay3D2software architecture, both in single- and multi-user versions. Section 6 presents the results fromformative and summative system evaluations. Finally, Section 7 concludes the paper.

2. RELATED WORK

OO programming paradigm requires the understanding of abstract concepts such as classes, objectsor message passing, among others. Visualization tools can help to understand better these abstractconcepts because they provide visual representations that are commonly easier to retain. A surveyabout the impact of the visualizations in the process of programming learning highlights thatinstructors think that the students are more motivated and they participate more actively whenvisualization tools are included in the learning sessions [14]. However, this survey also stressesthe limited pedagogical value of visualizations if the student is not engaged in them. For thesereason, the number of interactive visualization tools described in the literature has increased in thelast years.

Most of the interactive visualization tools for programming learning can be classified as peda-gogical Integrated Development Environments (pedagogical IDEs) or microworlds. The formersare IDEs specially developed for pedagogical purposes. These IDEs simplify the programmingand debugging tasks and they include visualization features about the behavior and changes inthe object state. The latters are environments populated with entities that can be programmed bythe student. Microworlds work as a sandbox where the student can watch the behavior and thechanges in these entities as a consequence of her programming task.

BlueJ [15] is one of the most common IDEs used in teaching OO programming. Java classesare visualized in BlueJ using simplified UML diagrams and it provides interactive creation andmanipulation of the objects. Jeliot3 [16] puts the emphasis in the visualization of message passingand changes in the object state in Java programs. jGrasp [17] is an editor with similar features toBlueJ or Jeliot, but it also provides support for the visualization of complex data structures, suchas linked lists or binary trees.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

237

Softw. Pract. Exper. 2012; :235–42 253

Page 4: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

One of the most popular microworlds was Karel the Robot [18]. In this microworld, the studentshave to program the behavior of a robot in order to collect different items in a grid world. In theprimitive version of this microworld students had to program the robot using Pascal. However,subsequent versions of Karel have been developed for OO languages such as C++ [19] or Java[20, 21]. Alice [22] is a 3D microworld with a big educational community that uses it. In Alice,the student is responsible for populating the world with her own 3D objects and programmingtheir behavior using a drag-and-drop interface. Later, the environment generates the animation thatrepresents the behavior programmed by the student. Greenfoot [23] is another microworld in 2D,similar to Alice, whose main feature is its integration with BlueJ, described before.

Some tools for learning programming state the importance of the collaborative work of thestudents. MUPPETS (Multi-user Programming Pedagogy for Enhancing Traditional Study) [24]is a microworld, similar to a massive multiplayer online game with an integrated IDE, where thestudents create and program objects in Java. The environment also provides support for sharing thecreated source code and communication tools. Other works support these collaborative tasks usingknown 3D social virtual environments like Second Life‡ . Esteves et al. [25] propose a frameworkfor the use of this virtual environment for teaching and learning in CS undergraduate courses.The students create and program objects inside Second Life using the Linden Scripting Language,provided by the virtual world. However, this work also stresses the problems encountered with theeditor and compilation errors.

The use and adaptation of multi-user virtual environments (MUVEs) like Second Life forlearning tasks have spread during the last years. In these worlds the students are actively engagedin the process of interpreting, analyzing, evaluating and solving problems. Moreover, the collabo-rative tasks and communication between students are supported by the environment. Furthermore,MUVEs can be adapted to implement learning strategies that focus on complex problems andtheir solutions, such as role playing or case studies [26]. The inclusion of these learning strategiesis commonly supported by the integration of Learning Management Systems (LMSs)—such asMoodle§—and MUVEs. The former provides student authentication, a controlled access to thelearning content and additional services like assessment tools or asynchronous communication,while the latter gives a 3D skin to the LMS and an attractive 3D world where the learning taskstake place.

SLOODLE (Simulation-linked OO Dynamic Learning) [27] is an initiative that brings a flexiblesupport for teaching and learning any kind of discipline in Second Life using Moodle. This workhas been extended in [28] providing support for tracking and recording the student interactionswith the virtual environment. The authors employ this extension in the Engineering EducationIsland, a world with interactive simulations for AC generators, DC motors or the execution cycleof CPU instructions, among others. In the domain of programming learning, NUCLEO system [29]is a framework that integrates Moodle and the Multiverse platform¶ for supporting problem-basedlearning activities. Although it has been employed for teaching languages like C++, this genericframework can be employed in other disciplines.

3. OVERVIEW OF VIRPLAY3D2

ViRPlay3D2 stands out in its originality, giving a novel visual metaphor for the fundamentalabstract concepts from the OO paradigm: classes, objects and message passing. A ViRPlay3D2scenario provides rich information about the classes and objects within an OO application. Thesescenarios can be played both in single-& and multi-user modes.

Using the single-user mode the user familiarizes and understands basic OO concepts, suchas message passing, objects and classes. In this mode, the user is not performing the role

‡Second Life information is available at http://secondlife.com/.§Moodle: http://moodle.org/.¶Multiverse: http://www.multiverse.net.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

238

Softw. Pract. Exper. 2012; :235–42 253

Page 5: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

of any object but she is an external avatar that observes and partially controls the role-playsimulation.

In multi-user mode, ViRPlay3D2 represents a virtual space where users discuss the interactionsamong objects needed to carry out a scenario execution. This running mode also supports collabo-rative design and reasoning about design decisions. Users are immersed in the environment insidean object avatar and they collaboratively complete the execution of a selected scenario. Inside theenvironment, each user is responsible for deciding the messages that her object should exchangewith other objects when it becomes the active object. This running mode incorporates communi-cation tools for discussing the message sequence and reaching agreements in controversial actions(i.e. modifying the design, or undoing or restarting the simulation). Additionally, multi-user modeincludes an instructor role, who can decide about the next execution step of any active object. Thisrole can be employed when there are not enough users to complete the scenario roles that shouldbe performed by human actors.

ViRPlay3D2 is not only used as an interactive visualization tool but also as a sandbox whereComputer Science students complete assignments about system understanding and design tasks.The actions performed by the students are saved into scripts that can be reproduced later by aninstructor in the own environment. In VirPlay3D2 we distinguish two ways to perform a scenario:

• Scripted-mode. A role-play script governs the scenario execution and all the simulationsteps are predefined. Users control the simulation progress deciding when to execute thenext simulation step, undoing the message passing or even restarting the simulation. Userengagement is enhanced allowing her to suggest the next step that should be performed. Ifthe message created is correct according to the scenario script, the corresponding step isperformed. Otherwise, the environment warns about the mistake and lets the user try againor request the automatic execution of the step.

• Free-mode. Users work in scenarios without a predefined script. This way, the users areresponsible for deciding which message passing comes next and when the simulation hasfinished. When employed in a single-user mode, the user acts as a coordinator who controls allthe message passing process. However, when used in conjunction with the multi-user mode,each user is only responsible for the message passing when the object that the user controlsbecomes the current active object. The user who plays the instructor role, if any, acts also asa coordinator, like in the single-user mode. The performed simulation is stored as a script,which can be executed later in ViRPlay3D2. The free-mode is a key element in the creationof scripted-mode scenarios, as we will see in Section 4.4.

4. VIRPLAY3D2 FEATURES

No matter the way the role-play is performed, ViRPlay3D2 shows a set of features and functionality.These requirements are classified into three main categories:

• Representation requirements or which elements that intervene in a role-play session requirea comprehensible metaphor within the RPVE.

• Information management or which kind of information extracted from the role-play sessionshas to be transferred to the RPVE and how to provide all this information without over-whelming the user.

• Interactions or which kind of actions and mechanics provides the RPVE in order to let theuser participate in the role-play sessions and feel that she leads the learning activity.

These features are described in the following sections. Additionally, Section 4.4 describes theauthoring tools deployed for creating scripted scenarios in ViRPlay3D2.

4.1. Representation requirements

One of the challenges during the development of ViRPlay3D2was how to provide an understandablevisual metaphor for the abstract concepts defined in the OO paradigm.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

239

Softw. Pract. Exper. 2012; :235–42 253

Page 6: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

Figure 2. Inventory system: (a) A class shows its CRC card and (b) An object displays its internal state.

The representation of objects and message passing is solved in an easy way, using the samemetaphors employed in the real world role-play sessions. First, the objects that intervene in therole-play session are represented by anthropomorphical 3D models. Objects that instantiate distinctclasses have different appearances. Second, the message passing is represented by throwing a ball.Additionally, the object who holds the ball in the RPVE represents the current active object in therole-play simulation.

The classes are represented as crates with a nameplate containing the class name. The objectsthat are instances of a class appear near the corresponding crate. Additionally, the visual aspect ofthe instances of a class appears on the top of the crates.

Actually, we detected two additional representation requirements. First, in single-user mode theuser needs an avatar to explore the virtual world. This avatar should be distinguishable from theobjects. In this version, the user avatar is only employed to interact with the rest of the elementswithin the RPVE and it does not perform any object role in the simulation. Second, we neededto distinguish a message passing concerning to invoking a method from that of returning from amethod invocation. To solve it, the former is represented by throwing the ball through the air tothe invokee, while the invokee rolls the ball toward the invoker when a method return is executed.

4.2. Information requirements

The environment manages information about the different elements in the scenario—classes, objectsand messages—and about the scenario itself.

We have used a classic metaphor employed in graphic adventures for representing and accessingthe information: the inventory. Each entity in the scenario simulation has an inventory that storesthe information about the real element that it represents. And the user interacts with the entitiesusing a ‘Look at’ action when looking up the information contained in its inventory.

Class inventories (Figure 2(a)) contain the associated CRC card, which shows the class respon-sibilities (left panel) and the class collaborators (right panel). By default, the lower panel showsthe textual description associated with the class. When a responsibility is selected, its textualdescription and the needed parameters appear in the lower panel.

An object inventory (Figure 2(b)) provides static and dynamic information about the corre-sponding object. The dynamic information represents the object state and consists of the objectattributes and their values and description. From the object inventory the user can access theinventory of the object’s class (static information of the object). We have also included a visualeffect and an informative message when an object changes its internal state.

The ball also has an inventory that contains information about the last message passed: docu-mentation about the invoked/returned method; the invoker; the invokee; the parameters and theiractual values during the message passing; and the returned value, if any. Additionally, every timea message passing is performed, the RPVE shows a text on the screen with the basic information

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

240

Softw. Pract. Exper. 2012; :235–42 253

Page 7: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

about that message. As we can see in Figure 1(b), the text oFigure, execute changeDisplayBoxusing aPoint, width and height means that the changeDisplayBox method is invoked in an objectcalled oFigure using as actual parameters the values aPoint, width and height.

Finally, the scenario inventory contains static information that can be accessed through thedesktop that appears in Figure 1(b): a textual description about the scenario execution and a classdiagram that shows the relations between the participants in the scenario. The scenario inventoryalso contains the simulation history, a textual log updated dynamically during the simulation. TheRPVE also provides keystroke shortcuts (hotkeys) to look up this history and the rest of informationcontained in the desktop.

4.3. Interactions and mechanics

ViRPlay3D2 provides users with an avatar to interact with the different entities in the environment.The user explores the environment controlling the avatar and looks up the entities’ inventoriesusing the ‘Look at’ action, mentioned above. ViRPlay3D2 can be easily configured to use one ofthe following ‘Look at’ action modes:

• Aiming at mode: The user has an aiming point (see the center of the Figure 1(b)) to aim atan entity and run the ‘Look at’ action in the distance. Then, the entity inventory appears onthe screen.

• Index mode: The user activates an index where all the entities that have an inventory appear.Once the user selects an entity, her avatar turns until it faces up the selected entity. Now theuser can automatically use the ‘Look at’ action to visualize the entity inventory.

Using the scripted mode the user also interacts with the RPVE controlling the role-play execution.The user controls the simulation progress deciding when to execute the next simulation step.Moreover, the user can undo the simulation and even restart it.

The user can also interact with the RPVE by means of the message passing mechanic. In thescripted mode, the user can participate as a coordinator suggesting the next simulation step. To dothat, the user employs the ‘Create Message’ tool (see Figure 3(a)) to configure the next message(in this case, the invokee object should be provided by the user) and requests the environmentto execute the message passing automatically. Then, the message is validated in order to confirmthat the message configured by the user is correct according to the stored scenario solution beforeexecuting it. Finally, the active object throws the ball to the invokee according to the configuredmessage. After any message passing, the simulation history is updated with the message details.

The ‘Create Message’ tool is also employed in the multi-user mode, when the user’s avatarbecomes the active object and she is responsible for passing the next message. In this mode,message passing is divided into three stages:

(1) Creating the message. The active object activates the ‘Create Message’ tool and the user fillsin the actual parameters and the return value (if any). The invoker is automatically fixed andthe invokee is selected among the active object collaborators.

(2) Throwing the ball. When the message creation finishes, the user throws the ball in thedirection that the avatar is aiming.

(3) Catching the ball. Only the message receiver (the invokee object) can catch the thrown ballby walking over it. After catching the ball, the receiver becomes the new active object.

In order to promote user collaboration in the multi-user mode, ViRPlay3D2 provides a ‘Commu-nication’ tool (see Figure 3(b)). This tool is a chat-like interface where a user can broadcastmessages to the other users. Each message is identified by the role performed by the user.

In the multi-user mode, some actions could cause some tricky situations when they are executedwithout a consensus. For example, undoing a simulation step should be done collaboratively, takinginto account the opinion of all participants. For this reason, we have added a consensus tool inViRPlay3D2. Every time a user tries to perform a controversial action—undoing a message passing,restarting the scenario or finishing it—the consensus tool is displayed for all users, informing aboutthe user and the controversial action that wants to perform. Then, they have a few seconds to vote

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

241

Softw. Pract. Exper. 2012; :235–42 253

Page 8: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

Figure 3. Two of the main interaction mechanics in VirPlay3D2: (a) The ‘CreateMessage’ tool and (b) The ‘Communication’ tool.

if they allow or forbid its execution. After the countdown the action is done immediately if it isaccepted by most of the participants. Anyway, an action can be unilaterally performed to avoiddeadlocks due to network problems or hesitant users.

All the communications and voting results obtained from the consensus tool are logged forassessing tasks. This way, an instructor who evaluates the final result of a simulation can checkwhether the actions were performed in a collaborative way or if a user worked independently fromthe rest of participants.

4.4. Authoring tools

Supporting authoring tasks is an essential challenge in educational software like ViRPlay3D2. So,it is mandatory to provide tools that ease the task of creating all the information managed by thevirtual environment while simulating a scenario. The design information is created by means ofthe ‘CRC card Editor’, a light and easy to use visual editor implemented in Java to generate CRCcards. With the editor, an instructor can create empty CRC cards, add responsibilities and linkCRC cards among them in order to define class collaborators. The final result is exported to aformat that can be shared by different ViRPlay3D2 scenarios.

The ‘CRC card editor’ tool includes a feature for parsing Javadoc-like comments and creatingthe corresponding CRC cards. This feature lets profit from the existence of case studies, whichare broadly used by the OO programming teaching community. Some well-known examples arethe Marine Biology Simulator or the Grid World, widely employed in the Advanced PlacementComputer Science courses‖ . These case-studies include well-commented application source code.Using the parsing feature of our ‘CRC Card Editor’ tool the instructor only has to refine theinformation extracted from the source code to generate the initial class design of a new scenario.

Previous versions of ViRPlay3D2 included a scenario map editor, based on a simple gamelevel editor, and a role-play diagram∗∗ editor to create the rest of information needed to generatea simulation scenario. Nowadays, these tools have been replaced by the authoring mode, an in-game facility for easily obtaining the initial scenario configuration and the scripted solution. Theauthoring mode avoids to learn how to use additional external tools, alleviating the authoring workfor instructors. The authoring mode employs the tracing saving features of the environment togenerate the new scenarios.

In this mode, the user loads a set of classes—whose CRC cards are previously developed usingthe ‘CRC Card Editor’—and starts a scenario where classes are the only elements that appear.The user interacts with these classes in order to create new instances. These objects are configured

‖Advanced Placement Computer Science: http://apcentral.collegeboard.com.∗∗A role-play diagram is a semiformal representation of a scenario execution that captures the changes on the objects’state [30].

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

242

Softw. Pract. Exper. 2012; :235–42 253

Page 9: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

giving them a name and fixing their initial state. Additionally, the user decides the sequence ofexchanged messages and uses the ‘Create Message’ tool to simulate the execution of this messagesequence. Finally, the user provides a name for the scenario, a textual description and the list ofroles that can be selected by users. The execution trace and the object states are saved, making upa scenario that can be simulated later in ViRPlay3D2.

5. SYSTEM ARCHITECTURE

ViRPlay3D2 has been developed following the game architecture described in [13]. We chose thisarchitecture due to their main features: (1) its flexibility, because the role-play environment logiccan be isolated from the render engine and (2) the easy way of transforming the single user environ-ment into a networked multiplayer environment. Our environment presents three main subsystems:the RPVE logic, the Application and the GUI (see Figure 4), described in the following subsec-tions. The adaptation of this architecture to a multiuser networked one is detailed in Section 5.4.We provide additional implementation details in Section 5.5.

5.1. RPVE logic subsystem

The RPVE logic subsystem manages the role-play virtual environment rules. It is divided intotwo main modules: one typically employed in game development, the World module, and onededicated to the specific tasks in our environment, the Role-play Manager. An additional module,the Simulator, coordinates the two main modules. World module is responsible for containing theworld entities and controlling the avatars’ movements in the virtual world. It also provides theavatar perception system for managing the interactions among the avatars and the entities thatpopulate the virtual world (classes, the ball, etc.).

The Simulator is the entrance point to the RPVE logic subsystem and it defines the commandcommunication protocol. Every subsystem that needs to communicate with the logic subsystemshould push a command in the simulator command queue. On each updating request, the Simulatorcomponent checks the command queue and distributes the command to the proper module. Wehave different command types:

• Movement commands (forward, backward, left and right turns) and ‘Look at’ action command(for displaying the inventory) are transferred to the World module.

Figure 4. ViRPlay3D2 architecture.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

243

Softw. Pract. Exper. 2012; :235–42 253

Page 10: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

• Role-play control commands (next step, undo or restart), create message commands (messageconfiguration and execution) and object state change commands are transmitted to the Role-play Manager module.

• Chat commands (chat activation and message sending) and consensus tool commands (forvoting) are interpreted and executed in the Simulator module by the discussion tools.

The Role-play Manager contains a repository that organizes the design information accessiblein the environment: CRC cards, object states and scenario description. The data contained inthe repository are employed to fill in the inventories with the corresponding design informationaccording to the entity type (a class, an object, the scenario or the ball).

The Role-play Manager is also responsible for controlling the role-play simulation. First, it loadsthe execution script of the role-play simulation in the Script Manager, if provided. Next, when theuser requests for the next simulation step, it updates the ball inventory with the message passed andperforms the next simulation step. If the user provides the next role-play step manually the Role-play Manager validates the next message passing in accordance with the scripted scenario solutionand performs the step when the message is correctly created. Moreover, the object state changesperformed by the script or manually by the users are also stored and linked to the simulationstep that caused the change. Execution step data is transferred to the Script Manager in orderto update the simulation history. When the scenario simulation concludes, the Script Managerprocesses the simulation history and saves an XML script file with the simulation trace. It is worthnoting that a message passing is an atomic action with a complex choreography in terms of thevirtual environment. When a message is going to be executed automatically or the user providesthe next step, the Role-play Manager coordinates the invoker and invokee avatars and the ballthrough the World module. The Role-play Manager requests the avatars to turn until they standface to face; then the invoker has to say the message that is going to send; later, it launches theball to the invokee avatar; finally, when the ball reaches the invokee avatar, this one has to catchit and finishes the message passing. Therefore, a manual message-passing execution requires theRole-play Manager to wait until the invoker launches the ball and the invokee catches it beforeupdating message passing information.

The RPVE logic subsystem is isolated from the other subsystems due to the way that theyexchange messages. The input entrance is the Simulator module, as we described before. Afterchecking the command queue and performing the corresponding actions according to the inputcommands, the world entities are updated. Every interesting change in the simulation state or inthe entities is propagated to an observer pool using events. Any module in the Application andGUI components that wants to be informed about concrete changes in the logic should registerwith the proper observer. We have defined a set of observer classes depending on the type ofinformation that they propagate:

• Entity and avatar observers inform about the changes in the rotation, position and visibilityof the world entities.

• Inventory observer informs about the requests for displaying the inventory and the changesin the information shown in the inventory.

• World observers inform at the start and at the end of the simulation about entity creationand destruction, the changes in the avatar perception (what the avatar can ‘look at’) and theenvironment messages.

• Simulator observers propagate consensus requests and the messages sent by the ‘Communi-cation’ tool.

• Role-play manager observers inform about the start and the end of a message passing, thechanges in object states and when the simulation concludes.

5.2. GUI subsystem

The GUI subsystem is responsible for rendering on demand the 3D entities in the scenegraph usinga concrete render engine. The 3D Manager stores the visual entities and maps them with its properentity in the RPVE logic subsystem. Every visual entity listens to the events propagated by its

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

244

Softw. Pract. Exper. 2012; :235–42 253

Page 11: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

corresponding logical entity in order to update properly the scene in the virtual world accordingto the changes in the simulation.

This subsystem also handles the 2D HUD (head-up display) and the events performed when theuser interacts with it. According to these interactions, the HUD module enqueues the events in aHUD event queue that will be processed by the Application subsystem.

5.3. Application subsystem

The Application subsystem is responsible for initializing and finishing the simulation environment.It contains the main loop that updates both logic entities and rendering engine. The applicationworks using a hierarchical state machine that controls the different simulation states (differentconfiguration menus, the simulation itself, showing an inventory, working with a tool). Eachapplication state decides if the logic subsystem is updated and if the scenegraph is rendered. Italso deals with the input events from keyboard, mouse or any other input devices. Additionally, anapplication state is responsible for showing the appropriate HUD and managing the events comingfrom the user interaction with the HUD. State transitions are performed in response to the userinput or logic subsystem events (i.e. showing an inventory or finishing a scenario simulation). Forthis reason, some states are registered as observers from the RPVE logic subsystem.

The Application subsystem contains modules for all the hardware-dependent functionalities. Itprovides modules for collecting different input device events, file systems, time servers or networkmodules. Most of them are implemented in the game engine, described in the Implementationsection.

5.4. Multiuser networked architecture

After completing a single-user version of ViRPlay3D2, we extended the system in order to providethe multi-user features. The multi-user mode has been deployed following a client–server approach.A user configures a ViRPlay3D2 instance in server mode and selects the scenario that will beperformed. Then the server waits for the client connections. The role-play participants run aViRPlay3D2 instance in remote client mode and connect to the server machine.

As stated before, the selected game architecture provides an easy way to extend the virtualenvironment with the multi-user capabilities, modifying the initial architecture as it appears inFigure 5. We have to add two additional proxy modules in charge of serializing commands and

Figure 5. ViRPlay3D2 architecture.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

245

Softw. Pract. Exper. 2012; :235–42 253

Page 12: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

events from the RPVE logic, sending them across the network and deserializing and propagatingto the corresponding modules. These proxies differ depending on the side (client or server) thatthey appear. The virtual environment is configured in a different manner depending on the runningmode:

• The server mode includes the RPVELogic Proxy. It listens to a port and receives the clientcommands across the network. Commands are validated and the proxy pushes them in theSimulator command queue. This proxy also implements all the observer interfaces providedby the RPVE logic subsystem to handle the simulation events. These events are packaged upand sent to the clients. Additionally, the server side can include a local Application and GUIsubsystems that work as a local client.

• The remote client mode is quite similar to the basic architecture but it differs in the waythat the RPVE logic subsystem works. In the remote client mode this subsystem is a copyof the server simulation state and it works as a puppet subsystem controlled by the AppGUIProxy. The commands inserted in the Puppet Logic subsystem are directly transferred to theAppGUI Proxy. This module serializes the commands and sends them to the server across thenetwork. The proxy listens to a port in order to receive the packages sent by the server proxy.It deserializes the simulation events and updates the puppet logic subsystem according tothe events received. This subsystem will propagate the corresponding events to the GUI andApplication subsystems using the observer interface described in the single-user architecture.

5.5. Implementation details

The development of ViRPlay3D2 started in 2007 and it is fully implemented in C++ and Tcl as thescripting language. The system works in simple Windows desktop machines with DirectX-capablegraphic cards.

The Application and GUI subsystems use Nebula 2 [31] for 2D and 3D rendering and input devicemanagement. Nebula 2 is an open-source 3D game and visualization engine developed by RadonLabs and employed in the development of several commercial games. It works as an abstractionlayer over DirectX that eases the rendering process and the collection of device events using DirectInput. Nebula 2 also provides some facilities to create and manage 2D interfaces. This abstraction isprovided using servers, individual objects with a unique name. Nebula 2 implements servers for 2Dand 3D graphics, input devices, file system, audio, scripting, networking, multithreading and time.

Nebula 2 supports scripting interfaces in Tcl, Python or Lua. The use of the Tcl scriptinginterface for creating the HUD has provided a flexible way to develop the tools and inventoryinterfaces. The main functionality was implemented in the RPVE logic subsystem in C++, while thefinal tool appearance was created in Tcl. The corresponding application state works as a translatorbetween the scripting functions in Tcl and the commands and simulation events from the RPVELogic subsystem.

Nebula 2 includes plug-ins to export Maya and 3DS Max format to its own model formats,which help us to create and enhance the visual aspect of the virtual environment. Additionally,we have employed GAMA [32], a Maya plug-in for automatic animated character generation, inorder to fast and easily develop the different avatar looks.

Although Nebula 2 supplies basic network capabilities, we preferred to develop our own networkserver using Enet library [33]. It provides a light and simple but robust network communicationlayer over UDP that mixes the best features from TCP and UDP protocols. To use it, we haveenhanced our RPVE logic classes with serializing and deserializing features in order to transfertheir state between server and clients using the networking server.

6. EVALUATIONS

The development of ViRPlay3D2 has followed a user-driven approach. After its implementation,users evaluated the tool. First, the final users assessed the usability and the metaphors in the RPVE(Section 6.1). Later, ViRPlay3D2 has been employed in several courses and we have assessed the

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

246

Softw. Pract. Exper. 2012; :235–42 253

Page 13: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

impact of its use on the students (Section 6.2). Students and instructors involved in the evaluationare from the Computer Science School at the Complutense University of Madrid.

6.1. Formative evaluation

After the development of ViRPlay3D, our first prototype, 20 students and 12 instructors participatedin a survey to assess the initial set of requirements of our RPVE. The results of this survey wereemployed to refine the RPVE requirements for evolving from ViRPlay3D into ViRPlay3D2.

ViRPlay3D2 final users, students and instructors, completed an online survey to evaluate theacceptance of this novel role-play environment and to compile information feedback about the toolitself. More concretely, the main goals of this survey were:

• To estimate the usefulness of the RPVE perceived by the final users.• To assess the clarity of the metaphors for OO concepts and the mechanics defined to transferthe role-play sessions into the virtual environment.

• To evaluate the usefulness of the design information contained in the environment.

Fifty-nine students and 12 instructors participated in the ViRPlay3D2 evaluation. Participantswere introduced in a guided role-play session with ViRPlay3D2. After that, we provided themwith another role-play scenario and the participants interacted with the environment without anyguidance. Finally, we encouraged the participants to fill in an online survey, with general questionsabout the environment, the clarity of the employed metaphors, the information contained in theRPVE, and the usefulness of the interactions and mechanics in the RPVE. The questions in thesurvey asked the participants to rate different ViRPlay3D2 features with answers on a five-pointLikert Scale. Finally, participants could provide free-text comments that helped us to understandtheir ratings.

As Figure 6 shows, the overall acceptance of the environment was extremely good. Participantsconsidered that the environment is easy to use and they enjoyed the experience of using it. Ingeneral, they had no trouble to find the information that they needed to understand the simulationand they felt an active part of the role-play session. They thought that the environment is moreuseful for understanding object interactions than design. Most of them would like to use this kindof tools in OO courses.

Participants considered that the metaphors employed in ViRPlay3D2 are not confusing (seeFigure 7). In general, the instructors provided higher ratings to the metaphors than the students.They highlighted the class metaphor and throwing the ball to represent the message passing as themost valuable ones. The ‘avatar holding the ball’—for representing the current active object—andthe ‘message passing’ were the most straightforward metaphors for the students. The weakest

Figure 6. Cumulative frequencies of the ratings about the general acceptance of ViRPlay3D2 (students onthe left, instructors on the right).

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

247

Softw. Pract. Exper. 2012; :235–42 253

Page 14: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

Figure 7. Cumulative frequencies of the ratings about the metaphors employed of ViRPlay3D2 (studentson the left, instructors on the right).

Figure 8. Cumulative frequencies of the ratings about the usefulness of the information contained in arole-play scenario in ViRPlay3D2 (students on the left, instructors on the right).

metaphor for both students and instructors was the one employed for the scenario informationcontainer, i.e. the desktop—although near 60% of students and more than 75% of instructors ratedit with a 4 or 5. Further comments revealed that the desktop metaphor had lower ratings due tothe fact that the students could use a keyboard shortcut to access the scenario inventory.

Most of the information contained in the RPVE was considered as useful for both studentsand instructors (see Figure 8). It is worth noting that students and instructors agreed with the lessuseful information in ViRPlay3D2: the scenario map contained in the desktop. They consideredthat the scenarios were simple enough and the ‘index mode’ alleviates the problem of finding theobjects and classes in the scenario. Additionally, the information contained in the ball was alsoone of the less useful information. They commented that the message displayed on the screen wasenough.

Finally, Figure 9 shows the results about the usefulness of the interactions. Surprisingly, studentswere more critic with the mechanics for accessing information—aiming at the entities and theindex mode were rated with 3 or more points by only 50% of the students. Later comments helpedus to realize that students preferred a faster access to inventories, but it seems that the index modeis not fast enough for them. However, instructors thought that the index mode is less interestingthan the aiming at mode, where students have to move their avatar searching for an entity in order

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

248

Softw. Pract. Exper. 2012; :235–42 253

Page 15: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

Figure 9. Cumulative frequencies of the ratings about the usefulness of the interaction mechanics providedby ViRPlay3D2 (students on the left, instructors on the right).

to access its inventory. Instructors considered that this kind of interaction gets the students involvedin the learning task. Additionally, it is worth noting that the communication tool received a lowerrating by the students as we expected. We believe that they did not consider it useful becauseduring the evaluation all the students were in the same room.

6.2. Summative evaluation

In addition to the subjective opinion of the instructors and students about ViRPlay3D2, wedecided to determine the impact of the use of the RPVE in the classroom. To do that, weconducted a study where we compared the scores obtained by the students in different testsrelated with two different role-play scenarios. With this study we tried to answer two researchquestions:

• Do the students who use the RPVE obtain higher scores in tests than the students who do notuse the RPVE?

• What is the influence of playing videogames in the test scores of the students who use theRPVE?

The study has been performed with students from several courses in OO Programming during2008–09 and 2009–10 academic courses. The course schedule includes two 3-h sessions in theuse of role-play in OO programming. During the first session (Session 1) students attended a brieflecture about the first case study employed in the classroom. Later, the students were randomlydistributed into two groups: a control group (CG) and an experimental group (EG). The CG workedon several role-play sessions without the RPVE. We provided the CG students with a paper versionof the CRC cards and the instructor was responsible for completing on a blackboard the diagramthat represents the message passing in the scenarios. The EG employed ViRPlay3D2 to completethe same role-play scenarios. Both groups completed two scenarios with the help of the instructorin Session 1. The EG worked with scripted scenarios so the students could follow the role-playsessions using the RPVE. Later, students should complete by themselves a new role-play scenario.CG students sketched a pen-and-paper sequence diagram that describes the message passing amongobjects to complete the scenario. The EG should complete the same scenario using the ‘CreateMessage’ tool in ViRPlay3D2. Later, CG and EG students completed an online test with questionsabout the simulated scenarios.

During the next 3-h session (Session 2), all the students worked with ViRPlay3D2. This timethey worked with a new case study. Once again, two scenarios were completed with the help ofthe instructor and the students performed the last one by themselves. Finally, students completedanother online test about the simulated scenarios.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

249

Softw. Pract. Exper. 2012; :235–42 253

Page 16: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

Table I. Breakdown of groups and videogame habits.

Casual player Frequent player Total

CG 12 14 26EG 12 19 31

Table II. Comparison of average grades between CG and EG.

Session 1 Session 2

Casual Regular Casual Regular

CG 80±11 83±1477±13 83±9 79±16 86±11

EG 76±19 85±1372±20 78±18 86±15 85±12

ViRPlay3D2 has been tested with 59 students from second year in Computer Science at CESFelipe II and Complutense University of Madrid. In general, most of the students knew the basicconcepts in OO programming although their knowledge in OO design was low. Most of themknew the basics about role-play but none of them have participated previously in a role-playsession in classroom. Additionally, we asked students about their preferences and habits in playingvideogames. Approximately half the group regularly plays videogames, meanwhile the other halfdoes not have special interest on them. Table I shows the student distribution in the differentgroups.

The comparison of the test scores after Session 1 and 2 reveals promising results. Table IIshows the test score distribution for each student group. The mean and standard deviation (mean±std.deviation) of the test scores—in a 100 point scale—are our descriptive statistics of the testscores. The results in Session 1 suggest a better performance of the CG, although the difference isnot statistically significant (Mann–WhitneyU = 374.5 p>0.1). However, we can see that the scoresafter Session 2 reflect a significant increase of the student grades within the EG (Mann–WhitneyU = 299 p<0.1). We suppose that the use of an RPVE imposes a small learning curve. Nevertheless,as the scores of the CG after Session 2 suggest, the adaptation to the new environment do notimpose a high detriment in the learning process: the students in CG improve their grades evenwhen they start to use ViRPlay3D2.

After Session 2, average scores of EG students are slightly higher than the average scores of CGstudents but they do not defer significantly (Mann–Whitney U = 366 p>0.1). Although this resultsuggests a success according to our first research question, the hypothesis should be corroboratedwith further studies.

In order to address the second research question, we analyzed the score distribution accordingto the student habits in playing videogames. The test scores of the students who do not use theRPVE have been excluded from this analysis (in italics in Table II). Test score averages in Casualand Regular columns in Table II suggest that, initially, the students with a regular player profileadapt faster to the use of the RPVE than the students considered as casual players. However, thedifferences in these scores are not statistically significant (Mann–Whitney U =302.5 p>0.1). Theaverage scores of the regular players of the EG in Session 1 and CG in Session 2 is 6 points higherthan the casual players in the same groups. We suppose that the casual players need more time toget used to the environment.

However, the higher increment of the average scores of the casual players in the EG group(their average score has grown in more than 14 points—from 72 to 86) compared to the averagescore of the regular players makes that kind of players achieve average scores that do not defersignificantly (Mann–WhitneyU =330.5 p>0.1) after Session 2. An hypothetical Session 3 shouldconfirm this trend if the average scores of the casual players in CG would reach the average scores

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

250

Softw. Pract. Exper. 2012; :235–42 253

Page 17: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

of the other groups. The main conclusion of this analysis suggests that the casual players need asmall adaptation to the RPVE but they overcome the initial difficulties very fast.

7. CONCLUSIONS

This paper has related the development of a novel type of environments for learning OOprogramming: role-play virtual environments. The development has followed a methodicalprocess to transfer to a 3D virtual environment the techniques that we have successfullyemployed in traditional role-play sessions in the classrooms. First, we have created a metaphorfor every basic element included in a role-play session. Additionally, we have includedall the information needed to perform the role-play scenario, making sure that the usershave the control on the access to this information. Finally, we have promoted user engage-ment providing them with interactive mechanics for controlling and completing the role-playsessions.

The development of this RPVE has also engaged the final users, instructors and students, in theevaluation of an early prototype. The information provided by the users have been employed inthe refinement of the interactions and metaphors presented in the environment. The final result isViRPlay3D2 (http://gaia.fdi.ucm.es/projects/virplay/), a role-play virtual environment for visual-izing and playing the interactions among objects that had occurred during the execution of an OOapplication. ViRPlay3D2 design is based on an extensible architecture highly used in videogamedevelopment.

ViRPlay3D2 has suffered two types of evaluations. The first one—the formative evaluation—has corroborated the good acceptance of the virtual environment for students and instructors. Theglobal opinion is that the tool is easy to use, enjoyable and the users would have the intention ofusing it in other courses. The refined metaphors employed in ViRPlay3D2 are understandable forthe final users and the mechanics included are useful in order to interact with the environment.The information provided by the environment is appropriate for understanding the scenarios underconsideration.

Due to its pedagogical nature, ViRPlay3D2 has also suffered a summative evaluation. We haveemployed it in introductory courses of OO programming and we have measured its impact onthe learners. ViRPlay3D2 has shown a smooth learning curve: the students who employed thetool obtained slightly lower scores than the students who participated in the traditional role-playduring the first session. However, the differences disappeared after the next session. Additionally,although the students with regular habits in playing games exhibited better results at first, theaverage scores tend to be similar after the following session. The novelty of the tool imposesan initial handicap for the students. Nevertheless, the high motivation exhibited by the studentsduring the use of ViRPlay3D2 in classrooms encourages us to continue employing it in futureOO courses. From the instructor’s point of view, although the creation of the virtual role-playscenarios imposes a little work overload, the use of this kind of virtual environments opensup the possibility of subsequent reruns of the role-play sessions by the students working ontheir own.

ACKNOWLEDGEMENTS

This work is supported by the Spanish Committee of Education and Science project under grant TIN2009-13692-C03-03. We also thank all the instructors and students involved in the evaluations.

REFERENCES

1. Beck K, Cunningham W. A laboratory for teaching object-oriented thinking.Conference on Object OrientedProgramming Systems Languages and Applications (OOPSLA 1989). ACM Press: New Orleans, LA, U.S.A,1989; 1–6.

2. Bergin J, Eckstein J, Wallingford E, Manns ML. Patterns for gaining different perspectives. The 8th Conferenceon Pattern Languages of Programs (PLoP 2001), Monticello, IL, U.S.A., 2001.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

251

Softw. Pract. Exper. 2012; :235–42 253

Page 18: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

G. JIMENEZ-DIAZ, P. A. GONZALEZ-CALERO AND M. GOMEZ-ALBARRAN

3. Andrianoff SK, Levine DB. Role playing in an object-oriented world. The 33rd SIGCSE Technical Symposiumon Computer Science Education (SIGCSE 2002). ACM Press: Cincinnati, KY, 2002; 121–125.

4. Clancy MJ, Linn MC. Patterns and pedagogy. The 30th SIGCSE Technical Symposium on Computer ScienceEducation (SIGCSE 1999). ACM Press: New Orleans, LA, U.S.A., 1999; 37–42.

5. Jimenez-Dıaz G, Gomez-Albarran M, Gonzalez-Calero PA. Teaching GoF design patterns through refactoringand role-play. International Journal of Engineering Education 2008; 24(4): 717–728.

6. Depradine C. A role-playing virtual world for web-based application courses. Computers and Education 2007;49:1081–1096.

7. Robertson J, Good J. Using a collaborative virtual role-play environment to foster characterisation in stories.Journal of Interactive Learning Research 2003; 14(1): 5–29.

8. Lonnroth L, Cronqvist B. Jirafa learning world–massively multiplayer online role-playing game for primaryschool math education. Proceedings of the 3rd European Conference on Games Based Learning, Grasz, 2009;242–247.

9. Navarro EO, van der Hoek A. Comprehensive evaluation of an educational software engineering simulationenvironment. The 20th Conference on Software Engineering Education and Training (CSEE&T 2007), Dublin,Ireland, 3–5 July 2007. IEEE Computer Society: Silver Spring, MD, 2007; 195–202.

10. Navarro EO, van der Hoek A. Multi-site evaluation of simse. Proceedings of the 40th SIGCSE Technical Symposiumon Computer Science Education, SIGCSE 2009, Chattanooga, TN, U.S.A., 4–7 March 2009, Fitzgerald S,Guzdial M, Lewandowski G, Wolfman SA (eds.). ACM: New York, 2009; 326–330.

11. Jimenez-Dıaz G, Gomez-Albarran M, Gonzalez-Calero PA. Pass the ball: Game-based learning of software design.The 6th International Conference on Entertainment Computing (Lecture Notes in Computer Science, vol. 4740).Springer: Berlin, 2007; 49–54.

12. Jimenez-Dıaz G, Gomez-Albarran M, Gonzalez-Calero PA. Role-play virtual environments: Recreational learningof software design. Times of Convergence. Technologies Across Learning Contexts, Third European Conference onTechnology Enhanced Learning, EC-TEL 2008, Maastricht, The Netherlands, September 16–19, 2008. Proceedings(Lecture Note in Computer Science, vol. 5192), Dillenbourg P, Specht M (eds). Springer: Berlin, 2008; 27–32.

13. McShaffry M. Game Coding Complete (3rd edn). Charles River Media, Boston, MA, U.S.A., 2009.14. Naps TL, Roßling G, Almstrum V, Dann W, Fleischer R, Hundhausen C, Korhonen A, Malmi L, McNally

M, Rodger S, Velazquez-Iturbide JA. Exploring the role of visualization and engagement in computer scienceeducation. Working Group Reports from ITiCSE on Innovation and Technology in Computer Science Education(ITiCSE 2002), Caspersen ME, Joyce D, Goelman D, Utting I (eds.). ACM Press: Århus, Denmark, 2002;131–152.

15. Kolling M, Rosenberg J. The BlueJ system and its pedagogy. Journal of Computer Science Education, Specialissue on Learning and Teaching Object Technology 2003; 13(4):249–268.

16. Moreno A, Myller N, Sutinen E, Ben-Ari M. Visualizing Programs with Jeliot 3. Working Conference onAdvanced Visual Interfaces (AVI 2004). ACM Press: Gallipoli, Italy, 2004; 373–376.

17. Cross II JH, Hendrix TD, Jain J, Barowski LA. Dynamic object viewers for data structures. Proceedings ofthe 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE 2007). ACM: Covington, KY,U.S.A., 2007; 4–8.

18. Pattis RE. Karel the Robot: A Gentle Introduction to the Art of Programming. Wiley: New York, 1995.19. Bergin J, Stehlik M, Roberts J, Pattis R. Karel++. A Gentle Introduction to the Art of Object-oriented Programming.

Wiley: New York, 1997.20. Bergin J, Stehlik M, Roberts J, Pattis R. Karel J. Robot. A Gentle Introduction to the Art of Object-oriented

Programming in Java. Dream Songs Press, 2005.21. Becker BW. Java: Learning to Program with Robots. Thomson Course Technology, 2006.22. Dann W, Cooper S, Pausch R. Learning to Program with Alice. Prentice-Hall: Harlow, England, 2005.23. Kolling M, Henriksen P. Game programming in introductory courses with direct state manipulation. The 10th

Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE 2005). ACM Press:Caparica, Portugal, 2005; 59–63.

24. Bierre KJ, Phelps AM. The use of muppets in an introductory java programming course. CITC5 ’04: Proceedingsof the 5th Conference on Information Technology Education. ACM: New York, NY, U.S.A., 2004; 122–127.Available at: http://doi.acm.org/10.1145/1029533.1029564 [27 March 2011].

25. Esteves M, Antunes R, Fonseca B, Morgado L, Martins P. Using second life in programming’s communities ofpractice. Groupware: Design, Implementation, and Use, 14th International Workshop, CRIWG 2008, Omaha, NE,

USA, September 14–18, 2008, Revised Selected Papers (Lecture Notes in Computer Science, vol. 5411), Briggs RO,Antunes P, de Vreede GJ, Read A (eds.). Springer: Berlin, 2008; 99–106.

26. Kluge S, Riley L. Teaching in virtual worlds: Opportunities and challenges. The Journal of Issues in InformingScience and Information Technology 2008; 5(1):127–135.

27. Livingstone D, Kemp J, Edgar E. From multi-user virtual environment to 3D virtual learning environment. ALT-J:Research in Learning Technology 2008; 16(3):139–150. Available at: http://www.informaworld.com/10.1080/09687760802526707 [27 March 2011].

28. Callaghan M, McCusker K, Losada J, Harkin JG, Wilson S. Engineering education island: Teaching engineeringin virtual worlds. ITALICS (Innovation in Teaching And Learning in Information and Computer Sciences) 2009;8(3):1–18.

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

252

Softw. Pract. Exper. 2012; :235–42 253

Page 19: Role-play virtual worlds for teaching object-oriented design: the ViRPlay development experience

ROLE PLAY VIRTUAL WORLDS FOR TEACHING OBJECT-ORIENTED DESIGN

29. Sancho-Thomas P, Fuentes-Fernandez R, Fernandez-Manjon B. Learning teamwork skills in universityprogramming courses. Computers and Education 2009; 53(2): 517–531.

30. Borstler J. Improving CRC-card role-play with role-play diagrams. The 20th Annual ACM SIGPLAN Conferenceon Object-oriented Programming, Systems, Languages, and Applications (OOPSLA 2005). ACM Press: SanDiego, CA, U.S.A., 2005; 356–364.

31. Nebula 2. Available at: http://www.radonlabs.de/technologynebula2.html [31 May 2010].32. Gama (automatic animated character generation). Available at: http://gaia.fdi.ucm.es/models/gama.html [31 May

2010].33. Enet library. Available at: http://enet.bespin.org/ [31 May 2010].

Copyright q 2011 John Wiley & Sons, Ltd.DOI: 10.1002/spe

253

Softw. Pract. Exper. 2012; :235–42 253