a learning setting based on competitions for agile software engineering

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

Duration (seconds)

# of Missing Primes

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

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


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


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


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.

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.

G1

G1

G1

G2

G2

G2

G3 G3 G3G4 G4

G4

G5

G5

G5

G6

G6

G6

0

1

2

3

4

5

6

Sprint 1 Sprint 2 Sprint 3

Group 1

Group 2

Group 3

Group 4

Group 5

Group 6

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

Students Course

Department Average

Faculty Average

University 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.