by: Thomas Meloche

Introduction

In order to mitigate problems with proprietary software development processes we encourage our clients to base their development process on open, published and supported standards. Two software development processes stand out as strong candidates for use with your development team:

• Extreme Programming (XP)

• The Rational Unified Process (Unified Process)

These processes are well documented and publicly available. In this paper, we will briefly introduce Extreme Programming and highlight how it is uniquely positioned to improve software development initiatives.

Extreme Programming 

Kent Beck is the driving force behind Extreme Programming (XP). XP ia a set of practices that has the potential to transform not only the development team but the entire delivery organization. It is especially valuable for those developing software iteratively, facing demanding business needs and rapidly changing requirements. In our estimation, XP is the only true iterative and incremental development process.

XP is called "extreme" because it takes commonly accepted programming practices and implements them with extreme devotion, from code reviews to testing. XP also challenges much of the conventional wisdom behind software development; such as the the theory that the cost of changing a piece of software will always increase drastically over time. XP disagrees, and sets in place practices to reduce this cost. XP then takes advantage of the benefits of being able to quickly and comfortably change software late in its lifecycle, even when the software is a mature product that has been shipped to the user community.

XP is considered an agile methodology because it has relatively few rules and a modest number of practices; about a dozen in all. The practices are easy to learn and understand although they may be difficult to implement. The difficulty is not the result of technical challenges but of social challenges. The difficulty arises because XP challenges many of the historical practices of software development, changing interactions with developers, users and customers.

XP Practices

Automated Unit and Functional Tests

XP practices include the writing of automated unit and functional tests. These tests give the system the freedom to improve and evolve in a process called Refactoring, where existing code is continually refined and improved as it is reused.

• XP puts responsibility for extensive unit testing directly on the developers.
• Unit tests are created for anything that could possibly break.
• Developers write unit tests first, before writing the production code.
• Unit tests must always be running at 100%. If the unit tests are broken, new development stops and the bug is fixed.

• XP practices seeks to create a functioning and productive team working in a close knit and collaborative environment.
• XP development work occurs in an open and collaborative workspace.
• XP requires continuous code review. This is accomplished by always programming in pairs, ensuring that all production code is reviewed and understood by at least two people.
• XP developers change pairs and assignments often. This ensures that the team as a whole understands the system as a whole.
• XP practices collective code stewardship rather than code ownership. Everyone on the team responsible for improving the design and the quality of the entire code base.
• The plan and status for each increment is publicly displayed to the entire team. Team members pitch in to help the team as a whole reach team goals.

XP practices implement a true iterative and incremental development process. A process that embraces change on cleanly defined iteration boundaries.

• Software is released in tight iterative cycles typically two weeks long.
• Planning is entirely revisited at the end of each iteration. Planning consists of writing, estimating and prioritizing stories (programmer tasks) for the next iteration.

XP Values

XP is a values-based methodology. The values are simplicity, communication, feedback and courage.  The Extreme Programming practices are a reflection of the core values as seen below:

Simplicity encourages:

• Delivering the simplest functionality that meets business needs

• Designing the simplest software that supports the needed functionality

• Building for today and not for tomorrow

• Writing code that is easy to read, understand, maintain and modify  

Communication is accomplished by:

• Collaborative workspaces

• Co-location of development and business space

• Paired development

• Frequently changing pair partners

• Frequently changing assignments

• Public status displays

• Short standup meetings

• Unit tests, demos and oral communication, not documentation

Feedback is provided by:

• Aggressive iterative and incremental releases

• Frequent releases to end users

• Co-location with end users

• Automated unit tests

• Automated functional tests

Courage is required to:

• Do the right thing in the face of opposition

• Do the practices required to succeed

Many of the XP practices are controversial when they are first introduced to an organization. They needn't be controversial, because they work. We fully expect almost all of the XP practices to become mainstream over the coming years, especially those practices focused on planning, collaboration and testing.

That being said, it is important to note that Extreme Programming is not a complete template for the entire delivery organization. Rather, XP is a set of best practices for managing the development team.

To complete the delivery team, you need to borrow practices from other processes including Interactive Design and The Unified Process. These other disciplines have workflows and activities that we assign to separate teams outside of the XP development team.

Extreme Programming's future is bright. As a process it gives the team the ability to grow, change and adapt as they encounter different applications and business needs. And more than any other process we have encountered Extreme Programming has the power to positively transform not just the development team but the entire delivery organization.

We utilize all of the Extreme Programming (XP) development team practices personally in The Software Factory and encourage you to seriously consider implementing them as well.

Interested in Learning More?

Tom, send me Rich's free white paper "Secrets of Software Success: Adapting Projects to an Accelerated Society"

We will not resell your contact information.

We hate spam as much as you do.

Privacy Policy: No Resale Zone.  Spam Policy: No Spam Zone.