Computers & Education 120 (2018) 64–74

Contents lists available at ScienceDirect

Computers & Education

journal homepage: www.elsevier.com/locate/compedu

Improving programming skills in engineering education through

T
problem-based game projects with Scratch
Damla Topallia,∗, Nergiz Ercil Cagiltayb
a
Atilim University, Computer Engineering Department, Turkey
b
Atilim University, Software Engineering Department, Turkey

AR TI CLE I NF O AB S T R A CT

Keywords: Nowadays, programming skills are receiving widespread attention for different age groups
Programming and programming languages alongside occupational education programs to better prepare individuals for their future careers.
Improving classroom teaching However, introducing programming concepts in an appropriate manner is a challenge in higher
Teaching/learning strategies education. The main assumption of this study is that enhancing the classical introduction to
Computer games
programming courses through real-life problem-based game development with Scratch pro-
Scratch
gramming environment potentially improves the learners' programming skills and motivation.
Accordingly, in this study, during one academic semester period, the Introduction to
Programming course for engineering students is enriched up to a certain level through real-life
game development projects with Scratch. The students are followed within a four-year period
starting from freshman until their graduation. The progress of the students who have taken the
Introduction to Programming course in enriched or classical form in the fourth year Senior-
project course are evaluated. The results show that by slightly improving the course curriculum
through real-life game development projects in the Scratch environment, students’ performance
on the graduation projects improved significantly. As a conclusion, game-based learning, pro-
blem-based learning, visual programming and projects are technologies that can potentially help
learners to perform better in the introduction to programming course, in turn affecting their
performances in projects.

1. Introduction

Computer programming requires skills in critical thinking, problem-solving, computational thinking and new system designs. The
need for computational thinking and improvements in the programming skills of individuals continue to receive widespread attention
to better prepare future citizens (Vaca-Cárdenas et al., 2015; Ball & Zorn, 2015). Because of this need, today, basic knowledge of
programming is part of almost all engineering programs curricula. However, usually, both students and instructors confronted with
several problems during these courses, and the programming concepts and language syntax may become barriers for learning pro-
gramming and an inhibiting factor for motivation among students. For instance, the average programming ability score of first year
students is reported to be only about 23 out of 110 (as cited in Ma, Ferguson, Roper, & Wood, 2011). Additionally, in early pro-
gramming courses, the attrition rate is found to be between 30 and 40 percent, which also shows how students struggle with
programming (Beaubouef & Mason, 2005).
The diversity in the students’ mathematical and problem-solving background is defined as a problem. Researchers report that high
number of concepts and skills to learn in a limited time, absence of incorporation of interactive media and instant feedback in

∗
Corresponding author.
E-mail address: damla.topalli@atilim.edu.tr (D. Topalli).

https://doi.org/10.1016/j.compedu.2018.01.011
Received 26 July 2017; Received in revised form 9 January 2018; Accepted 15 January 2018
Available online 31 January 2018
0360-1315/ © 2018 Elsevier Ltd. All rights reserved.
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

instruction, and lack of mathematical background are the main barriers in learning programming (Rizvi, Humphries, Major, Jones, &
Lauzun, 2011). Researchers have concluded that students need sufficient programming user-interfaces and also a prior knowledge of
problem-solving skills (Allan & Kolesar, 1996).
Studies found in the literature reveal that many problems in learning programming originate from the complexity of concepts
such as variables, loops, arrays, functions, and of syntax in programming languages. These complexities may become barriers for
learning programming and diminish student motivation. Allan and Kolesar (1996) claimed that students are overwhelmed due to the
number and complexity of the concepts to be learned. According to them, more importantly, the course may create a deformed image
of what programming actually is (Allan & Kolesar, 1996). They report that “for many students in CS1 [introduction to programming
course], it appears that rather than learning the basic concepts of the field, their energies are devoted to learning syntax”. Robins,
Routree, and Rountree (2003) describe students with less motivation to programming as ‘inefficient’. These students are likely to give
up easily when they face a problem in the course, thereby becoming more prone to failure at the end of the semester (Robins et al.,
2003).
Additionally, it is well known that the design and structure of software systems become more important than the coding itself
(Hughes, 1989). It is reported that only 1/6 of the effort for software development is dedicated to coding (Papatheocharous, Bibi,
Stamelos, & Andreou, 2017). Rather than learning real problem-solving skills, they resort to trial-and-error and rather than ‘getting
the big picture’ of computer science, they narrow their focus to ‘getting this program to run’ (Allan & Kolesar, 1996). Based on the
studies found in the literature, in teaching introduction to programming concepts the following issues are to be dealt with:

