Conference PaperPDF Available

How can a simulation game support the development of computational problem-solving strategies?

Authors:

Abstract and Figures

Game-based learning using interactive environments to impart theoretical and applied knowledge for introductory programming courses is divided in two popular approaches: " game making " and " game playing ". Various studies have been conducted following greatly the former approach in secondary and tertiary education with controversial results. However, there has been relatively little research shown about how game playing can be associated with the development of computational thinking and how fundamental programming concepts can be supported by playing games. This work investigates how a simulation game should be designed to support the development of computational problem-solving strategies through the medium of learning fundamental computer science concepts, by proposing a theoretical game playing framework.
Content may be subject to copyright.
The present paper below is an original authors’ working draft version that led
to an article publication. A reference in APA settings to this work should
always be done using the following citation:
Pellas, N. & Vosinakis, S. (2017). How can a simulation game support the
development of computational problem-solving strategies? IEEE Global
Engineering Education Conference (EDUCON 2017) (pp.1124-1131).
Athens: Greece.
This material is presented to ensure timely dissemination of scholarly and
technical work. Copyright and all rights therein are retained by authors or by
other copyright holders. All persons copying this information are expected to
adhere to the terms and constraints invoked by each author's copyright. In
most cases, these works may not be reposted without the explicit permission
of the copyright holder.
How can a simulation game support the development
of computational problem-solving strategies?
Nikolaos Pellas, Spyridon Vosinakis
Dept. of Product & Systems Design Engineering
University of the Aegean
Syros, Greece
e-mail: npellas@aegean.gr, spyrosv@aegean.gr
AbstractGame-based learning using interactive
environments to impart theoretical and applied knowledge for
introductory programming courses is divided in two popular
approaches: “game making” and “game playing”. Various
studies have been conducted following greatly the former
approach in secondary and tertiary education with controversial
results. However, there has been relatively little research shown
about how game playing can be associated with the development
of computational thinking and how fundamental programming
concepts can be supported by playing games. This work
investigates how a simulation game should be designed to support
the development of computational problem-solving strategies
through the medium of learning fundamental computer science
concepts, by proposing a theoretical game playing framework.
Keywordscomputing education; computational problem-
solving; game-based learning; Open Sim; Scratch4SL
I. INTRODUCTION
Computer science (CS) is a key field for advancement and
innovation in different STEM (Science, Technology,
Engineering, and Mathematics) disciplines. One of the most
significant scope in modern computing is the way of fostering
students’ logical thinking and problem-solving skills in
combination with coding, by analyzing a strategy that can be
applied as a proposed solution for real-world problems [1-3].
There is a broad agreement that computational thinking (CT),
and its core, computational problem-solving, pave a pathway
of recognizing the prerequisites for thinking how to solve
problems and interest in finding the most efficient way to
apply solutions, like a computer scientist [4,5]. Additionally,
literature reviews [6,7] have been undertaken to define what
skills are necessary to support CT and how interactive
environments can become effective tools for students who try
to transfer their thinking solutions into workable plans and
algorithms with precise instructions in an abstract manner.
Worldwide curricula have widely used game-based learning
(GBL) as a pedagogical approach for developing CT,
following “game making” (exercise in learning programing by
designing a game) or “game playing” (exercise in learning
programing by playing a game). These are implemented either
with visual programming environments, like Alice [8], Scratch
[9] or with three-dimensional (3D) virtual worlds (VWs), like
Second Life (SL) [10] and Neverwinter Nights 2 [11]. The
former approach is referred as the most “mainstream” in
learning programming. It is based on algorithmic design and
the artistic expression through interactive narrative-based or
interactive games that students create [6,9].
However, the existing research has well-documented a
wide range of difficulties and deficits for students aged 13-16
years old (high school), who mostly tend to focus on surface
knowledge acquisition. Some of the most important reasons
are the following [12-14]: (a) lack of skills in problem-solving
and different levels of abstract reasoning cause usually failure
in expressing problem solutions as programs and (b) lack of
logical reasoning and algorithmic thinking skills frame a
purely technically-centered process for translating mental
representations of problems and solutions into source code.
These skills are applied in a natural way of formalizing tacit
knowledge during game playing, but students cannot
inherently conceptualize their cognitive thinking process in
playable modes to concretize logically abstract concepts.
Previous studies [9,11] have found out that students by
creating and programming simple games cannot articulate CT
skills [3] and they fail to internalize computational problem-
solving strategies converting a more inferential realistic
interpretation in game playing. For example, visual
programming environments lower the barrier of writing
syntactically correct a computer language, due to the general
use of a palette with visualized control-flow and command
blocks. Taking into consideration only this feature, students,
firstly, do not necessarily take advantage of intuitive, natural
modality for user-interaction in activities that required CT
skills, and secondly, they are not encouraged for a more
general understanding of computational concepts [11,15,16].
Up to date, a game playing approach using a simulation
game (SG) is another notable option for introductory CS
courses [4,16]. In general, a SG covers a wide range of
activities in real-life conditions to apply abstract knowledge
that reflected on various learning purposes, such as training,
analysis or prediction. In CS courses, a SG can present
embodied problem situations fostering students’ problem-
solving ability, and thus experience on acquiesce within a
scientific discovery process [4]. Particularly interesting is the
creation of SGs in 3D VWs, like SL [17] or Open Sim [18].
The representational fidelity of such a “world” can offer a
persistent game-like environment with multimedia and a/-
synchronous communication tools for the creation of engaging
and interactive activities to understand better CS concepts.
Recent works have focused on VWs’ own scripting language
learning [18] or problem-solving constructions avoiding the
syntax complexity with Scratch4SL (S4SL) [10].
Despite the previous efforts [7-9], little is known regarding
how game playing in a SG can be related with the
development of computational problem-solving strategies for
high-school CS courses. This research seeks to propose: (a) an
ongoing game playing framework and its benefits in acquiring
CT skills for high school introductory CS courses; (b) a case
on how a SG supports students to think computationally in
order to express and apply a logical way of thinking to a
solution using programming constructs for a simulated real-
world problem; and (c) a rationale on how in-game
elements/characteristics created in a 3D VW, like Open Sim
should be mapped in the direction of helping students use their
problem-solving, logical and abstract skills for the analysis of
sub-parts of a computational problem. Students can also use
S4SL to implement the proposed solutions using programming
constructs that can be applied.
II. BACKGROUND
A. Computational problem-solving and interactive
environments
To become well-educated in an increasingly computing-
driven world and be prepared for the demands of the 21st-
century, students need to have a deeper understanding on the
role that the fundamentals of CS concepts can play in real-
world problems [3,7]. Wing [19] defines CT as a problem-
solving process in relation with conceptualizing, developing
abstractions and designing systems, which requires the use of
logical thinking with concepts fundamental to computing.
Computational problem-solving strategy is a cognitive
thinking process for the analysis of steps focusing not only on
a solution to a problem using logical and abstract thinking, but
also to the implementation of this process with basic
programming concepts that are applied with computing tools
[1,4]. Consequently, learning to think “computationally”
includes the pervasiveness of CS programming constructs and
problem-solving strategies. Still today, prior works [2,3,7,14]
have pointed out a subtle distinction between computational
thinking and programming. In principle approval, CT does not
require programming at all, although in practice, representing
a solution based on the analysis of strategy for programming
to a problem is generally applied as a perfect way to evaluate
the thinking process of a proposed solution [4,13].
Understanding how the development and implementation
of a computational problem-solving strategy can allow
students to solve problems by playing, has recently gained the
research interests at a large extent [2-5]. Previous literature
reviews of this field [6,7] have been undertaken to define what
skills involve CT and how interactive environments can
become effective tools for students who must be enable to
transfer their thinking solutions into workable plans and
algorithms in an abstract manner. The literature in GBL for
introductory CS courses focuses on game making or game
playing approaches to facilitate the development of CT skills.
The interactive environments that have been extensively
utilized for these purposes are separated in two categories: (1)
visual programming and (2) 3D VWs. In the first category,
students can program one or more “sprites” (i.e. iconic
characters) on a “stage(scene background) using a palette of
programming blocks and the result is usually animation, game,
or interactive art. The graphical code building blocks has
shown considerable promise in programming languages
syntax, aimed at giving students a first introduction to
computation. The most remarkable features are the
applicability and visualization of algorithmic control flow
(code tracing) by “dragging-and-dropping” graphical code
blocks. These blocks are resembled like jigsaw puzzle pieces
through logically and specific instructions (control flow blocks
nesting), with a view to avoid syntax errors and finally
propose solutions to a problem expressed as design patterns
(executive solutions built from combinations of blocks
consisted of simple programming constructs) [6,8].
In game playing approaches, students play computer
games that promote algorithmic thinking and basic
programming skills, mainly, by using Code.org website. Code
art and semi-structured story-based or interactive games
remain a good starting point to enhance the digital fluency
reflected with creative computing experience. Yet, another
worthy effort is to create contexts which can allow personal
expressions with digital technology for authentic problems,
corresponding to the analogies of solving simulated real-life
problems [7,8,16]. SGs can present embodied problem
situations fostering students’ problem-solving ability and thus
acquiesce to experience within a scientific discovery process,
inducing the expression [7,17,19,20]: (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. This
vision poses an understanding of basic computational
concepts, in addition with the ability to use and communicate
these concepts effectively, and (b) on how obtain solutions to
a problem by performing a sequence of steps that are applied
as design patterns through acquiring programming skills. It
becomes then clear to what extent are these patterns implying
the need for simulation to interpret the abstractions
(automation). Both are reflected as undisputed keystones for
developing computational problem-solving strategies.
On the other hand, 3D VWs offer a sense of authentic
problem situations through interactive activities, in which
students can provide solutions to simulated real-life problems,
track errors optically and understand better the consequences
of their actions at the same time [17,18]. Instructional
approaches based on simulations can enhance students’
abilities to apply abstract knowledge by situating learning in
authentic, virtual contexts similar to the environments in
which learners' skills should be used. The 3D visually-rich
graphical interface permits users who are spatially distributed
(or not) to interact using a-/synchronous communication tools
with others as embodied representations (called “avatars”). A
3D multi-user VW provides interactive simulations in a
plausible illusion and it permits users [17,21]: (i) to construct
simulated real-life problem-based contexts, using built in tools
to create and modify objects and practice competencies; (ii) to
refine rules of the spatial proximity with high representational
fidelity via a multi-user environment that provides prompt
feedback; and (iii) to understand conceptual theorems or
metaphorical representations (metaphors) of their ideas
without spatio-temporal physical constraints through
embodied actions, including view control, navigation, and
object manipulation by interacting with other peers in a
common virtual place. Existing research on 3D VWs straddle
several academic disciplines, ranging to all STEM disciplines,
including CS as well. Similarly noteworthy are the results
from previous studies, which have already found positive
attributes in learning, as students were able to: (i) understand
better introductory programming constructs by avoiding
syntax errors of Linden Scripting language (LSL) via S4SL for
constructing 3D artifacts with behavior in SL [10], (ii) allow
the communication and interaction with their peers or with the
instructor to develop CS basics concepts using LSL [18], and
(iii) improve students’ comprehension in basic programming
concepts with regard to replace traditional languages, create
and integrate behavior by writing simple scripts via LSL [22].
B. Frameworks for analyzing computational understanding
Since not only gaining knowledge in using programming
concepts is the key point of CS courses, an understanding
about the thinking process that followed as a problem-solving
strategy is a crucial point for measuring what students have
learned. A conventional way to measure strategy based on CT
is to analyze student-made computer games that includes three
aspects to game programming: (a) visual palette used for
combining fundamental CS constructs in building blocks, (b)
design patterns included multiple programming constructs to
create instances of patterns, and (c) game characteristics,
which are a combination of programming constructs and
design patterns, giving the player’s actions to overcome in-
game challenges. For this reason, a large body of literature has
proposed various frameworks for identifying the types of
thinking in which students are engaged while programming.
Indicative examples are as follows: (a) with respect to Scratch,
Brennan and Resnick [9] have proposed a framework with the
three dimensions of computational thinking: computational
concepts, computational practices and computational
perspectives; and Foundations for Advancing Computational
Thinking (FACT) aimed to prepare and motivate middle
school student engagement with algorithmic problem-solving
[5], (b) regarding Agentsheets, the Design principles for the
simulation creation toolkit for creating and programming
computer science simulations [15], (c) in relation to Stagecast
Creator, a coding framework for describing strategic analyses
of students’ games creations [23], (d) in regards to Alice, the
game Computational Sophistication Model for measuring
students computational learning by game making [8], and (e)
Scalable Game Design to correlate CT skills relevant to
game design and simulations [24].
Although visual programming environments are useful for
creating enthusiasm and motivation in programming, it is
arguable whether students with little or no programming
background can develop skills in CT through this approach [6-
9]. Two are the most important viewpoints. The first addresses
to the emphasis of analysis and process design that stemmed
from procedure-oriented programming. A large number of
studies [4,7,9,15,16] underlined some drawbacks. In many
cases, students try to comprehend source code that implies in a
“programming as activity’’ perspective, rather than a set of
combined problem solving, logical and abstract thinking skills,
which can be associated with programming constructs in order
to be solved computational problems. By “decoding the code”
through exhibits relevant output functionality and readability
of code commands sequentially or syntactically correct,
students are focused explicitly on the declarative aspects of
programmers’ knowledge by designing games, in which they
seek to solve only problems at a superficial level [9,11]. The
second viewpoint is the visualization thinking and the analysis
of thinking process that are not emphasized on the
development attribute on expressing computational problem-
solving strategies, but on describing strong operability in
computational practices through code syntax. The main result
is the difficulty in decomposing and formulating a problem.
The transformation of plans with syntactically correct
instructions for execution and assess the consequent results of
those instructions inferring to [6,9,11,23]: (a) the presentation
of digital artifacts or applications, including stories or digital
games that seemed too simple or without purpose and (b) the
interpretation of applications, where proper writing code
fragments are executed correctly, but the design patterns
cannot support any proposed solutions to a problem. Thence,
code documentation is neither exactly what student would
want to present, nor assist their trials to comprehend source
code, causing often significant conceptual gaps [9,23].
Students may not be helped to develop/enhance their problem-
solving skills substantially, albeit the implementation of
design patterns using a palette with programming constructs
seemed to empower their programming skills.
On the other side, the way in which students try to write
syntactically correct the scripting language code of the most
known 3D VWs, like SL or Open Sim, given its difficultly and
similarity with other general-purpose, like C, is still not well-
documented. Alternatively, Girvan et al. [10] by using S4SL
and following Constructionism as the theoretical
underpinning, have placed an emphasis on the process of
constructing shareable artefacts in SL. S4SL provides a
graphical palette with control flow programing constructs and
instruction commands movements, similar with Scratch’s
palette features. It is also used as a free-plug module in SL or
Open Sim, giving users an easy way to integrate behaviors and
interactions to objects without financial cost.
Bearing in mind all the aforementioned and conceiving
that computational problem-solving strategies require the
cultivation and connection of problem-solving with
development of programming skills for presenting design
patterns as solutions to a problem, it is crucial to compensating
the design requirements and guidelines proposed by relevant
studies [5-9], in which their learning scenarios can be
implemented, either in visual programing environments or in
3D VWs. Hence, the hypothesis that arises, is whether the
combination of the positive effects on learning performance
from design features and characteristics of each category
could fill the “gaps” detected in each, and thus facilitate the
creation of an innovative environment supporting the
development of computational problem-solving strategies.
Particularly interesting to meet the required design guidelines
needs, which are noticed above, is the combination of S4SL
palette with a 3D VW, such as Open Sim. Open Sim is an
open source (free-of-charge) server platform that contains a
3D networked, interactive and multi-user virtual environment
with a persistent workflow accessible simultaneously by many
users in the same time and place.
Due to the surge of game making approaches, an
alternative and certainly less explored for the development of
computational problem-solving is through digital game
playing. Until today, there is little consensus referring the
essential characteristics regarding game playing frameworks
for SGs, which can support the development of students’
computational problem-solving strategies. Therefore, there is
an urgent need to have a better understanding of the impact of
SGs in introductory programming courses and the
development of CT strategies through game-play.
To address the above issues, Garris et al. [25] game-based
learning model explicitly illustrating integral SG features and
perceptions for active learning processes. This game-based
learning model emphasizes both motivation and process
aspects associated with skill-based learning outcomes.
According to this model, a game for learning should
continuously present a motivating goal at an appropriate level
of challenge where learners can have full control of their
learning activity. Such a game can promote in-depth learning
while interacting with it. Garris et al. [25] categorized game
characteristics as “fantasy, rules/goals, sensory stimuli,
challenge, mystery and control”. The same authors have also
proposed design principles for the conceptualization of design
guidelines in SGs. In this line, based on the game cycle of the
input process output game model, the following principles
are extracted: user motivation and persistent engagement (P1),
clear and challenging goals (P2), system’s feedback on user’s
actions (P3), scaffolding process (P4) and debriefing based on
skill-based learning outcomes (P5), both with instructional
support. The development of a SG for learning CT using
Garris et al. [25] model can be considered as the most
appropriate for the following reasons: (a) students can
intrinsically identify objections of the main problem, handle
its’ sub-parts and propose a solution; (b) students recognize a
way of understanding how they to think before start coding
based on their judgements and behaviors; and (c) the
development of cognitive learning outcomes comes from
strategic knowledge that requires learned principles using
different skills. The above reasons imply the development of
understanding when and why principles should be applied
through in-game activities through discovery learning.
Referring that a game playing approach can add several
prominent learning and instruction principles to computational
problem-solving strategies, this work investigates how these
principles may be applied to design game-like learning
systems and facilitate flow learning experience in GBL.
The focus of this work is to outline a game playing
framework for supporting the development of computational
problem-solving strategies through a SG. The proposed game
playing framework can facilitate students to practice and
develop computational problem-solving strategies for high
school students, regardless their programming knowledge
background. Also, this work intends to elucidate and
concretize precise design guidelines and characteristics of a
SG created via Open Sim and S4SL with the intention of
imposing how to apply programming constructs in simulated
real-life problem-based contexts. Open Sim and S4SL can be
considered a powerful set of tools serving as bridge the gap
between problem formulation and solution expression.
III. TOWARDS A GAME PLAYING FRAMEWORK
A. Rationale and design decisions
As SGs are increasingly being applied for introductory CS
courses [4,16], how can designers integrate game playing
guidelines and principles is becoming more imperative. In
sum, it can be beneficial to develop an instructional game-
based framework for CT planning development, with the
purpose of discussing: (a) what are the game characteristics
that should be used for student engagement, (b) in which
instructional circumstances students need to have the
assistance in pursuance of recognizing, if they really tried to
cultivate CT skills, and (c) how to assess if students adopt CT
skills into simulated real-life problem-based context, by
mapping through explicit abstractions their naturally-
expressed thinking solutions built to workable plans and
algorithms with precise instructions. Evidence from other
works [1,11,24] also suggest that once students understand
conceptually how to present a pattern, they are able to transfer
and use it in the context they choose as well, highlighting that
problem-solving in game-based context is regarded as an
activity that can be approached meaningfully with a playful
attitude. Understanding of game events and having the ability
to describe events in natural language can be a good starting
point that would allow them to engage with basic
computational concepts. Specifically, where the goal is to help
students develop their understanding on computation and/or
use computation in simulated realistic settings, a question that
arises is whether natural language might be a preferred
notation in understanding how students use CS concepts to
solve a problem through programming, given its familiarity
and ubiquity that exists in real life [11,16]. To this notion, an
interactive environment must address not only to syntactic, but
also semantic and pragmatic concerns regarding the
consequences of programming in solving a problem. Based on
the relevant literature [7,12,20,23], three are the
presuppositions that need to be supported:
(1) Decomposition and formulation of the main problem
(abstraction): Decomposing and formulating the main
problem is associated with “abstract conceptualization”. It is
the first step that allow students to conceptualize, either
verbally, e.g., by trying to formulate a question such as “How
can I solve this problem, by using and making in-game
elements work for this effort?” or visually, e.g., by describing
students’ thoughts in diagrammatic representations or in
natural language texts in place of identifying in-game objects’
behaviors and relationships. At the beginning of a path from
problem formulation to solution expression, two are the most
prudent characteristics that need to be referred. The first is
visual thinking for the problem formulation, so that students
can organize their thoughts, describe object interactions and
improve their ability not only to think, but also to
communicate them [23]. The second is the use of spatial
metaphors that can support a conceptualization approach for
improving critical thinking and problem-solving skills in
visual thinking, giving to all users the opportunity to organize
information visually [20];
(2) Description and expression of a solution (automation):
The right analogies in expressing the correct computational
rules and concepts. It is required an understanding of logical
reasoning in order to use and communicate these concepts
effectively (e.g. how students can propose a solution based on
their natural perceptions and if its rules/concepts can be
transferred to programming constructs for execution). Many
studies [7,11,24] have addressed the syntactic challenges of
end-user programming shifting from syntactic to semantic and
pragmatic concerns. This process supports a focus on essence
for visualizing behaviors with building blocks consist of
motion commands (command blocks) and programming
constructs (control flow blocks) that can be integrated to
objects by composing programming constructs as design
patterns to propose executive solutions for a problem;
(3) Execution and evaluation of design patterns (strategy
analysis): To known how to program effectively for solving a
problem, students need both to explain and understand the
syntax and semantics of programming concepts, and combine
these features into valid computer programs. The evaluation of
students’ solutions and thinking process as a cognitive
problem-solving strategy to transfer a solution that defined as
a natural perception into workable instructional plans for
solving problems can be achieved through programming. To
evaluate the development of effective design strategies, a
scaffolding teaching approach is suggested to support students
in mastering this nesting composition method of programming
constructs as design patterns [20,24]. For instance, integrating
explicit educational instructions and extra feedback by the
instructor on the composition of programming plans with
visualized program tracking in game play mechanisms, users
can deeply understand how nested control-flow blocks work
and what are the subsequent effects of the chosen actions.
Pertaining on the above, a SG should support students to
(a) create correct and complete computational rule
specifications for problem-solving, using firstly natural
expressions; (b) develop an understanding of computational
concepts, and the appropriate programming constructs to
practice a solution for the given facts of a problem and (c)
transform programming problems into workable plans and
algorithms using programming constructs. Therefore, this
contribution aims to (i) propose a game playing framework for
supporting students to learn how to solve computational
problems in simulated realistic contexts by interacting with the
provided visual programming elements, and (ii) understand
the entire process on how students interact with a proposed
environment, so as to examine their performance in
computational problem solving based on different design
patterns that they propose. To address these issues, the present
work tries to extend game model cycle of Garris et al. [25] and
proposes an on-going game playing framework with specific
design guidelines and its benefits in acquiring CT skills to
support learning introductory CS courses. The following
proposed guidelines are along with a reference to Garris et al.
[25] principles from which they arose (indicated as P1 for
user motivation and persistent engagement, etc. which are
referred in the Background):
1st guideline (G1): Motivating students to participate in
active learning tasks- While a computer game is intrinsically
motivating, there should be developed sub-parts of the main
problem with clear and challenging tasks. Users can achieve
higher level learning by solving relevant sub-goals, in order to
start analyze, create, apply and evaluate each proposed
solution. This process will allow them more properly to think
logically and critically for the analysis and expression of
solutions to a problem (P1);
2nd guideline (G2): Simulating an authentic problem- The
simulation of an authentic problem should be available for
exploration at the beginning. Data visualization and
representation should avail more clearly the operation of
learning activities that students can be involved. If students are
more interested and involved knowing what they precisely
have to do, they devote more time on actively pursuing
through challenging activities (P2);
3rd guideline (G3): System’s feedback on user’s actions- A
SG should not only simulate a real-world problem that may be
encountered in everyday life of students, but it should also
provide prompt feedback during the run-time of students’
actions, either optically or acoustically to better conceptualize
concrete game playing examples to abstract strategy (P3);
4th guideline (G4): Facilitating the development of
computational problem-solving strategies through a
scaffolding process- The game should allow students to
develop their problem-solving strategies for scaffolding the
program construction, i.e. before finalize the solution, program
should be broken down into sub-programs which would make
the given task manageable by collecting and using the
appropriate data to propose a solution for each sub-part of the
main problem. Take for example, through an interactive game
playing, where students need to know how to insert behaviors
in objects with the purpose of making both interact to each
other. On the other hand, the instructor should demonstrate
how such a sub-program could be constructed. Even if
frustrating tasks are observed, the instructor should guide the
students by prompting them with questions on their problem-
solving process (e.g., which is the main reason of putting that
command there?) (P4);
5th guideline (G5): Applying design patterns to propose an
answer for the main problem’s question- Students’ embodied
experiences/ideas should be simulated through actions that are
performed on the sub-parts of the main problem. By helping
students to understand how to transfer of behaviors in different
objects, it is considered as a crucial process in recognizing
how these actions will (or not) solve a problem. In this
perspective, students can propose design patterns to
implement their ideas by coding and using programming
constructs (e.g., repetition or selection) in control flow
instruction commands. This approach can foster computational
practices and perspectives, as students need to review and
think about the programming process by modifying building
blocks of programming constructs, and present program
execution consequences for omissions or commissions of the
code segments (P5).
Figure 1 illustrates the proposed framework and game
guidelines, which can be designed to be an integral part of
game characteristics to support the design guidelines (G) that
have been previously described. These are: (a) Fantasy: A SG
should offer analogies or metaphors for real-world processes
that permit users to have experience with phenomena or tasks
which sometimes cannot be done in real-world settings. For
example, students as embedded systems engineers can
integrate behavior in objects responding to events, or issue
commands to actuate controls; (b) Rules/Goals: The rules
describe the goal structure of the game. The game designer
should predetermine also the game mechanics that would help
users who lag while play; it could include bonus or subsidies
or for their poor performance to have a score board with
penalties. If students can understand and specify
computational rules, they may use and express relevant basic
computational concepts correctly to propose their solutions;
(c) Challenge: Games should employ progressive difficulty
levels, multiple goals, and appropriate information to ensure
certain learning outcomes. Performance feedback and score
keeping allow players to track progress toward desired goals.
A challenging task is created by things, like time pressure and
opponent play. Fellowship should be encouraged by sharing
information among team members or announcing the winning
conditions with awards that are more difficult to achieve each
one. In a fading scaffolding process, the instructor’s role is
explicitly to scaffold and assist students to use their virtual
characters and then start to play following sequences of game
rules (algorithmic thinking patterns); (d) Mystery: Simulations
that incorporate these features become more game-like. For
example, in a game-based environment, users are trained in a
simulation that incorporates features, such as role-playing and
scoring that are not present in the real-world task. Users can
be curious about their performance based on their solutions
that expressed as design patterns; (e) Control: A sense of
freedom inside a gaming task allows users to select/refine
strategies, manage the direction of activity, and make
decisions that directly affect outcomes, even if actions are not
instructionally relevant. This sense, beyond the
implementation of each learning task, it gives to each user the
ability to explore, recognize the problem space, and propose
alternative solutions; and (f) Sensory stimuli in a SG includes
sound effects, dynamic graphics, and other media sources.
Such an environment should not disrupt at a large extent the
stability of normal sensations and perceptions. It can also
allow the user to have a more reliable experience, like
programming a train and the railway model that is needed for
the integration of behaviors in the environment to understand
simulated phenomena, such as gravity, in contexts that mimic
those measured when driving as in reality.
As it is shown in Figure 1, students need initially to be
engaged in game tasks, which will in turn generate their desire
for improvement through attractive learning scenarios, such as
role-playing (Stage 1). These tasks will help students to
develop computational problem-solving strategies regarding
the targeted educational content and through several tasks,
they will be able to produce a set of learning outcomes (Stage
2). In the end, the learning objectives will be achieved and
evaluated after the game experience (Stage 3). It is of great
importance to mention that players continuously need to
increase their problem visualization and solution-development
as they progress through a game. In this demand, segmented
four stages (S1-S4) can be aligned with the proposed game
design guidelines (G1-G5). The first stage (S1) is aligned with
the 1st and 2nd guidelines, the second stage (S2) is collimated
with the 4th guideline, the third stage (S3) relates to the 5th
guideline, and the fourth stage (S4) is allied to the 3rd
guideline for the system’s feedback cycle.
Figure 1: The illustration of the proposed framework
This proposed game playing framework is developed
specifically for designing games to identify how CS concepts
can be associated with specific learning tasks to support the
development of computational problem-solving.
B. An instructional design approach
The next step that will lead to the proper construction of
this framework is the identification of the instructional
methodology that a game will be based on. According to the
proposed framework, a SG prototype may have the following
characteristics: (a) the simulation of authentic problem
situation and functionalities in fading scaffolding processes for
supporting users’ roles (students and instructor), (b) the visual
metaphors of Open Sim related to innate CT skills and
conceptualize them into algorithmic rules through abstract
thinking logic, and (c) the S4SL palette use to eliminate split
attention in code syntax, focusing on goals of users’ solutions
that applied as results of computational problem-solving
strategies. By using a game simulation, players can carefully
consider how the actions will (or not) solve a problem. Thus,
students can have the opportunity to program the transfer
behaviors of an object according to their experience in a
simulated real-world context. Similarly, novices are allowed to
learn the process of solving a computational problem, giving
instructions on how a robot vacuum cleaner should clean a
room without hitting on tables, humans or animals. While
single-user applications in SGs (one single user and the
simulation environment) are provided in conventional
instructional approaches, 3D VWs, like Open Sim can provide
opportunities for designing a multi-user SG to interact with
other peers in situations with new identities (i.e. as avatars) in
the form of role-playing. By way of illustration, the ability to
change the appearance of one’s avatar to fit the role that can
play, for example as an embedded system engineer in a
problem space, can become a powerful contributor to the
veracity of simulation. This ability can affect positively the
user’s willingness to participate, for example as an
engineer who want to specialize knowledge in exploring the
interactions through a process of controlling how various
devices and machines can be worked correctly and
simultaneously in a modern simulated house.
The rationale for utilizing S4SL and Open Sim can provide
multiple opportunities for students to learn programming
commands. These are: (a) the emphasis on the design of
algorithmic problem-solving activities by avoiding syntax
errors from LSL; (b) the visually-rich set of tools to create,
edit and syntax multiple artifacts via S4SL to coordinate the
learning procedure using a-/synchronous communication tools
in Open Sim; (c) the direct feedback based on their actions in
a common environment by copying and pasting from
Scratch’s palette blocks as design patterns to an object’s
notecard for integrating behaviors; and (d) the S4SL palette is
frequently used in high schools and this feature can help
students’ motivation and participation in programming.
Three are the goals that considered as important for
helping students articulate and transfer their thinking solutions
from natural language to workable plans and algorithms with
precise instructions in coding using Open Sim and S4SL.
These goals are the following:
(a) Integration of the learning material within the game
interface: Providing a natural way of formalizing knowledge
to an abstract manner in a simulated real-life problem-based
context during game play has a critical place. Decomposing
innate thinking into abstract representations using visual
metaphors of Open Sim employ an approach that should infer
and predetermine the designer specific strategic rules
corresponding to multiple movements that are the most
appropriate to be done by students. Using this method,
students can choose between two or more appropriate options
or directly specify another one. In this occasion, although
users can previously solve low granularity problems, such as
creating a robot, they have also the chance to create a
simulation-based environment, integrate to it several objects
with behaviors that interact with other objects or avatars in the
same environment and find solutions to an authentic problem;
(b) Transfer from tacit thinking to concrete thoughts of
computational concepts: Providing activities to a natural way
of formalizing students’ ideas during game play is crucial
place to assist them explicitly link their game actions to CT.
The instructor needs to explain the primary aim of the courses
and to suggest students on how they can propose the right
rules or directly specify a new rule (e.g. pseudo-code or full
sentences in natural language) before programming. Students
should try to explain their solutions that require the
articulation of CT skills (e.g. abstract logic, expression of
rules in naturally game-play settings that should be applied
through coding). The technological infrastructure of Open Sim
also makes it possible for an authentic problem, not only to be
simulated visually, but also simplified by removing factors,
which would need to be addressed in real-life. A specific
example is when providing ready-made scripts or objects with
integrated behaviors for movement, in which users start to
work focusing directly on specific sub-parts of a problem; and
(c) Transform students’ thinking knowledge through in-
game play settings into formal logic and analysis about a
solution in coding: Student’s progress in scaffolding activities
requires the process of concreteness in transferring from
natural expression to coding via S4SL. Therefore, S4SL
palette can be used to minimize the split attention effect by
avoiding any misconception in code syntax. More specifically,
students can program the objects’ behavior via S4SL, by
writing building blocks to copy-paste from the palette into
LSL scripts, and receive an immediate visual feedback of how
their programs running inside Open Sim. The instructor can
coordinate the in-game learning process, give feedback on
users’ actions or frustration tolerance for ambiguity
movements and evaluate their progress when they present and
observe program execution consequences at runtime.
Table 1 associates a process about how students can
develop their skills in game play with the previously defined
CT skills from the aforementioned analysis, so that supporting
computational problem-solving development through in-game
settings. This table also validates how cognitive thinking skills
(e.g. logical or abstract thinking etc.) can be developed in
game playing modes and the foundation of CT skills outlined
based on the literature in dwelling on problem solving,
understanding problems, and formulating solutions [3]. Using
this type of game playing in a SG, students can visualize their
efforts according to their dispositions and attitudes that are
essential dimensions of CT, as aligned with the proposed
game design principles (G1-G5) to understand how they can
apply them effectively to every programming construct.
Learning tasks associated with CT concepts and CT
skill definition [3]
Proposed game activities
Develop an algorithmic thinking of logical steps for the
proposed solution to the main problem.
Logical thinking skills: Logical steps required for
constructing a solution to the given problem.
Describe a possible solution as an
algorithm to complete sub-goals of the main problem
using natural language (G1).
Problem identification and decomposition into a collection
of intermediate sub-goals.
Problem-solving skills: Process of breaking down a large
problem into smaller sub-parts.
Analyze the path that is better to be followed.
Try to understand how you can move your object in
Open Sim (G2).
1.Abstraction and data representation as steps in creating
algorithm
2.Design and implement solution to the sub-goals of the
Designate the movements of an object, spatially. Try
to transmit your solution in coding for the object’s
movements and observe the results during the run-
main problem
Abstract thinking skills: Explanation of how and which
programming constructs can be utilized.
time. Is the naturally-expressed solution that is given
implemented correctly based on the proposed
instructions and rules? Is it easy to follow a solution
algorithm and observe the expected behaviors? (G3)
Automation, practice in run-time mode the proposed steps
using programing commands and instructions
Critical and algorithmic thinking skills: It is a way of
getting to a solution through the clear definition of the steps
needed required actions, and events to other similar
phenomena.
Debug and observe errors with purposed of
monitoring a solution algorithm, by using control
flow principles (G4)
Algorithms testing and debugging processes: Create
efficient and repeatable design patterns
Applied strategic planning skills: (a) Identifying,
analyzing, and implementing possible solutions with the
goal of achieving the most efficient and effective
combination of steps and resources and (b) Understanding
the conjunction of analogies between the naturally-
expressed solutions with coding design patterns
Implement a solution plan according to the given
instructions and detect any potential errors logically
by executing programming commands blocks via
Scratch4SL (G5).
Simulation and parallelization: Problem generation and
pattern generalization
Expression and communication skills: Solving problems
in a similar way based on the previous experience solving
the same type of problems. Generalizing and transferring
this problem-solving process to a wide variety of problems.
Examine by benchmarking with other peers the
proposed design patterns. What differences can be
observed for scoring better in the game according to
the proposed design patterns? Discuss with other
peers and with the CS instructor (G5).
Table 1 - Description of activities associating with game playing
A case study using the proposed framework and design
guidelines in a SG can be implemented, following blended
instructional format by spending some hours in school’s
computer laboratory and some others in supplementary online
courses. CS concepts that want to present the instructor,
should be made in the conventional computer laboratory and
the implementation of any concept that learned in the SG
created in Open Sim. Initially, even before the beginning of
this study, the instructor need to establish and ensure students
access in Open Sim and S4SL, either if courses will be done in
a computer laboratory or online, with the purpose of resolving
any technical issues and allow them to participate seamlessly,
like doing a homework. The instructor has also the
responsibility: (a) to attend in all courses (face-to-face and/or
supplementary online) and assist students’ efforts, (b) to give
the appropriate feedback for compilation or execution of nay
detected errors and (c) to access on users’ actions, either
online via Open Sim or offline in rubrics, which can provide a
general understanding on how students start thinking about
solving sub-goals of the problem before coding.
IV. CONCLUSION AND FUTURE WORK
This work outlines a theoretical game playing framework
for the creation of SGs that can support the development of
computational problem-solving strategies. Main findings of
this work may be of interest to instructional designers who
want to take in advance a learning environment for high-
school CS courses. The results may be predominantly helpful
for instructors or educators who design (in-) formal instruction
using a SG to foster students’ computational problem-solving
strategies. Based on the proposed design guidelines, a SG can
present the core function of CT, in which the key operations of
abstracting and modeling can foster students’ thinking about a
problem. The results of abstracting and modeling
understandings are executed in order to be applied effectively
and efficiently the design patterns for simulated real-life
problems, as a process that allows the evaluation and
debugging of thinking. According to the proposed framework
using Open Sim and S4SL, a SG prototype for a real-life
problem, with scaffolding leaning tasks reflecting on students’
solutions through coding is also being developed.
REFERENCES
[1] M. Bienkowski, E. Snow, D. W. Rutstein & S. Grover. Assessment
design patterns for computational thinking practices in secondary
computer science: A first look (SRI technical report). Menlo Park, CA:
SRI International, 2015.
[2] Webb et al.. Computer science in K-12 school curricula of the 2lst
century: Why, what and when? Educ. & Inf. Tech.. 2016.
[3] CSTA & ISTE. Computational Thinking in K12 Education leadership
toolkit, 2011.
[4] C. Liu, Y. Cheng & C. Huang. The effect of simulation games on the
learning of computational problem solving. Comp. & Educ., Vol. 57, pp.
19071918, 2011.
[5] S. Grover, R. Pea & S. Cooper. Designing for deeper learning in a
blended computer science course for middle school students. Comp.
Scien. Educ., Vol. 25, pp. 199-237, 2015.
[6] S. Grover & R. Pea. Computational thinking in K12: A review of the
state of the field. Educ. Researc., Vol. 42, pp. 3843, 2013.
[7] S.Y. Lye & J.H. Koh. Review on teaching and learning of computational
thinking through programming: What is next for K-12?” Comp. in Hum.
Behav., Vol. 41, pp. 51-61, 2014.
[8] L. Werner, J. Denner & S. Campe. Children Programming Games: A
Strategy for Measuring Computational Learning. TOCE, Vol. 14. 2015.
[9] K. Brennan & M. Resnick. New frameworks for studying and assessing
the development of computational thinking. In Proc. of the Annual
meeting of the Amer.Educ. Res. Ass., Vancouver, Canada, 2012.
[10] C. Girvan, B. Tangney & T. Savage, SLurtles: Supporting
constructionist learning in Second Life. Comp. & Educ., Vol. 61, pp.
115-132, 2013.
[11] K. Howland & J. Good, Learning to communicate computationally with
Flip: A bi-modal programming language for game creation. Comp. &
Educ., Vol. 80, pp. 224240, 2015.
[12] S. Davies. The effects of emphasizing computational thinking in an
introductory programming course. 38th Annual Frontiers in Education
Conference, Saratoga Springs, NY, 2008, pp. 3-8.
[13] M. Guzdial. Paving the way for computational thinking. CACM, Vol.
51, pp. 25-27, 2008.
[14] S. Cooper, L. C. Perez, and D. Rainey. K-12 computational learning.
CACM , Vol. 53, pp. 2729, 2010.
[15] A. Basawapatna. Alexander Meets Michotte: A Simulation Tool Based
on Pattern Programming and Phenomenology. Educ. Tech. & Soc.,
Vol.19, pp. 277291, 2016.
[16] Y. Lee M. Mauriello, J. Ahn & B. Bederson. Ctarcade: Computational
thinking with games in school age children. Inter. J. of Child-Comp.
Inter., Vol. 2, pp.26 33, 2014.
[17] J. Good, K. Howland & L. Thackray. Problem-based learning spanning
real and virtual worlds: A case study in second life. ALT Journal,
Vol.16, pp. 163172, 2008.
[18] M. Rico, G., Martinez-Muñoz, X. Alaman, D., Camacho, & E. Pulido. A
Programming Experience of High School Students in a Virtual World
Platform. Int. J. of Eng. Educ., Vol.27, 2011.
[19] J. Wing, Computational thinking. CACM, Vol. 49, pp. 3335, 2006.
[20] Y. Kafai & Q. Burke. Constructionist Gaming: Understanding the
Benefits of Making Games for Learning, Educ. Psych., Vol. 50, pp. 313-
334, 2015.
[21] B., Dalgarno & M. Lee. What are the learning affordances of 3-D virtual
environments? BJET, Vol.41, pp. 1032, 2010.
[22] M. Esteves, B. Fonseca, L. Morgado & P. Martins. Improving teaching
and learning of computer programming through the use of the Second
Life virtual world. BJET, Vol.42, 4, pp. 624-637, 2011.
[23] J. Denner, L. Werner & E. Ortiz. Computer games created by middle
school girls: Can they be used to measure understanding of computer
science concepts? Comp. & Educ., Vol.58, 2012, pp. 240-249.
[24] Repenning, A., et al., N. Scalable game design: A strategy to bring
systemic computer science education to schools through game design
and simulation creation. ACM TOCE, Vol.15, pp. 131, 2015.
[25] R. Garris, R., Ahlers & E. Driskell. Games, motivation, and learning: A
research and practice model. Sim. & Gam., Vol. 33, pp. 441-467, 2002.
... With the introduction of computational thinking in education, its integration into game programming has been discussed and studied by many researchers. Several specific design guidelines were proposed that help computational thinking skills to effectively integrate into the learning environment, which in turn can foster students' computational problem-solving skills (Pellas & Vosinakis, 2017 Brennan and Resnick (2012) examined the assessment of these dimensions by project portfolio analysis, artefact-based interviews and design scenarios. They also listed the strength and limitations of these assessment types. ...
... Their findings show a strong relationship between students' programming skills with Scratch and their computational thinking skills. The study by Pellas and Vosinakis (2017) examines how to design a simulation game to foster the development of computational problem-solving techniques by learning the fundamental computer science concepts and introduces a theoretical game playing framework. This theoretical game playing framework with several game design guidelines, which includes concepts of computational thinking such as abstraction, decomposition, algorithmic thinking and evaluation, and this framework can be used to foster students' thinking about a real-life problem (Pellas & Vosinakis, 2017). ...
... The study by Pellas and Vosinakis (2017) examines how to design a simulation game to foster the development of computational problem-solving techniques by learning the fundamental computer science concepts and introduces a theoretical game playing framework. This theoretical game playing framework with several game design guidelines, which includes concepts of computational thinking such as abstraction, decomposition, algorithmic thinking and evaluation, and this framework can be used to foster students' thinking about a real-life problem (Pellas & Vosinakis, 2017). Not only computer games but also various types of technology toys and board games are used in the learning process of computational thinking (Lin, 2015). ...
Thesis
Computational thinking, a form of thinking and problem solving, is defined as a mental process for abstracting problems and formulating solutions. Computational thinking is considered to be an essential skill for everyone and has become the centre of attention in education settings. There is a limited number of tools to measure computational thinking skills by multiple-choice questions, and limited research on the relationship between computational thinking and other domains. The purpose of this research is to investigate the relationship between computational thinking performance, perception of computational thinking skills and school achievement of secondary school students. Computational thinking performance of secondary school students in Kazakhstan is measured by using a bespoke multiple-choice test, which focuses on the following elements of computational thinking: logical thinking, abstraction and generalisation. The perceptions of computational thinking skills are self-reported using a pre-existing questionnaire, which covers the following factors: creativity, algorithmic thinking, cooperation, critical thinking and problem solving. The General Knowledge Test results that contain scores for 14 different subjects are used as indicators of students’ school achievement, with further sub-scores for the science subjects, language subjects and humanities. The sample group of 775 grade eight students are drawn from 28 secondary schools across Kazakhstan. The validity and reliability of the multiple-choice questions are established by using Item Response Theory models. The item difficulty, discrimination and guessing coefficients are calculated; and the item characteristic curves for each question and test information functions for each quiz are obtained. As a result, the multiple-choice questions are concluded as a valid and reliable tool to measure the computational thinking performance of students. Multiple regression is used to examine the relationship between computational thinking performance, perception of computational thinking and school achievement sub-scores. The results of the data analysis show that science subjects, language subjects and perception of computational thinking skills are significant predictors for computational thinking performance, showing a moderate relationship between computational thinking performance and school achievement. However, no significant relationship is found between humanities subject scores and computational thinking performance. This study also adds to the literature for the studies that investigate the relationship between computational thinking skills and other variables. This research contributes to the development of validated tools to measure computational thinking performance by using multiple-choice questions. This study investigates the relationship between computational thinking performance and general school achievement of secondary school students, and its findings shed light on the measurement of children’s cognitive development. The findings can help in designing better curricula by adjusting subjects that enhance children’s higher-order thinking abilities. The findings obtained in this research also adds to the literature for the studies that investigate the relationship between computational thinking skills and other variables.
... The former refers to a block-based programming language with a colored palette displayed through various stages (backdrops) or elements (sprites), providing students with a visual means to organize their commands and instructions written in natural language. This supports the process of operating and coding visual objects for the production of computing innovations (Pellas & Vosinakis, 2017). The latter involves 3DVWs that can project an authentic and immersive (learning) experience on a computer screen through simulated realism. ...
... Several researchers (Grover & Pea, 2013;Tikva & Tambouris, 2021) have suggested the use of SGs created via interactive environments to foster students' CT skills. SGs offer embodied learning tasks based on visual characters and elements/objects, which can support students' CT skills to apply their solution plans into code by taking advantage of the intuitive, natural modality of scientific discovery processes projected within two-dimensional (2D) and three-dimensional (3D) problem-solving contexts (Pellas & Vosinakis, 2017). ...
Article
Full-text available
There is substantial evidence that incorporating interactive environments for game-based instruction has a significant potential to support the development of computational thinking and programming skills in primary education students. However, it is not clear whether a simulation game (SG) with different user interface elements, created via three-dimensional (3D) virtual worlds and visual programming environments to project various problem-solving exercises in a simulated reality, can significantly influence students to think and practice "computationally" their solution plans into code. The current study aims to identify any possible added value of each instructional approach by measuring students' game experience and learning performance. This quasi-experimental study involved ninety participants (n=90) aged between 10 and 11 years that consisted of two comparison conditions. The experimental group (n=45) received training using OpenSimulator in combination with Scratch4SL, whereas the control group (n=45) was solely trained using Scratch. The findings indicate considerable differences in students' game experience and satisfaction, but no statistically significant difference in their learning performance and knowledge gain was identified. This study provides several design implications for user interface and game elements to inform educational practitioners and instructors about the benefits that each approach can offer students for better knowledge acquisition and deeper disciplinary understanding.
... Visual programming environments (e.g., Scratch, Alice, AgentSheets) and three-dimensional (3D) virtual worlds (3DVWs; e.g., Active Worlds, OpenSimulator, Second Life ™ ) have received much attention due to various tools that enclose and allow students to design, create and program interactive animations, games, and storytelling applications (Lye & Koh, 2014). The former offers a block-based programming language with a colored palette displayed by using various stages (backdrops) or elements (sprites) for students to organize their visual commands and instructions written in natural language, supporting the process of operating and coding visual objects for the (re-)production of computing innovations (Pellas & Vosinakis, 2017). The latter entails 3DVWs that can project on a computer screen authentic and immersive (learning) experience through simulated realism. ...
... Relevant literature reviews (Kafai & Proctor, 2021;Lye & Koh, 2014) concluded that SGs created by using interactive environments can become appropriate in several tasks, connecting theory and practice in visual coding for better knowledge acquisition. Previous studies (Çakiroğlu & Çevik, 2022;Pellas & Vosinakis, 2017) have stressed the importance of establishing visual or/and symbolic representations with playful design elements. Such tasks can be easily used by students to introduce and explain CT concepts related to abstraction, algorithms, automation, decomposition, and generalization for spotting and solving problems. ...
Article
Full-text available
Background: Owing to the exponential growth of three-dimensional (3D) environments among researchers and educators to create simulation games (SGs) in primary education, there is a growing interest to examine their potential support in computer science courses instead of visual programming environments. Objectives: This study explores the relationships between students’ learning performance, focusing on computational thinking (CT) and programming skills development, in association with their cognitive load (mental load and mental effort) and emotions (happiness, anger, anxiety, sadness) by playing a SG. Methods: A total of two-hundred and ninety participants (n=290) in fifth-grade classes (10-11 years old) of Greek primary schools completed all pre-and post-intervention tests. A quasi-experimental study was conducted over a 14-week timetable course and in two comparison conditions, in which a SG was created by using OpenSimulator&Scratch4SL and Scratch for the experimental group (n=145) and the control group (n=145), respectively. To further investigate the effectiveness of the proposed SG in each teaching intervention, an exploration of relationships between students’ learning performance, cognitive load, and emotions through multiple analyses, depending on correlation, t-tests, correlation, and hierarchal regression were delivered. Results and Conclusions: The findings indicate that the proposed SG created by using OpenSimulator&Scratch4SL positively affected students’ emotions and cognitive load, whereas there was no significant difference in learning gain between the two groups. Implications: This study provides empirical evidence on the effects of SGs on students’ knowledge acquisition, highlighting the importance of considering both cognitive and emotional components in the design of these games. The findings offer valuable insights for implications and design guidelines.
... Notably, computer games are found to positively impact students' achievement and motivation. Meanwhile, cluster 3 highlights themes such as CT integration in K-12 education, instructional methods for CT, programming instruction, and the development of CT skills via learning games, interactives, and simulations [78,[110][111][112][113]. These tendencies in co-citation networks underscore the importance of teaching approaches aimed at enhancing students' achievement and attitudes via GBL [114]. ...
Article
Full-text available
Over the last decade, research on evolving computational thinking (CT) has garnered heightened attention. Assessing the publication tendencies and nucleus contents of investigations on progressing CT to direct future research initiatives, develop policies, and integrate them into instructional materials is timely and exceedingly essential in education. Therefore, this research reviewed publications on progressing CT to identify research trends and core contents published in the Scopus database from 2008 to May 2022. For this reason, this study applied bibliometric and content analysis to 132 selected publications. After examining bibliometrics, the findings indicate a steady increase in publications related to game-based learning (GBL) and CT, reaching a peak in 2021, with the United States emerging as the most prolific contributor in terms of authors, institutions, and countries). The leading country in citations is primarily China. The document that received the most citations is Hsu’s 2018 paper on “Computers and Education”. Analysis of keywords and themes reveals core content tendencies, emphasizing teaching methods and attitudes aimed at improving CT via GBL. These results offer valuable insights for researchers and educators to inform their future work. However, future studies may benefit from including other databases such as Web of Science (WoS) and PubMed, employing alternative bibliometric software like VOSviewer or CiteSpace, as well as collecting data from June 2022.
... Practically, GBL can be implemented through three approaches. According to Pellas and Vosinakis (2017), only a few studies have been done in the playing games approach. Therefore, the study found the playing games approach as an opportunity to be explored in the learning of CT skills. ...
Article
Full-text available
This study proved the design and content validity process of a computational thinking game-based learning module. The process involved a two-step method: instrument design and judgmental evidence. Content domain identification, item generation, and instrument construction were included in the former step while the latter involved seven experts to review and rate the essentiality, relevancy, and clarity of the generated 30 items in the first and 34 items in the second round. Suggestions and ratings by the panel of experts in the second step were used to examine the instrument content validity through content validity ratio (CVR), content validity index (CVI), and modified kappa statistic approach. The findings manifested the second round promised better results with the increment of totally essential items by 59.41 percent and the increment of total relevant, clear, and excellent items by 3.33 percent. It implies in the second round that 79.41 percent of overall items were significantly essential, and 100 percent of the overall items were significantly relevant, clear, and excellent. Overall, the instrument got significant content validity after the second round by s-CVI/UA=0.97 and s-CVI/Average=0.99. Hence, the instrument has a great potential to measure the content validity of a brand-new computational thinking game-based learning module. However, it was then recommended to involve more experts during content domain determination and item generation and to further explore the findings that support the content validity of 33 items on instrument reliability.
... Practically, GBL can be implemented through three approaches. According to Pellas and Vosinakis (2017), only a few studies have been done in the playing games approach. Therefore, the study found the playing games approach as an opportunity to be explored in the learning of CT skills. ...
Article
Full-text available
This study proved the design and content validity process of a computational thinking game-based learning module. The process involved a two-step method: instrument design and judgmental evidence. Content domain identification, item generation, and instrument construction were included in the former step while the latter involved seven experts to review and rate the essentiality, relevancy, and clarity of the generated 30 items in the first and 34 items in the second round. Suggestions and ratings by the panel of experts in the second step were used to examine the instrument content validity through content validity ratio (CVR), content validity index (CVI), and modified kappa statistic approach. The findings manifested the second round promised better results with the increment of totally essential items by 59.41 percent and the increment of total relevant, clear, and excellent items by 3.33 percent. It implies in the second round that 79.41 percent of overall items were significantly essential, and 100 percent of the overall items were significantly relevant, clear, and excellent. Overall, the instrument got significant content validity after the second round by s-CVI/UA=0.97 and s-CVI/Average=0.99. Hence, the instrument has a great potential to measure the content validity of a brand-new computational thinking game-based learning module. However, it was then recommended to involve more experts during content domain determination and item generation and to further explore the findings that support the content validity of 33 items on instrument reliability.
... CT involves formulating problems with tools and methods such as computers and data analysis, finding possible solutions, and using these solutions to solve other similar problems (Barr, Harrison, and Conery, 2011;Wing, 2008). This process also defined as computational problem solving (Pellas, Vosinakis, 2017). According to Dierbach (2012), two things are needed to solve a problem computationally: a solution proposal that covers all relevant aspects of the problem and an algorithm that can solve the problem using this solution proposal. ...
Article
Full-text available
This study reports the findings of a program that aims to develop pre-service science teachers’ computational problem-solving skills and views on using information and communications technology in science education. To this end, pre-service science teachers were trained on computational thinking, computational problem solving, designing an algorithm, and Python coding, and then they were asked to solve problem situations determined within the science education program using the computational problem-solving process. The study was conducted in a faculty of education in Turkey and carried out conducted in an elective course in the spring semester of the 2019 - 2020 academic year (in an online platform due to the Covid-19 Pandemic). 38 pre-service science teachers were included in the study. In this process, pre-service science teachers’ conceptual development levels regarding computational thinking and their views regarding the use of ICT in schools were collected quantitatively. The development of computational problem-solving skills of pre-service science teachers was scored by a rubric developed in this study. According to the analyzes, pre-service science teachers increased knowledge of computational thinking (t = -5,969, p = .000), enhanced views regarding the use of ICT in schools (t = -2,436, p = .020), and developed computational problem-solving skills (χ2(2) = 9.000, p = 0,011). These findings have the potential to provide evidence on how computational problem-solving skills can be integrated into science teacher education programs.
... The final and certainly the least common way is to facilitate the teaching and learning of introductory computer programming through the use of video game technologies in an educational game context, also referred to as serious games, due to several exhibiting features of games such as learnercentricity, interactivity and immediate feedback. The rationale behind this educational gaming context, which is the fundamental argument for serious games, is that the immersive and engaging nature of game-play encourages students to greater levels of investigation, experimentation and re-use [33], [34]. Such games can thus support the realization of basic programming constructs in addition to planning algorithms and enhancing problem-solving skills [17]. ...
Article
Full-text available
Computer Science (CS) is a profession that positively impacts every single area of society without which today’s world would come to a complete halt. Yet, there is a consensus that CS has serious conundrums particularly in attracting students, low motivation for learning computer programming and developing computational thinking (CT) skills. New motivational methods are needed to take the attention of students and adapt to their learning patterns as how people learn have changed drastically over the last two decades. To address these issues, video games and video game-based tools are proposed as a primary approach for motivating and supporting students in developing their skills in CT and support their learning of introductory programming. This research is concerned with the capture of statistical evidence on the educational effectiveness of playing a serious game specifically designed to enhance the development of CT skills to facilitate learning introductory computer programming. A total of 190 students were invited to participate in a quasi-experimental pre-post study for the purpose of analyzing the impact of an adhoc game on students’ confidence in learning programming constructs and using their skills in CT. All students were studying a CS degree at the time and they were all registered to a first-year computer programming course. 151 out of 190 students successfully completed the study and the findings suggest that a) the intrinsic motivation to learn programming; b) students’ perception of their knowledge and their tangible knowledge in key programming constructs (i.e. programming sequence, methods, decision making and loops); and c) students’ confidence in using their CT skills were all statistically and significantly improved after playing the game. Additionally, students perceived computer programming significantly less difficult in their post study responses when compared to their pre study responses.
... Virtual worlds with their various features could be used as a tool in the teaching of programming. They offer exciting new environment for learners to engage in programming through the construction of meaningful 3D artefacts within group studies; something that is arguably difficult to achieve with other programming environments (Pellas & Vosinakis, 2017). ...
Article
As one of the most desired skills for contemporary education and career, problem-solving is fundamental and critical in game-based learning research. However, students' implicit and self-controlled learning processes in games make it difficult to understand their problem-solving behaviors. Observational and qualitative methods, such as interviews and exams, fail to capture students' in-process difficulties. By integrating data mining techniques, this study explored students' problem-solving processes in a puzzle-based game. First, we applied the Continuous Hidden Markov Model to identify students' problem-solving phases and the transition probabilities between these phases. Second, we employed sequence mining techniques to investigate problem-solving patterns and strategies facilitating students' problem-solving processes. The results suggested that most students were stuck in a certain phase, with only a few able to transfer to systematic phases by applying efficient strategies. At the beginning of the puzzle, the most popular strategy was testing one dimension of the solution at each attempt. In contrast, the other two strategies (remove or add untested dimensions one by one) played pivotal roles in promoting transitions to higher problem-solving phases. The findings of this study shed light on when, how, and why students advanced their effective problem-solving processes. Using the Continuous Hidden Markov Model and sequence mining techniques, we provide considerable promise for uncovering students' problem-solving processes, which helps trigger future scaffolds and interventions to support students’ personalized learning in game-based learning environments.
Article
Full-text available
In this paper we have examined the position and roles of Computer Science in curricula in the light of recent calls for curriculum change and we have proposed principles and issues to consider in curriculum design as well as identifying priority areas for further research. The paper is based on discussions within and beyond the International Federation of Information Processing (IFIP) Education Community since 2012 as well as an analysis of curriculum developments in five different countries. Emerging themes have been discussed with reference to important perspectives from curriculum theory including “powerful knowledge” as a key element of entitlement and management of the growth of expertise. Based on this analysis we have identified areas of consensus as well as constraints, risks and issues that are still subject to controversy. There is an emerging consensus of the importance of Computer Science and the nature of its “powerful knowledge”. Furthermore current understanding of the opportunities and benefits for starting to learn Computer Science early in primary schools has identified this early start as an entitlement and equity issue. There is a strong consensus that teacher professional development in Computer Science Education is critical for supporting curriculum change and is currently a major challenge in many countries. Other key issues include understanding how the growth of expertise affects potential structure and sequencing in the curriculum and the balance of content. Further considerations include how new technological opportunities interact with pedagogical approaches and can provide new potential for the growth of expertise.
Article
Full-text available
Simulation and modeling activities, a key point of computational thinking, are currently not being integrated into the science classroom. This paper describes a new visual programming tool entitled the Simulation Creation Toolkit. The Simulation Creation Toolkit is a high level pattern-based phenomenological approach to bringing rapid simulation creation into the classroom environment. Students create agent-based simulations via analogy between the real world phenomena they are trying to represent and “interacticons,” which are visual animations of generic agents enacting the phenomena. This approach obviates the need for students to implement low level and often time-consuming agent behavior programming and yet, requires the use of abstraction, which is a key component of computational thinking. Initial data shows that students in the classroom can implement simulations faster using the Simulation Creation Toolkit as compared to the end-user programming level and begins to show that students can use the Simulation Creation Toolkit to create simulations through analogical reasoning. In this sense, Simulation Creation toolkit provides an initial data point into the integration of Computational Thinking activities through simulation construction in the classroom environment.
Article
Full-text available
The focus of this research was to create and test an introductory computer science course for middle school. Titled “Foundations for Advancing Computational Thinking” (FACT), the course aims to prepare and motivate middle school learners for future engagement with algorithmic problem solving. FACT was also piloted as a seven-week course on Stanford’s OpenEdX MOOC platform for blended in-class learning. Unique aspects of FACT include balanced pedagogical designs that address the cognitive, interpersonal, and intrapersonal aspects of “deeper learning”; a focus on pedagogical strategies for mediating and assessing for transfer from block-based to text-based programming; curricular materials for remedying misperceptions of computing; and “systems of assessments” (including formative and summative quizzes and tests, directed as well as open-ended programming assignments, and a transfer test) to get a comprehensive picture of students’ deeper computational learning. Empirical investigations, accomplished over two iterations of a design-based research effort with students (aged 11–14 years) in a public school, sought to examine student understanding of algorithmic constructs, and how well students transferred this learning from Scratch to text-based languages. Changes in student perceptions of computing as a discipline were measured. Results and mixed-method analyses revealed that students in both studies (1) achieved substantial learning gains in algorithmic thinking skills, (2) were able to transfer their learning from Scratch to a text-based programming context, and (3) achieved significant growth toward a more mature understanding of computing as a discipline. Factor analyses of prior computing experience, multivariate regression analyses, and qualitative analyses of student projects and artifact-based interviews were conducted to better understand the factors affecting learning outcomes. Prior computing experiences (as measured by a pretest) and math ability were found to be strong predictors of learning outcomes.
Article
Full-text available
Teaching basic computational concepts and skills to school children is currently a curricular focus in many countries. Running parallel to this trend are advances in programming environments and teaching methods which aim to make computer science more accessible, and more motivating. In this paper, we describe the design and evaluation of Flip, a programming language that aims to help 11-15 year olds develop computational skills through creating their own 3D role-playing games. Flip has two main components: 1) a visual language (based on an interlocking blocks design common to many current visual languages), and 2) a dynamically updating natural language version of the script under creation. This programming-language/natural-language pairing is a unique feature of Flip, designed to allow learners to draw upon their familiarity with natural language to “decode the code”. Flip aims to support young people in developing an understanding of computational concepts as well as the skills to use and communicate these concepts effectively. This paper investigates the extent to which Flip can be used by young people to create working scripts, and examines improvements in their expression of computational rules and concepts after using the tool. We provide an overview of the design and implementation of Flip before describing an evaluation study carried out with 12-13 year olds in a naturalistic setting. Over the course of 8 weeks, the majority of students were able to use Flip to write small programs to bring about interactive behaviours in the games they created. Furthermore, there was a significant improvement in their computational communication after using Flip (as measured by a pre/post-test). An additional finding was that girls wrote more, and more complex, scripts than did boys, and there was a trend for girls to show greater learning gains relative to the boys.
Article
Full-text available
We believe that children as young as ten can directly benefit from opportunities to engage in computational thinking. One approach to provide these opportunities is to focus on social game play. Understanding game play is common across a range of media and ages. Children can begin by solving puzzles on paper, continue on game boards, and ultimately complete their solutions on computers. Through this process, learners can be guided through increasingly complex algorithmic thinking activities that are built from their tacit knowledge and excitement about game play. This paper describes our approach to teaching computational thinking skills without traditional programming—but instead by building on children’s existing game playing interest and skills. We built a system called CTArcade, with an initial game (Tic-Tac-Toe), which we evaluated with 18 children aged 10–15. The study shows that our particular approach helped young children to better articulate algorithmic thinking patterns, which were tacitly present when they played naturally on paper, but not explicitly apparent to them until they used the CTArcade interface.
Article
Full-text available
Jeannette Wing’s influential article on computational thinking 6 years ago argued for adding this new competency to every child’s analytical ability as a vital ingredient of science, technology, engineering, and mathematics (STEM) learning. What is computational thinking? Why did this article resonate with so many and serve as a rallying cry for educators, education researchers, and policy makers? How have they interpreted Wing’s definition, and what advances have been made since Wing’s article was published? This article frames the current state of discourse on computational thinking in K–12 education by examining mostly recently published academic literature that uses Wing’s article as a springboard, identifies gaps in research, and articulates priorities for future inquiries.
Article
This article reports the results of a study of the relationship of computer game programming to computational learning (CL). The results contribute to the growing body of knowledge about how to define and measure CL among children by proposing a new concept, Game Computational Sophistication (GCS). We analyzed 231 games programmed by 325 11 and 12 year olds with a range of prior computer experience who attended a voluntary technology class during or after school. Findings suggest that students’ games exhibited a range of GCS: programs composed of sequences of simple programming constructs; programs composed of programming constructs, some of which are used to implement higher-order patterns; and programs composed of game mechanics built from combinations of patterns “glued” together with simple programming constructs. We use case studies of students’ games to illustrate how variation in the use and integration of programming constructs, patterns, and game mechanics can be used to demonstrate evidence of CL. The study contributes to an understanding of what CL looks like in middle school, how to assess it, and how game-programming activities might promote CL.
Article
Programming is more than just coding, for, it exposes students to computational thinking which involves problem-solving using computer science concepts like abstraction and decomposition. Even for non-computing majors, computational thinking is applicable and useful in their daily lives. The three dimensions of computational thinking are computational concepts, computational practices and computational perspectives. In recent years, the availability of free and user-friendly programming languages has fuelled the interest of researchers and educators to explore how computational thinking can be introduced in K-12 contexts. Through an analysis of 27 available intervention studies, this paper presents the current trends of empirical research in the development of computational thinking through programming and suggests possible research and instructional implications. From the review, we propose that more K-12 intervention studies centering on computational practices and computational perspectives could be conducted in the regular classroom. To better examine these two dimensions, students could be asked to verbalize their thought process using think aloud protocol while programming and their on-screen programming activity could be captured and analyzed. Predetermined categories based on both past and recent programming studies could be used to guide the analysis of the qualitative data. As for the instructional implication, it is proposed that a constructionism-based problem-solving learning environment, with information processing, scaffolding and reflection activities, could be designed to foster computational practices and computational perspectives.
Article
Constructionism places an emphasis on the process of constructing shareable artefacts. Many virtual worlds, such as Second Life, provide learners with tools for the construction of objects and hence may facilitate in-world constructionist learning experiences. However, the construction tools available present learners with a significant barrier (or ‘high-floor’) for the novice to first master. To address this problem, this paper presents the design concepts, first implementation and analysis of SLurtles (programmable turtles in Second Life), easy-to-use, programmable construction tools for use in Second Life. During a pilot study 24 postgraduate learners in pairs and working at distance from one another, programmed SLurtles to create interactive installations in Second Life over four weeks. Open interviews were conducted, chat logs recorded and learners artefacts and reflections were collected and analysed using qualitative methods. Findings show that SLurtles provide learners with a programmable, low-floor, high-ceiling and wide-wall construction tool, which supported their construction of a wide range of complex artefacts as part of a constructionist learning experience in Second Life.