Learning to think and practice computationally via a 3D

simulation game

Nikolaos Pellas and Spyridon Vosinakis University of the Aegean, Greece

{npellas, spyrosv}@aegean.gr

Abstract—Various studies have presented controversial results about the way

that young students tried to cultivate and practice their computational thinking

(CT) skills with Computer science concepts through the game making programming. However, there is still limited evidence addressing how the

gameplay of a simulation game (SG) can be associated with the development of

computational problem-solving practices. Therefore, the purpose of the present

study is threefold: (a) to elaborate a rationale on how a 3D SG can support the

development of computational problem-solving practices using OpenSimulator with Scratch4SL, (b) to analyze how the in-game elements should be mapped to

assist basic CT skills cultivation and programming concepts to support students

in learning how to think and practice computationally , and (c) to summarize the

findings from a preliminary mixed methods study following a game playing

approach in regard to the learning experience with a total of fifteen (n=15) junior high school students. The results indicate that students had a greater range of

expressing sufficiently alternative and self-explanatory solutions in blended

instruction. The instructor’s feedback and guidance facilitate them to rationalize

decisions taken on the cognitive aspects of computational practices in coding.

Keywords— Computational thinking; Game-based learning; Virtual Worlds

1 Introduction

Learning programming as an indispensable part of Computer science (CS) in K-12

education is a cognitively complex and demanding task. It requires a synthesis of

cognitive thinking skills, such as problem-solving, logical reasoning and algorithmic

thinking that enables students to transfer their thinking solutions into workable plans

and algorithms for proposing solutions to real-world problems [1]. Previous research

efforts [1,2] and literature reviews [3-5] came to the conclusion that computational

thinking (CT) paves a pathway of recognizing the prerequisites in a broad range of

analytical and logical ways of human’s thinking on how to solve problems finding the

most efficient in order to apply solutions. Subsequently, learning to think and practice

computationally includes the pervasive use of fundamental programming constructs

(e.g., selection, sequencing, repetition) in a computational problem-solving strategy

related to the analysis of designing, planning and debugging a proposed solution that

can be applied as a perfect way to evaluate the correctness of a thinking process [6,7].

Even more, CS curriculums worldwide have been widely intended to provide game-

based learning (GBL) approaches as more appropriate to fulfill students’ learning needs

and experiences through formal or informal instructional contexts [3], either with

exercises for learning programming by designing a game (game making) or with

exercises for learning programming by playing a game (game playing) [6,8]. Two are

the most distinctive categories of interactive environments that these approaches are

implemented: (a) visual programming environments (VPEs), like Alice, AgentCubes,

Scratch etc. [4] or three-dimensional (3D) virtual worlds (VWs), like Second Life (SL)

[9,10], OpenSimulator (OS) [11] or Neverwinter Nights 2 [12].

On the other side, a series of ongoing studies have pointed out reasons causing

difficulties in student learning experience by practicing with understanding the use of

core programming concepts in relation to CT as a problem-solving process. First, the

inadequacy of learning at an initial stage alongside with the development of CT skills

by paying attention to syntax or semantics of the first programming language, when CS

instructors and students use interactive environments lacking the means to abstract

functionality into functions and procedures [3]. This leads to the description of vague

abstractions which are specified by expressions of code commands in simple or without

purpose projects [2,9]. Assessing student computational understanding is still unable,

due to inability in connecting practically the abstract representations with programming

constructs [7]. Second, lack of problem-solving, logical and abstract reasoning skills,

which are regarded as essential for spotting and solving problems . Lack of such skills

hinders student information on how plan solutions, decompose a problem into smaller

subparts and apprehend errors to debug by testing and figuring out possible mistakes

before coding to ensure the accuracy of final projects, e.g. games, stories, artifacts [2,6].

Lastly, with the inefficient process of memorizing and executing continuously the same

programming constructs referring to small exercises that are based on school textbooks’

core aspects of learning cannot be explicitly investigated how fostering and assessing

the transfer of CT skills to future real-world contexts[4]. Such a process is inappropriate

for understanding how the cognitive thinking process of solving a problem is re flected

