The traditional software development process is linear, with time-bound activities scheduled one after another. For instance, design starts when analysis is over, and coding starts when the design is done. The customer sees the product at the end of all activities, and the developers then fix the bugs or make improvements on the finished product. This concept works well if customer requirements remain static. In practice, requirements change frequently, and the frequent editing of the completed programs cause software ‘rot.’
Extreme Programming (XP) is an agile approach to software development, resembling a jigsaw puzzle with many small pieces. Individually the pieces or iterations make no sense, but when combined they make for a complete package. Such an approach makes the software code resilient, making it easy to incorporate changes.
Image Credit: Wikimedia Commons
The first step in extreme programming software developing process is design. The three major guiding techniques adopted during the design phase are considerations of simplicity, use of CRC cards, and spike solutions.
- Simplicity: Extreme Programming software development process thrives on simplicity. The ways to attain simplicity include keeping the code clean and concise by expressing a thing only once and not adding functionality early in anticipation of a need. Experience proves that anticipated needs never arise 90 percent of the time. Simplicity makes it easy to understand, modify, and extend the code.
- CRC Cards: The design phase of Extreme Programming makes use of software class, responsibilities, and collaboration (CRC) cards. These cards allow for a departure from the traditional procedural mindset and make possible implementation of object technology. Such cards allow all members of the project teams to contribute ideas and collate the best ideas into the design.
- Spike Solutions: Extreme Programming approaches tough technical or design problems through spike solutions or simple programs to explore potential solutions. The spike addresses only the problem under examination and ignores all other concerns.
Extreme Programming progresses through iterations. The iterations in Extreme Programming methods ensure development of objects and classes that, when combined, provide the complete product.
Each iteration starts with a meeting between the customer and all members of the programming team. The customer prepares a ‘user story,’ a simple description of the desired functionality. The programming team prepares the plan, time, and costs of carrying out the requirements laid out in the user story and breaks down each feature of the user story into individual engineering tasks. Individual developers then sign up for the specific tasks.
The information in user stories finds use in developing three levels of plans: one plan for the tasks in the current iteration, another plan for stories in the next iteration, and a third plan that looks into the future and groups stories into larger deployments. Such plans are, however, temporary; and new plans are required every time the customer has a new insight or the schedule departs from the plan.
Extreme Programming software development process gives priority to the actual coding over all other tasks.
Standards related to coding include:
- Adherence to metaphor or standards on names, class names, and methods.
- Using uniform styles and formats to ensure compatibility among the work of different team members.
- Pair programming or developing code by two programmers working together on a single machine to produce higher quality code at the same or less cost.
- Strict adherence to 40-hour work weeks to ensure developers’ mental and physical conditions remain at top.
Developers integrate and commit the code they develop into a dedicated repository every few hours or at the end of the day. This system of continuous integration preempts diverging or fragmented development efforts. This ensures that only one development pair integrates, tests, and commits changes at any given moment, and a sequential form of integration prevents conflicts of integration when various developers try to integrate at the same time.
Image Credit: flickr.com/fdecomite
Acceptance testing is of key importance in Extreme Programming. The customer provides the developer with functional or acceptance tests to validate the features. The developers subject the developed code to this test and continue to modify the code until the code passes the test. The test runs several times for confirmation.
Extreme Programming adopts a system of continual feedback to make changes at the development change itself rather than at the end of the project.
During the project development process, developers provide customers with acceptance test scores and demonstrations and take feedback. Such feedback might entail change in requirements, and the code is redone at this stage itself.
A feedback system also exists between developers and project managers through daily meetings.
At the end of the iteration, the programmers deliver a working system without bugs to the customer. The developed code passing the specified acceptance test and the customer having no additional requirements from the user story developed at the start of the iteration ends the specific iteration.
Releases or the combination of one or more iterations deliver value to the customer. The addition of each new requirement mandates re-release.
Please be sure to check out the other items in Bright Hub’s collection of Agile project management guides and discussions.
- Hutagalung, Wilfrid. Extreme Programming. https://www.umsl.edu/~sauterv/analysis/f06Papers/Hutagalung/
- Jarvis, Bob & Gridstock, Steven. Extreme Programing (XP), Six Sigma and CMMI How they can work together. https://www.sei.cmu.edu/library/assets/jarvis-gristock.pdf