|
|
|
|
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
|
|
|
|
|
|
|