in practices for the execution and verification of this process correctness [7,12].

Although recent studies [2,13] have argued on how students cultivate and apply CT

skills mostly with creative computing or artistic expression tasks in game making

programming using various interactive environments, limited research demonstrated

how gameplay of a simulation game (SG) can be associated with the development of

computational problem-solving and how it can support greatly the implementation of

computational practices. Accordingly, a substantial body of literature reviews has come

to the statement that there is an overt “gap” concerning, either the creation and use of

new interactive environments [3,4] or the combination of already known “tools” for

game playing tasks [8]. Therefore, there is a need to have a better understanding about

the impact of digital games for introductory programming on the cultivation of CT

skills and on the learning experience from students’ computational practices via a SG.

To address the aforementioned challenge, this study’s hypothesis is whether the

combination of the most significant design features and characteristics of visual

programming environments , like the visual palette of Scratch4SL (S4SL) to prevent

syntax complexity in coding and the realistic representational fidelity of a 3D VW can

support the cultivation of computational practices fostering the transfer of learning

outcomes as proposed solutions for a real-world problem in game playing modes.

Hence, the purpose of the present study is threefold: (a) to elaborate a rationale on how

a 3D SG can support the development of computational problem-solving practices,

using OS with S4SL, (b) to analyze how in-game elements should be mapped to basic

CT skills and programming concepts, following a game playing approach to supporting

students in learning how to think and practice computationally, and (c) to summarize

the findings inferring to computational practices related to the use of (simple or nested)

sequence, conditionals or iteration methods to solve a computational problem. A

preliminary testing about the effectiveness of a 3D SG on students’ learning experience

was conducted in after-school programming sessions with a total of fifteen (n=15)

junior high school students who participated voluntarily in blended instruction.

2 Background

Wing [13] defines CT as a problem-solving process for conceptualizing, developing

abstractions and designing systems that require the use of human’s logical and

analytical thinking with concepts fundamental to computing. Additionally, relevant

literature reviews [3,5] have also proposed an operational definition for CT covering a

wide variety of skills that need to be cultivated. Such skills eventually assist humans to

understand how programming can become more effortful and unfold the support of

computational tools to think how to solve problems. The literature in GBL focuses on

“game making” or “game playing” approaches to facilitate the development o f CT skills

by utilizing: (i) VPEs and (ii) 3D VWs. The most remarkable features of the former

category are [6]: a) the applicability and visualization of algorithmic control flow (code

tracing) using a “drag and drop” process facilitating code blocks organization and

documentation, b) the assembly of coloured blocks that resemble like a jigsaw puzzle

through logically and specific commands with constructs (control flow blocks nesting),

with a view to eschewing syntax errors and c) the execution of proposed solutions to a

problem that are expressed as solutions created by combining simple or nested code

blocks (design patterns).

However, game making using VPEs has become a target of negative criticism from

a growing body of literature [3,6,12]. Students tend to create game-based applications

using trial-and-error modes of design patterns, by copying and pasting the same code

of other projects or by using only some programming constructs, rather than patterns

emerging from a thinking before the coding process. Thence, the transformation of

plans with syntactically correct instructions for execution and assess the consequent

results of those instructions inferring to [6,12,13]: (a) the presentation of digital artifacts

or applications, including stories or digital games that seemed too simple or without

purpose. By developing and programming simple games, students cannot adequately

articulate CT skills, failing to internalize computational problem-solving practices in a

more inferential realistic interpretation through game playing mechanisms, and (b) the

interpretation of applications, where proper writing code fragments are executed

correctly, but the difficulty in decomposing and formulating a problem is observed, as

students struggle to understand if their design patterns can support any proposed

solution to a problem, even in abstract manner. Thereupon, code documentation is

neither what exactly students would like to present, nor assist their trials to comprehend

source code, causing often significant conceptual gaps [9,23].

Alternatively, through game playing in Code.org, students can play computer

games, like Angry Birds that promote mainly the algorithmic thinking and basic

programming skills. Nevertheless, even in this case, previous studies [14,15] have

criticized such an approach because games of this site do not support all possible

programming phases and possible biases for the development of CT skills. Another