1. Learners' mathematical background and problem-solving skills are critical for building better algorithms.
2. The complex programming structures and concepts lowers the motivation of the learners.
3. The language syntax is a barrier for learners to better understand the main programming concepts.
4. Students need to aware of the place of the coding in the software development process to see the big picture.

In order to address these problems, in the literature several studies are conducted. Below the results of this research are sum-
marized.

2. Related work

As it is becoming widely used in higher education, problem-based learning stimulates learning information and concepts brought
out by the problem through teaching both a method of approaching the problem and developing the right attitude towards problem-
solving (Schwartz, 2013). Problem-solving is reported as an effective and meaningful learning approach with which learners have to
analyze the strategies to solve the problems by themselves and it is considered as an effective learning method (Liu, Cheng, & Huang,
2011). Computational problem-solving involves the development of computer programs to solve a problem, and is regarded as the
core competency of computer science education because computer science involves broad problem-solving skills, rather than purely
technically-centered activities (Liu et al., 2011).
Parallel to these studies, Liu et al. (2011) also reported that, when learning computational problem-solving with games, students
are more likely to experience flow in the learning process compared to traditional lectures. Similarly, another study reports that game
construction involving both design and programming activities can support the middle school girls' learning of computer science
concepts (Denner, Werner, & Ortiz, 2012). Also, it is seen that using games in higher education, students enjoy e-learning and
achieved a level of learning as in the traditional courses (Ebner & Holzinger, 2007). Game development projects are also shown to
improve software engineers’ success (Cagiltay, 2007).
Accordingly, other strategies have been proposed such as using narrative tools, visual programming and flow-model tools with
instant feedback and also abstraction in syntax as to concentrate on algorithms (Rizvi et al., 2011). As they promote design and
structured approaches, functional programming languages are critical for successful programming (Hughes, 1989), as they denote
appropriate abstraction to express the essence of the algorithm and enable individuals to concentrate on the design rather than the
language details (Joosten, Van Den Berg, & Van Der Hoeven, 1993). For instance, Joosten et al. (1993) devised and implemented a
new computer programming course for the freshman through a functional programming approach, further reporting that the quality
of the introductory programming course improved as a result. They also add that students better learned abstraction as a design, and
also their skills in problem-solving and formal manipulation were reinforced (Joosten et al., 1993). Studies show that when the
Introduction to Programming course is provided using object visualization in a 3D animation environment, students’ performance
increases (Cooper, Dann, & Pausch, 2003).
Scratch is one of the programming environments using a functional programming approach (Maloney, Resnick, Rusk, Silverman,
& Eastmond, 2010). It is also a visual programming environment (Resnick, Kafai, & Maeda, 2005; Maloney et al., 2008, 2010;
Cárdenas et al., 2014; Vaca-Cárdenas et al., 2015) which offers an easy-to-implement structure and algorithm of the programs.
Studies show that Scratch is a tool to help learning programming contents in an exciting and easy way (Vaca-Cárdenas et al., 2015). It
has been suggested that Scratch can be used in introductory computer science courses (Harvey & Mönig, 2010). It is a tool with a
drag-and-drop interactive environment to teach programming and targets to eliminate syntax errors and introduce new concepts
attractively (Adams & Webster, 2012). Developed by the MIT Media Lab of the UCLA Graduate School of Education and Information
Studies, Scratch mostly targets students in secondary school (Rizvi et al., 2011). Even though it is claimed that Scratch appeals more
to younger audience (Smith, 2009), some universities (like Harvard, Berkley, and the University of California) have used Scratch as
an introduction to programming (Resnick et al., 2009). Scratch and other similar products, such as Alice and Greenfoot environments,

65
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

