-------------------------------------------------
Software Engineering

Research Assignment 2015
-------------------------------------------------
Software Engineering

Research Assignment 2015
211515576
Zaahirah Sheik Ismail
211515576
Zaahirah Sheik Ismail

Table of Contents Statement of research problem 2 Context or background to the research problem 2 Literature survey 3 Research Methods 4 Research Justification 7 Conclusion 7 Bibliography 8

Statement of research problem
The purpose of this study is to find out if the adoption of Extreme programming in a learning environment has improved student productivity. It is a software development process used by small teams who have rapidly changing requirements. With regard to students, all students that are studying software development modules are also faced with this problem where by the requirements are continuously changing as they get deeper within their project. This paper is to show if extreme programming is actually helping students become more productive regardless of the ever changing requirements.
Context or background to the research problem
In this day and age the most widely used form of agile development in software development is extreme programming which was proposed by Kent Beck in 1996. Many parameters contribute to the success of XP. Researchers concluded that using XP in an educational domain has many benefits, where they have seen that less skilled students were able to show more progress than they would have if a traditional methodology were used.(Assassa, Mathkour, & Al Dossari). XP offers a number of practices, values and principles which are advised to be adopted in order to run a software development project(Assassa et al., 2006). These values include communication, simplicity, feedback and courage. Extreme programming has four stages which are planning, design, coding and testing.
Extreme programming uses an object-oriented approach which has four framework activities namely, planning, design, coding and testing. The five principles of XP are Rapid feedback, assume simplicity, incremental change, embracing change and quality work. XP suggests that the design of a project should be for the simplest possible working solution for the current set of requirements of the project and not for the requirements we expect to encounter in the future(Astrachan, Duvall, & Wallingford, 2001).The main factors of XP are pair programming, releasing in small increments and refactoring.
Students who study software development will be given projects to work on that need to be delivered within a certain period of time. This project will need to be of good quality, contain minimal errors and show a significant amount of development standards that will be expected from students in the course. As a student in this situation I am able to relate to the problems we encounter when given this project. Most of these projects are done in groups and the problems faced by students are that they do not manage their time accordingly as to the project being completed on time, there is a lack of communication between team members as a result people tend to do the incorrect work, not much thought is given before they begin coding. Students tend to only test their programs at the end and then deal with the errors, this is a problem as the number of errors could be too large to sort out in the allocated time or many of those errors could be critical to the performance of the software. Taking into consideration all the above mentioned problems faced by students that decrease their productivity and cause their projects not to be of proper standard, this paper will help create an understanding as to whether Extreme Programming will help in solving some, if not all these problems.
Literature survey
A research paper on bringing extreme programming to the classroom suggests that even though the academic requirements, methods and goal differ from that to industry, it was found that many of the aspects in the extreme programming methodology can be added into the curriculum of the students studying computer science and programming in a university. It also mentions that the demands of the students and professors where different to that of professional and industrial software developers.(Astrachan et al., 2001).
Pair programming is one of the main factors of extreme programming. The main focus of studies that were conducted on pair programming was to determine the students’ attitudes towards pair programming and to also mention the benefit that pair programing offers to students, such as improved learning and academic performance. In the paper by Williams and Cockburn they mention that the initially implementation on pair programming didn’t actually work as students were working on separate computers and then joining their work(Cockburn & Williams, 2000). They referred to this as partner programming. However the students eventually realized that this was taking longer to work independently and then checking the errors as they had to teach their partners everything they learned in making the changes.
The benefits of pair programming that was found where that many mistakes were being caught as they were being typed out rather than in later testing or in the field(Cockburn & Williams, 2000). They also mention that teams work faster in pairs and are able to deliver much faster as opposed to individual coding. At the end of the project there are many people who have enough knowledge about the project rather than just one person. Another study concludes that pair programming is easily adopted and is an enjoyable way of coding(Muller & Tichy, 2001).
The writing of test case is to ensure that the application works correctly as per customer requirement so it can use in real time environment. Test cases specify the functionality and are continuously rerun. Writing test case and executing test case give confidence to release software. In the study by Muller and Tichy it was found that students had difficulty in writing test cases before they could actually start coding it out. This was one of the adoptions of extreme programming students had a problem with. Muller also found that at times, test case was impractical. Writing test cases before coding was a new method for students and they found it difficult to adapt it(Muller & Tichy, 2001).
Unit testing is testing individual components of software to determine if it works correctly. Unit testing is used to improve quality of the software so that the number of bugs and errors is reduced.
Extreme programming suggests that code needs to be delivered in small increments. One of the problems faced by students in the adoption of extreme programming was that they were unable to deliver designs in small increments. If their designs worked well and were large they didn’t feel the need to refactor. Refactoring is to remove redundancy and eliminate unused functionality. Refactoring throughout the entire project helps increase quality as well as saves time (Muller & Tichy, 2001)
Research Methods
An experiment was conducted at the Santa Clara University which was run over a ten week period. This experiment consisted of traditional teams and Extreme programming teams. This experiment showed that the traditional teams managed to deliver more functional software compared to that of the XP teams. The teams were unable to adopt many practices such as lack of customer engagement and lack of code ownership(Noll & Atkinson, 2003).
A survey that was conducted with 45 students in different levels of computer science programs at two different institutes, namely the Southern Alberta Institute of Technology and the University of Calgary, to determine the student’s opinions on using extreme programming practices in their design and programming assignments. They survey showed that students found working with a partner to be helpful; however partners need to be matched according to their qualification and experiences. With regard to test first design, students experienced difficulties as they were not used to thinking the test-first way. Overall student were excited to use the extreme programming practices and had a positive experience from it(Melnik & Maurer, 2002).
An experiment that ran for 12 weeks in the summer of 2000 consisted of 11 students. The first 3 weeks allowed students to familiarize themselves with XP practices and the remaining weeks were to work on a major project. Students met weekly to work in pairs on their projects. Students were asked to fill out questionnaires throughout the 12 weeks. These questionnaires were based on the XP practises and what the students have learnt thus far and what difficulties were they facing and suggestions for improvement. They experiment that pair programming was adopted well however releasing in small increments seem to be a problem for students and due to communication overhead XP only works well in small teams(Muller & Tichy, 2001).
This study focuses on pair programming as part of a lecture, small releases from student groups and refactoring to understand programming and design patterns. The study was based on the lecturer’s perspective and on the students’ perspectives. Pair programming was the first aspect of XP that was investigated. Some of the methods used were getting random students to contribute in discussions, dividing the class into groups to come up with different solutions and deriving questions based on the programming problem. Secondly was the aspect of releasing in small increments, students were given 2-7 day period to complete a release, this showed groups were able to successfully release on time and produce good quality software than compared to previous experiences. The refactoring aspect of XP was taught to the students by first instructing them to develop the simplest working solution to solve a problem and then they were asked to change that solution to accommodate for changes in the problem specifications. The design of the curriculum and methods were to help the student’s practices certain aspects of XP. By giving them a view of how programs are constructed they are able to learn how these principles help improve the way the students think about programming and program design(Astrachan et al., 2001).
Another study conducted used a survey that was given to the students. The survey asked questions concerning their use of XP method. The table below is an example of the survey that was used(Johnson & Caristi, 2001).

