The Case Against Extreme Programmin

The Case Against Extreme Programming

The Four XP Values

Kết quả (Việt) 1:

The Case Against Extreme ProgrammingThe Four XP Values<< XP's AudienceEmbracing ChangeOne of XP's goals is to make it okay (both culturally and practically) to make changes at any stage in the project. All modern software processes recognise that change is an inevitable part of any project: as an understanding of the customer's requirements improves, new use cases are identified (or old ones removed); or sudden changes in the business environment might change the course of the project. In a well designed, highly modular system, it is possible to take these changes in our stride. By tracing a proposed change from the requirements down through the architecture to the low-level design, we can calculate pretty accurately how much the change will cost. Then the customer can make an informed decision about whether or not to go ahead with the change.XP takes this a step further, by attempting to make change a good thing: to "embrace change".The cost of change rising exponentially over time(Source: Extreme Programming Explained, Kent Beck)In the software engineering world, it is widely understood that the cost of change increases as any project progresses. In the beginning, few resources have been committed. Later on not only have resources been expended but the interactions of thousands of decisions have increased the complexity of making changes. Nevertheless, XPers claim to have found a way to flatten the Cost of Change curve.As Kent Beck says in Extreme Programming Explained:"This is one of the premises of XP. It is the technical premise of XP. If the cost of change rose slowly over time, you would act completely differently from how you do under the assumption that costs rise exponentially."Kent is right when he says that modern tools are helping to reduce the cost of change. However, the curve is by no means flattened, and it could be argued that it never will be.In addition, there is a fundamental aspect of Cost of Change that Kent appears to have missed. I have been wracking my brains to try and understand if XP really takes this into account, but I can't see it. The problem is this:Once you have written something, no matter how cheaply you did it, it cost something to write. If you want to change it for something else, nothing can change the fact that you spent time writing the code that must now be changed (or even scrapped entirely). Even if the change is inexpensive, the cost of writing the first version must still be taken into account. Put another way: you can do a U-turn in system functionality or design, but not in time.I think the reason why I have been unable to find a specific answer to this paradox, is because all of XP is about answering it. Its four Values are there to try and bring down the cost of making changes. The four Values are in turn supported by twelve Rules (or thirteen, depending where you look).If the combined Values really work, then the cost of making a thousand changes in direction is offset by the apparent surge in productivity that we get from: Communication, Simplicity, Feedback and Courage. XP Value: CommunicationXP makes a big issue about its core value of Communication. This is wonderful, as communication is definitely a key factor to the success of any project, XP or otherwise.Unfortunately, XP also makes a big issue about not doing any documentation (or at least very little, or none at all). I think this is partly why XP has such a broad appeal amongst earnest young programmers. After all, documentation really sucks, right? Just like homework always sucked. XP Value: SimplicityXP promotes a throwaway approach to source code (i.e. write, toss, rewrite). And so, through countless waves of throwaway code, the design gradually (hopefully) starts to evolve. To counter this time-consuming, high risk approach, we are encouraged to keep everything simple. The theory is that if you are constantly re-evaluating where the project needs to go, then you might lose only a week or two down any particular design blind alley.From Extreme Programming Explained again:"XP is making a bet. It is betting that it is better to do a simple thing today and pay a little more tomorrow to change it if it needs it, than to do a more complicated thing today that may never be used anyway."Better still, don't bet! If you have planned, architected and designed properly, you are much less likely to have to throw any work away.
In fact, the above quote is playing down the amount of rewriting that takes place. To justify this approach, Kent uses the example of a general purpose dialog for displaying text. He explains that a programmer needed to display a message dialog, but decided to make the dialog multi-purpose "in case anyone else would like to use it." Two days were then spent writing the "smart dialog", after which the requirements had changed and it wasn't needed anyway. This is a fine example,