are designed for supporting the acquisition of problem-solving and programming concepts (Utting, Cooper, Kölling, Maloney, &
Resnick, 2010). These environments can alter both the context and content of programming. Rather than solving problems - such as
generation of prime numbers or calculating factorials - students can create stories or games of their own interest with Scratch or
similar environments (Cooper & Cunningham, 2010). Yet, the specific effects of the context and the environment of programming are
not fully clarified (Lewis, 2010). As an environment, Scratch uses blocks of commands; thus, there is no typing error or mis-
remembering of the syntax involved in the “bugs”. The only possibility is the semantic error for an undesired outcome. Another
impact of the Scratch environment is that complex elements, such as loops or conditionals, can be expressed in a more natural way
(Parsons & Haden, 2007). Studies report that using Scratch in educational settings significantly improves learning programming
concepts, logic, and computational practices with an active approach for 5th and 6th grade students (Sáez-López, Román-González, &
Vázquez-Cano, 2016).
Accordingly, in this study, the classical Introduction to Programming course curriculum is enriched to address some problems of
learning programming. In the literature, there are evidences showing that active learning including problem-based learning improves
students' performance from 50th percentile to 68th percentile of that class (Freeman et al., 2014). Hence, in this study, problem-based
learning, game-based learning and visual programming approaches are implemented to enrich the course curriculum. In other words,
through individual project development, this study aims to show students the ‘big picture’ of software development process, create an
active-learning environment, improve the students' motivation and eliminate the syntax barriers for the programming. After im-
plementing the enriched course, the impact of the enriched course on students' progress is aimed to be understood. In what follows,
the method and the results of the study are provided.

3. Materials and methods

This study is an experimental one, conducted during four years with Computer Engineering (COMPE), Software Engineering (SE)
and Information Systems Engineering (ISE) students. All the students enrolled in these departments are selected through the na-
tionwide examination NWA (Examination of Transition to Higher-Education). Hence, they all come from the same pool based on their
exam results. However, most of the students at this university have lower profiles, possibly implying that they have had low math and
science scores in this examination. Additionally, considering the Secondary School Education in the country, the overall achievement
in mathematics is below the average of the Organization for Economic Co-operation and Development countries - i.e.: 420 vs. 490
points (Gurria, 2016). The problems that the students face, as previously cited from the literature, are the numerous concepts and
skills to learn and getting lost in the details of syntax without developing problem-solving skills.
In all of these three Information Technology (IT) programs of the university (COMPE, SE and ISE), students are required to take an
introduction to computer programming course in their second term. This course is a core course for all three departments that,
according to the chain rules, without passing this course successfully they cannot move on to other related core courses at their
departments. As a result, this course is the main opportunity to prepare students for the upcoming subsequent core subjects. As seen
from Fig. 1, during the 2012 Spring semester, the Introduction to Programming course is offered in an enriched form through real-life
game development projects with Scratch. Hence, other than this semester the students took the course in a classical form.
The Senior-project course is the one in which the students design and develop a project within groups which reflects their general
knowledge and experience gained during the program. In this study, 322 students who took the Senior-project course offered during
February 2012 and June 2016 are taken into consideration. Among them, 48 took the enriched introduction to programming course,
whereas the remaining 274 took it in the classical form (Table 1).
Students’ letter grades received from each course are considered as the dependent variables for the analyses. The details about the
classical course, enriched course, Senior-project course and the participants are provided below.

3.1. Classical course

The course is offered in the second semester of the IT programs at this university with the main aim to teach programming
concepts - such as variables, conditional statements, loops, functions, arrays, pointers, structures and files - through C programming
language. This course is offered as three hours theoretical and two hours laboratory (4-credit) instructions per week throughout the
semester. During the theoretical part, the concepts are introduced theoretically with several examples in the class. Parallel to this
theoretical study, during the laboratory hours students are asked to work individually on the given problems related to the concepts
introduced in the theoretical lectures.
The grading in this course is commonly performed according to the evaluations as shown in Table 2, and is based on two midterms

Fig. 1. The implementation of the enriched course.

66
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

Table 1
Participants’ entrance years.

Entrance Year Classical Scratch

n % n % Total

2003 3 1.1 3
2004 5 1.8 5
2005 10 3.6 10
2006 9 3.3 9
2007 117 42.7 14 29.2 131
2008 83 30.3 9 18.8 92
2009 23 8.4 8 16.7 31
2010 6 2.2 10 20.8 16
2011 14 5.1 7 14.6 21
2012 4 1.5 4
Total 274 100 48 100 322