worthy game playing approach is the creation of SGs in 3D VWs, as it be adequately

combined the effects of “flow” (a state of enjoyment and psychological immersion

referring to the optimal experience when users are engaged through in-game challenges

to succeed goals of each activity) and “presence” (a human’s feeling of being

somewhere or having an effect by taking part in activities at a different place than truly

is his/her location) [16]. Roleplay learning systems, such as SGs that are created in 3D

VWs are increasingly applied to foster practical cognitive thinking skills through

active/exploratory learning experience facilitating a flow learning experience [9,10].

The most noticeable characteristics to support GBL in CS courses are as follows: (a)

the common and persistent environment to all users can give CS instructors

opportunities to evaluate students’ computing skills and competences at the same time

during the learning process or to provide constructive feedback using a/-synchronous

communication tools [11], (b) self-evaluation and reflection upon students’ cognitive

thinking process are achieved visually or acoustically by integrating behavior in objects

or by creating artifacts to link abstract-concept formation to a more concrete game

experience for learning gain [9], (c) enhancement of creative computing for

constructing 3D artifacts with behavior in SL by avoiding syntax errors of Linden

Scripting language (LSL) via S4SL [10]. However, the way in which students try to

write syntactically correct the scripting language code of the most known 3D VWs,

given its similarity with other general-purpose, like C, is still not well-documented.

Up to date, few notable efforts [4,6,8] have referred design frameworks and

guidelines that allow users to conceive computational problem-solving strategies

required for the cultivation and the connection of problem-solving with the

development of programming skills to apply design patterns as solutions to a problem.

For example, Lye and Koh [4] have proposed an imperative number of design

guidelines and directions towards a constructivist (thinking-doing) problem-solving

learning approach. In addition, Kafai and Burke [8] have already recommended the

connection of serious gaming opportunities in a simulated world, like SimCity with

Scratch 2.0 environment for writing programs.

According to the above-mentioned, the focus of this contribution aims to outline the

learning procedure on how students can interact with a 3D SG to examine their

computational problem-solving practices based on different design patterns that they

propose. OS and S4SL can be considered as a powerful set of tools for bridging the

“gap” between problem formulation and solution expression with the intention of

imposing how to apply programming constructs in simulated real-life problem-solving

contexts. The representational fidelity of OS offers an interactive environment that can

support authentic (open-ended) problem-based learning conditions in view of fostering

students’ cognitive thinking skills. By using S4SL, students can get focus on expressing

and applying solutions based on logical reasoning and algorithmic thinking for

assessing the correctness of their thinking process into computational practices .

3 Design decisions and rationale to utilize a simulation game

SGs support students’ problem-solving practices and learning experience reflected on

two undisputed keystones of CT inducing the expression [1,3,8]: (a) on how the

pertinent behaviors are considered from logical and abstract thinking (abstraction) in

favor of formulating and testing solutions to a problem by specifying computational

rules and concepts and (b) on how to obtain solutions to a problem by performing a

sequence of steps that are applied through programming skills as design patterns. It

becomes then clear to what extent are these patterns implying the need for simulation

to interpret the abstractions (automation) requiring access to computing tools. To this

notion, three-goal examples to design are considered as important for helping students

to articulate and transfer their thinking solutions from tacit thinking to workable plans

and algorithms [1,6,15]: (a) Integration of the learning material within the game

interface: A natural way of formalizing knowledge to an abstract manner in a simulated

problem-solving context during gameplay is imperative. Formulating innate thinking

into abstract representations using visual metaphors of a 3D VW employs an approach

that should infer and predetermine the designer specify algorithmic rules corresponding

to multiple movements that are the most appropriate to be done by users. For example,

the visual metaphors of OS support introductory programming learning in regard to the

conceptualization of algorithmic rules through abstract thinking logic that illustrated in

simulated real-world and problem-solving contexts; (b) Transfer from tacit thinking to

concrete thoughts of computational concepts: In-game activities should allow users to

describe the learning situation in which they attend and explicitly link their actions

during gameplay through CT skills cultivation. The reflective observation of the

concrete experience and implementation of computational problem-solving practices

