Buy My Account


Basics
Overview
Video Demos
Pricing & Ordering
Sample Applications
Customers
News & Reviews
Download Now!

Product Tour
Product Tour
Web Applications
Mobile Applications
SharePoint Applications
Charts and Reports
Security
Architecture & Code
Team Development

Technical Materials
Training Courses
Online Help
Technical Forums
White Papers
What's New in V9.0
One Day Web Apps E-book
System Requirements
Product Roadmap
Version History

Evolving with Extreme Programming

"XP is not a radically new, untried concept. Rather, the rules of XP have evolved from the best software engineering practices over the past 30 years. Those who use XP as an excuse to not do things right, deserve what they get...Those who can learn the XP way, and mold the XP rules to fit their business environment will see tremendous benefit. XP is all about good software engineering."
- Ed Carroll, former VP of Engineering for Egghead.com

June 1, 2005

A Little Review: What is XP?

The gurus of Extreme Programming (XP): Kent Beck, Ward Cunningham, Ron Jefferies, Martin Fowler, and others; define the four essentials of XP as: communication, simplicity, feedback, and courage.
  • Communication must be continuous between customers, developers, management, and anyone else who will influence project success.
  • Simplicity is a goal (or directive, if goal is not strong enough) that influences not only program design and code, but also work processes, planning decisions and team interaction.
  • Feedback is probably most embodied by testing. Test your assumptions, automate your test, test often, and most importantly, create your automated test first (before creating the code).
  • Courage refers to having the guts to make a change. Some might also add, the courage to accept criticism; or to jump-in and be a true team member.
These essentials are then spread across a set of rules:

Planning Coding
User stories are written The customer is always available
Release planning creates the schedule Code must be written to agreed standards
Make frequent small releases Code the unit test first
The Project Velocity is measured All production code is pair programmed
The project is divided into iterations Only one pair integrates code at a time
Iteration planning starts each iteration Integrate often
Move people around Use collective code ownership
A stand-up meeting starts each day Leave optimization till last
Fix XP when it breaks No overtime

Designing Testing
Simplicity All code must have unit tests
Choose a system metaphor All code must pass all unit tests before it
Use CRC cards for design sessions can be released
Create spike solutions to reduce risk When a bug is found, tests are created
No functionality is added early Acceptance tests are run often and the
Refactor whenever and wherever possible score is published

Estimating

The XP planning process starts with User Stories; short (3 sentence) descriptions of “what” written by the customer. The rule is that stories should be combined, broken down or otherwise defined and divided into estimated iterations of 1-3 weeks. The iterations in the release plan make the schedule.

This 1-3 week time limit is not unlike an old estimating technique I’ve used; where the assumption is that an average skilled person should be able to predict all or most of the tasks necessary in a one to two week work element. I once led an engineering team where a certain project manager had a lot of trouble meeting his schedule commitments. After about the 5th excuse, all I wanted to do was to scream, “What about the word ‘done(!)’ don’t you understand?” He simply could not foresee all of the variables in any given situation. That experience illustrated for me a small weakness in the planning process, if estimates are based on the guess work of the team members.

I do not mean to say that the XP technique is bad, it may be fine for an in-house development team. However, there are situations when a more accurate estimate is necessary; for example, when an software engineering outsourcing firm estimates a fixed price proposal. One successful firm, combines the ideas of short storied definitions with some of the structure in use cases, coupled with a powerful Use Case Point (UCP) parametric analysis model to obtain very accurate estimates. This automated process considers factors such as actual delivered history on thousands of projects; use case complexity; engineer skill; object re-use; and other factors to quickly calculate a highly accurate project cost. This firm consistently produces estimates that are greater than 91% accurate, 95% of the time, on projects that average 60 man-months each. Compare that figure to any industry study on project estimation accuracy; which typically run around 30-50% accurate.

Read more!

Frequent Small Releases

The XP guru’s built their concept of frequent small releases on older concepts, such as Rapid Application Development or evolving a system through multiple prototypes. These concepts were all trying to achieve the same objective; keep the customer engaged in the project by shortening the release cycle and show them parts of the system as the system evolved.

