Nile Journal of Communication & Computer Science

Volume 5, June 2023

Journal Webpage: https://njccs.journals.ekb.eg

Project-based Iterative Teaching Model for Introductory

Programming Course
Shahid, Maida , Pervaiz, Kashmala , Hassan, Awais , Khurshid, Khaldoon

Computer Science Department, University of Engineering and Technology, Lahore

Abstract
Introductory programming courses are considered to be the most important courses taught to
undergraduate computer science students. However, teaching these courses in the best way possible has
always been difficult. Mostly, students are unable to form the relation between the theory and the
practical work. Thus, they find it difficult to put their skills to use, when they are required. This has been
a centre of discussion among educational researchers for quite a long time. Many approaches have been
brought forward and out of these; Project-based Learning is on top. PBL has been introduced in
combination with various other frameworks to teach programming i.e., agile, scrum and task-driven
teaching. Although, none of these approaches provides the teaching content for developing the project
iteratively. In this research, we have merged Project-based Learning with an iterative approach to build-
up a teaching model that will help students learn the skills and implement them accordingly with the
help of a project. Students learn one skill at a time and implement that in the project. We also present our
experience with the course taught according to this approach to undergraduate computer science students
of session 2020 at the University of Engineering and Technology, Lahore, Pakistan. Results show that
the iterative teaching model proposed in this paper addresses various shortfalls of the previously
presented techniques and fulfils the requirements of an introductory programming course. Furthermore,
the results also show an increase in the motivation of the students towards learning programming.

Keywords: introductory programming course, project-based learning, iterative project-based learning,

teaching model, computer science

1. Introduction

From classical computers to quantum computers (Mermin, 2007), the journey on the road of
technological advancement continues. Programming (Gries, 2012) is the core of this revolution. Due to
this, the trend of becoming programmers has increased in the students (Adeoti, 2019). Although, the
majority of the students perceive different programming languages as hard to learn (Vega et al., 2013).
This is due to the fact that most educational institutions follow the Knowledge Based-Learning (KBL)
approach (Whitehall & Lu, 1994). In the KBL approach, students are given excessive information, even
the information that is not needed at the moment. The students learn from the lectures fixed at the pace
the professor has decided. Furthermore, there is incoherence between the concepts taught in the theory
and the project in the lab (Raval, 2019). Therefore, KBL has not proved to be effective for developing
the problem-solving skills in students.
 Besides efficiently transmitting information in the theory session, the teacher should also focus
on developing an association between the theory and practice (Fioravanti et al., 2018). Balancing the
theory and practice is a recurring challenge to teach programming languages and has been the centre of
debate among various educational researchers. To find the balance between theory and practice, many
methodologies have been introduced e.g., project import (Guang-yong, 2011), ACM competition
platform (HeYingsheng, 2009), task-driven teaching (Liu et al., 2018). These approaches make students
to write various programs which aim at certain teaching objectives, but these practises are not designed
according to the students’ future professional position in the real world (Ge & Ding, 2012).
In order to become a successful programmer, a student must know how the logistics of
programming works, how to debug it, and mainly how to develop the skills along with the syntax and
semantics (Jazayeri, 2015). Thus, the basic challenge for the instructor of programming is to know how
to direct the learners and how to prepare them for professional life to achieve the targeted goals of
software companies (Amamoua & Cheniti-Belcadhi, 2018).
To fulfil these needs, educational researchers have proposed a student-centred pedagogical
approach called Project-based Learning (PBL) (Souza et al., 2019). PBL directs the focus on the
motivation of students and their skills development at the application level. Student-centred approaches
develop higher motivation in the learner as they learn by doing. Hence, better learning on the
development level (Prikladnicki et al., 2009). PBL aims towards the motivation of students by providing
them with a vision. The students steadily approach their goals while gaining knowledge and developing
relative skills. This raises motivation and makes the learning process pleasurable for students as they
proceed towards their goal. When students find the learning process aligned with their interests, they
develop a sense of pleasure and motivation. The brain of these students releases a neurotransmitter called
dopamine which boosts motivation in students and provokes them to learn new concepts (Krauss &
Boss, 2013). PBL approach is accepted widely due to its connection between theoretical knowledge and
its practical application (Todorova et al., 2010).
The main purpose of this approach is to make students work-ready as it is a pedagogical approach
to prepare students for professional life after university (Olayinka & Stannett, 2020). In the last two
decades, the PBL approach has been generally acknowledged due to its pattern of distribution over
several iterative deliverables and feedback queues, which encourage the students towards quicker
development (Siegeris et al., 2018).
For further addition to the advantages of PBL, there have been several valuable studies about the
methods and techniques used for teaching different courses using PBL with the agile approach e.g., the
contents of the courses are modelled in a weekly manner (Giese et al., 2020) which develops a roadmap
to be implemented in a duration of a week. On the other hand, some models emphasize learning through
a series of cycles such as the scaffolding technique (Bygstad et al., 2009), in which a student is provided
with the necessary support to moderately master the skill which is needed to complete a task. In
(Sakulvirikitkul et al., 2019), the concept of Agile Scrum software development is presented which
focuses on the development of a learning process as per the Scrum Framework to be followed by
students and acquire various programming skills along the way.
Although many studies are using PBL with the agile approach to develop the project, but the
project is offered at the end of the semester which makes it unfit, because students are unable to form a
connection between the learned concepts and the project and they have to use all the previously learned
programming concepts. Moreover, none of these studies provides the teaching contents (theoretical
programming concepts) in an iterative manner for developing the project. As, it is tough for the teacher
to map the project tasks with the contents delivered via lectures and develop them incrementally because
the project task needs to be prepared in a way, they do not require the knowledge or skill that students
have not learned yet. Thus, the present agile-based PBL lacks the design of the iterative learning path
towards project development. Due to this, most of the students fail to deliver a fully functional project at
the end of their semester.
Thus, the goal of this research is to propose an iterative teaching model for programming content
and fully mapped projects with those contents to help the learners in expanding their programming skills
and striving in professional life. In simple words, the aim is to use the iterative method of content
delivery with project development throughout the entire course. This will increase the motivation of the
students. It will allow the students to learn a skill from the lectures delivered in the classroom and then
apply that skill directly to the project in the form of solving a subproblem or developing a sub-feature of
the project. In the end, the students will be able to develop the whole project incrementally by learning
and implementing it step by step. In particular, a student will learn a skill through theoretical lectures and
then practically implement it to develop a part of the project during the lab sessions.
This paper focuses on answering these two research questions: What possible phases need to be
part of iterative PBL? What effect does the proposed PBL have on the extrinsic and intrinsic motivation
of students?
Rest of the paper is structured as follows: Section 2 provides a detailed literature review on the
teaching methodologies and presents a research matrix to summarise the survey. In section 3, we discuss
our proposed iterative project-based learning methodology for teaching the introductory programming
course. Section 4 describes the experimental framework used to evaluate our proposed teaching model.
Section 5 and 6 gives the results obtained and then discusses those results respectively. Section 7
concludes our paper.