not only assimilate abstract conceptualization without remaining tacit , but also facilitate

student understanding on how and why use computational concepts in two aspects: (i)

by decomposing abstract representations of the main problem to articulate a natural

way in an effort of formalizing tacit knowledge and (ii) by conceptualizing an abstract

logic thinking during gameplay to instantiate design patterns for testing and debugging

a proposed solution; and (c) Transform students’ thinking knowledge through in-game

play settings into formal logic and analysis about a solution in coding: Student’s

progress through in-game activities requires the process of concreteness a solution by

transforming a natural way of innate thinking to coding. A SG created in OS provides

an intuitive-natural modality for user-interaction. Thus, users can articulate and transfer

from tacit thinking to concrete their thoughts by practicing with understanding the use

of core programming concepts in relation to CT for developing and implementing

computational problem-solving practices. S4SL usage eliminates split attention of code

syntax and users can make the focus on goals of solutions that are applied as results of

computational problem-solving practices (design patterns).

Inevitably, prior works [6,15] have suggested tools that can foster CT skills

cultivation with visual thinking by supporting problem formulation in applications,

such as simulations when various evocative spatial metaphors are offered as alternative

options for game playing. The in-game use of evocative visual objects can be

considered as powerful conceptualization approach. Also, other works [4,15] have

advocated that such characteristics can assist the forging of abstractions which

predominately serve as the beginning of a path from problem formulation to solution

expression. These tools are expected to support GBL since through spatial reasoning

the logical relations satisfy make more clear and understandable the in-game objectives

that players need to achieve using inductive and abstract reasoning [14,15]. Abstract

simulations created in 3D VWs can be considered as suitable for helping users to

understand the concepts by taking the chance to take advantage from the formation of

spatial knowledge representations that support problem-solving learning tasks [6,11].

Based on all the above and in response to the first purpose of this study, the following

proposed instructional guidance in Table 1 is dedicated to blended instruction and it

constitutes of: (a) the learning tasks associated with the operational definition of CT as

a problem-solving process with specific learning objectives [5], (b) the CT skills that

need to be cultivated during in-game process [5], (c) the proposed guidelines (G1-G5)

from Pellas and Vosinakis [6] study about the creation of a SG and (d) game activities

that can assist students to express and apply computational problem-solving practices:

Table 1. Game activities associated with characteristics and skills of CT Sessions 1st session 2nd session 3rd session 4th session 5th session 6th session

Operational

definition of

CT

Formulating

problems

Logically

organizing and analyzing the data

Representing data

through abstraction

Automating

solutions through algorithmic thinking

Identify ing,

analyzing and implementing possible solutions

Generalizing

and transferring a problem-solving process to solution

CT skills Problem-solving

Problem-solving

Abstraction Algorithmic thinking

Design-based thinking

Pattern recognition

Proposed

guidelines

Student motivation (G1)

Student active participation (G2a)

Simulation of an authentic problem (G2b)

System’s feedback on user’s actions (G3)

Development of computational practices (G4)

Apply ing design patterns (G5)

In-game

activities

(Students

should be

able to…)

Decompose in subparts the

main problem

Analyze a cleaning path

and describe the RVC ‘s movements

Designate the RVC’s movements

in spatially -explicit context

Transform a solution to

algorithm and debug it by finding errors

Implement in coding the

proposed solutions via Scratch4SL

Examine the effectiveness

of the proposed design patterns

4 Method

4.1 Setting and sampling

This study was conducted in an intensive 2-week period with 6 sessions. The first 4

sessions lasted 4 hours in face-to-face sessions and the other 2 sessions lasted 2 hours

in supplementary online during the Spring trimester 2017. The sample comprised of 7

girls (Mage: 13.87, SD: 1.13) and 8 boys (Mage: 14.74, SD: 1.15) volunteered to

participate and they were from the local schools. All participants were recruited to

attend in all after-school sessions and they wanted to learn how to code using interactive

environments. Also, all of them were coding novices, but all had a previous experience

with Scratch. When the participants were selected, the main researcher contacted their

teachers and parents in order to obtain the necessary consent from both the student and

