Slashdot Mirror
Extreme Programming Refactored
The Previous Extreme - What XP Set out to Fix It had previously been accepted practice to spend months (years, even, on large-scale projects) gathering requirements, then another year or two on design, before a single line of production code had been written. The infamous "big bang delivery" occurred when this gigantic monolith of a software system was finally delivered to the customer, only for the customer to retort that this was nothing like what he wanted.
It was also accepted practice to divide the system into separate subsystems, and attempt to integrate them after several months. By this time, each subsystem would have taken on a life of its own, and integrating these disparate monoliths together gave a whole new meaning to "plug and pray."
How XP "Fixes" It XP takes the development process to the other extreme, by shortening the "waterfall" lifecycle to weeks, days, even minutes. In fact, Kent Beck describes XP as a "waterfall run through a blender." Iterations typically last for a week or two; there is a high emphasis on code quality via unit testing; and code is integrated "constantly" so that it never becomes out of synch with the rest of the project. Beck is often quoted for saying that the XP practices "turn the dial all the way up to 10" -- that is, if something is good (testing, integrating, pair programming etc), well then, let's do it all the time.
There's a lot to be gained from learning about XP, and agile practices in general. However, many feel that XP has taken things too far. By taking things to the opposite extreme, we're just introducing a fresh set of problems. The optimum solution, then, must lie somewhere between these two extremes. That is fundamentally what Extreme Programming Refactored (XPR) is about.
Optimizing the Process There's been a lot of controversy surrounding this book. It grew out of an equally controversial article that appeared on the author's website. XP advocates were arguing on Yahoo! Groups over XPR's good and bad points, miraculously, months before the book was even available. XP zealots were even posting messages telling others not to buy the book, before they'd even had a chance to read it for themselves and find out what it's all about.It's important to note that XPR isn't the anti-XP slam piece that some people had been expecting. It does rip into the XP practices in plenty of detail, but importantly it also describes alternatives, and talks about the good aspects of XP.
The authors make the argument that "turning the dial up to 10" mostly isn't such a good thing, and that to achieve our "holy grail" development process, we just need to turn the dial down a little bit -- let the milk simmer rather than boil over. We can do this by adding in some additional practices that take the burden off the overloaded, heavily interdependent XP practices.
For example, not everyone likes to pair program (with two people sitting at one computer). It just isn't for everyone. However, XP relies on everybody in the team pairing all the time. So if you don't like to "pair up," what choice do you have but to leave the project? XPR adjusts the other practices, placing a bigger emphasis on up-front design and documentation, so that pairing up doesn't have to be mandatory.
XPR also argues that it is possible to achieve a decent design before writing the code. The authors don't want a return to "BDUF" (Big Design Up Front), but instead to achieve an ideal middle-ground. The result is more akin to the monthly Sprints found in Scrum (www.controlchaos.com).
Similarly, XPR argues that the customer (and users) usually do have a pretty good idea what they want from a new system, and that they don't have to see a live system first before realizing that they wanted something entirely different. The authors argue in favour of interaction design as a way of achieving this goal.
XPR achieves all of this with more than a mild dose of satire. It's important to realize this -- the book is essentially "taking the piss" out of the more extreme XP practices, and the quasi-religious Extremo culture that has quickly grown up around XP. It has lots of serious things to say, but has a slight danger of that being lost "in the chuckles." There again, the danger is less to do with the book, and more to do with the reader.
XP sealots will never be swayed by such a book, naturally, but they are not the audience. It is for those undecided, or the cowed XP skeptics who know something is very wrong at the heart of the beast, but haven't have the words to say it. Even for zealots, I'd hope they'd put the hatred for long enough to at least temper their XP actions, to turn the dial down a little, to read the contents with the possibility in their minds that XP isn't the final perfect expression of all programming methodologies. Just for a while...
If you are scared of the contents, a favorite XP accusation, then of course you'll point out the 'needless humour,' blah blah, anything rther than address what the book says. Form will be far more addressable than content. It's the old "ignore this man, he wears a colourful tie" excuse, pick on some small detail that you feel is a weakness and totally ignore all the embarrassing questions you'd rather not address. If you like the contents, then the humour will be seen as a playful, court-jester like addition to what is a seriously analytical book
In conclusion, this book is well written, thought provoking, and above all entertaining (an aspect which seems to be proving almost heretical among some XP advocates). I found this to be a fun read, unlike some books, it was never a chore. It's extremely conversational, like having a cynical, wise-cracking guide. It's a pity more computer books aren't this fun. A spoonful of sugar and all that...
In fact this book is pretty damn wonderful. I know, it may sound a bit gushing, but before you review my review, give the book a read yourself. It's a thing of beauty, a rare mix of positive and negative, sweet and sour, opinion, and XP's favorite emotion, courage, courage enough to say "the emperor has no clothes." I can't see how you could read this book from beginning to end and not see XP in a different light.
In fact, XP programmers would do well to read this book, as it presents the negative path, something other than sunny-day scenarios. Using these warnings and guidelines, they'd have much more successful projects, as this book points out the dangers of lack of XP discipline, fragility and so on.
The truth is that I couldn't do justice to this book in such a short review. There is just so much evidence, so many contradictions pointed out, endless damning words from XPer's own mouths. It was supposed to be a small book to start of with, 150 pages or so, but due to the sheer body of evidence and submitted real life stories from those in the trenches, it bloomed to 400+ pages.
As Doug Rosenberg says "I don't want to be nearby when somebody decides to deploy an air traffic control system or some missile-targeting software that has been developed with no written requirements, and where the programmers made the design up as they went along." At least don't say you weren't warned!
You can purchase Extreme Programming Refactored: The Case Against XP from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
That's almost as bad as reviewing a book titled "Linux isn't always the answer."
I am delighted to see that XP has now been revisited and is being shown to not be the end-all of development styles. Perhaps with the slightly less "extreme" version, more managers will be willing to accept the changes. I have never had a boss accept XP, simply because they were scared of it (IMHO).
stuff |
The Previous Extreme is pure fantasy. It has been well known for a long time that big bang or waterfall models don't work well. For example see the Ian Sommerville Software Engineering book - it's mentioned the 'spiral' model (iterating out from the core of a small well understood system) for at least ten years. I couldn't read any more of this "book review" after such a bunch of nonsense.
Well, have you?
I'm about to start a project using pair programming (not exactly Extreme, but something like that) and I don't like it one bit
Pair programming is uncomfortable on our reduced space. And it's noisy.
Are the inconveniences worth it?
Kilroy was here!
XP and refactoring. Two over-blown buzzwords that go great together.
the customer (and users) usually do have a pretty good idea what they want from a new system
This a most telling quote as most developers have never talked to an actual customer in their entire career.
I think the next programming movement should be called XTTFC for Extreme Talking To a Fucking Customer.
sPh
there are numerous factual erros on what xp is in this book..
One example..if using xp must pari program..
wrong! XP like any software process allows you take and use only those features that work with your project something this book author forgets to point out...
Don't Tread on OpenSource
Reasonable, well thought out, non-extreme methods mean the terrorists have won. Oh, wait. That's a different article.
Anyway, how do you scream at the top of your lungs "MIDDLE GROOOOOUUUND"?
The XP guys _have_ made a mark in the world. Now, how that is going to work out longer term, remains to be seen. XP _is_ influecing stuff like IBM's Rational Unified Process.
I tend to like XP. I haven't worked in an XP shop, but I have used it in class projects and some project of my own.
Right now, lots shops have processes that are non-existant or chaotic--that is what XP really needs to be compared against. XP isn't "the emperor" more like an upstart prince edging in on the territory of being eyed(but not governed) by Emperor RUP.
My gut is that was is motivating books like this:
is the fact that XP is being adopted in places where stuff like RUP just would never get a toe in the door in its present state.
The major stages of the opponents of an invention:
a) it won't work
b) its evil
c) its not really new
d) we invented it
This stuff strikes me as somewhere between stage a-b.
If there was a book called "Why Linux Sucks", and I contributed to it, and I agreed with it, would that make me a fair reviewer for it? You can find links to some possibly less biased reviews at softwarereality.com. It's also worth reading the comments on the Case Against XP article on the same site, by one of the authors of the book.
having a team of programmers who:
Like to program,
are properly trained and schooled,
who are paid enough,
and are given enough time to do the job right.
Everything else is fluff or a fad.
Your hybrid is not saving the environment. Its purpose is to make you feel good about buying something.
I would have like to have seen less of the pre-emptive rebuttal and more reviews on some of the findings and recommendations.
Drop the dogma and theology, and give us the hard core, nitty-gritty, down and dirty facts.
After reading the disclaimer "I should point out that I get a couple of small mentions in this book (the authors quote an email from me), and I also happen to agree with a lot of what the authors say. But I'll try to be as impartial as I can with this review." I was a little skeptical. It's pretty easy to enjoy a book that uses your ideas for content. I know it's not an entire book written around one e-mail but it's always a nice stroke to the ego to be found printable. That aside I think that although he did point out that the the writer is fair in his addressing the good and bad of XP and that the review is likely close to the truth, I feel as though the reviewer has taken more than great lengths to defend the book against the nay-sayers and "zealots". I'd like another review before running out to pick it up.
Look,
.
Nobody should shun any alternative aproach to software development in favor of established "software development practices" when a huge percentage of projects, very very close to 100%, come in late and massively over budget
I'm one of those people who have seen XP tried and failed, and to be honest I never found it a suprise. I was educated to be a software engineer, and that the best way to deliver software effectively is to understand the problem domain. Iterative models like RUP or DSDM are great ways of delivering functionality quickly... XP is not... however there are some ideas in XP that are completely un-original that can work
1) Pair programming - first seen in the "Surgical Team" idea from the mythical man month
2) Unit Tests upfront - first seen in the 60s with the moon landing and space programmes.
3) Iterations - First seen during the 80s with the rise of object oriented systems
The ONE original idea in XP is simple...
You don't need requirements before you start coding. For godsake that is a friggin DILBERT cartoon.
XP assumes the John Wayne school of hacking, just hack hack and your talent will get you through. The reality is that if you are brilliant ANY process would be okay, and if you aren't you need more process to make sure you don't FUBAR things.
I loathe XP, its a strong word but to me it represents the Microsoft view of software in its documented form. Quality doesn't matter, it isn't engineering...
Its just lobbing together some-stuff.
I'm an engineer... what are you ?
An Eye for an Eye will make the whole world blind - Gandhi
I cannot attest to actually having been involved in any project which used XP as defined but I can say the following about what I consider similar:
I used to work at a company that strangely enough fostered both getting things done quickly for some projects while fostering a long drawn out method for other projects.
The company was a consulting firm which always needed an answer yesterday for this or that problem.
They also wrote fairly large simulation packages for the FAA. Some of these projects would go up to three years. Lots of planning etc. was usually done.
Regardless of which type project I worked on I always tended to be the type who would get something working quick and then iterate over it several times if necessary.
Others tended to be going at what I considered to be a snails pace mode. They would plan for days, weeks, months on something that I never considered worth that much planning.
I could usually have a pretty good prototype working with a couple of major revisions made before the "planning types" could even get out a initial prototype.
But, over the years I noticed that I (and those like me) tended to get "officially finished" in about the same amount of time that the annoying guys who planned everything out to the Nth degree got finished.
Was my product any better than their's? No not really.
Which methodology was better? It's hard to say, I know I certainly always liked to utilize new methodologies that worked well while they liked to stick with the tried and true.
About the only thing that I can say is that my internal company clients usually appreciated that they had something to work with earlier rather than later.
They knew it was a rough version, but hey, if you need it now, you need it now. And two years from now may not pay the bills.
So, lots of times I came out looking like a hero.
But, looking back on it now I'd have to say that my own personal version of XP wasn't any better than my counterpart's long drawn out process, at least in terms of a final product.
My $0.02 worth.
Sorry if I was too far off-topic...
Caution: Contents under pressure
But "real design" doesn't work, at least, not very well.
"Real design," as you call it, requires that you keep to yourself, code code code in secret and hope what was defined in the beginning is still what the customer wants.
XP requires everyone to stretch beyond the "standard" development method. But for some reason, developers don't think they need to stretch.
The lack of future planning in XP is not a flaw, it's like that on purpose. I believe that hacking is the best most ideal way to code. XP facilitates hacking on a company wide scale, so even non-developers understand the progress being made.
A programmer is a machine for converting coffee into code.
XP, like any other process, fits some places and doesn't fit others. While some XP nut-cases may claim otherwise (just like people who market Rational products may claim that RUP should be used for everything), I've never seen the claim made in the pro-XP literature that XP was good for everything.
XP is appropriate for projects where:
Requirements are likely to change or are not well understood.
The customer is readily available
The team is reasonably experienced in the tools being used
etc
Air traffic control and missile guidence, while hopefully satisfying the third item up there, don't satisfy the first two. The customer is generally unavailable (I'm guessing here), and the requirements are understood remarkably well. Further, since these would be critical government projects, you wouldn't even have the choice to use XP. Heavy up front documentation is the only way to go on them.
Perhaps a better statement would be "I'd hate to be around when a major company decides to deploy an accounting system that has been developed with written requirements that aren't in the form I'm used to (user stories) and where the programmers modified the design to suit shifting requirements as they went along." Except, of course, that that is exactly how XP got started and it worked just fine (on a project that had previously been failing).
I don't think he want's to review his own book, that would mean too much reading. He's opting for the easier way out, which is to review the review.
So to continue the trend, I will review the review of the review:
I feel the author was self serving while complaining about the original review. Although this review may not have been a "New York Times" quality review, the substance of the book was aptly reviewed, making the review of the review quite useless.
---
Tomorrow we review the review of the SCO code by SGI.
I've been though a lot of XP. I feel pairing is one of the more crucial aspects of XP. In other words, if you don't pair, you're not doing XP. Make no mistake, pairing is not for everyone. Do you have a cranky,maverick,social misfit who writes brilliant code? Let 'em...don't try to force 'em to pair. Pairing works when a) the people want to pair, b) the people are socially compatible. Pairing forces you to code...no surfing or other dicking around. One coder grabs the keyboard/mouse and does some work, say throwdown a new class or method. Or, more likely, code the test class first. Keep going until you feel "empty" or tired, then pass the torch. The other coder watches and contemplates the code, and offers advise. They are an instantiation of YOUR coding conscience. Coding alone, you may say to yourself "fsck it..i'll clean it up later", but while pairing, the other coder's duty is to say "why are you doing it that way? How about this?" and so on. It has to be COLLABORITIVE, not COMBATIVE..although that happens. If you pair, make sure pairs are always rotating...don't let the same folks always pair. Keep the pairing times short...half day is plenty. Pairing helps to eliminate "hot spots" in the skill set...i.e. experts in one area. It will not eliminate it...people will naturally gravitate to the things they like. Pairing will tire you out, as you tend to "go hard" (==productive) for the day. I think some of the best code I've written was while pairing...if I factor in time spent/unit coded. I've written some brilliant stuff alone, but it took longer. REMEMBER: the other half of the pair who does not have the keyboard must stay involved...question the codier, try to find flaws. They are not just sitting there watching the other half. If you see a pair talking to each other and looking at the screen and pointing, and passing the keyboard back and forth, and just cranking...you've got a good pair. Pairing works, if the pairs work. read this too: http://www.objectmentor.com/resources/articles/xpe pisode.htm
The web-posted material on which this book is based is not a thoughful critique. It is parody, yes, but not a critique. One of the central points made is that XP requires, e.g., strong unit testing and refactoring to work. Yep. If you don't do that, XP doesn't work well. Yep. These are points no XP advocate denys. The material ends up making the claim that if you don't do XP you can't do XP. This is quasi-interesting, if utterly obvious, but not the basis for a book-length attack on XP.
Skip this book and buy McBreen's if you want to read a critique. Join the Yahoo group and state your critique thoughfully, and read how some of the major thinkers in XP respond. Then make up your mind.
I think Extreme Programming XP made some significant improvements over Extreme Programming 2002, but it will be better when the .NET framework comes in the box in Extreme Programming 2003
The "waterfall" was great for determining exactly what the user wanted but then ended up delivering it five years later after the requirements had changed.
"Use-case" analysis was great for determining how the user would interact with the system but tended to automate the existing processes instead of figuring out how automation could make the process unnecessary.
OO was great for implementing the non-reusable objects determined to be needed by "use-case" analysis (see previous item).
Too many shops implement XP as an excuse for not understanding the user requirements but just bashing out a bunch of high quality code that solves *the wrong problem* in a short amount of time. This isn't a criticism of XP so much as a criticism of the way it is misused (as has every other innovative software development technique).
The basic problem is and always has been that inventing the future is difficult mainly because the future has a habit of changing while we're busy trying to invent it. No technique other than a time machine will ever solve this problem because it is inherent in the invention process.
They that can give up essential liberty to obtain a little temporary safety deserve neither safety nor liberty.
Ben
Extreme Programming or Rapid Application Development is just an excuse to bypass solid process in order to ship faster. Does it do the job better? No.
General problems with the approach:
Design on the fly. You get less features, more hastily implemented. Code is less maintainable.
Without a plan up front, you have QA scrambling to keep up. Testing is full of gaps in coverage. Product is more buggy as a result.
The only real benefit is shipping faster. You make everyone work harder and get an inferior product as a result. I suppose Marketing will be happy with that as long as the customers will pay for it.
Personally, I prefer doing the job WELL, not just doing the job, but I seem to be in the minority in the development industry these days. I know a lot of engineers would prefer to do the job well, but go along for whatever reason.
Having been involved in development for about 10 years, I've seen product quality decline over the years. Products in general have become more complex, but defects have increased substantially. I'd like to see a lower level of defects maintained and value to customer in stability, reliability and functionality/features increased.
Call me a dreamer.
> But "real design" doesn't work, at least, not very well.
Says who? Works pretty well for me. My team and I are generally *more* productive when we design *before* we code. Ever hear the saying, "Measure seven times, cut once"?
> "Real design," as you call it, requires that you keep to
> yourself, code code code in secret and hope what was
> defined in the beginning is still what the customer wants.
*cough*bull*cough*shit*cough*
A development *team* usually consists of a point person through whom the specs are communicated, an architect who puts together the high level system design (including interfaces if possible), coders who take their cue from the architect, and testers who make sure that the code meets the specifications - thus closing the loop. There is a LOT of communication going on there. However, your team is only as strong as its weakest link. I'll give anyone the boot who can't accomplish their job (as is all to often the case from "wanna get rich, but don't know how to program/test/communicate" kids coming out of school these days).
> The lack of future planning in XP is not a flaw, it's like
> that on purpose. I believe that hacking is the best most
> ideal way to code.
Dear Lord. You people are INSANE. When the f**k are managers going to stop hiring people who actually know more than themselves about programming? No self respecting manager should EVER allow juniors like this guy to decide how development should progress.
Javascript + Nintendo DSi = DSiCade
It's why Liberals need to listen to Rush now and then. It's why neo-cons should read Franken.
So anyone using XP who says "don't read this book" is probably delusioinal in several respects.
As another poster remarked, though, it's a bit annoying to read a review that does not include snips of key points and some analysis. This is endemic in /. reviews. Reviewers, please go look at the form of articles in the Sunday Book Review and follow it!
-dB
"It if was easy to do, we'd find someone cheaper than you to do it."
This a most telling quote as most developers have never talked to an actual customer in their entire career.
"On-Site Customer" is one of the tenets of XP.. Of course, this isn't always practical, but having instant access to the customer is one of the things that makes XP work...
You know, sometimes we just want to pick our noses or read a news story on the web. Pair programming makes this impossible as there is always some idiot practically sitting on your lap. This is why it will always be perceived as punishment.
While the ad-hominen attack against the parent meta-review's author was on target, and the increase in the level of abstraction was intriguing (though not entirely original), this meta-review was too short to be informative.
I always thought that extreme programming was like, jumping out of an airplane with a laptop.
Oh well, another dream shattered.
Stem
Every time someone here said "I've seen XP, and it didn't work," the XP defenders say "what you saw wasn't XP".
Does that mean that a necessary requirement for XP to be XP is for it be successful? In other words, the failures disqualify a process from being XP?
Isn't that a rather self-fulfilling condition?
Anyone who loves or hates any language, platform, or manufacturer, doesn't know what they're talking about.
No self respecting manager should EVER allow juniors like this guy to decide how development should progress.
Unfortunately, most managers were either junior programmers who weren't any good at it or non-programmers with MBAs.
Healthcare article at Kuro5hin
Beck is often quoted for saying that the XP practices "turn the dial all the way up to 10" -- that is, if something is good (testing, integrating, pair programming etc), well then, let's do it all the time.
Nigel: "All the numbers go to 11..."
Director Marty Dibergi: "I see, and most amps go up to 10. Does that mean it's louder?"
Nigel: "Well, it's one louder, isn't it? You see, most blokes will be playing at 10...you're on 10 on your guitar. Where can you go from there?...Nowhere, exactly. So when we need that extra push over the cliff, you know what we do?"
Marty: "Put it to 11."
Nigel: "Exactly. One louder."
Marty: "Why don't just make 10 louder and make 10 the top number and make that a little louder?"
Nigel (chewing gum, pauses while he considers the question, then states confidently): "These go to 11."
Karma: Chevy Kavalierma.
Nope, pair programming takes two hackers and attempts to turn them into one disciplined programmer.
Perhaps this way, the code will be commented, have tidy layout, and be readable. Meaningful (to more than one person) variable names might be used. Boundary checking done. Good test cases written, and used. Other programmers may be able to work on this code at a latter date. The code may do what was specified (for this particular task) as the one programmer keeps the other one focussed on the job in hand.
If the developer is *that* senior, he should be capable of explaining what he is doing to the lesser minds in the company. Treat it as a mentor slot. And of course, that's only for 50% - the other half of the time is watching the other guy, advising, perhaps teaching, and guiding.
The question the developer should ask himself, "Is he really a malodorous jerk, or am I so socially inept that I am unable to work with people who may not be as skilled as I am?".
Unit testing, especially as a foundation for refactoring; continuous integration, read hourly builds; and the flexibility to revise design decisions when the need becomes obvious -- all of these principles are absolutely indispensible in any modern software project. Failing to do any of these things is an outrageous, inexcusable lapse. But these ideas are better understood and more obvious now than they were before Kent Beck came along with XP.
I see all the other posts in the thread so far claiming that some or all of these concepts were known earlier, before they were emphasized by XP. But that does not discredit the approach. Frankly, there's rarely anything new under the sun, but sometimes someone has to come up with a kind of philosophy just to help us realize how effective certain ideas can be. I think all programmatic software methodologies are like this -- they try to emphasize methods that are known to have worked well in the past, and try to draw useful generalizations about them.
Nowadays, most of the UP people are adopting many ideas emphasized by XP -- I attended a tutorial by Craig Larman last year in which he argued that no conflict between the UP and XP exists at all. But no one was saying these things before XP was articulated.
Incidentally, I think it's clear that the waterfall is an unmitigated disaster. I was once in a project that was managed that way, a big fat loser of millions, the worst nightmare of my career, took down a whole dot-com agency. Those were the days.
I don't agree with all of XP -- a complex system has to start with a fairly sophisticated analysis and design (but it better be designed flexibly enough to change over time if necessary). And I can't imagine pair programming, never tried it and don't want to. But even if the Emperor is not wearing purple and crimson ermine minks with linings of silver and gold, he's not naked either. On the contrary, his suit is fairly presentable.
Always keep a sapphire in your mind
The unfortunate thing is that most reviewers have lost all sense of reality. One would think a 5-star review represents a classic for all time--maybe something on par with Shakespeare, or (dare I suggest) Design Patterns. A one-star review represents something absolutely worthless and/or dishonest, like the half-made-up Bellisiles' book "Arming America."
Extreme Programming Refactored is neither a classic, nor is it a complete waste of money. There are some good insights in the book, as it points out some of the pitfalls in the application of XP. It is for the most part well-written, but it also resorts to cheap shots and name calling. There are some serious problems with the book as well, including incorrect information and ignorant testimonials.
Most honest people would agree with this assessment of the book. Unfortunately, the bulk of the reviewers aren't. Honest, that is. XP haters rate it five stars, XP lovers rate it one star. [I fall on the pro-XP side of the fence, in case you cared.]
Even big-process bigot Steve McConnell chirps in with a 5-star review. Gosh, Steve, does that mean you think the book is a software development classic, on par or even better than your book Code Complete, which only gets 4.5 stars on average?
In any case, I did write a review of the book at Amazon, complete with quotes and such, and I didn't give it 5 stars, nor did I give it 1 star. But I guess my review sucked, because McConnell's review got more happy-popularity-votes than mine did.
Extreme Programming =
1. User department has some idea of what they want.
2. Users sit down with you and give feedback while you develop the system for them.
3. Regression tests are created early to ensure that changes don't break anything.
4. Another developer works with you to help eliminate coding errors, etc.
5. Users get exactly what they *really* wanted since they were there driving the development and evolution of it.
Non-Extreme Programming =
1. User department has some idea of what they want.
2. Business Analyst manages to interpret 80% of this and puts it in a Requirement spec.
3. Systems Analyst manages to interpret 80% of the Requirements spec and puts it in a Functional spec.
4. Coders manage to produce 80% of the features they sort of understood in the Functional spec.
5. The users test something not at all resembling what they expected, but they are happy to *finally* get something to look at.
6. Users end up with an incomplete, out of date piece of junk that is nothing like they *really* were hoping for in the first place.
A very good point... it's interesting that many of the same people who argue against Extreme Programming being sloppy are also the sort who are die-hard supporters of the Open Source/hacker methodology of development. If it's so bad to adapt the code as requirements change, how many Open Source projects follow a large formalized design document as opposed to accepting useful patches as they come up?
/when it works/, but it's very easy for it to fall apart, and then it is more harmful than helpful.
/really/ works. But if you throw the balance off slightly, if you can't have all the prerequisites for XP, it rapidly becomes more frustrating and damaging than normal development methods are.
/whole/ company being the big one.
However, there's a lot more to XP, and there are some definite weaknesses in it...I say this as an XP supporter. I'm also going to make the same argument I've made in most of the previous XP articles on here; XP is absolutely great
I was part of an Extreme Programming team that saw both ends of the spectrum. We had internal support, we met with our customer every two weeks and had an iteration planning meeting, and we were productive beyond all reason. When the requirements for part of the project changed, we were able to adapt quickly; our code was small, reusable and modular, so we were able to quickly make adaptations when the end-goal target changed. The code was largely bug-free because of pair programming, where one would work on design while the other coded, and we caught errors much more easily. Meetings were held standing up so that no one wanted them to go on for too long, and it kept them short. Our team was responsible for our own hires, which meant we picked folks who could fit into the pair-programming model well. We took a break every two hours to keep from burning out, we had separate 'personal' spaces as opposed to the pair programming computers...
It was one of the most rewarding development experiences I have ever been part of. Every bit of glowing, golden praise I had heard about XP working well seemed to be true.
But things changed inside the company when management changed hands. We lost the support for two-week iteration planning meetings, and had to work in six-month intervals. We lost the ability to hold stand-up meetings and were stuck in long conference calls. Our team got too large and fragmented into smaller bits, and the pair programming model broke down. Trying to stick to XP became an exercise in frustration and warfare with management. And as we let go of bits and pieces of XP, under pressure, the remaining pieces were weakened. Iteration planning only works if you can actually interact with the customer at an iteration-level, for instance... and so our targets became less easily defined since they were set out months in advance. Made it easier and easier for specific people to concentrate on tasks than having to swap around per-session... which ended up meaning instead of knowing all the code as we had before, anyone able to take over any area, we became specialized in specific areas of the project. And so on...watching XP collapse around us. And it was depressing, really, to see what had been a productive, active environment be stifled.
So that's my first-hand experience. When XP works...it
And more and more, it's harder to find the support for the XP procedures in a corporate environment. Bits and pieces that are in XP -- such as making modifications as they're needed rather than trying to plan overly far ahead for goals that might change, or writing test-suites for your code, and making clearly-understood code -- are of course sensible procedures. But the overall conglomerate only works if you have certain things...support within the
--Rachel
Says who? Works pretty well for me. My team and I are generally *more* productive when we design *before* we code. Ever hear the saying, "Measure seven times, cut once"?
Having done things both ways, I'd say that incremental design improvement is the way to go.
Having done XP for a few years, I spend about 20% of my design time up front, about 30% while coding, and the rest while refactoring.
I like this a lot more than trying to do 100% of the design up front. Why? Because your design is only as good as the information you have at the time you do the design. For non-trival projects, it's impossible to have all the information you need up front; even if users never changed their minds once they saw the result (ha!), any good developer learns things as they go.
It also turns out to be much more productive. If I have to do all my design up front, I'm much more likely to overdesign; much better to have too much than too little. But if I do my design on a just-in-time basis, I can avoid a lot of needless work.
And as a bonus, my designs end up being better. The product may be version 1.0, but because I've been iterating over my architecture along the way, the architecture is version 5.0.
Apologies to the previous Slashdot poster who originally posted the below text, but I though it was so on the mark that I copied and kept it. It bears repeating:
I've seen SO many of these come and go. You can never question them while they're in the ascendancy.
Stage 1 consists of proof by repeated assertion, and "case studies" that actually describe only how projects using the Methodology were _started_. Lots of detail on how managers and workers were organized and brought on board, etc. Anecdotal success stories where you cannot tell whether the success actually had anything to do with the use of the Methodology or whether they just had a good team that would have succeeded anyway, or whether it was just Hawthorne Effect. No clear evidence that _other things being equal_ using the Methodology instead of some other process actually has a beneficial effect.
Stage 2 occurs when a Methodology has been used in enough real projects by a real-world variety of programmers, then you start to see the articles that say "in order for it to work, you MUST have conditions a, b, c, d, and e." One of the conditions is usually the enthusiastic involvement of upper management. But, hey, if you have the enthusiastic involvement of upper management you can probably get ANY project to succeed. Another is usually the adoption of the entire methodology, no "piecemeal" approaches. Another is usually the provision of adequate training. No real-world project ever meets all these conditions, therefore no failed project using the Methodology is deemed to disprove its efficacy.
Stage 3 occurs when people start to notice that the Methodology doesn't particularly work. Well, actually, it's never phrased that way. Nobody ever _admits_ that the Methodology was a fad which has now been abandoned. Instead, they simply say they are adopting the _new_ Methodology, which it is said, DOES work. Or at any rate WILL work. Provided, of course, that you adopt all of it, have the enthusiastic backing of upper management, and adequate training.
There is an interesting interview between Alan Cooper and Kent Beck at http://www.fawcette.com/interviews/beck_cooper/def ault.asp
Cooper was testing his ideas on goal centered design through his "Design+Fun" workshops. I offered up the opinion to Alan that software design is a bi-directional search: with firmware on one end and wetware on the other end. Alan and Kent start from either side of this search.
From XP, I gather that there is much exploration of the domain of APIs to deploy a solution. Writing code immediately helps document the search in such a domain.
From Goal centered design, there is much exploration of the range of a customer's goals. Writing designs helps document the search in such a range.
Using both: Goals help prune unnecessary features, while XP helps prune unrealistic expectations. While using either method could get the job done, perhaps using both is more efficient.
I don't care if it's structured programming, OOP, Smalltalk, Java, RAD, use-case analysis, XP, or XPR... no language, tool, methodology, or management style can provide a quick fix for the difficult problems of organizing, designing, implementing, and maintaining a significant software project.
By all means, read this book (or any other) if you feel it might bring something positive to your development process, and adapt what you can to your own project. Just don't fall into the trap of thinking that XPR (or anything else) will solve all your problems, and if it doesn't that you must not have done it right.