2. Related Work

Various methodologies have been proposed and presented in the past to engage students in the learning
process. In the beginning, a pedagogical approach Knowledge-Based Learning (KBL) (Whitehall & Lu,
1994) was introduced in which certain educational objectives needed to be fulfilled using various tools
and technologies.
Mann, S. et. al. (Haden & Mann, 2003) introduced a two-semester introductory programming
sequence to form a relation between traditional procedural programming and advanced Object-Oriented
system development. The approach was to deliver the new material in each lesson that builds as much as
possible on that learned in earlier lessons. The authors observed their students and classify the errors
they made in the set of 36 types of errors. The outcome or shortfall observed by assessing the learners
was that the students learned to use the complex components but they didn’t develop an understanding of
the task performed. In 2005, a tool named Phoenix (Flood & Lockhart, 2005) was introduced to make the
students collaborate with the teachers on the conceptual development of the programming language they
used. In that way, the students came up with the essential ideas and became familiar and confident about
the task to be performed in that programming language. A survey was conducted and the students
responded positively in the favour of Phoenix. The approach was not evaluated for the performance of
students and was under development for exploration over the internet.
Robins, A. et. al. (Robins et al., 2003) considered a widely used approach for teaching various
programming languages to novice learners and gave the respective results while depicting various
shortcomings. Under this approach a course was designed based on lectures and practical laboratory
work, the focus was shifted to the knowledge basis besides a conventional curriculum i.e., the taught
components of the language and their usage. The author identified several trends that summarise that this
method of teaching doesn't provide the learners with sufficient knowledge and the learners are not
provided with satisfactory instruction.
 T.B. Bati et. al. (Bati et al., 2014) proposed an approach to redesign a course to teaching and