the legal guardian for the data collection.

4.2 Instrumentation and data analysis

For assessing the experiential dimensions, a mixed-methods study was followed to

bring the strengths of research forms in favor of validating the results. At the end of

this experiment, quantitative data were gathered through close-ended self-reporting

questionnaire responses of participants [17] given the option of writing short comments

(Table 2), whilst maintaining anonymity and confidentiality. Their answers analyzed

according to the guidelines of user experience studies [18]. Supplementary, qualitative

data were collected through open-ended interview questions to understand students’

enchantment and engagement using the proposed SG.

For assessing the user experience, this study followed the research considerations by

Bargas-Avila and Hornbæk [17] who identified several aspects of experiential

dimensions that should be utilized. All statements in this work are expressed and rated

simply on a 5-point Likert scale [strongly disagree (1) to strongly agree (5)]. The items

about the procedure for measuring student learning experience was based on 16

questions, translated into the Greek language and separated in three subparts: learning

effectiveness (LE), learning procedure (LP) and user experience (UX). Subparts about

students’ learning outcomes and experiences concerned with issues that are ubiquitous

in respective work; in specific, all identified aspects (aesthetics of interaction

engagement, usability, usefulness, visual appeal) related to user experience [17].

Cronbach’s alpha (α) of the main questionnaire was 0.835, reflecting on a reasonable

internal consistency of the variables to describe students’ expectations.

Data were analyzed using: (a) guidelines of usability metrics for evaluating the user

experience [18], including each user’s response into the top-2-boxes (positive

responses) or the bottom-2-boxes (negative responses), (b) probing questions from the

instructor provided feedback by posing questions to each participant when s/he seemed

to get confused helping them find an adequate direction to propose a solution , and (c)

code tracing via S4SL, the instructor evaluated the applicability of algorithmic control

flow to identify whether the adoption of selection control-flow blocks and the

exploitation of nesting composition among programming constructs were achieved.

4.3 Procedure

The aim of this teaching intervention was the exploitation of a roleplay 3D SG

following an instructive guided approach with step-by-step programming exercises and

the investigation of its impact on students’ learning outcomes depending on

computational practices. Having the role of embedded software engineers, students

should assist an old woman with special needs, who moves only with her wheelchair

and struggles to clean all rooms of her house. In gameplay context, they need to

elaborate a solution aimed at creating unique algorithms with logically and precise

instructions and finally to propose solutions as design patterns for this problem. In this

vein, students first need to navigate, determine movement positions and describe the

best cleaning path that an autonomous robot vacuum cleaner (RVC) should follow in

sufficient time. Their solutions need to be implemented by integrating behavior from

S4SL to OS, where a robot cleaner should move and clean five rooms that are

differentiated in spatial geometry layout, in terms of division among house furniture or

objects and calculate arithmetically distances without causing hits or damages. House

furniture and objects in square floors are seen as evocative spatial metaphors of basic

geometric shapes (e.g., triangle, square, hexagon) assisting students to think and

practice computationally with an abstract conceptualization approach alongside with a

pathfinding for a simulated real-world problem. Abstract spatial representations of

geometric shapes were extensively used in this 3D SG, such as a triangle, for example ,

to prevent hitting a table, players need to determine arithmetic computation between

chairs and table distance (e.g., each side’s square floor has width and height 5m

respectively) or-/and calculate degrees of turning correctly (e.g., 90o for square or 45o

for equilateral triangle) to traverse the robot a specific cleaning path down from the

table (movement on X and Y axis), without hitting the table lamp (impact on crashing

to Z axis). This process was becoming more compelling, since it was expected from

students to implement these computational strategies through practices via S4SL in

order to be presented the shortest path between the present location and the goal

location of the robot. The main researcher has to propose the use of at least one

programming construct for each room that should be included in the solution, albeit

students were free to propose alternative solutions using other constructs.

Fig 1. Illustration of the in-game learning process in Room B

For learning through gameplay challenges, students need to analyze how to plan a

solution for a cleaning path problem, subdivide it into smaller parts, and apprehend

hypothetical error situations for retrieving visual feedback by means of OS. They