I cannot tell you how many times I have been told by management (those guys with the pointy hair) to release the prototype into production. My guess is that the XP gurus just admitted to themselves, there was no point in calling it a prototype; it will be released, so we might as well plan on it from the start.

Seriously though, the concept of frequent small (full) releases, makes good sense. Customers often have the expectation that they can throw their requirements at the engineers; and then magic happens and the engineers throw a completed application back. Frequent small releases, requires frequent iterated involvement by the customer. Frequent iterations are very effective in keeping a customer engaged in a project; which is all important when trying to give the customer what they want.

Read more!

Collaborative Ownership

Most software engineering managers assign one person to solve a coding problem, and that person then becomes the only one who can fix any future problems. I inherited this very problem once (maybe more often), where 40 software engineers were affectively divided across 40 application modules. Each engineer had the segment of code that only they could work on (fix). If anyone left the team, I heard the scream, “I can’t fix this, I’ve never seen this code!”

XP encourages collaborative ownership through concepts like pair programming (pair analysis, pair design), and moving people around. I like to go one step further, and add peer reviews and structured code walk-through. I cannot think of a better tool to train inexperienced engineers on code standards, or to get engineers out of their fear (or arrogance) of having others see their code, than with true peer reviews (meaning, without management).

Read more!

Design

I’m hopeful that most senior software engineers will see most of the XP rules as the basic rules of good software engineering. Concepts like, keep the code (or design) clean and simple; choose a system metaphor; create spike solutions (aka prototype); or even the basis of refactoring whenever and wherever possible; are rules that many good software engineers have followed for a long time.

For some reason, there are others who need to be told to do these things over and over. I once led a very large project, where I was forced to lay-off several members of the project team before their planned roll-off. It was interesting, and painful, to see how poorly some of these under-achievers wrote code; discovered when the remaining project members picked up the left behind work. Needless to say, we paid a lot more attention to each others code after that experience.

Ward Cunningham, one of the XP collaborators, gave me a great example of how XP tries to solve this problem. He said:

    “A lot of programmers are afraid to make schema changes. What if they were to start a project with the simplest schema. Then as the project evolves, they would be forced to change the schema many times. By the end of the project, they would no longer be afraid to change schema.”
That is a great example of designing with simplicity and developing with courage!

Pair Programming

Pair programming is an interesting, but contentious concept; and I wish that I had had the insight to have used it more often. At one point, I created SWAT teams, made up of 4-6 analyst and engineers. The results were great, and the teams enjoyed the experience. However, I found it very difficult to keep the teams together.

The XP rules of moving people around and collaborative ownership of code are integral to effective pairing. In hind-sight, I can see that engineers are the most energized about solving a problem when they are working with another person, a partner. This is true whether the partner is a business end-user, systems analyst, junior programmer or senior architect. Perhaps, even engineers are social animals.

Read more!

Testing

The XP rule I find most valuable is the rule to create an automated test before creating any code. This is such a powerful concept; why don’t more engineers do this? I know an engineering team that does the XP testing concepts so well, that they predict ahead of each iteration, what their testing error rate should be, as a regular step in their process. Then if they do not find the number of errors predicted, they go back and investigate both their code and the test. This process regularly produces code that is very near defect free, on-time, and on-schedule. They have some software products that were released to have thousands of users for years, with no reported errors.

Conclusion

XP is not a radically new, untried concept. Rather, the rules of XP have evolved from the best software engineering practices over the past 30 years. Those who use XP as an excuse to not do things right, deserve what they get (and in my opinion, cannot have read the books, articles, or web sites). Those who can learn the XP way, and mold the XP rules to fit their business environment will see tremendous benefit. XP is all about good software engineering.

About the author

Ed Carroll has been building software products for over 20 years, with particular expertise in automating economic analyses, decision support, and supply chain management process. He is presently a sales executive with Agilis Solutions, and has provided strategic technology leadership for a variety of companies. He is the former vice president of engineering for Egghead.com, and has held senior technology leadership positions at Nike and Boeing.

Contact Ed Carroll

  Support   Company Info  
 

Privacy Statement