learning of programming by using constructive alignment and Bloom’s taxonomy. The assessment
activities were designed with a focus on students' formative assessment i.e., assignments, projects and
journals. Additional assessments included alignment between assignments, incremental grade
improvement etc. The formative assessment activities were evaluated and the outcomes were that the
mean score of the students was above the passing percentile of 50% in every assessment activity. The
quantitative and qualitative findings indicated that the method had a positive but weak impact on
learning. The students exhibited poor performance in different assessments due to the English questions,
this indicates the liabilities in the design and implementation of the model. The evaluative role of the
assessments was also inadequate in comparison to the higher discriminating role of the final
examination.
The author proposed a theoretical framework as part of an empirical study (Von Hausswolff,
2021) for understanding how students learn to program. The framework showed the utility of the
developed concepts and how to deepen the understanding of these concepts in a definite learning
environment. The two developed concepts ‘practical thinking’ and ‘come to an agreement' were the basis
of developing the understanding of students’ experiences. This empirical study comprised first-year
engineering students who were learning text-based programming in Python. The course consisted of 15
lectures, and six mandatory computer labs of two hours each, and also practised programming without a
computer. Also, the students were assigned to a number of TAs. The students needed to finish three tasks
to pass the course: a written exam after eight weeks, a larger assignment after the exam, and six
computer lab assignments before the exam. Most of the students approved the creative and open
perception of the course. The paper had a fallback as only one researcher did the collection of empirical
data and the students who were interviewed could be biassed.
The major issue with KBL was that the learners often failed to identify where to adequately
implement the domain knowledge (Sangster & Wilson, 1991). This induced the need to develop
methodologies for students to learn and master their skills as well as knowing how and where to
implement these.
To learn efficiently, learners should be taught in such a manner that will help them become an
expert in their skills. Project-based learning is a pedagogical approach that has almost made it true that
the student learns more from working on projects than from lectures (Bygstad et al., 2009). It has been
said that the students learn more by solving a problem in a real-world environment where the teachers
play the role of coach. In 2010, the modern PBL approach attracted a large number of students by the
statement “Everything I know, I know how to use and where to apply” (Todorova et al., 2010). Nazdri
et. al. (Nadzri et al., 2012) proposed that with the passage of time PBL is switching more and more from
a traditional teacher-centred approach to a student-centred approach. They said that PBL is a teaching
strategy, in which the communication and presentation skills of both participants and the facilitators are
vital.
Over time many researchers have put a greater emphasis on Project-based learning, in which it is
believed that the students develop skills through the agile exploration of real-world challenges. Vega et.
al. (Vega et al., 2013) proposed an incremental approach to PBL called Cupi2. This approach went
through a series of phases incrementally which let the students master various programming skills. The
implementation of this method increased the average grade of students. The number of students
disapproving of computer programming courses had decreased, from 28% to 10%. Meanwhile, it was
highly expensive for institutions because it featured the software factory approach. Cupi2 is somewhat
similar to the one proposed in this paper. However, Cupi2 did not incrementally develop the contents
while developing the project. One particular disadvantage of this approach was that it was extremely
costly for the majority of institutions due to its approach to software factory.
Ge et. al. (Ge & Ding, 2012) put forward an approach to transform the theoretical and abstract
course contents of Programming Practice course into task-driven cases. The idea was to refine the
original data structure teaching content; meanwhile, aiming at students’ professional position
competence. The methodology concentrated on three main objectives: Professional ability, Social ability
and Methodological ability. Students grasped the skills in the process of learning and completing tasks
while obtaining suitable knowledge. There is no explanation of results for the methodology so, it isn't
certain that the approach is attaining all the goals that it claimed.
With time, many techniques were merged with PBL to increase its effectiveness, one of which is
outcome-based education (Dr Indiramma, 2014). It was adopted to teach the theoretical foundation of
computation in which the project preparation was done and the outcome was explained and
communicated to students. The students were also presented with a list of projects and requirements. The
projects were designed with respect to the course structure. Firstly, the students finalised the topics and
discussed the steps to be followed to implement the project i.e., the information gathering and
requirements. Projects were implemented respectively based on different aspects e.g., simulation, coding
or using suitable tools. When the implementation was completed by students, a demonstration and
presentation were taken from the students following the report writing. The understanding level and
satisfaction of each student displayed that this combined method of PBL and traditional teaching gained
more positive points. Since every student has different learning capabilities, some students considered
this method a little difficult due to its implementation issues. There were no specified guidelines for the
project that students needed to develop. The diversity in those projects made it hard for teachers to
standardise the results. An experience report by Mehdi Jazayeri (Jazayeri, 2015) displayed an approach
for teaching the course of Introductory programming to software engineering students, in which PBL
was combined with a mastery learning approach. Mastery learning is also a pedagogical approach that
allows the learner to develop skills in a way where skills are divided into levels of difficulty. Each
student must master one skill before mastering the next skill. The course was structured in two phases: a
programming mastery phase and a project design phase. The students were allowed in the second phase
only if they had mastered the first one. Its main focus was to eliminate the intimidating students which it
was able to achieve. The implementation of this method has shown that it helped the strong students
more than the weak students as, the motivation in weak students dropped because they performed
averagely in the first phase and weren’t allowed to take up the rest of the course in the second phase.
Another similar method combined the PBL with Project Management (Fioravanti et al., 2018) for
teaching Software Engineering students. The method was introduced to help students face real-life
challenges by developing software in the business context. The lectures were dotted with project lessons,
so the students learned the theory and then applied it to the project. The feedback of students, conducted
through a questionnaire sent by email, demonstrated a positive response. There was an increase in
students’ motivation (56.0%), students’ approval of approach (54.8% agreed and 38.1% partially agreed)
and effectiveness of the learning process (26.2% totally agreed and 40.5% partially agreed). The
questionnaire illustrated a few drawbacks of this approach as it faced many challenges due to lack of
planning, different times of each stage and mainly the integration of projects.
Souza et. al. (Souza et al., 2019) evaluated students’ perception towards PBL through feedback
by comparing the results of 17 students who were taught under PBL and non-PBL techniques. As for the
PBL approach, a software project central to the course was introduced. The project was based on real-
world problems and the activities were driven by meaningful questions. The development of the project
was divided into scrum sprints. Meanwhile, the students provided evidence of the tasks performed. The
instructors mentored the students to attain the goals of the project. Various PBL principles were adapted
i.e., driving questions and balance between guidance and freedom of choice etc. The focus was entirely
shifted to student-centred teaching. The students taught under this PBL teaching methodology showed
positive achievements, they were considered to be more suited for allowing the development of
competencies as they learn-by-doing, with higher motivation, and displayed a more active role in the
learning process. The students taught under non-PBL were also monitored and the main reason for their
negative response was defined under the categories “Project as Learning Tool”, “Documentation” and
“Development Process”. The results and the concreteness of the approach were criticised because they
were solely dependent on the surveys filled by the students. There was no output on how the
programming skills of students were improved by developing the project taught under the Project-based
learning approach.
In recent times, many researchers have found the agile approach to be taught by project-based
learning and this has given us many fruitful results due to its iterative nature. One of these techniques
(Olayinka & Stannett, 2020) was to teach agile software development where students worked to develop
software for clients. The development of these projects is defined in the form of sprints. Students were
required to submit a short report at the end of each sprint presenting what they planned to do, what they
achieved and the plan for the next sprint. Several students were unaware of different agile terminologies
which made it hard to achieve the results that had been planned. Another analogous methodology was set
out which was also designed based on the agile approach (Giese et al., 2020) in which students worked
on three different, smaller modelling projects, each with a different focus: analysis, high-level and low-
level design. The model lacked the basic skill of initiating motivation in the students which happens to
be the core advantage of any PBL technique. A similar model was designed using PBL (Sakulvirikitkul
et al., 2020) and the concept of agile software development, which consisted of two phases. The students
were required to follow the framework of scrum and gave feedback at the end of each sprint. The method
was appreciated by many experts who evaluated it and spoke about how it is a flexible approach that
develops a good learning potential in students. The model was proposed for all courses but was
inapplicable to some of these courses because of their non-divisibility in the form of cycles.
The above-mentioned details are summarised in the form of a research matrix in Table 1.

After analyzing the shortcomings of the recent works, there is an immense need to provide a
content-based agile approach. Some of the above-mentioned methodologies promoting agile software
development combined with the PBL didn’t have any clearly defined iterative learning path. This
resulted in the reduction of motivation in the students and therefore they avoided learning the
programming courses.
Therefore, in this paper, we propose an agile-based fully mapped project with contents to
enhance the programming skills of the students. The iterative method of content delivery with project
development defines a learning path that will help students to master the skills, thus increasing their
motivation level and helping them in their professional careers. Complete methodology is explained in
the next section.
 Table 1. Research Matrix
Sr. Reference PBL Iterative Approach Strength Weakness
No.
1 Bygstad et. al. Yes Yes Scaffolding approach The students learned from The experimental data are from only one
(2009) achievements instead of failures. case. (1400 students over 5 years at the
Norwegian School of IT).

2 Todorova et. al. Yes No Traditional lecture- The methodology is based on the Inadequate timeline. Students were
(2010) based education preceding course structure which unable to implement the third project.
combined with lets the students learn the
project-based programming skills in the form of a
learning. learning path.

3 Nadzri et. al. Yes Yes Sessional approach The study focused on both No results or evidence on the practical
(2012) hardware & software integration. implementation of the approach.

4 Vega et. al. (2013) Yes Yes Integral learning The theory focuses the most on the It is highly costly for institutions due to
approach - Cupi2 student's motivation, while they the involvement of software factory.
develop programming skills that
they can apply in the real world
incrementally.

5 Ge et. al. (2012) Yes No Task-driven approach This approach focused on students’ No results have been shown in the paper
professional positions by to prove the correctness of the proposed
integrating classroom method.