should debug their cognitive thinking process by trying to test and figure out possible

misconceptions in computational practices via S4SL. These practices are combined

with programming constructs (serial sequence, if/else statement or loop) and

instruction/movement commands for executing the design patterns. For example, Fig.

1 depicts a problem on how moving the robot in a cleaning path, by coding a solution,

like being square root spiral. When the robot moved under the table (root), the user

needs to use the same design patterns with iteration and commands blocks in relation

to numbers or variables. It is imperative to take the advantage from the environment’s

spatial layout comprising all of the rules for performing arithmetic computations for

the distance of the robot between the avatar and house furniture. There are also some

noteworthy core gameplay mechanics, basic rules, and functions in this SG. First, each

player should describe and apply an algorithm that calculates the most efficient route

for cleaning. To identify and present the proposed solution, each player should copy

and paste the commands and programming constructs via S4SL palette inside the

RVC’s notecard explaining a step-by-step solution before executing her/his proposed

solution. Second, six checkpoints inside each room are allowed for the mapping process

which is preceded by the players. The correct pass of the robot above them means no

counting on the total time until the final solution finished. Third, whenever the robot is

programmed to passing and cleaning all dust gray signs off the floor, for rewarding, it

gains energy, giving grades to the player. If gathering the smallest possible number of

code blocks for cleaning each room based on resilient planning, execution time and

fewer hits on the house furniture or objects, then such a player is declared as the winner.

5 Results

Regarding the participants’ background based on demographics information, almost

more than half percent (55%) of them find really important their participation in CS

courses with reasoning and learning capabilities to be the implementation of various

tasks using programming environments. It seemed that most of them (60%) had

previous experience with Scratch. Some of them (20%) answered that they knew about

SGs, such as The Sims or Minecraft and some others (33%) who had utilized them.

Table 2. Short comments on how the SG contributing to LE, LP, and UX Learning

effectiveness

(LE)

(a) Roleplay

scenario [n=8, 54%]

(b) Exploration and

problem description [n=2, 13%]

(c) Learning

objectives [n=2, 13%]

(d) Chat or voice

communication [n=2, 13%]

(e) Visual

feedback [n=1, 7%]

Learning

procedure

(LP)

(a) OpenSim and Scratch4SL [n=5, 40%]

(b) Instructor’s feedback [n=4, 30%]

(c) Game context [n=2, 10%]

(d) Understanding of user control in the game [n=2, 10%]

(e) In-game visual elements [n=2, 10%]

User

experience

(UX)

(a) The game setting (RVC, 5 rooms, visual objects, etc.)

[n=5, 30%]

(b) In-game problem recognition accuracy [n=3, 20%]

(c) Interactivity with visual objects

[n=3, 20%]

(d) The 3D graphical user interface [n=2, 15%]

(e) The anthropomorphic avatar

[n=2, 15%]

The vast majority of participants reported on several points of view about the RVC

simulator. In Fig. 2, the top-2-box scores include responses to the two most favorable

response options, i.e. ranking percentage based on their answers was e.g., from 87%

(13 out of 15 students) about expressing and applying their solutions to 67% (10 out of

15 students) about decomposing in subparts the main problem. Slightly more than half

of them (54%) referred that roleplay scenario and problem description contributing to

LE (Table 2). A student reported that “Some facts in the game are really represented

well. This helped me not only to rationalize my decisions by applying and explaining

my solution but also to know why I used some programming constructs without only

proposing zigzag movement as cleaning path”. Another one said that “S4SL helped me

to apply a proposed solution, as I visually saw the results of the code inside OS”. In

contrast, other users could not easily recognize the interaction between elements inside

the house (Visual feedback: 7%) complaining one of them that “Sometimes I struggled

to understand if the robot collided with house furniture or objects, when I was applied

for my program”, albeit in the end their preference than Scratch or Alice was referred.

The use of communication tools to succeed the learning objectives were mentioned less

from few users (13%), maybe due to the instructor’s feedback in face-to-face tasks.

Fig 2. Horizontal stacked bar chart of top/bottom-2-boxes of user responses about the LE

