A Learning Setting Based on Competitions for Agile Software Engineering

Davut Çulha

Abstract

In learning, competitions are used for years in applications of robotics because of the increased learning efficiency.
Likewise, competitions can be used as learning catalyzers in software engineering. In this work, a graduate-level
course in software engineering is flourished with a learning setting based on competitions. The course relies on
teaching agile software engineering methodologies. A project is implemented using an agile methodology because of
the preparation of the students to the real world. From the software engineering point of view, software development
should be learned by the students by experiencing the entire development life cycle. From the business point of view,
the students should learn to take roles in software development by experiencing teamwork and collaboration, and they
should be ready for the software development issues of real life. Competition-based learning supports these two points
of view by increasing teamwork, creating self-motivation, and by simulating today’s fast-changing environments. In
short, learning efficiency is increased for a course of agile software engineering using a competition-based learning
setting by adapting a problem from mathematics.

Keywords

Competition-based learning, agile development, software development

1. Introduction

Competition-based learning is a learning methodology in which students’ learning willingness is increased (Altin and
Pedaste 2013). In robotics education, competition-based learning is mostly and effectively applied. This work is an
attempt for software engineering education to universalize competition-based learning. First application of
competition-based learning to software engineering shows that competitions increase learning motivation of students
(Çulha 2016). Although there is a possibility to apply competition-based learning to many fields in education, its
application is mostly localized to robotics.

In software engineering, the speed of software development becomes crucial. Therefore, agility and agile
methodologies are important (Prasad 2014, Begel and Nagappan 2007, Dingsoyr, Nerur, Balijepally and Moe 2012,
Dyba and Dingsoyr 2008). Consequently, usage of agile methodologies increases in development of software. Agile
methodologies have short development cycles to react fast to the changing customer requirements. The short
development cycles are also useful in software engineering education as well as agility. If agile methodologies are
projected in software engineering education, the students can experience all the activities of software development.
Software engineering courses should maximize some benefits of the course. First of all, the students should feel they
do real world applications because they will encounter them after graduation. Secondly, they should learn teamwork
because in the real world most of the software development cannot be completed alone. Thirdly, they should learn to
develop software in projects because most of the software development are realized as projects. Lastly, they should
learn software development life cycle because they will encounter all the development activities in real life. In
conclusion, if a team project is employed in a competition environment in a software engineering course, most of the
important benefits are maximized. In this setting, competition-based learning also behaves like a catalyzer to increase
the learning efficiency.

The remaining part of this work proceeds as follows. In the section that follows, related work is given. In the third
section, the course is described. Then, the definition of project is made. In the fifth section, the methodology applied
is explained. After that, the implementations of the project are presented by considering their results. Then, discussion
and conclusion are made.

2. Related Work

In order to increase the efficiency of learning, some methodologies are applied to courses. One of them is competition-
based learning. In competition-based learning, learning outcomes are achieved through competitions. In robotics
education, competitions are used widely among the developed robots. In Altin and Pedaste (2013), Jung (2013), Paulik
and Krishnan (2001, 1999), Hyyppa (2004), applications of competition-based learning are effectively realized as a
learning method.

In Burguillo (2010), competition-based learning is applied via a framework which uses Game Theory tournaments.
Increase in the learning performance and motivation of students are achieved by the tournaments. In Silva and Madeira
(2010), for an engineering program, a programming course is designed based on competition-based learning. The
application is realized through a framework which is a mixture of collaboration and competition-based learning.

In Chung (2008), the advantages of competition based learning are given as the following: competitions motivate and
promote students to work harder; students ask more questions than regular home works; in some cases, students work
beyond the class topics; it enhances the learning objectives in the class. However, less cooperation between teams is
observed as a drawback. That drawback is partially solved by requiring presentations to share ideas.

Software engineering can be taught using computer games. In a course of software engineering, teaching of software
development life cycle is realized efficiently using computer game-based projects (Claypool and Claypool 2005).
Simulation of real world can be done using computer games. Likewise, mathematics is used in Brazier, Taylor, Basu
and Sircar (2006) to efficiently realize the real world.