Table 2
Grading in classical course.

Grading Type %

Midterm Exam 1 20
Midterm Exam 2 20
Final Exam 30
Lab Work 15
Assignments 10
Participation + Quiz 5

and a final exam. The laboratory performance of the students are also evaluated and reflected in their final grades. They are usually
expected to complete two or three assignments to better implement their knowledge by writing a full program.
The failure rate is usually over 50% - which is very high - and in order to be successful, students often have to take this course
several times. In this course, they have problems for understanding the programming concepts, generating an algorithm to solve a
problem and implementing this algorithm with appropriate programming comments. Another issue is their study habits adapted
during their k-12 education. Students usually expect to get a predefined list of problems and study on these problems, or memorize
them, to be able to score well in exams. This is because they have been prepared for the university entrance exams by studying in this
way and do not know what to do when faced with a new situation. They mostly have problems in implementing their previously
learned concepts in new settings and solving anticipated problems. Accordingly, in this course they fail to generate new solutions for
new scenarios, and to understand the main programming concepts.

3.2. Enriched course

As a result of the studies found in the literature and the authors’ experience for more than 15 years in teaching the introductory
programming course, it can be assumed that a less-syntax and more-problem-solving-oriented design may help students to reach the
threshold for success in this course. Therefore, by an algorithm-first approach for programming exercises and, more importantly,
integration of the Scratch programming language into the course curriculum, the classical course content is enriched. The main
assumption is that Scratch addresses the programming problems of students by offering easy modifications in programming con-
structs (i.e. variables, loops, control statements, functions, etc.), live animations of the program output which also acts as an instant
feedback, and game development which improves their motivation through the lessons.
Accordingly, in the 2012 Spring semester, the Introduction to Programming course was enriched with the Scratch environment. In
this semester, as a traditional course, two midterms and a final written exam were given to the students and they were asked to
prepare two homework studies using C programming language. They did the laboratory work in a similar way to the previous years.
However, during the last 15 min of each laboratory activity, they were introduced to the Scratch environment. For seven weeks,
students were introduced to the main Scratch concepts and, afterwards, were asked to prepare their game projects. For the projects,
they were required to develop a game to teach certain concepts about English language learning or science to fifth-grade students.
Two domain experts from science teaching and English language teaching also helped them to better understand the requirements
for game development. Students were asked to prepare storyboards of their game project designs to show each scene of the game as to
how it looks and what type of interactions it includes. These documents were monitored and feedback was provided by the course
instructor and domain experts. Then, students coded their Scratch game projects individually. As seen from Fig. 2, they used Scratch
programming blocks to create their games.
The game concepts were chosen freely. Some examples of the projects developed for English Language teaching and for science
concepts are shown in Fig. 3 and Fig. 4, respectively.

67
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

Fig. 2. Enriched course: Scratch example for ‘clothes’ game.

68
 D. Topalli, N.E. Cagiltay

69
Fig. 3. Enriched course: Scratch examples for english language teaching.
Computers & Education 120 (2018) 64–74
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

Fig. 4. Enriched course: Scratch examples for science concepts.

70
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

Table 3
Grading in enriched course.

Grading Type %

Midterm Exam 1 20
Midterm Exam 2 20
Final Exam 30
Lab Work 10
Assignments 5
Scratch Game Project 15

The main expectation with the Scratch game project implementation in this semester was to help the students to better understand
the key programming concepts by showing the comments and their results after execution in a visual way, to help them find solutions
for some real-life problems that they face during the game development, and to build connections between C language components
and Scratch programming through their algorithm design.
In addition to the previous years, in this semester the Scratch game project is evaluated as 15% of their end-of-term grade. As seen
in Table 3, while the midterm and final exams had the same percentage, lab work was decreased by 5 percent and homework by 5
percent.

3.3. Senior-project course