6 Dr Indiramma Yes No Outcome-based study with actual work. The difference in the students’ learning
M. (2014) education aligned with capabilities was not dealt with. Slow
PBL. learners were unable to do any of the
implementations.

7 Jazayeri, M. Yes No Mastery Learning The paper proved to have The approach was unable to achieve its
(2015) with PBL. successfully met its goal of aim which was to eliminate the
enhancing the learning outcomes of intimidating students.
students.
8 Fioravanti et. al. Yes No Phasal approach The technique focused on the No specific path to be followed by the
(2018) learning capabilities of students. students to achieve their goals.
The weak students weren’t allowed
in the project phase thus, avoiding
the unreasonable burden.

9 Souza et. al. Yes No Project-based The approach was designed in a lack of planning, different times of each
(2019) approach. way where students from all stage and mainly the integration of pro-
disciplines were able to develop jects.
their computing skills.

10 Olayinka et. al. Yes Yes Agile software The approach focused on The framework is quite limited to make
(2020) development. developing competencies and educators embrace the principles of PBL
motivation in students. for practical work.

11 Giese et. al. Yes Yes Project-based The framework is targeted towards The method skipped the part where
(2020) modelling - Model II. the multicultural dimension. students need to get familiar with various
agile terminologies.

12 Sakulvirikitkulet. Yes Yes Agile software The approach focused on early The implementation of the method failed
al. (2020) development. learning successes, personal and to develop motivation in students as the
regular feedback which displayed majority of students in 2017 were still
the increase in students’ not ready to further deepen their
participation rate from 40 - 70%. knowledge in the field.

3. Methodology

In an attempt to bridge the previously mentioned gaps, we proposed the following methodology that will
provide the basis of our teaching model.

Project-Based Learning: Firstly, we choose a project for the introductory programming course
that will fit the Project-Based Learning approach.
 Agile Methodology: Then, we divide the contents of the course in an iterative manner to be
taught in the theory class and implement the chosen project iteratively using the concepts learnt in the
class

Iterative Development: Lastly, we deliver these contents to the students with respect to the
project that has been chosen before. The delivery of these contents’ grounds on the following stages:
 Inception

 Elaboration

 Construction

 Transition

The Inception and Elaboration are delivered in the classroom while the Construction and
Transition are covered during the lab sessions.
Figure 1 shows the proposed methodology of our Iterative Project Based Teaching Model.

Figure 1 Methodology of Iterative Project Based Teaching Model

Figure 1 shows six iterations that students follow during the first introduction course. In the first
class, we show the complete working copy of the chosen project to the students and what they are
required to develop throughout the semester in a series of iterations. We divide the project with reference
to the above six iterations. We display the requirements to complete the project and brief the students
that they will be able to complete this project while achieving the programming skills step by step.
For the development of the project, we stick to the iterative development organised over four
phases. This cycle is followed individually for each iteration. Students fulfil the requirements visioned in
the Inception phase. Firstly, we provide the students with a vision in the form of requirements related to
the task to be performed. These requirements are given as Agile User Stories. Secondly, we design the
concepts to be covered according to the task performed by students in the specific iteration in the
Elaboration phase. We teach those concepts in the class. Thirdly in the Construction phase, we make
students master these concepts by implementing the given task in the computer labs. If the student fails
to acquire the required knowledge of the current iteration, then extra time is invested in the construction
phase; otherwise, the student moves on to the next phase. Lastly in the Transition phase, we have a
discussion session with the students to identify the shortcomings in the project implemented with the
current concepts. After identifying the shortcoming, the students are given new requirements that
overcome the previous shortcomings. This circle continues, and the shortcomings of the one iteration
generate the need for the next iteration.
Figure 2 outlines the overall flow of the proposed teaching model:
 Figure 2 Flow of Iterative Project Based Teaching Model

The whole methodology progresses in the form of an iterative cycle of software development
from the first to the last iteration. The students develop the whole project at the end of the semester by
completing the smaller subtasks of the bigger project in each iteration and then improving those tasks to
make the final project.

3.1. 1st Iteration of Point of Sales Application

Point of Sales is selected for implementation by the students enrolled in the introductory
programming course. Figure 3 explains the basic flow of our project-based learning model for the 1st
iteration.

Figure 3 1st Iteration

The students cover a set of stages in each iteration. The stages for 1st iteration according to our
model are defined below:
3.1.1 Inception: The students are given the vision as requirements for the first iteration. The

description of vision is to convert one form of data (input) into another form of data (output)

using mathematical expressions. The students are provided with the agile user stories. So, the

students are able to extract the task they have to complete in order to develop the complete

project.

Following template of agile user story is followed for the Point of Sales Application (Table 2).

Table 2. Agile User Story for 1st Iteration

Template Story As an I want to perform So that I can
ID
1 9 Admin Calculate the Price of 5 Products. Calculate the Price of product w.r.t.
it's quantity.
2 10 Admin Calculate the Total Price of 5 Calculate the Sum of Prices of the
Products. Products bought.

3 11 Admin Calculate the Total Payable Calculate the Total Payable Amount
Amount (incl. tax) of 5 Products. after adding the tax (5%).

3.1.2. Elaboration: The elaboration phase includes the designing of the project for the 1st iteration i.e.,

the concepts that will be used while implementing the project according to the vision in the

inception phase. These concepts are first taught in the classroom so that students have the

required knowledge to develop the project.

Following are the concepts covered in the first iteration (Table 3).

Table 3. Concepts Covered in 1st Iteration

Variables Variables are used to name the memory locations in which the values are
stored. The values can be changed on runtime. All the inputs will be
taken into the variables.
Input (cin) Cin is used to get input from the user through the keyboard into the
variables.
Output (cout) Cout is used to display/print the contents of a program onto the output
screen.
Mathematical Expressions Arithmetic operators are used to creating mathematical expressions with
(Arithmetic Operators) variables.

3.1.3. Construction: In the construction phase, the students implement the project according to the

vision. The complete output of the task that the student is required to develop is given to the

students.

Figure 4 gives the output of the 1st iteration according to the vision.
 Figure 4 Output Screen for 1st Iteration

During the lab session, we make sure that the student has gained the required knowledge with
respect to the 1st iteration only then a student is allowed for the transition phase. If not, the student
spends extra time to fully grasp the required skills.
3.1.4 Transition: At the end of the iteration, the students and teachers review the project and discuss

