In the decade since the inception of XP, a lot has happened in the development world. Chet Hendrickson, author of Extreme Programming Installed , talks about the most interesting of these changes.



When I'm feeling particularly arrogant, I'll sometimes say that I was doing XP before it had a name. While that's true, it really isn't very interesting. Perhaps more interesting is what has happened to this thing we call XP since it became something worthy of a name.

In Extreme Programming Installed, we described 13 core practices. Over the years, I've come to believe that those 13 are not themselves XP, but just the things you do to teach yourself what XP really is. Nonetheless, those practices tell us a lot about what developers and teams should do to be successful. They still represent many truths about how to do iterative and incremental development.

Most of those original XP practices are as valid today as they were 10 years ago. I'll leave it to others to write about those. For this article, I want to look at the things that have changed.

User Story Size

Our original advice was that a user story shouldn't extend beyond the length of your iteration. If your iteration was three weeks (as it was in the original formulation of XP), individual stories should each take less than three weeks to complete. We weren't even very forceful in that limit. C3 had a few stories that were estimated at around 20 days, but we felt it was good to try.

Today, no one would condone a 20 day story.

The desire for smaller stories came to us from Don Wells. Don was an original member of the C3 team. He had left to start the second XP project over at Ford and later returned to Chrysler. Don had hit upon the idea that if all your stories were sufficiently small, you could handle most project-management activities just by counting them.

How small is "small"? Back when I was a COBOL programmer, I discovered that if I broke down the things I was working on to chunks no larger than three days, I could estimate with reasonable accuracy. So that's my maximum story size—three days. Any story estimated to take more than three days to complete should be broken into smaller stories.

Each of those new, smaller stories must have business value. They're not engineering tasks. If you use this strategy, you won't need engineering tasks in order to do your iteration planning—you just use the stories.

Iteration length

When we did C3, we settled on three-week iterations. We believed that an iterative approach made a lot of sense; however, having failed to get anything done in 14 months, we couldn't convince ourselves that one or two weeks was enough to have real progress. We wanted a fixed length, and a month didn't really do that. Four weeks looked a lot like a month, so that was out, leaving us with three weeks—so three weeks it was.

Three weeks was long enough to complete some real business value, but not so long that if we blew one iteration, it would sink the project. Three weeks worked well for us, well enough that it became the XP standard.

But now that user stories can be completed in three days or less, do we need three weeks to get something done? Of course not.

Changing the iteration length was one of the first things attempted by teams adopting XP. A few groups tried longer iterations, but this is almost always a sign of dysfunction. Most groups tried smaller iterations, with two weeks becoming the new standard, and one week not uncommon.

Today, some teams are going even further by eliminating iterations altogether.

Many teams are using a Kanban-like approach, in which the development team pulls stories from a queue of things "to be worked on," and either releases them upon completion or when some predefined bundle is ready. Some of these teams have done away with the estimation of individual stories altogether, and instead track the elapsed time from entering the queue until the story is released to the end user.

These approaches seem to have merit, and are the subject of intense discussion on the extremeprogramming, kanbandev, and leanagile Yahoo! discussion groups.

Metaphor

I still think system metaphor was a good idea. It's a pity that we could never explain what it was.

Controlling the language used within a team is perhaps the most powerful move an individual or faction can make. The adoption of a real and useful system metaphor requires the surrender of your native language and the acceptance of a new, alien one. It was common to find groups within large teams expressing their hegemony over others through the use of "naïve" metaphor. This was usually done by leaders of the developer group—folks who may even be clinging to an "architect" title. They would call the names found on their system architecture diagrams by a metaphor—things like business layer and data access object.

When you saw this, you knew that the team was split: developers on one side, business analysts and QA folks on the other. You also knew that the developer side had already won some internal battle for control.

It didn't take too many teams like this to make system metaphor useless.

Dispersed Teams

I left Chrysler in 2000 and went to work for a Chicago-based consulting company. The first team I worked with there had a team lead, five or six developers, and two business analysts (BAs) acting as the customer. The developers had a small, open work area that pretty much met our needs and almost fulfilled XP's need for a team room. The business analysts sat in low-walled cubicles about 20 feet away. The developer area didn't have a door, so you could stand in the middle of the room and see the back of the business analysts' heads.

This was the almost part. Our team was geographically dispersed. Yes, it was only 20 feet. Yes, they could have thrown a rock and hit one of us without much effort. And yet, it was too far!

My best recollection of the dysfunction caused by this distance was a conversation between two of the developers, wondering what a written bit of business requirement meant. They went back and forth for the better part of a half hour. The people who knew the answer were just 20 feet away—you could see them, and if they sneezed you would say, "Gesundheit." And, yet the developers kept talking to only each other, with me watching in amazement.

Finally, they decided that they didn't know the answer, and that the best solution was to go on to something they understood better. They weren't going to work on their highest priority, but rather on something of less value. I couldn't stand it any longer and suggested that they go and talk to the business analyst who had written the story for clarification.

Have I mentioned that the BA was within spitting distance?

Did the developers stand up and walk over to the BA's desk? No, one of them picked up the phone and called! I could hear the phone ring and the BA answer and discuss the issue.

If this is the sort of thing that happens when your team is split by 20 feet, what do you think happens when they're in separate buildings or different states, or on different continents? I know that we have reasons for spreading our teams around the globe. I just don't believe that there are good reasons.

We Thought We Were Going to Change the World

On the whole, I look back at where we were in 2000, and I think that we've mostly moved in the right directions. I still miss metaphor and will argue that your developers and customers should be closer together, but I do believe we have changed the world.

The ideas that first found purchase in extreme programming, Scrum, and Crystal, and in the writings of people who cared about improving the world of software development, have made a real difference. Is there a Java developer who hasn't at least heard of JUnit? Or a job shop salesman who doesn't tout his company as being Agile?

I can't wait to see where we'll be in another 10 years.