In agile software development, development of software is done using agile methods. Agile methodologies became
widespread in recent years (Dingsoyr, Nerur, Balijepally and Moe 2012). In software engineering, engineering
principles are applied to software development. Traditional software engineering courses exploit traditional
methodologies in their syllabuses. A traditional software engineering methodology is Unified Process (Jacobson,
Booch and Rumbaugh 1999), which is employed in the education of a software engineering course (Young and
Needham 2013). In agile software engineering, software development is realized using agile principles. In a software
engineering course (Reichlmayr 2003), Test-driven Development (Beck 2003) is exploited, which is an agile
methodology. In the course, a project is developed in teams. Furthermore, the methodology has short incremental
release cycles. Accordingly, this team-based agile teaching of software engineering makes students converge to real
world software development activities.
In real world applications, the software life cycle usually is longer than a term. Hereby, real world projects cannot be
developed in a term period for students. However, the students should learn the different activities of software
development in their software engineering courses. Since agile methodologies have iterations, including agile
methodologies causes students to feel the life cycle of development of software. In a software engineering course
(Shukla and Williams 2002), Extreme Programming (Lindstrom and Jeffries 2004) is applied, which is a well-known
agile methodology. Especially, important agile practices are integrated to the course.

Real world applications are usually developed in teams because a single developer cannot complete in a reasonable
time. From this point of view, a teamwork is needed implicitly in software development. Therefore, the students of
software engineering courses can be familiar with developing software in teams. Eventually, a big enough development
task should be assigned to students, which should not be developed simply by a student alone. At that time, the project-
based task comes as a solution. Similarly, in real life, software development is realized as projects. In short, a software
engineering course to converge to the real life should reinforce students to learn teamwork, working for a project, and
the entire life cycle of development of software.

