Extreme Programming (XP)
Extreme Programming, or XP, is a discipline of software development
based on principles of simplicity, communication, feedback, and courage.
We are using Extreme Programming in collaboration with some of the
useful processes of other software methodologies for faster delivery
of projects to clients.
Extreme Programming (XP) is most beneficial in response to
problem domains whose requirements change. You may not have a firm
idea of what the system should do. You may have a system whose functionality
is expected to change every few months. In many software environments
dynamically changing requirements is the only constant.
This is when XP will succeed while other methodologies do not. The
XP practices are set up to mitigate the risk and increase the likelihood
of success. XP produces best result when the team size is relatively
small i.e. small group of progammers.
Twelve XP practices which e-Zest Solutions
India Follow:
1.The Planning Process, sometimes called the Planning Game.
The XP planning process allows the XP "customer" to define the business
value of desired features, and uses cost estimates provided by the
programmers, to choose what needs to be done and what needs to be
deferred. The effect of XP's planning process is that it is easy to
steer the project to success.
2. Small Releases. XP teams put a simple system into production
early, and update it frequently on a very short cycle.
3. Metaphor. XP teams use a common "system of names" and
a common system description that guides development and communication.
4.Simple Design. A program built with XP should be the simplest
program that meets the current requirements. There is not much building
"for the future". Instead, the focus is on providing business value.
Of course it is necessary to ensure that you have a good design, and
in XP this is brought about through "refactoring", discussed below.
5.Testing. XP teams focus on validation of the software at
all times. Programmers develop software by writing tests first, then
software that fulfills the requirements reflected in the tests. Customers
provide acceptance tests that enable them to be certain that the features
they need are provided.
6.Refactoring XP teams improve the design of the system throughout
the entire development. Keeping the software clean does this: without
duplication, with high communication, simple, yet complete.
7.Pair Programming. XP programmers write all production code
in pairs, two programmers working together at one machine. Pair programming
has been shown by many experiments to produce better software at similar
or lower cost than programmers working alone.
8.Collective Ownership. All the code belongs to all the programmers.
This lets the team go at full speed, because when something needs
changing, it can be changed without delay.
9.Continuous Integration. XP teams integrate and build the
software system multiple times per day. This keeps all the programmers
on the same page, and enables very rapid progress. Perhaps surprisingly,
integrating more frequently tends to eliminate integration problems
that plague teams who integrate less often.
10.40-hour Week. Tired programmers make more mistakes. XP
teams do not work excessive overtime, keeping themselves fresh, healthy,
and effective.
11.On-site Customer. An XP project is steered by a dedicated
individual who is empowered to determine requirements, set priorities,
and answer questions as the programmers have them. The effect of being
there is that communication improves, with less hard-copy documentation
- often one of the most expensive parts of a software project.
12.Coding Standard. For a team to work effectively in pairs,
and to share ownership of all the code, all the programmers need to
write the code in the same way, with rules that make sure the code
communicates clearly.