In terms of LP, again many participants were at the top-2-box scores. Ranking

percentage based on their answers was e.g., from 73% (11 out of 15 students) about

understanding instructor’s feedback to 53% (8 out of 15 students) for the effective

communication and successful implementation of design patterns for proposing

solutions to each subpart of the main problem (Fig. 3). Others reported on several points

of view with regards to the SG that contributed to the LP (Table 2) with the most notable

to be the combination of OS with S4SL (40%). After the game context, understanding

of in-game user control and visual elements follow with 10% to each. The combination

of OS and S4SL was necessary for integrating behavior inside the robot to follow a

cleaning path and getting responses of its movement , in an effort of proposing and

applying visually solutions through design patterns . The coding phase to visualize a

proposed solution was referred by others as an important feature, especially because it

enables them to assess their thinking process: “The S4SL palette enabled me to write

correctly the code, while I was previously described and proposed a solution in natural

language”. Another one participant referred that “The instructor guided my practices

and he helped me with the code responses in order to be applied my planning”.

Fig 3. Horizontal stacked bar chart of top/bottom-2-boxes of user responses about the LP

With respect to the UX, most participants were at the top-2-box scores (Fig. 4). For

instance, the top-2-box score is 67% (10 out of 15 students) of students who felt

engaged with the VRC simulator rating it favorably compared to their counterparts who

have opposite opinion according to a bottom-2-score of 13% (2 out of 15 students).

Participants reported on several aspects of the SG, which contributed to positive user

experience (Table 2) with highest to be the game setting (30%). The anthropomorphic

avatar representation and the 3D graphical user interface follow with 15%. A

representative answer reported that “It was a motivating setup of playing in-game

tasks”. Other one said, “In past, sometimes I did not have the opportunity to present

my code and speak of why I used some programming constructs”.

Fig 4. Horizontal stacked bar chart of top/bottom-2-boxes of user responses about their UX

Negative aspects of the UX were reported about interactivity among visual objects

(15%), like “When the robot stroked a table or a sofa, sometimes I did not recognize

the error message, maybe because of the poor quality of graphics”. Few users struggled

to log into OS, said that “I was observed slow loading times in my entrance” at the

beginning or others did not copy and paste correctly the code into the notecard of RVC.

6 Discussion and Conclusion

The main purpose of this study was to investigate the effectiveness of a 3D SG to

introductory programming high school course settings. The RVC simulator provides

affordances for instructive guided support through informal blended instruction to CT

teaching. Furthermore, it enables the free experimentation and reflection of students in

a concrete problem-solving space by exploring and expressing solutions through design

patterns. Their answers revealed the positive acceptance about how instruction using

S4SL and OS engaged them in innovative and interactive learning situations since they

had very satisfactory performance and user experience. Findings of this preliminary

testing unveil that a great number of students found this 3D SG interesting, fascinating

and relevant to their previous experience with other roleplay SGs, like The Sims or

Minecraft. Without so highly advanced, but with simple design patterns to be nested

and presented as final solutions, students appeared not having any difficulties in

producing some good computational problem-solving practices. Based on code tracing

analysis, the applicability of selection control-flow blocks and the exploitation of

nesting composition among programming constructs, for instance, such as mastering

if/else conditionals with numbers using S4SL, students are ample to propose well-

defined solutions and learning outcomes that can be easily visualized in OS. Consistent

with Howland’s and Good’s [12] study findings, a block-based palette is regarded as a

reliable tool for high school students to avoid syntax errors in programming and trigger

more in problem-solving via 3D roleplay games by expressing and applying more

succinct and precise rules with instructions in combination with programming

constructs. On the other side, contrary to the results of past efforts [2,7], students of this

study using a 3D SG seemed to have reasonable efforts by answering why they used

specific programming constructs and instructions in computational practices , dodging

the vague syntax of programming constructs. Such a process can give valuable answers

for assessing how students try to think and practice computationally before coding. This

can also give evidence of a deeper understanding from the description of a cognitive

thinking process to the comprehension and production of coded solutions.

In conclusion, this study’s findings may be of interest to instructional designers who

want to take in advance a 3D SG and design (in-)formal introductory programming