In Paulik and Krishnan (2001, 1999), the software engineering is taught using project-based approach. All activities
and the entire development life cycle of software can be taught in software engineering courses. One way of doing this
is assigning a semester-long project to the students. These kinds of project-based courses usually assign to the students
a single project for the entire term. While developing the project, students pass through the phases of the software
development life cycle. They encounter obstacles of development. They apply software engineering practices. They
participate in the activities of the life cycle. In a course of software engineering, a semester-long project is assigned to
the students (Claypool and Claypool 2005, Young and Needham 2013, Collofello and Woodfield 1982. The students
learn basics of software engineering, its theory, and practices. In Marmorstein (2011), open source projects are
employed. In Pletch and Agajanian (2007), a project is implemented to support teamwork in a software engineering
course. The team project helps to students to examine process and people relations in addition to real life issues in
software engineering. In Baker, Navarro and van der Hoek (2005), real world projects are simulated with a card game
in course projects. Therefore, software engineering processes related to real life are experienced using course projects.

3. Course Description

Competitions are used to improve the learning efficiency in a graduate-level course of software engineering at Atilim
University. The course is coded as SE571 with the name Agile Software Development Approaches. In the course, all
the major agile methodologies are covered with an emphasis on Scrum (Schwaber 2004) and Extreme Programming
(Lindstrom and Jeffries 2004). In order to be clearer, the other educated approaches are Test Driven Development
(TDD), Dynamic Systems Development Method (DSDM), Feature-driven Development (FDD), Lean, Kanban, Agile
Unified, and Crystal (Highsmith 2002). Agile project management (Fernandez and Fernandez 2008) is also covered in
the course.

The aim of the course is to teach the significance of agile methodologies, comparing of agile methodologies, how to
evaluate whether projects follow agile principles, and how to determine a suitable agile methodology for a specific
project.

In the course, 4 hours are taught weekly, of which 2 are for lectures and 2 are for application. Midterm and final exams
form the 50% of the total grades. 20% comes from the assignments. The rest 30% is reserved to a project. In the
University, this course has never been taught before. However, there is a similar undergraduate course called as Agile
Methods in Software Development. In the previous years, the undergraduate course was given with the same format.
In the last term, competition-based learning was applied (Çulha 2016). According to the lessons learned from the
undergraduate course application, the competition-based learning setting was crystallized in the course SE571. In this
term, competition-based adjustment is done again for the project part of the course. Scrum methodology is followed
in the project. There were 16 enrolled students in the course. 6 teams were built from them, where each team has 2 or
3 members. The project is evaluated in two parts. In the first part, the written report of the project is dealt, where how
the Scrum methodology is applied is evaluated. This classical evaluation constitute big part of the grading with a
percentage of 70. The remained 30% of the evaluation is reserved for competition. According to the performance in
the competitions, the teams get their points from this competition part.

The students are enrolled to the course from Software Engineering and Information Technology Departments at Atilim
University. All of the students are master or PhD students.

4. Project Description

The project is based on competition. Therefore, a suitable problem for competition is designed. For this reason,
mathematics is used to find the problem. The aim of the problem basically is to find the missing intermediate prime
numbers in a text file in a given time. The text file is taken as input file to the program. It contains consecutive prime
numbers starting from the first prime number. Some prime numbers are extracted from the input file. The aim of the
program is to find those missing prime numbers. The input file is arranged according to the competitions.

The program which will be written for the project takes a parameter. It is in seconds for the duration. Also, the given
text file is taken as input implicitly. In the determined duration, the program finds all the missing prime numbers of
the given text file. The program outputs a text file including all the missing primes. In the output file, all the missing
prime numbers should be in order. In other words, if there is another number than the expected missing number in the
location of the output file, the previous correctly found missing prime numbers will be evaluated for the performance.
The others will not be evaluated even if there are some other missing prime numbers located ahead. Java will be used
in all coding, where external libraries will not be used.

The project will be completed in 3 iterations, where a four-week duration is selected for each of them. At the end of
each sprint, the groups will prepare a report to certify the success of applying Scrum methodology. Furthermore, for
each iteration, the competition of the prepared programs will be executed in a computer which runs on Windows 7
operating system. The selected computer runs with two CPUs at 3.00GHz and 2.67GHz, and 4GB of RAM.

The ability of adaptation to fast-changing environments is important in agile methodologies. To support adaptation of
fast-changing environments, supplementary requirements are requested for each iteration. These requirements will be
used students to feel the fast-changing environment as well as to increase the motivation in the course.

Group size of 2 or 3 was determined for forming groups. 6 groups were comprised from the enrolled 16 students. At
the end of each iteration, each group prepares a report with a developed program.

5. The Methodology

In Figure 1, the methodology applied is shown. Each iteration of the software development is also an exercise stage
for the competition. The sprint is completed with a competition.
 Figure 1. The applied methodology

In competitions, there should be an availability to do better and better performances. There should not be exact
solutions to differentiate the students according to their performances. Therefore, the problem of the project should be
selected as suitable for competitions. If the given input file is small, the exact solutions can be found. However, the
size of the input file can be adjusted as big enough as not examined in the given duration. In consequence, the problem
is suitable for competition.

6. Implementations of the Project

The results are checked using a simple written program. This program inputs a file composed of consecutive missing
primes. The first missing prime is found, and is checked with the missing prime list. If these numbers are the same, the
next missing prime is found, and is checked with the next number in the list. It finds the first correctly ordered missing
numbers according to the missing prime list for the whole file. If the missing number is not the expected missing prime,
then it ceases and accepts the previous missing numbers for the performance evaluation.

Table 1 shows the competitions for the iterations. At the end of the first sprint, the duration 120 seconds is used for the
competition of the programs. For the second sprint, the duration is decreased to 80 seconds. For the last sprint, the
duration is also decreased, and became 10 seconds. In the third column of the table, the number of missing primes are
shown. In the first sprint an input text file prepared with 15 missing prime numbers. In the second sprint, the input file
is designed with 6 missing prime numbers. In the last sprint, the input file size is increased and its number of missing
primes also increased.
 Table 1. Competitions

# of
Duration
Missing Group 1 Group 2 Group 3 Group 4 Group 5 Group 6
(seconds)
Primes
Sprint 1 120 15 9 0 15 15 0 14
Sprint 2 80 6 6 6 6 6 6 6
Sprint 3 10 20 1 0 20 2 0 0

In the second sprint, to increase the tension of rivalry the program complexity is increased. However, all groups found
the exact number of missing primes. Therefore, all of them were the winner of the competition. A suitable adjustment
in the program complexity was needed. In the third sprint, the problem complexity is increased drastically with a very
small number for the parameter of duration.

In Table 2, the ranks in the competitions are displayed. In the first sprint, there are two groups in the first position. In
the second sprint, all the groups are in the first position. In the third sprint, three of them finished the competition at
fourth place.

Table 2. Ranks

Group 1 Group 2 Group 3 Group 4 Group 5 Group 6

Sprint 1 3 4 1 1 5 2
Sprint 2 1 1 1 1 1 1
Sprint 3 3 4 1 2 4 4

In Table 3, the grades of the groups are shown. These grades are for 30% of the total project grade. According to the
competition performance, the groups at first place take 30 full points, whereas the following places at the competitions
take their grades by decreasing 5 points from the full grade successively. Actually, the major part of the total project
grade comes from the traditional part with a percentage of 70%.

Table 3. Competition grades

Group 1 Group 2 Group 3 Group 4 Group 5 Group 6

Sprint 1 20 15 30 30 10 25
Sprint 2 30 30 30 30 30 30
Sprint 3 20 15 30 25 15 15

In Table 4, the report grades of the groups are displayed. This part is the 70% of the total project grade. How
appropriately the Scrum methodology is applied is measured using this part. The report grades exhibit that the full
grade is taken nearly by all the groups. Competition motivated students to do better work. As a result, they prepared
good reports for the sprints. Motivation obtained from competition is contagious in good meaning. This contagiousness
looks like the motivation ripples generated by daily scrums in Scrum methodology. In other words, the excitement of
competition extends to the report part, to the whole course, and maybe to other courses. In consequence, fine and well
formatted reports were submitted by the students, and which proved that the Scrum methodology was learned well. In
short, competition affects the course very positively.

Table 4. Report grades

Group 1 Group 2 Group 3 Group 4 Group 5 Group 6

Sprint 1 68 70 64 66 63 67
Sprint 2 70 70 60 67 62 68
Sprint 3 30 70 47 62 61 70

In Table 5, the total project grades over 100 are shown. As a last column, the total grades of the groups are shown.
According to this table, the maximum grades are taken in the second iteration. In the last iteration, the total grades
were kept at minimum.

Table 5. Total grades

Group 1 Group 2 Group 3 Group 4 Group 5 Group 6 Total

Sprint 1 88 85 94 96 73 92 528
Sprint 2 100 100 90 97 92 98 577
Sprint 3 50 85 77 87 76 85 460

In Table 6, the efforts of the groups are given. Efforts spent were recorded by the groups during the sprints. At the
report of the sprint, each effort was documented by the groups. In the last column of the table, the total efforts are seen.
In the second iteration, the groups spent the maximum effort with a total of 110 hours. In the last iteration, they spent
their minimum efforts.

Table 6. Total efforts (in hours)

Group 1 Group 2 Group 3 Group 4 Group 5 Group 6 Total

Sprint 1 16 31 12 10 21 9 99
Sprint 2 20 24 9 16 26 15 110
Sprint 3 9 12 8 9 28 13 79

In Table 7, the total grades are also added to the table as well as the corresponding total efforts. The contagious
motivation of competition affects the report grades indirectly. Hence, groups spent more efforts took more grades.
Therefore, the total grades and efforts are aligned. Fortunately, the expected correlation was obtained.
 Table 7. Total efforts and grades

Total Effort (hours) Total Grade

Sprint 1 99 528
Sprint 2 110 577
Sprint 3 79 460

In Figure 2, the group performances are displayed through the sprints. In fact, in the first and in the last sprint,
competition is felt deeply by the students. At the end of the second sprint, all groups shared the first place of the
competition.

G3 G4 G1 G2 G3 G4 G5 G6 G3
1

G6 G4 Group 1
2
Group 2
G1 G1
3 Group 3

G2 G2 G5 G6 Group 4
4 Group 5
G5 Group 6
5

6
Sprint 1 Sprint 2 Sprint 3

Figure 2. Performance of the groups through the sprints

7. Discussion

The total efforts spent by the students can be seen in Table 7. According to this, the project was found as interesting
from the students. They were surprised when the project was announced because they did not establish the relation
with agile software development. They thought that the project is a mathematics project. Moreover, they were also
surprised from the competition part because they said they did not experience it before in the courses. During the
implementation of the project, they implemented several algorithms, of which some were searched from the internet,
and some were their own trial algorithms. All these efforts were reported by the students. For the project, many hours
were spent especially in the first two sprints as shown in Table 7. From the undergraduate level corresponding course,
it is known that students learn many things in the first 3 sprints. According to student reports, they learned how to
apply the Scrum methodology very well. In agile methodologies, communication among team members increase the
success of development. The students used daily scrums as a default communication way. However, they also used
social media as wells as phone, e-mail, and internet for communication. In consequence, they maximized the
communication in the teams.
Students get excited because of competitions. Even after the competitions, they study on the finished parts, and write
the program again, and asks for the re-execution of the finished parts. Those are directed to the next competitions
without demolishing their excitements.

For each sprint, adapting to the changing environment was expected. For this reason, some supplementary changes are
appended to the sprint requirements. First of all, for each sprint, the duration is decreased, and students are not informed
about their values. A few rules are changed, or extracted totally, with addition of new rules. For example, the number
of written lines of codes in the programs is restricted. Likely, threading is forbidden. The students adapted to these
changes as expected according to their reports.

In Çulha (2016), a project is implemented in the application of agile software engineering using competition-based
learning. The project is realized using Scrum methodology in teams. The project is established around a prime number
problem from mathematics like the applied problem in the course. According to Çulha (2016), the number of iterations
were high because students lost their interest with problem. Actually, there are 5 sprints and the last 2 sprints did not
catch the concern of the students. Hence, in this work, only 3 sprints were taken. Three sprints fitted to the course well
because the students did not lose their relevance to the project. Moreover, generally, duration for a sprint is 30 days.
As a result, 3 sprints properly settled down for a single-term agile software engineering course. Moreover, in Çulha
(2016), for each iteration, some little changes were made to increase the concern of the students. The same method
was applied in this course by changing duration parameter in the sprints. These little changes multiplied the excitement
of students to the course.

Competitions are easily arranged in robotics courses because designed robots are competed in a straightforward
manner. However, preparing settings in other areas is difficult. In this study, the competition-based learning is
expanded to software engineering area. Probably, its extension to computer science area as a whole would be not
difficult. Absolutely, extending to other areas may be hard, but the gain in learning efficiency would tolerate that
adversity.

Mathematics is a good place to find competition-based problems. Simple mathematical problems should be prepared
for the competitions. Those problems should be enclosed with the related core course material. Hence, students do not
feel that the assignment is pure mathematics.

The competition problems should measure the performance of the competitions. In other words, there should be better
results every time even if obtaining good results.

Table 8. Course evaluation

# of Department Faculty University

Course
Students Average Average Average
Evaluation (over 5) 15 4.45 4.15 4.32 4.32

When students compete, they should not feel that the course is like a gambling. In other words, the whole evaluation
of the course should not depend on the competitions. At that time, students would get angry, there would be serious
conflicts among the teams and inside teams. According to the observations, less than quarter of the course evaluation
would depend on competitions. In this course, nearly 10% of the course evaluation comes from the competitions. This
percentage is not big, and not very small, but it fits well because the satisfaction level of the course is above the
university average. In Table 8, the results of the course evaluation questionnaire are displayed. 15 students are attended
to the questionnaire, and the evaluation score for the course is 4.45 over 5 whereas university average is 4.32.
Another method was applied to take away competitions from gambling. The evaluations do not depend on the actual
performances of the competitions because there would be big gaps among teams. At that time, the winner gets the
whole grade, whereas others get nearly zero grades. In consequence, the evaluation of the competitions depends on the
order of competition results. In Table 2, the ranks are determined for this purpose.

The teams are formed as 2 or 3-student teams. In agile approaches, communication among team members is an
important factor for success. Moreover, it is known that communication in small teams is better. As a result, it is
observed that the size 3 for teams in this course is a good choice to learn collaboration and teamwork.

8. Conclusion

Main contribution of the paper is that problems from mathematics can be exploited in software engineering education.
Competitions enhance the quality of education in software engineering. In software engineering education, a good
motivator is obtained via competition-based learning. Especially, for agile software engineering education, the
application of competition-based learning creates also the fast-changing environment where agile software
development runs.

In agile software development, frequent inspections of the project like daily scrums generate motivation ripples in the
project environment. Likewise, the competitions generate similar motivation ripples on students. These motivation
ripples improve the total quality of the course. Furthermore, these motivation ripples affects the learning in the other
courses. These affects can be investigated in future researches.

Another contribution of the paper is that the competition atmosphere strengthens the communication among the
students. In agile software engineering, the strong communication is a sought thing, and agile software engineering
also increase the communication among stakeholders implicitly.

In the paper, applying competitions in learning of agile software engineering is presented for a graduate-level course.
Real world is simulated using competitions. Students were motivated by competition-based setting to find the missing
prime numbers. In agile software development, self-motivation should be increased. Competitions assist students to
gain self-motivation. The word “agile” has the meaning “quick” in addition to other meanings. Therefore, in agile
methodologies, being quick is inevitable. Fast changes in the environment are again inevitable in today’s software
development. Competition-based settings provide agile environments to software development. Consequently,
adaptation to the fast-changing environment is achieved. It is observed that teaching of software engineering is
increased in efficiency by applying competition-based learning approach.

Competition-based projects creates simulations of fast-changing environments of real world. In agile software
development courses, development issues related to real world can be encountered by competition-based projects.

In agile software development, strengthening the communication among the stakeholders of the projects may be the
main cause of the success of the agile software development. Competitions increase the motivations of the students.
They want to be winner of the competitions. Therefore, they increase the teamwork by increasing the communication
between their team members. In brief, agile software development is a right place to apply competition-based learning.

Furthermore, competition-based learning contributes to the base concepts of computer science. The students try to
optimize time and space usage. Space and time management in programming are demanded in competition-based
settings because of obtaining good performance. For the future work, contagious effect of competition-based learning
can be studied.
References

Altin, H. and Pedaste, M. (2013) Learning Approaches to Applying Robotics in Science Education. Journal of Baltic
Science Education.

Baker, A., Navarro, E.O. and van der Hoek, A. (2005) An Experimental Card Game for Teaching Software Engineering
Processes. Journal of Systems and Software.

Beck, K. (2003) Test-driven Development: by Example. Addison-Wesley Professional.

Begel, A. and Nagappan, N. (2007) Usage and Perceptions of Agile Software Development in an Industrial Context:
An Exploratory Study. In Empirical Software Engineering and Measurement.

Brazier, P., Villalobos, M.C., Taylor, M., Basu, K. and Sircar, T. (2006) A Cross-Disciplinary Software Engineering
Project Implemented as a Web Service. Proc of the 9th International Conference on Engineering Education.

Burguillo, J. C. (2010) Using Game Theory and Competition-based Learning to Stimulate Student Motivation and
Performance. Computers & Education.

Chung, C.J. C. (2008) Learning through Competitions – Competition Based Learning (CBL). LTU CTL Conference,
April 2008.

Claypool, K.T. and Claypool, M. (2005) Teaching Software Engineering Through Game Design. ITiCSE.

Collofello, J. and Woodfield, S. (1982) A Project-unified Software Engineering Course Sequence. ACM SIGCSE
Bulletin.

Çulha, D. (2016) Applying Competition-based Learning to Agile Software Engineering. Comput. Appl. Eng. Educ.

Dingsoyr, T., Nerur, S., Balijepally, V., and Moe, N.B. (2012) A Decade of Agile Methodologies: Towards
Explaining Agile Software Development. Journal of Systems and Software.

Dyba, T. and Dingsoyr, T. (2008) Empirical Studies of Agile Software Development: a Systematic Review.
Information and Software Technology.

Fernandez, D.J. and Fernandez, J.D. (2008) Agile Project Management - Agilism versus Traditional Approaches.
Journal of Computer Information Systems.

Highsmith, J.A. (2002) Agile Software Development Ecosystems. Addison Wesley Professional.

Hyyppa, K. (2004) Competition - An Efficient Method to Get Students Committed. ICALT, IEEE Computer Society.

Jacobson, I., Booch, G. and Rumbaugh, J. (1999) The Unified Software Development Process. Reading, MA, Addison-
Wesley.

Jung, S. (2013) Experiences in Developing an Experimental Robotics Course Program for Undergraduate Education.
IEEE Trans. Education.

Lindstrom, L. and Jeffries, R. (2004) Extreme Programming and Agile Software Development Methodologies.
Information Systems Management.

Marmorstein, R.M. (2011) Open Source Contribution as an Effective Software Engineering Class Project. ITiCSE.
Paulik, M.J. and Krishnan, N.M. (2001) A Competition-motivated Capstone Design Course: the Result of a Fifteen-
year Evolution. IEEE Trans. Education.

Paulik, M. J. and Krishnan, M. (1999) An Autonomous Ground Vehicle Competition-driven Capstone Design Course.
Proc. 1999 Frontiers Educ. Conf. Nov 1999.

Pletch, A. and Agajanian, A. (2007) A Software Engineering Project that Looks Like the Real World. Journal of
Computing Sciences in Colleges.

Prasad, M.K. (2014) Agile Computing – A Case Study.

Reichlmayr, T. (2003) The Agile Approach in an Undergraduate Software Engineering Course Project. Proc. 33rd
Annual Frontiers in Education.

Schwaber, K. (2004) Agile Project Management with Scrum. Washington, Microsoft Press.

Shukla, A. and Williams, L.A. (2002) Adapting Extreme Programming for a Core Software Engineering Course.
Software Engineering Education and Training. Proceedings. Los Alamitos, CA, IEEE Computer Society

Silva, B. and Madeira, R.N. (2010) A Study and a Proposal of a Collaborative and Competitive Learning
Methodology. IEEE Education Engineering.

Young, P. and Needham, P. (2013) Using a Class-Wide, Semester-Long Project to Teach Software Engineering
Principles. GSTF Journal on Computing.