The Senior-project course is offered to the senior students of the three departments by the same instructors. Before graduation, all
students have to successfully pass this course, in which participants are required to plan and design a project within a team en-
vironment. Designing a software project according to the given system or user requirements and, then, developing the project
according to these specifications plays an important role in the course success. They are required to develop several standardized
documents describing the design and development of the software system. Hence, developing programming skills throughout their
undergraduate studies is crucial in order to be successful in this course. During these stages, course instructors guide each team. After
the development of the project, the testing was conducted and the students were required to draft their reports including these
activities. At the end of the semester, they submitted their final reports and presented their projects to be evaluated by the Senior-
project committee. The evaluations are performed by the committee to evaluate each project group member individually through
code reviews and project presentations. Hence, each group member receives different grades depending on their performance during
and at the end of the project development process.

3.4. Participants

During the period between February 2012 and June 2016, a total of 395 students took the Senior-project course in the IT
Departments of the university. Among these 395 students, 66 enrolled in their departments upon taking Transfer Exam which means
that they have taken the Introduction to Programming course from other institutions. Three of them were double major students
which also indicates that they have taken the Introduction to Programming course from their departments at this university. Four of
them were undergraduate transfer students, who had taken the Introduction to Programming course from other programs at this
university. Hence, this study is conducted with 322 students. Among these 322 students, 274 have taken the Introduction to
Programming course in traditional form. On the other hand, 48 have taken the enriched form of the Introduction to Programming
Course. During the 2012 Spring semester, the Introduction to Programming course is offered by enriching the content with real-life
Scratch game projects as described earlier. There were 84 students enrolled in this course. However, 36 of them have not taken
Senior-project course, yet. Hence, 48 of the students were considered for this study.
In order to test the equal distribution of groups (experimental and control), their distribution based on gender, enrolled de-
partments, CGPA and the pre-knowledge and skill levels on programming concepts were analyzed.
As seen from Table 4, 64% of the experimental group (enriched course) and 68% of the control group (classical course) (See

Table 4
Students’ Information for the Enriched Course (experimental group).

Department Gender Total

F M

n % n % n %

Computer Eng. 10 22 17 31 27 53
Information Sys. Eng. 5 11 7 16 12 27
Software Eng. 1 2 8 18 9 20
Total 16 36 32 64 48 100

71
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

Table 5
Students’ Information for the Classical Course (control group).

Department Gender Total

F M

n % n % n %

Computer Eng. 47 32 100 68 147 54

Information Sys. Eng. 21 43 28 57 49 18
Software Eng. 20 26 58 74 78 28
Total 88 32 186 68 274 100

Table 5) were male which can be considered as normal for the gender distribution of the engineering students in general in this
country. Additionally, the gender distribution of both groups can be considered as similar for this study.
To better understand if the CGPA distribution of both groups are similar, an independent sample t-test was conducted. The test
was not significant, with t(322) = 0.459, p = 0.647 indicating that the students’ average CGPA in the experimental group (enriched
course) (M = 1.70, SD = 0.94) is similar to that of (M = 1.76, SD = 0.94) students in the control group (classical course) within a
0.05 confidence interval (See Fig. 5, CGPA Int. Prog. Course).
Students who take the Introduction to Programming course usually have no prior knowledge in programming concepts. Hence,
their pre-knowledge and skills in programming are assumed to be equivalent.

3.5. Hypothesis of the study

There are three main hypothesis of this study as described below:

H1. Students in the enriched Introduction to Programming course (experimental group) perform better than those in the classical
Introduction to Programming course (control group).
H2. Students who have taken the enriched Introduction to Programming course (experimental group) perform better in the Senior-
project course than the students who have taken the classical Introduction to Programming course (control group).
H3. Students in the experimental group (who have taken the enriched Introduction to Programming course) perform better in their
overall engineering program than those in the control group (who have taken the classical Introduction to Programming course).

3.6. Research method

This study is designed as a longitudinal experimental research (Menard, 2007), in which data are collected in different times. In
order to answer the above research questions, first students’ performance on these three courses are evaluated experimentally. During
one academic semester period, the enriched Introduction to Programming course for engineering students is offered. Afterwards, the
students are followed within a four-year period starting from freshman until their graduation. Then, the progress of the students who
have taken the Introduction to Programming course in enriched or classical form in the fourth year Senior-project course are
evaluated. The courses considered for this study are offered in a standard form in this university. All exam questions and assessment is
done in a standardized manner. Accordingly, to minimize the bias, the grading is also performed in a similar technique each semester.
For this reason, only a small part of the course could be modified in the enriched form.