courses in blended instruction to foster students’ computational problem-solving

practices. Some educational implications that should be underlined using OS with S4SL

are as follows: (a) students can think critically and logically so as to organize code

blocks design patterns and execute programs for a simulated real-world problem, (b)

students were able to understand evocative spatial metaphors inside OS, referring from

almost all of them different computational practices in coding, and (c) students’

learning experiences and achievements affected positively their overall performance in

order to transform easily their thinking solutions into workable plans and algorithms.

The results about computational understanding cannot be easily generalized, due to

the limitation of small sample size in a time-intensive after-school program. To widen

and generalize a more efficient way to foster computational problem-solving, a quasi-

experimental study should conduct with an experimental group that will utilize OS and

S4SL compared to a control group that will use the visual programming environ ment

of Scratch with the same subparts of the main problem illustrated in the RVC simulator.

7 References

1. Liu, C. Cheng, Y. & Huang, C. (2011). The effect of simulation games on the learning of

computational problem-solving. Computers & Education, 57: 1907–1918.

2. Mouza et al. (2016). Development, implementation, and outcomes of an equitable Computer

science after-school program: Findings from middle-school students. Journal of Research

on Technology in Education, 48: 84-104.

3. Grover S. & Pea, R. (2013). Computational thinking in K–12: A review of the state of the

field. Educational Researcher, 42: 38–43.

4. Lye, S. & Koh, L. (2014). Review on teaching and learning of computational thinking through programming: What is next for K-12? Computers in Human Behavior, 41: 51-61.

5. Kalelioglu, F., Gülbahar, Y. & Kukul, V. (2016). A framework for computational thinking

based on a systematic research review. Baltic Journal of Modern Computing, 4: 583-596.

6. Pellas, N. & Vosinakis, S. (2017). How can a simulation game support the development of

computational problem-solving strategies? EDUCON. IEEE: Athens, pp. 1124-1131.

7. Brennan, K. & Resnick, M. (2012). New frameworks for studying and assessing the

development of computational thinking. In AERA. Vancouver, Canada.

8. Kafai Y. & Burke, Q. (2015). Constructionist gaming: Understanding the benefits of making

games for learning. Educational Psychologist, 50: 313-334.

9. Esteves, M. et al. (2011) Improving teaching and learning of computer programming

through the use of the Second Life virtual world. BJET, 42: 624-637.

10. Girvan, C., Tangney, B. & Savage, T. (2013). SLurtles: Supporting constructionist learning

in Second Life. Computers & Education., 61: 115-132.

11. Rico, M. et al. (2011). Improving the programming experience of high school students by

means of virtual worlds. International Journal of Engineering Education, 27: 52–60.

12. Howland, K. & Good, J. (2015). Learning to communicate computationally with Flip: A bi-

modal programming language for game creation. Computers & Education, 80: 224–240.

13. Wing, J. (2006). Computational thinking. CACM, 49: 33–35.

14. Theodoropoulos, A., Antoniou, A. & Lepouras, G. (2016). How do different cognitive styles

affect learning programming? Insights from a Game-Based Approach in Greek Schools.

ACM Transactions on Computing Education, 17:3.

15. Román-González, M., Pérez-González, J.-C. & Jiménez-Fernández, C. (2017). Which

cognitive abilities underlie computational thinking? Criterion validity of the computational

thinking Test. Computers in Human Behavior, 72: 678-691.

16. Faiola, A. Newlon, C. Pfaff, D. & Smyslova, O. (2013). Correlating the effects of flow and

telepresence in virtual worlds: Enhancing our understanding of user behavior in game-based

learning. Computers in Human Behavior, 29: 1113–1121.

17. Bargas-Avila, J. A. & Hornbæk, K. (2011). Old wine in new bottles or novel challenges: a

critical analysis of empirical studies of user experience. In SIGCHI. New York, USA: ACM,

pp. 2689–2698.

18. Tullis, T. & Albert, W. (2013). Measuring the user experience: collecting, analyz ing, and

presenting usability metrics. San Francisco, CA, USA: Morgan Kaufmann Publishers Inc.