certain shortcomings in the current iteration. After finding the fallbacks the students will transit

to the next iteration, to overcome these shortcomings and further improve the project. The results

after the review on the first iteration are given below.

 No checks: The user can enter whatever amount or quantity of the products he desires. Even

if that quantity or those prices don’t exist in the system. e.g., in the above program, a user can

enter whichever amount he wants.

 Sequential Execution: Programs always run-in sequential order. What if the requirement is

to do something if a certain condition is satisfied? e.g., what if a user has entered an invalid

input.

This process continues for 6 iterations. In the 6th iteration, the students are provided with the
final requirements of the project. In this iteration, students develop the complete project. In the end, the
whole project is reviewed and matters are discussed between the students and the teachers.
Appendix-A elaborates the details related to all six iterations of the proposed teaching model
including the phases of iterative development process demonstrating the Point of Sales project i.e.,
description of the vision and corresponding agile user stories, concepts covered in the elaboration phase,
sample code snippets and respective output screens of the transition phase and then finally the drawbacks
of the iteration in the transition phase.
4. Experimentation

Two undergraduate sessions of students were taught in the introductory course at the Department of
Computer Science at The University of Engineering & Technology, Lahore.
 2019 Session

 2020 Session

The course plan for both sessions is as follows:

 3 hours theoretical lectures

 9 hours practical labs

The 2019 session was taught with the traditional lecture-style (non-PBL) while the 2020 session was
taught by the Iterative Project-based Teaching Model (PBL). Both sessions had the strength of 150
students. The 2019 session had 103 male students and 47 female students. The session of 2020 had 94
male students and 56 female students as shown in Table 4.

Table 4. Experimental Dataset

Session Methodology Class Size Female Students Male Students
2019 Non-PBL 150 47 103
2020 PBL 150 56 94

The students of both sessions were taught theoretical lectures of 3 hours. The students of the
2019 batch did practical labs on problem-solving techniques related to independent examples e.g.,
finding an area of a square, calculating the square root of a number etc. Meanwhile, in the 2020 session’s
students were given a project (Point of Sales Application) in their first class. The students implemented
the skills learned from the theoretical classes to this project in the 6 hours of practical labs. Rest of the 3
hours of lab work was dedicated to real-world problem-solving skills.
Figure 5 outlines the details of the experimentation:

Figure 5 Extended Flow of Iterative Project Based Teaching Model

With the progression of the course, the students were assessed based on quizzes, assignments,
mid-term exams, final term, iterative project deliverables, and survey questionnaires. In the end, students
of both sessions were given the same Term Project (University Admission Management System) to
develop for final evaluation. In this project the students were required to develop the admission
management system in which the admin user can add students based on the admission criteria, put
certain checks on the data to filter the options and save the records to the hard-disk etc. The proposed
PBL approach is evaluated based on two things:
 Levels achieved by students in the development of projects.

 Surveys conducted at the end of the semester.

The students were assessed based on the following levels:

Table 5: Assessment Levels

Beginner Level The students who were able to change menus along with clearing the
previous screen e.g., displaying items on the console.
Moderate Level The students who were able to perform CRUD operations on the arrays
and perform various other functions on the data e.g., Sorting etc.
Expert Level The students were able to implement the full features of file handling
e.g., reading the data from the file as well as writing data from an array
into the file.

The conducted survey, for both sessions, was designed to evaluate the student’s motivation and
satisfaction levels. Students were provided with three choices to express their opinions i.e., Weak,
Normal and Strong. Survey questions were categorised as follows: In Q1 students were questioned about
their status of motivation. Q2, Q3 & Q4 had targeted the understanding level of the student. Q5, Q6, &
Q7 inquired the students regarding the preparations to carry out the enforced teaching method. In Q8
students were asked if the workload was manageable in line with other subjects. Q9 questioned the
students about the future they see for themselves and, Q10 implied onto the flexibility of the professor.
The details related to survey questions are given in Appendix-B.
We selected the survey questionnaire as the grounds of feedback analysis from students of both
sessions which will help us to improve the effectiveness of our teaching model. We designed the survey
questions to receive feedback from students regarding the teaching model e.g., the teacher, their
motivation and the workload etc. Both the students of session 2019 and 2020 filled out the survey after
the completion of their semester project.
5. Results

The details of the results are given below:

5.1. Project Development Results:

The following bar chart represents the results of Traditional Teaching Style in comparison to
Iterative Project-based Teaching Model (Figure 6):

Figure 6 Project Development Results

The above figure shows the number of students on its x-axis and their respective programming
levels on the y-axis. The orange colour represents the proposed Iterative Project-based Teaching Model
(PBL) while the colour blue represents Traditional Teaching Style (non-PBL). It shows that 69.34% of
students taught by PBL, reached the Moderate Level. On the other hand, 60% of students reached the
Moderate Level. The session of 2019 (non-PBL) showed poor performance as there were 32% of
students who got stuck at only Beginner Level and 12% of students got to reach the Expert Level. 20%
of students from the 2020 session reached the Expert Level and only 10.67% of students were evaluated
on Beginner Level.

5.2. Survey Results:

Figure 7 and Figure 8 illustrate the surveys conducted by the students of both sessions at the end
of the semester:
 Figure 7 Survey Results of Students taught under PBL

Figure 8 Survey Results of Students taught under non-PBL