Fig. 5. Students' performance in ‘Introduction to Programming’ & ‘Senior Project’ Courses.

72
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

4. Results

An independent sample t-test was conducted to evaluate the hypothesis that students in the enriched Introduction to
Programming course (experimental group) perform better than those in the classical Introduction to Programming course (control
group). In this comparison, the dependent variable was the letter grade of the students determined after the completion of the course.
The test was significant, t(322) = −2.82, p = 0.005, indicating that on average the students in the enriched Introduction to
Programming course (experimental group) performed better (M = 1.85, SD = 1.31) than those in the classical Introduction to
Programming course (control group) (M = 1.29, SD = 1.27) in the Introduction to Programming course within a 0.05 confidence
interval (See Fig. 5, Grade in Int. Prog. Course).
As the assessment of both courses is performed in similar procedures other than the Scratch Game Project, which is included in the
enriched course, to eliminate the effect of project grades on students’ course performance, their grades are recalculated by excluding
the Scratch Game Project grades. In this way, the grades of both courses are calculated by using exactly the same rubric. In this
comparison, the dependent variable was the letter grade of the students determined after the completion of the course by excluding
the Scratch Game Project grades. The test was significant, t(322) = −2.19, p = 0.029, indicating that on average the students in the
enriched Introduction to Programming course (experimental group) performed better (M = 1.73, SD = 1.37) than those in the
classical Introduction to Programming course (control group) (M = 1.29, SD = 1.27) in Introduction to Programming course within a
0.05 confidence interval (See Fig. 5, Grade in Int. Prog. Course (Excluding Project)).
Besides these results, in this study the students' progress in the Senior-project course is analyzed to understand the effect of the
enriched course on their progress in the Senior-project course. In this analyses the dependent variable was the final letter grades of
the students after the Senior-project course. An independent sample t-test was conducted to evaluate the hypothesis that students’
who have taken the enriched Introduction to Programming course in their first year perform better in the Senior-project course that
the students who have taken the classical introduction to programming course. The test was significant, t(322) = −5.40, p = 0.000,
indicating that those who have taken the enriched Introduction to Programming course in their first year (experimental group)
performed better (M = 3.16, SD = 0.65) than those who have taken the classical Introduction to Programming course (control group)
(M = 2.56, SD = 0.96) in the graduation projects within a 0.05 confidence interval (See Fig. 5, Grade in Senior-project course).
Moreover, an independent sample t-test was conducted to evaluate the hypothesis that students in the experimental group per-
form better in their overall engineering program than those in the control group. In this analysis, the dependent variable was the
students’ graduation CGPA. The test was not significant, t(322) = −0.375, p = 0.709, indicating that the graduation CGPA of the
students in the experimental group (M = 2.42, SD = 0.58) on average is similar to the ones in the control group (M = 2.39,
SD = 0.53).
It should also be noted that the failure rate for the enriched course is similar to the classical course. Almost all the students that
failed in the enriched course were the ones who did not attend the course at all. Our earlier study, which reports the questionnaire
results implemented in the enriched Introduction to Programming course, is also providing supportive results (Ozoran, Cagiltay, &
Topalli, 2012). Participants have declared that, Scratch projects cause students to spend more time for the course, help to learn
algorithms and programming concepts, learn animations and games, make comments on the code as well as teach system thinking,
increase students’ creativity, improve problem solving skills and make programming more enjoyable (Ozoran et al., 2012).

5. Discussions and conclusions