Research Justification
Many of the research that was conducted on Extreme programming in an educational environment covers most of the basic aspects of Extreme programming practices, however there some gaps that are missing and need to filled.
Some of the missing gaps in Extreme Programming that need to be further researched: * There is a lack of experiments on the use of Extreme Programming on a large scale. This needs to be included in future experiments. * Has Extreme programming practises being introduced at the appropriate time in the education aspect? * Are Experiments helping students understand Extreme Programming practices in an educational domain?
Conclusion
Based on all the information provided in this paper, it is evident that the adoption of Extreme Programming in a learning environment benefited students. The initial problem occurs when students are being introduced to XP however once they are comfortable with it, it helps them develop better software and to deliver their work on time. This study was to determine if XP has increased student productivity and I would like to conclude that as much as some students find the XP practices difficult to adopt many other students are positively benefiting from it.

Bibliography

Assassa, G., Mathkour, H., & Al Dossari, H. (2006). Extreme programming: A case study in software engineering courses.

Astrachan, O., Duvall, R. C., & Wallingford, E. (2001). Bringing extreme programming to the classroom. Paper presented at the XP Universe.

Cockburn, A., & Williams, L. (2000). The costs and benefits of pair programming. Extreme programming examined, 223-247.

Johnson, D. H., & Caristi, J. (2001). Extreme programming and the software design course. Paper presented at the Proceedings of XP Universe.

Melnik, G., & Maurer, F. (2002). Perceptions of agile practices: A student survey Extreme Programming and Agile Methods—XP/Agile Universe 2002 (pp. 241-250): Springer.

Muller, M. M., & Tichy, W. F. (2001). Case study: extreme programming in a university environment. Paper presented at the Software Engineering, 2001. ICSE 2001. Proceedings of the 23rd International Conference on.

Noll, J., & Atkinson, D. C. (2003). Comparing extreme programming to traditional development for student projects: A case study Extreme Programming and Agile Processes in Software Engineering (pp. 372-374): Springer.