Both of the bar charts (Figure 7 and Figure 8) display the number of students on their x-axis and
the survey questions on the y-axis. The grey colour represents the number of students who selected the
“Strong” choice for their answer, the orange colour shows the number of students who made the
“Normal” choice and the blue colour displays the choice “Weak” made by students.
6. Discussion
After a thorough survey of the agile methodologies proposed in the past to teach programming
courses with project-based learning, we present the teaching of introductory programming course
through an iterative model. Previous methodologies failed to fully cover the gap between the theoretical
lectures and their practical implementation. To bridge this gap, we propose a content-based iterative
approach to bridge the gap. This new approach teaches the programming constructs to the students by
developing the project iteratively.
The presented project-based teaching model collaborates with the content-based agile approach.
The contents of the course were delivered through the agile technique in addition to the project to be
developed. Six iterations were designed to teach introductory programming courses. These iterations
advanced by walking through the four stages of iterative project development. The students were given
the requirements to perform a task in the inception phase then, they learned the concepts designed in the
elaboration stage. The students implemented the concepts concerning their project in the construction
phase. Lastly, in the transition stage, teachers and students had a meeting and reviewed the shortcomings
of the current iteration.
The results show that teaching through iteratively mapped projects help students to improve their
problem-solving skills based on real-life problems. There has been a rise in motivation when the students
identify the improvement in their programming skills. Through the survey questions we have deduced
that most of the students taught under PBL have responded positively when they were asked about their
future in the field of software development. Developing the projects through this iterative method,
students were motivated to plan their future professional positions in the discipline of computer science.
Here, we represent our analysis to the Research Questions defined in the introduction section.
The results exhibit the positive outcomes in line of hypothesis based on previously mentioned research
questions, as:
First research question was to inquire what possible phases needed to be part of the iterative PBL.
The phases of the iterations were designed by following the phases of iterative project development.
Each iteration of our teaching model was planned under the inception, elaboration, construction and
transition phase. At the transition phase, the teacher and students discussed the shortcomings of the task
performed which laid the foundation of the next iteration. The iterations were drafted in a way so that the
next iteration could improve and refine the shortcomings of the previous one. In this way, the students
developed their skills most adequately.
Second research question was to see the effect of the proposed PBL on the extrinsic and intrinsic
motivation of students. The survey conducted by students of both sessions indicated that a large number
of students taught under PBL had developed intrinsic motivation due to their mastery of skills in project
development. The extrinsic motivation was also high in students of session 2020 because of the iterative
project they implemented in the labs. In the session, 2020 students exclaimed that they will be willing to
learn more programming languages in the future. They also widely participated during the classrooms
both the theoretical deliverables and the labs. On the contrary, the students taught under non-PBL failed
to develop an evident motivation because 32% of students got stuck on the beginner level.
7. Conclusion
After performing a detailed analysis of the past studies, we propose an Iterative project-based
teaching model, to teach programming course. The presented approach presents the solution to various
challenges that were faced while teaching programming languages such as, it makes students learn
through a defined learning path, it increases motivation in students and it makes students understand
better about where, when and how to use a specific skill. The iterative teaching model has proven
through positive results that the students taught under PBL preferred to learn and heighten their
knowledge in programming languages than the ones who were taught under non-PBL methodology.
This iterative teaching model can be extended or redeveloped for other senior-level programming
courses with minor changes. We intend to evolve this model and propose a similar framework for the
course of Object-Oriented Programming taught in the C# (C Sharp) programming language. Future
investigations could also include whether any other action or activity i.e., student’s previous degree,
student’s work experience, peer assessment, and instructor participation in resolving the issues faced by
students, have an impact on results or not.
References
Amamoua, S., and Cheniti-Belcadhi, L. (2018). Tutoring In Project-Based Learning. 22nd
International Conference on Knowledge-Based and Intelligent Information & Engineering Systems.
https://doi.org/10.1016/j.procs.2018.07.221
Adeoti, J., O. (2019). Technopreneurship and national development: Powering Businesses and
the Economy with New Technologies. Nigerian Institute of Social and Economic Research, 2019.
Bati, T. B., Gelderblom, H., & Van Biljon, J. (2014). A blended learning approach for teaching
computer programming: design for large classes in Sub-Saharan Africa. Computer Science Education,
24(1), 71-99. https://doi.org/10.1080/08993408.2014.897850
 Bygstad, B., Krogstie B. R., & Grønli T. (2009). Learning from achievement: scaffolding student