This study is conducted to better understand the effect of enriched introduction to the programming course on students' per-
formances. The results show that, by slightly improving the course content through real-life game development in the Scratch
environment, students' performance in the Senior-projects improved significantly which may be an indicator that the game projects
improve students’ motivation towards the introduction to programming concepts. Additionally, as they were able to see the big
picture of the software development cycle and the place of coding in that cycle their understanding of programming concepts was
most probably better conceptualized enabling them to better integrate the other concepts in their program within this big picture. The
Scratch visual programming environment also most probably helped them not just concentrate on the syntax problems but on the
design and development of the general system and algorithms. By solving a real-life problem and getting feedback from domain
experts, they most likely are better motivated and work harder to solve the problem that is defined by the domain experts, in turn,
improving their problem-solving skills.
Supportively, earlier results from this enriched course (Ozoran et al., 2012), report that, as they had to spend more time to better
understand the concepts and implement them into their game, students in the enriched course had an improved notion of the
programming concepts. During the game development process, error finding and problem-fixing increased their problem solving
skills (Ozoran et al., 2012).
As a conclusion, it can be reported that by enriching the classical curriculum of Introduction to Programming courses, some
problems faced with during these courses, such as low motivation, low problem-solving skills and mathematical background, can be
addressed. Game-based learning, real-life project-based learning and visual programming environments, such as Scratch, are some
concepts that can be incorporated into the curriculum of the Introduction to Programming courses for addressing some of the course
problems and for improving the learners' performance. These are potential technologies to help learners better perform in the
Introduction to Programming course which, in turn, also affects students' Senior-project performances. As a summary, main con-
tributions of this study is two-folded. First, it is shown that by slightly enhancing the traditional course structures, students’ progress
in the course can be improved. Second, it is shown that potentially real-life problem-based game projects with Scratch improve

73
D. Topalli, N.E. Cagiltay Computers & Education 120 (2018) 64–74

learning programming concepts.

Because of the nature of the study, it was not possible to create more controlled groups for the experimental study. In this study,
the equally distribution of the groups is tested by gender distribution and CGPA of the students. However, in future studies, whenever
possible, implementing a pre-test to better understand the pre-knowledge and skill levels of groups in the introduction of pro-
gramming concepts would improve the method of the study. In this study, it was not possible to build randomly assigned groups,
which may also be another matter for consideration in future studies. Additionally, by introducing some concepts in software life
cycle steps, such as requirements collection, design, development and testing, would also improve the software projects of the
students and their conceptualization of the education program. Two domain experts from science teaching and English language
teaching helped the enriched course students to make clear the requirements for the game development. Even the support was very
minimal, ‘Hawthorne effect' might have occurred that may cause students feel themselves as important and part of something new
(Gillespie, 1993; Lazzari, 2009). For the future studies it may be better controlled. Finally, as this study is conducted on higher
education context, it may be tested if similar strategies also work for K-12 education levels as well.

References

