The History Of Extreme Programming

Extreme Programming (XP) is a software engineering methodology that has been formulated in 1996 by Kent Beck. It is a lightweight development methodology, XP is one of several popular agile processes. XP has received fair media attention, and is most renowned for its practices that are sometimes regarded as controversial, such as pair programming and test-driven development. It has already been proven to be very successful because it reaches to the customer satisfaction. Instead of delivering everything at the same time the XP focus on some date far in the future, this process delivers the software you need as you need it, in other words Extreme Programming empowers the developers to confidently respond to changing customer requirements, even late in the project development life cycle. The philosophy of Extreme Programming is teamwork, in other words Managers, Customers and Developers are all equal partners in a collaborative team. The implement is simple regarding Extreme Programming, yet effective environment enabling teams to become productive.

XP is built on four values:

Communication: Extreme programmers constantly communicate with their customers and fellow programmers.

Simplicity: The keep their design simple and clean.

Feedback: They get feedback by testing their software starting on day one

Courage/ Respect: They deliver the system to the customers as early as possible and implement changes as suggested. Every small success deepens their respect for the unique contributions of each and every team member.

The main differences with Extreme Programming is that it accepts that humans are imperfect

and builds a process that not only accepts progressive elaboration, but makes this reality a central theme to all of its other practices. There is also recognition that the proscribed practices in the real world can be very challenging, to overcome this difficulty the practices interlock and complement each other.

With this tools that have been mention the Extreme Programming are able to courageously respond to changing requirements and technology.

Figure1: Extreme Programming Overview

[1] http://www.extremeprogramming.org/

12 practices of Kent Beck used in an XP project:

There are strong relationships between XP and its practices. Without practices it’s not XP, and without practicing the practices of XP it cannot deliver benefits.

Figure2: Dependencies between the 12 practices of XP

1) Planning Game:

This is focused on determining requirements details. The customers and developers are both part of this. In a planning game the customers and the developers sit in a room together. They make plans for software releases and iterations together, identifying each role clearly. Planning game involves the making of story cards from each user’s point of view and splitting each story into task cards for individual developers then they make plans that take into consideration the volume of work and the schedule based on these cards.

2) Small Releases:

In small releases developers put quickly a simple system into production, and then release new versions in a very short time.

3) Metaphor:

In metaphor, developers in the team share story or understandings about how their programs work.

4) Simple Design:

The system should be designed as simply as possible at any given moment. Keep code simple and extra complexity is removed as soon as it is discovered. Always keep in mind the principle of YAGNI (“You aren’t going to need it”).

5) Testing

Programmers continually write unit tests, which must run flawlessly for development to continue.

Customers define test cases for system releases.

6) Refactoring:

Without changing their behavior, improve the internal structures of programs.

7) Pair Programming:

Production code which is actually used in the final product, is written with the celebration of two programmers at same machine.

8) Collective Ownership:

Programming code is the property of few programmers it owned by the team collectively, and anyone can change code anywhere and at anytime.

9) Continuous Integration:

Integrate and build the system many times in a day, every time a task is implemented.

10) 40-hour Week:

This is the rule of XP that no work more than 40 hours. Never work overtime a second week in a row.

11) On-site Customer:

In whole project include a real, live user on the team who is available fulltime on site to answer questions.

12) Coding Standards:

Programmers write common rules to standardize coding styles in the team.

XP has 4 basic activities, coding, testing, listening and designing, which are conducted by five major roles, programmer, customer, tester, tracker, and coach.

Iteration is a key concept in XP. The time constant in the different iterations range from seconds to months.

Figure3: Planning/feedback loops in XP

[2][3] http://www.acis.org.co/fileadmin/Curso_Memorias/Curso_CMMI_Sep06/Modulo%202%20-%20Product%20Engineering%20/xp_rup.pdf

(Article: Analysis of the Interaction between Practices

for Introducing XP Effectivel by Osamu Kobayashi and Mitsuyoshi Kawabata)

Comparing two methodologies:

Comparing two methodologies requires some form of empirical studies, The framework used is a combination of 2 established frameworks, one is Zachman’s which consists of the 6 categories what, how, where, who, when and why and the 2nd one is Checkland’s framework is called CATWOE and has six other categories. CATWOE is the abbreviation of Client, Actor, Transformation, World view, Owner, Environment.

