Slashdot Log In
Extreme Programming Refactored
from the can-you-remind-me-of-my-mantra dept.
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.
Some refinement is always welcome (Score:3, Interesting)
Absolutely Hopeless and Clueless (Score:3, Insightful)
Re:Absolutely Hopeless and Clueless (Score:5, Insightful)
A: The flush model.
On a more serious note, the waterfall model does work for certain problem domains, notably those where the requirements are well understood in advance and unlikely to change significantly over the course of development, and where reliability of the final product is critical. This assumes you have the resources (time and people) to do it properly -- and this is why the waterfall method has gotten a bad reputation -- it's been applied where there is insufficient time/resources or the requirements aren't well understood.
Most business applications, for example. The waterfull method is wonderfully suited to something like spacecraft control software, where the spiral approach (we called it "stepwise refinement" twenty-five years ago when I was in college -- there's nothing new) just wouldn't work. But businesses are both constantly changing and adaptable -- a business app that only implements half the requested features is probably still more useful than not, where as software to control complex hardware that's only half done is nearly useless (except that some testing can be done, perhaps).
As always, it's a matter of picking the right tool for the job, rather than picking up your hammer and treating everything as a nail.
Parent
A place for everything (Score:3, Interesting)
"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 impleme
Ask Slashdot: Have you used Extreme programming (Score:3, Interesting)
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?
Re:Ask Slashdot: Have you used Extreme programming (Score:4, Insightful)
I would have to say that pair programming isn't really worth it. I personally can't stand the lack of productivity that is inherent to having two programmers sit around and watch each other type.
My version of pair programming is to have one developer write a test harness while the other one develops the actual code to be tested. This forces each of them to communicate with each other, generally via a very informal spec or direct communication with the client.
This ties two people closely together with the immediate need, but it doesn't require complete overlap. I'm not convinced that two brains are better than one - typing is an inherently blocking process, and whiteboarding happens either way.
Anway, what good hacker wants to watch someone else type? Or play a game? Or do anything? Coding isn't a spectator sport.
Parent
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Interesting)
I think it could be especially useful when you are working on a problem that you are not really sure how to
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Insightful)
Right. Also, I forgot to mention how incredibly important it is to switch between being the tester and being the coder. If you don't do this then it's too easy for both parties to be lazy, and there's no way to check or enforce the quality of code.
At my current job, I've actually outsourced the implementation of the tests (because we're a very small shop) but I'm making the product manager the only interface with the test developers. This keeps me honest, and has the "nice" side effect of making me docume
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Interesting)
The steps we follow:
Re:Ask Slashdot: Have you used Extreme programming (Score:5, Insightful)
If you don't do pair programming, you need to replace it with a less extreme version of code reviews, such as simply reviewing each patch before it is checked in. The type of pair programming you describe involves no code reviews, and therefore is no substitute for pair programming.
Parent
Re:Two idiots don't make a genius (Score:3, Insightful)
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
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Funny)
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Insightful)
Who hates the idea of pair programming? Smarties ofcourse. They dont want to lose what they feel makes them
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Insightful)
Anyway, I've found you simply cannot get 2 good coders by shackling one good and one poor coder together. The bad one generally doesn't learn anything and the good one just gets frustrated and angry.
Pair programming might work if the poor coder had a desire to learn, but it's been my experience that this usually isn't true. Learning to be
Re:Ask Slashdot: Have you used Extreme programming (Score:5, Insightful)
More likely they're just driven insane by having to wait on the other person. Depends on how bad an impedence mismatch you have. Programmer productivity can vary by an order of magnitude or more between individuals (so called "superprogrammers", although the term is silly). If you have one of the latter, no amount of "skill transference" is going to bring the former up to the same speed, any more than teaming someone with an IQ of 150 with someone with an IQ of 110 is going to raise the latter's IQ to 130. (It might, through frustration, lower the former's though
On the other hand, if you're just talking about a couple of average programmers, one of whom has a couple of years more experience, then yeah, it makes sense.
They are bad for business anyways.
Depends. Nobody needs prima donnas, of course (well, except ballet companies, I suppose
(Of course, you may not have the choice. Superprogrammers aren't nearly as prevalent as the number of average programmers who think they're "super" would indicate
Parent
Re:Ask Slashdot: Have you used Extreme programming (Score:5, Funny)
Are the inconveniences worth it?
If your partner is really hot, then yes.
Parent
Re:Ask Slashdot: Have you used Extreme programming (Score:3, Insightful)
The truth about pair programming is that only the right mix of personalities and skills will work. I've done it with people where it worked great. With others, really badly.
Re:Ask Slashdot: Have you used Extreme programming (Score:4, Insightful)
When you have a good and balanced team, pair programming will occur naturally. At some point someone is having stuck on some problem (design, bug,
I believe that Natural Pair Programming with mentoring and code review are a lot better than full-time pair programming. This will help junior developer get up to speed more quickly without having to have two brains waisting their time on trivial problems.
I also like the idea of the other poster saying that you can have one developer write the Unit Test while the other write the business code (you should inverse roles often though). This also benefit having two brain work on different thing while maintaining synergy and increasing the odd of catching bugs.
Parent
Pairing works...sometimes (Score:3, Insightful)
You put your chocolate in my peanut butter (Score:5, Funny)
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.
"On-Site Customer" (Score:3, Informative)
"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...
Re:"On-Site Customer" (Score:3, Informative)
"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...
Can't remember which XP book it was in but one of them stated that if necessary you can use a proxy for the customer. I think they gave an example of an internal project manager or business analyst. Obviously, the more the proxy knows about the customer's business, the better.
Definition of a review (Score:5, Insightful)
sPh
Definition of a review Review (Score:4, Funny)
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.
Parent
"Definition of a review Review" reviewed (Score:4, Funny)
Parent
Factual errors (Score:4, Informative)
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...
Re:Factual errors (Score:5, Insightful)
> and use only those features that work with
> your project
Sure, you can do whatever you want. But XP without pair programming isn't XP, it's.... something else. "Pretty Adventuresome Programming", maybe.
Some folks don't like XP because it's hard - it's hard to write unit tests, and it's hard to pair program and share knowledge and so forth. That's fine... but if you're rejecting XP because you don't like doing those things, don't blame XP.
Parent
Middle ground? MIDDLE GROUND?!? (Score:5, Funny)
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"?
Balance (Score:3, Interesting)
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.
Sheesh. (Score:3, Insightful)
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 [softwarereality.com] at softwarereality.com. It's also worth reading the comments [softwarereality.com] on the Case Against XP [softwarereality.com] article on the same site, by one of the authors of the book.
Nothing beats... (Score:5, Insightful)
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.
Is this a review or a rebuttal? (Score:4, Interesting)
Drop the dogma and theology, and give us the hard core, nitty-gritty, down and dirty facts.
Maybe he shouldn't have reviewed it... (Score:3, Insightful)
Bollocks to "software development practices" (Score:3, Informative)
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
Re:Bollocks to "software development practices" (Score:3, Insightful)
-Gwala
My experience (Score:5, Interesting)
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...
Loverly Staw Man you have there. (Score:4, Insightful)
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).
Major problems with this book (Score:5, Informative)
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.
anyone who says "don't read this book" (Score:5, Insightful)
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
Pair programming == punishment (Score:5, Insightful)
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.
Re:Pair programming == punishment (Score:4, Interesting)
Have you ever actually tried pair programming?
I'm not an 'exceptional programmer' - I'm just a fucking good one.
When pair programming, I benefit from the expertise and experience of another developer. I avoid making silly mistakes, because he spots them for me. I don't write as many bugs, because he spots them. I don't dither about variable names, or whether to refactor a method, or which algorithm to use - because I have someone to help me keep focussed, someone that helps me make swift decisions, that keeps me on track and moving forwards.
Sure, sometimes I want to read a news story on the web. That's why when pair programming we take a break every hour or two. It depends on the progress we're making, how focussed we are, whether we've got the code to compile and pass all its tests.
Pair programming is not punishment. It's an enlightening experience, a joy to participate in, something I want to do more often.
Nobody is such an exceptional programmer that they can't learn from someone who still needs to look up the language syntax. Lose your ego, open your mind, and actually try PP.
~Cederic
Parent
No True Scotsman Fallacy (Score:4, Insightful)
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?
Why stop at 10? (Score:5, Funny)
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."
The Emperor has a relatively decent suit (Score:5, Insightful)
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 [craiglarman.com] 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.
Re:XP v the Engineer (Score:5, Insightful)
> is to understand the problem domain
That's part of the process, yup. And there's a lot of other stuff, too.
> You don't need requirements before you
> start coding
What about the planning game? What about user stories? Read this [xprogramming.com] for better information on XP requirements gathering.
XP has the concept of figuring out what customer want... but XP doesn't demand that you and the customer pretend that every detail of the system is in a bunch of white binders filled with stuff like "the system shall...". Instead, you and the customer work together to develop a system that meets the customer's ever-changing requirements.
> if you aren't you need more process to
> make sure you don't FUBAR things
That's the beauty of XP - it assumes that we aren't geniuses and thus we use unit tests, refactoring, pair programming to keep the code under control.
Parent
Re:XP Programming (Score:3, Insightful)
"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 facil
Re:XP Programming (Score:4, Interesting)
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.
Parent
Re:XP Programming (Score:3, Funny)
Unfortunately, most managers were either junior programmers who weren't any good at it or non-programmers with MBAs.
Re:XP Programming (Score:4, Insightful)
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
Parent
Re:It's just an excuse (Score:5, Insightful)
How would you achieve this? I'd probably do things like:
Of course, by the time you do all that, you've got the heart of XP.
Parent