Adams, J. C., & Webster, A. R. (2012, February). What do students learn about programming from game, music video, and storytelling projects? Proceedings of the 43rd
ACM technical symposium on computer science education (pp. 643–648). ACM.
Allan, V. H., & Kolesar, M. V. (1996). Teaching computer science: A problem solving approach that works.
Ball, T., & Zorn, B. (2015). Teach foundational language principles. Communications of the ACM, 58(5), 30–31.
Beaubouef, T., & Mason, J. (2005). Why the high attrition rate for computer science students: Some thoughts and observations. ACM SIGCSE Bulletin, 37(2), 103–106.
Cagiltay, N. E. (2007). Teaching software engineering by means of computer-game development: Challenges and opportunities. British Journal of Educational
Technology, 38(3), 405–415.
Cárdenas, L. V., Vizueta, D. O., Tavernise, A., Gabriele, L., Bertacchini, F., Pantano, P., et al. (2014). Darwin has come back to the Galápagos Islands: An educational
journey to discover biological evolution. EDULEARN14 proceedings (pp. 6088–6095). IATED.
Cooper, S., & Cunningham, S. (2010). Teaching computer science in context. Acm Inroads, 1(1), 5–8.
Cooper, S., Dann, W., & Pausch, R. (2003, February). Teaching objects-first in introductory computer science. ACM SIGCSE bulletin (Vol. 35, No. 1, pp. 191–195). ACM.
Denner, J., Werner, L., & Ortiz, E. (2012). Computer games created by middle school girls: Can they be used to measure understanding of computer science concepts?
Computers & Education, 58(1), 240–249.
Ebner, M., & Holzinger, A. (2007). Successful implementation of user-centered game based learning in higher education: An example from civil engineering. Computers
& Education, 49(3), 873–890.
Freeman, S., Eddy, S. L., McDonough, M., Smith, M. K., Okoroafor, N., Jordt, H., et al. (2014). Active learning increases student performance in science, engineering,
and mathematics. Proceedings of the National Academy of Sciences, 111(23), 8410–8415.
Gillespie, R. (1993). Manufacturing knowledge: A history of the Hawthorne experiments. Cambridge University Press.
Gurria, A. (2016). PISA 2015 results in focus. PISA in focus, Vol. 67, 1.
Harvey, B., & Mönig, J. (2010). Bringing “no ceiling” to scratch: Can one language serve kids and computer scientists. Proc. Constructionism.
Hughes, J. (1989). Why functional programming matters. The computer journal, 32(2), 98–107.
Joosten, S., Van Den Berg, K., & Van Der Hoeven, G. (1993). Teaching functional programming to first-year students. Journal of Functional Programming, 3(01), 49–65.
Lazzari, M. (2009). Creative use of podcasting in higher education and its effect on competitive agency. Computers & Education, 52(1), 27–34.
Lewis, C. M. (2010, March). How programming environment shapes perception, learning and goals: Logo vs. scratch. Proceedings of the 41st ACM technical symposium on
computer science education (pp. 346–350). ACM.
Liu, C. C., Cheng, Y. B., & Huang, C. W. (2011). The effect of simulation games on the learning of computational problem solving. Computers & Education, 57(3),
1907–1918.
Ma, L., Ferguson, J., Roper, M., & Wood, M. (2011). Investigating and improving the models of programming concepts held by the novice programmers. Computer
Science Education, 21(1), 57–80.
Maloney, J. H., Peppler, K., Kafai, Y., Resnick, M., & Rusk, N. (2008). Programming by choice: Urban youth learning programming with scratch (Vol. 40, No. 1, pp.
367–371). ACM.
Maloney, J., Resnick, M., Rusk, N., Silverman, B., & Eastmond, E. (2010). The scratch programming language and environment. ACM Transactions on Computing
Education (TOCE), 10(4), 16.
Menard, S. (2007). Handbook of longitudinal research: Design, measurement, and analysis. Elsevier.
Ozoran, D., Cagiltay, N., & Topalli, D. (2012). Using scratch in introduction to programming course for engineering students. 2nd international engineering education
conference (IEEC2012) (pp. 125–132). .
Papatheocharous, E., Bibi, S., Stamelos, I., & Andreou, A. S. (2017). An investigation of effort distribution among development phases: A four-stage progressive
software cost estimation model. Journal of Software: Evolution and Process, 29(10).
Parsons, D., & Haden, P. (2007, July). Programming osmosis: Knowledge transfer from imperative to visual programming environments. Procedings of the twentieth
annual NACCQ conference (pp. 209–215). .
Resnick, M., Kafai, Y., & Maeda, J. (2005). A networked, media-rich programming environment to enhance technological fluency at after-school centers in economically-
disadvantaged communities.
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., ... Kafai, Y. (2009). Scratch: Programming for all. Communications of the ACM,
52(11), 60–67.
Rizvi, M., Humphries, T., Major, D., Jones, M., & Lauzun, H. (2011). A CS0 course using scratch. Journal of Computing Sciences in Colleges, 26(3), 19–27.
Robins, A., Routree, J., & Rountree, N. (2003). Learning and teaching programming: A review and discussion. Computer Science Education, 13(2), 137–172.
Sáez-López, J. M., Román-González, M., & Vázquez-Cano, E. (2016). Visual programming languages integrated across the curriculum in elementary school: A two year
case study using “Scratch” in five schools. Computers & Education, 97, 129–141.
Schwartz, P. (2013). Problem-based learning. Routledge.
Smith, B. J. (2009, September). Conceptual graphs as a visual programming language for teaching programming. Visual languages and human-centric computing, 2009.
VL/HCC 2009. IEEE symposium on (pp. 258–259). IEEE.
Utting, I., Cooper, S., Kölling, M., Maloney, J., & Resnick, M. (2010). Alice, greenfoot, and scratch–a discussion. ACM Transactions on Computing Education (TOCE),
10(4), 17.
Vaca-Cárdenas, L. A., Bertacchini, F., Tavernise, A., Gabriele, L., Valenti, A., Olmedo, D. E., ... Bilotta, E. (2015, September). Coding with Scratch: The design of an
educational setting for Elementary pre-service teachers. Interactive collaborative learning (ICL), 2015 international conference on (pp. 1171–1177). IEEE.

74