In the following table I combine the frameworks an an order to utilize the strengths of both:

zechman

Checkland

what

Transformation

why?

World view

when & where?

Environment

how?

who?

Client, Actor, Owner

1) What?

The Rational Unified Process (RUP) is an iterative software development process framework created by the Rational Software Corporation. The Rational Software Corporation was acquired by IBM in 2003. RUP is a thick methodology; the whole software design process is described with high detail. RUP has evolved in conjunction with the Unified Modeling Language (UML). RUP is designed for large software projects.

On the other hand XP has its origins in practical applications in projects during the 1990’s; it is formulated by Kent Beck. XP is a lightweight methodology and used for small to medium sized software development teams. XP is intended to meet the demands of a context with unclear and volatile requirements. XP is not a commercial methodology unlike RUP.

The origin of RUP and XP are similar. Both methodologies based on experience from software engineering and are evolved during the same decade, although RUP is bit older in age.

There are two different underlying philosophies behind RUP and XP. RUP takes to a large extent a technical management perspective while XP is uses in development staff. RUP describes the whole software design process with high

detail; RUP is a very complex methodology and is difficult to comprehend for both

project managers and project members. Therefore, it is not the most appropriate software design methodology for most small projects. While XP is originally designed for small to medium sized projects,

The distribution of the methodologies is different; RUP is a commercial product, no open or free standard. Before RUP can be used, the RUP has to be bought from IBM as an electronic software and documentation package while XP is freeware methodology and every one can use it freely.

2)Why?

I analyze advantages and disadvantages of RUP and XP from different perspectives like what is the financial, technical and social aspect of these methodologies on each other.

2.1) Financial:

Financial issues of both RUP and XP are different. Rup is a commercial product not open or free standard and owned by IBM, one should buy RUP from IBM as an electronic software and documentation package then it is available to use while XP offers the freeware solution and open to use for everyone, which is financially an advantage.

2.2) Technical perspective

When we compare these 2 methodologies from technical perspective, RUP provides the organization a large amount of development tools and documents. It is delivered online via the web, and updated in new releases, all information about the software development methodology is available at the project members fingertips. Also, the newest version of RUP is always present on the computer of each team member. On the other hand XP leads to simplicity it is more user friendly, it is not specific to a single tool but its depends on the user choice that which tool he wants to use and which to reject.

2.3) Social perspective:

The social perspective of RUP and XP are also related to the commercial versus freeware discussion. The selection on of methodology is depends on the software development company requirements and needs. Small and medium size software development companies like to use XP because of its free availability on the other hand larger software development companies take interest to buying software licenses, and hence buying licenses for methodology is quite natural.

Extent

RUP includes a large amount of formal process paperwork, role description and documentation etc it is also because of these properties called heavy weight or thick methodology while XP is very lightweight or thin methodology, both in its presentation and in the practical applications. The following table shows the difference in extent of the RUP and XP, there all the roles of an XP project are presented, with their counterparts in RUP, constituting a small subset of the RUP roles. In total, RUP comprises more than 80 major artifacts, 150 activities and 40 roles.

Team

XP roles

RUP roles

Customer team

Customer

Requirements specifier

System analyst

Project manager

Tracker

Tester

Test analyst

Tester

Test system administrator

Development team

Programmer

Implementer Designer Integrator

System administrator

Coach

In summary, RUP is a much more extensive

methodology than XP, for good and for bad.

[2]http://www.acis.org.co/fileadmin/Curso_Memorias/Curso_CMMI_Sep06/Modulo%202%20-%20Product%20Engineering%20/xp_rup.pdf

Project drivers

RUP is use case driven, i.e. descriptions of use of the

system are implemented, and continuously integrated and

tested. XP applies test-driven design, i.e. test case are

derived and implemented before the code is written. XP

has user stories to guide what to implement. These user

stories are less extensive descriptions, compared to the

RUP use cases, where the complete scenario for the

interaction between the user and the system is defined.

Regarding planning, both methodologies agree on that

a complete project cannot be planned in detail. RUP

proclaims continuous changes in the plans, while XP

advocates planning only the very near future in detail.