projects in software engineering. Int. J. Networking and Virtual Organisations, Vol. 6, No. 2, 2009.
https://doi/abs/10.1504/IJNVO.2009.02297
[Dr Indiramma M. (2014). Project based learning – Theoretical Foundation of Computation
course. 2014 International Conference on Interactive Collaborative Learning (ICL).
https://10.1109/ICL.2014.7017882
Fioravanti, M. L., Sena B., Paschoal, L. N., Silva, L. R, Allian, A. P., Nakagawa E. Y., Souza, S.
R. S., Isotani, S. & Barbosa E. F. (2018). Integrating Project Based Learning and Project Management
for Software Engineering Teaching: An Experience Report. SIGCSE ’18: The 49th ACM Technical
Symposium on Computer Science Education, Feb. 21–24, 2018, Baltimore, MD, USA. ACM, New
York, NY, USA, 6 pages. https://doi.org/10.1145/3159450.3159599
Flood, R., & Lockhart, B. (2005). Teaching programming collaboratively. In Proceedings of the
10th annual SIGCSE conference on Innovation and technology in computer science education (pp. 321-
324). https://doi/pdf/10.1145/1067445.1067533
Giese, H., Lambers, L., & Zöllner, C. (2020). From classic to agile: Experiences from more than
a decade of project-based modeling education. In ACM/IEEE 23rd International Conference on Model
Driven Engineering Languages and Systems (MODELS ’20 Companion), October 18–23, 2020, Virtual
Event, Canada. ACM, New York, NY, USA, 10 pages. https://doi.org/10.1145/3417990.3418743
Ge, Q., & Ding, G. (2012). Exploration of Project-based Teaching Content Reforms on
Programming Practice Course. The 7th International Conference on Computer Science & Education
(ICCSE 2012). https://doi.org/10.1109/ICCSE.2012.6295327
Guang-yong H. (2011). Study and practice of import Scrum agile software development. 2011
IEEE 3rd International Conference on Communication Software and Networks.
https://doi.org/10.1109/ICCSN.2011.6013698
Gries, D. (2012). The science of programming. Springer Science & Business Media.
HeYingsheng, Lu Rongbo,Chen Guoping. (2009). ACM Contest Platform in Computer Science
Teaching Research [J]. Computer Education, 2009
Haden, P., & Mann, S. (2003). The trouble with teaching programming. Proceedings of the
NACCQ, 63-70
Jazayeri, M. (2015). Combining Mastery Learning with Project-Based Learning in a First
Programming Course: An Experience Report. IEEE/ACM 37th IEEE International Conference on
Software Engineering. https://doi.org/10.1109/ICSE.2015.163
Krauss, J., & Boss, S. (2013). Thinking through project-based learning: Guiding deeper inquiry.
Corwin Press.
Liu, H.-H.; Su, Y.-S. (2018). Effects of Using Task-Driven Classroom Teaching on Students’
Learning Attitudes and Learning Effectiveness in an Information Technology Course. Sustainability
2018, 10, 3957. https://doi.org/10.3390/su10113957
Mermin, N. D. (2007). Quantum computer science: an introduction. Cambridge University Press.
Nadzri, N., Ramli, M. S., Said N. M., & Yusof, Y. (2012). UTILIZING PROJECT - BASED
LEARNING IN TEACHING OBJECT ORIENTED PROGRAMMING AND DATA STRUCTURE TO
ENGINEERING TECHNOLOGY STUDENTS. Lifelong Learning International Conference 2012
(3LInC’12) / 86
Nayak, A. S., Hiremath, N. D., Umadevi F.M., & Garagad, V. G. (2021). A Hands-on approach
in Teaching Computer Organization & Architecture through Project Based Learning. Journal of
Engineering Education Transformations, Volume 34, January 2021, Special issue, eISSN 2394-1707
 Olayinka, O., & Stannett, M., (2020). Experiencing the Sheffield Team Software Project: A
project-based learning approach to teaching Agile. 2020 IEEE Global Engineering Education Conference
(EDUCON). https://doi.org/10.1109/EDUCON45650.2020.9125175
Prikladnicki, R., Bessa A., Albuquerque, Christiane., G., Wangenheim, V., and Cabral, R. (2009).
Ensino de Engenharia de Software: Desafios, Estratégias de Ensino e Lições Aprendidas. Proceedings of
FEES09 Fórum de Educação em Engenharia de Software. Fortaleza, CE.
Raval, M. S. (2019). Hybrid project-based learning in computer vision. International Journal of
Electrical Engineering & Education 0(0) 1–13
Robins, A., Rountree, J., & Rountree, N. (2003). Learning and teaching programming: A review
and discussion. Computer science education, 13(2), 137-172.
https://doi.org/10.1076/csed.13.2.137.14200
Sakulvirikitkul, P., Sintanakul, K., & Srisomphan, j. (2020). The Design of a Learning Process
for Promoting Teamwork using Project-Based Learning and the Concept of Agile Software
Development. International Journal of Emerging Technologies in Learning (iJET), 15(3), 207-222.
Kassel, Germany: International Journal of Emerging Technology in Learning.
Souza, M., Moreira, R., & Figueiredo, E. (2019). Students Perception on the use of Project-Based
Learning in Software Engineering Education. In XXXIII BRAZILIAN SYMPOSIUM ON SOFTWARE
ENGINEERING (SBES 2019), September 23–27, 2019, Salvador, Brazil. ACM, New York, NY USA,
10 pages. https://doi.org/10.1145/3350768.3352457
Siegeris, J. and Barke, H. 2019. Agile for agile - new ideas for the transformation of student
projects. Projektmanagement und Vorgehensmodelle 2019 - Neue Vorgehensmodelle in Projekten -
Führung, Kulturen und Infrastrukturen im Wandel. Bonn: Gesellschaft für Informatik e.V.. (S. 151-164).
http://handle/20.500.12116/34839
Sangster, A. & Wilson, R., A. (1991). KNOWLEDGE-BASED LEARNING WITHIN THE
ACCOUNTING CURRICULUM. British Accounting Review (1991) 23, 243-261.
https://doi.org/10.1016/0890-8389(91)90087-I
Todorova, M., Hristov, H., Stefanova, E., & Nikolova, N. (2010). How to Build Up
Contemporary Software Professionals Project-Based Learning in Data Structure and Programming.
Proceedings of International Conference on SOFTWARE, SERVICES & SEMANTIC
TECHNOLOGIES. http://hdl.handle.net/10506/622
Vega, C., Jiménez, C., & Villalobos, J. (2013). A scalable and incremental project-based learning
approach for CS1/CS2 courses. Educ Inf Technol (2013) 18:309–329. https://doi/.org/10.1007/s10639-
012-9242-8
Von Hausswolff, K. (2021). Practical thinking while learning to program–novices’ experiences
and hands-on encounters. Computer Science Education, 1-25.
https://doi.org/10.1080/08993408.2021.1953295
Whitehall, B. L., & Lu, S. C. (1994). Theory completion using knowledge-based learning.
Machine learning: A multistrategy approach, 165.
Appendix-A
1st Iteration
1. Inception:

Description Analyse and write computer programs for converting one form of data (input) into another
form of data using mathematical expressions.

Agile User Story:

Template Story As an I want to So that I can
ID
1 9 Admin Calculate the Price of 5 Products. Calculate the Price of product w.r.t.
it's quantity.

2 10 Admin Calculate the Total Price of 5 Calculate the Sum of Prices of the
Products. Products bought.

3 11 Admin Calculate the Total Payable Calculate the Total Payable Amount
Amount (incl. tax) of 5 Products. after adding the tax (5%).
2. Elaboration:

This iteration will cover the following concepts:

Variables Variables are used to name the memory locations in which the values are
stored. The values can be changed on runtime. All the inputs will be taken
into the variables.

Input (cin) Cin is used to get input from the user through the keyboard into the
variables.

Output (cout) Cout is used to display/print the contents of a program onto the output
screen.

Mathematical Expressions Arithmetic operators are used to creating mathematical expressions with
(Arithmetic Operators) variables.
3. Construction:

Below is the sample code for 1st iteration:

 Complete Screenshot of the task performed:

4. Transition:

After performing the above task, we find the following drawbacks:

 No checks: The user can enter whatever amount or quantity of the products he desires.

Even if that quantity or those prices don’t exist in the system.

e.g., in the above program a user can enter whichever amount he wants.
 Sequential Execution: Programs always run in a sequential order. What if the requirement

is to do something if a certain condition is satisfied?

e.g., what if a user has entered an invalid input.

From this point on everything will base on the previously written or presented learning skills. In other
words, further learning skills will be solely based on all the previously elaborated learning skills making
it the extension of the project from one learning skill to another.
2nd Iteration
1. Inception:

Description Analyze and solve computational problems based on single and multiple conditions.

Agile User Story:

Template Story As an I want to So that I can
ID
4 5 Admin Check the quantity of products (Stock). Manage the stock in case of
shortage of products.

5 8 Admin Check if the customer entered the valid Check if the choice entered
Choice. by the customer is valid to
proceed further.

6 12 Admin Check if the customer entered a certain Manage different GSTs

choice than a previously specified GST w.r.t. to various products.
should be applied w.r.t. to that price.

7 13 Admin Check the total payable amount of the three Manage my order and will
products added into the cart. only pay for the products
that I want to buy.
8 14 Admin Check if the total payable amount exceeds a Give gift cards to certain
certain limit, then they get two gift cards. customers. So that they can
feel satisfied with our
services.
9 15 Admin Check if the customer has bought a Give discounts to certain
combination of two certain products OR a customers. So that they can
specific quantity of one product then they get feel satisfied with our
a discount on the whole cart. services.
2. Elaboration:

This iteration will cover the following concepts:

Conditional statements (if, if-else, if… Conditional statements are used to change the flow of our
else-if…else) program.

Logical Operators (&&, ||, !) Logical operators are used to combine two or more
conditions/constraints.
3. Construction:

Below is the sample code for 2nd iteration:

 Complete Screenshot of the task performed:

4. Transition:

After performing the above task, we find the following drawbacks:

 Large number of variables: We declare a large number of variables to store data of the

same type. Thus, using a lot of variables and increasing the compile time of the program.

3rd Iteration
1. Inception:

Description Analyse and solve complex computational problems involving

repetition of dependent and independent iterations.
Agile User Story:
Template Story As an I want to perform So that I can
ID
10 2 Admin View the list of products. Keep record of which products to
add or remove.

11 3 Admin Add new products to the previously Keep the application growing.
existing list.

12 4 Admin Edit the details of products. Manage the details of various

products.

13 6 Admin Remove products from the Remove outdated items.

previously existing list.
2. Elaboration:

This iteration will cover the following concepts:

Arrays The arrays are used to store multiple values of the same datatype. Each element of an array can
individually be referred to according to the need.
3. Construction:

Below is the sample code for 3rd iteration:

Complete Screenshot of the task performed:

4. Transition:

After performing the above task, we find the following drawbacks:

 Specified Operations: We need the user to choose from the menu repeatedly.
  Code Repetition: We are writing the same code multiple times.

4th Iteration
1. Inception:

Description Analyse and solve complex computational problems involving large

amounts of data.

Agile User Story:

Template Story As an I want to perform So that I can
ID
14 16 Admin Purchase the products as much Purchase the desired products without any
as he wants. limitation.

15 17 Admin View the Orders List (Sales Perform various tasks on the Orders List.
Record). e.g., Calculate the customer purchases or
finding the marketing information.

16 18 Admin View the sorted list of Orders Manage the customers in the Orders List.
(based on the customer’s total
bill).
17 19 Admin View the High Value Find the High Value Customers in the
Customer (based on the Orders List.
number of times a customer
visited).

18 20 Admin View the Monthly Income. Estimate the Profit or Loss of my store.
2. Elaboration:

This iteration will cover the following concepts:

Loops (for, while, The loops are used to execute a block of code repeatedly based on the
do…while) satisfaction of a particular condition.
3. Construction:

Below is the sample code for 4th iteration:

Complete Screenshot of the task performed:

 4. Transition:

After performing the above task, we find the following drawbacks:

 Code Readability: Difficult to read the code because of its complexity.

 Maintenance: Difficult to maintain the code in the same place.

 Testing: If a part of code needs to be tested then the complete program is executed.

5th Iteration
1. Inception:

Description Analyse and solve complex computational problems by

decomposing into reusable blocks of code.

Agile User Story:

Template Story As an I want to perform So that I can
ID
19 1 Admin Login into the Prevent unauthorised users from logging in as
system. Administrator.
AND
Perform various operations.

20 23 Admin Logout of the Exit the system and prevent unauthorised users
system. from logging in as Administrator.

21 7 Admin Add a customer into Maintain record of the upcoming customers.

the system.
2. Elaboration:

This iteration will cover the following concepts:

Functions (Built-in, Functions are used to increase the reusability of code i.e., define the code
User-defined) once and use it as many times as wanted.
3. Construction:
 Below is the sample code for 5th iteration:

In main () function the above function will be called as follows:

Complete Screenshot of the task performed:

4. Transition:

After performing the above task, we find the following drawbacks:

  No Permanent Storage: There is no record keeping in the system up until now. If the

Admin adds a customer into the system, then the data related to it can’t be viewed once

the program is closed.

6th Iteration
1. Inception:

Description Analyse and solve complex computational problems by using persistently

stored data.

Agile User Story:

Template Story As an I want to perform So that I can
ID
22 21 Admin Read orders from the CSV file. List down the customers who have
visited in the past.

23 22 Admin Write the new customers data Keep record of all the upcoming
in the file. customers.
2. Elaboration:

This iteration will cover the following concepts:

File To use various elements of file handling in our program to read data from the file into the
Handling arrays and then display it on the output screen. As well as, to write data from the arrays to
the file.
3. Construction:

Below is the sample code for 6th iteration:

Complete Screenshot of the task performed:

Meanwhile the CSV file looked like this:

To add a new customer’s data in the .csv file.

 Meanwhile the CSV file looked like this:

4. Transition:
After performing the above task, we find the following drawbacks:
 Requirements Completed.

 Can be implemented with Object-Oriented Programming (OOP).

 Appendix-B
1. How motivated do you feel to deepen your knowledge about the programming courses?

Weak Normal Strong

2. Do you think your programming skills are better than before after taking up this course?

Weak Normal Strong

3. Does practical laboratory work help you in understanding the concepts better?

Weak Normal Strong

4. Is the expenditure of time for learning to program appropriate?

Weak Normal Strong

5. Does the classroom & laboratory atmosphere is friendly and pleasant for learning programming?

Weak Normal Strong

6. Do you feel like this is the course field (programming) where you belong?

Weak Normal Strong

7. In your opinion, is this approach suitable to teach programming?

Weak Normal Strong

8. Is the workload manageable in line with other courses up until now?

Weak Normal Strong

9. How do you feel about holding a better professional position in the future after taking up this course?

Weak Normal Strong

10. How would you rate your overall experience with the professor after taking this course?

Weak Normal Strong

1