Are You Doing Xp

There is an "us" doing and defining ExtremeProgramming (WardCunningham, RonJeffries, MartinFowler, KentBeck). "We" want to expand the community of Extremists, but we don't want to diffuse the meaning of ExtremeProgramming. Caught on the horns of this dilemma, we turn to the ExtremeValues: Sounds impossible. One of the XP principles is that you want to get as many people making good decisions as possible. Therefore, it's not extreme to create a review board to decide for you if you are extreme. It is extreme to let you decide if your project is extreme. We'll tell you what we think that means. If you decide your project is extreme, you can become part of the community refining the same definitions you just used to decide if you were part of the community. Damned circular, but it's the simplest thing that could possibly work.

Here's a short list of what "we" think makes a project extreme:

If your project is extreme, please put it on the list of ExtremeProgrammingProjects

My own view is that there are some things that if you aren't doing them, you aren't doing XP. I'm not sure what they are, but I feel sure they are there. In particular, can anyone do XP without testing? without refactoring?

Imagine someone who sets out to do the simplest thing that could possibly work, but doesn't refactor. IMO, he's hosed, end of story. Doing XP? I don't think so.

Imagine someone who refactors without UnitTests. Ditto hosed. Ditto not XP.

Imagine a project with tests, but the techies have a BuildForTheFuture orientation. Quite possibly doomed. Are they doing XP?

I dunno, I'm just an egg, but I think calling the tail a leg doesn't make it one. -- RonJeffries

I think this is one of the things that really needs to improve about the way XP is taught. A definition needs to be exclusive as well as inclusive, but you don't have a simple and sane way of excluding AlmostExtremeProgramming. There have been accusations that people admonishing them when they fail (IfXpIsntWorkingYoureNotDoingXp). Of course, if you succeed, does anyone ask if you're doing AlmostExtremeProgramming?

If you read the comments on;sid=2001/4/3/182249/2098 you will see what I mean. The author, maleficient, says he's doing XP at his place of work, but he isn't. Others basically reiterate the same beliefs about XP. People have essentially defined CollectiveCodeOwnership and PairProgramming as XP.

I gave up explaining XP to them because I don't even understand XP well enough myself. I'm not sure why people insist on using IndexCards, there aren't suitable quality assurance for the domains I work in, and there aren't very good replacements for OnsiteCustomer in a product environment (well, in my opinion marketing isn't a good substitute).

I think XP is too rigidly inclusively defined. This leads to people either giving up on it before they start or making up a (broken) definition of their own so they can talk about it. Additionally, it's too loosely exclusively defined as I discuss on RunawayReligion. -- SunirShah?

Is the problem with XP that it's "rigidly defined"... or is it, as Alistair notes below, that it is different - in particular, its having an actual content at odds with how we usually practice software engineering ? In the latter case, it's no surprise that one would have trouble explaining XP; it's a matter of CognitiveDissonance.

We start out in the programming craft with an intuition of what good software is. Then, due to the circumstances of the profession being what they are, we find ourselves practicing that craft in ways that contradict that intuition. And, naturally, we follow the path of least resistance : we adjust our thinking to fit the practices, rather than the reverse.

What XP offers is a way of thinking about the discipline of software engineering which accords more with our intuitions about good software than with currently accepted practice. Its practitioners follow that up with a generosity in explaining that way of thinking and helping others put it into practice, and an apparent disregard for the security of their own pet opinions, which I find nothing short of amazing.

I made a strong effort to have XP adopted where I work. The project where I was involved did badly. Now, I could look to XP for a scapegoat. "It didn't work; surely that can't be my fault, so XP doesn't work". I have a different perspective. The projects where I wasn't involved did even more badly. And, in spite of my efforts, we never got anywhere near a process that I could honestly qualify as extreme in the sense outlined above.

Now the best we can hope for is to have a chance to do well on our next projects, having learned something this time around. The unfortunate reality is that a business doesn't get unlimited opportunities to make mistakes; if a business makes too many mistakes, it is all to likely that the persons involved will go their separate ways, and will not have the opportunity to apply as a team the lessons they learned as a team. That is why it helps to have ExtremeProgramming uncompromisingly defined, but also clearly and flexibly. -- LaurentBossavit

I consider NanoIncrements near to the core of XP, if not in it. NanoIncrements plan for change, as above, but also imply (what is for some of us) surprising economics - that increments can be so short and still be economically effective. -- AlistairCockburn

I consider distributed and continuous design to be near to the core of XP. It is made possible with objects; is the dual of simplicity; and it motivates the other values of communication and testing. But, then, this is just the side of XP that I find most interesting. (Could it be that we are agreeing?) -- WardCunningham

Ward, I was real glad to see you write the word design above. If ExtremeProgramming is about Listening, Testing, Coding, and Refactoring then where is the design? Use CRC cards? Fine. But, I remember an article that I read back in the early 90s that has the answer (for me). TheSourceCodeIsTheDesign. -- MichaelFeathers

There is great truth here. WardAndKent teach us to go quickly to code, because there we learn so much more. And they teach us to code with ExtremeClarity, which makes the design evident within the code. Yes, as discussions in MethodCommenting and elsewhere suggest, there still are things that are harder to see in the code than one would wish. But IMO the bulk of truth lies here: TheSourceCodeIsTheDesign. -- RonJeffries

My first thought of Extreme Programming was that the programmer writes programs to write programs. Compiler design doesn't count - it's not intelligent enough. For example, creating a unique (disposable) programming language to accomplish a particular web project where the project description largely becomes the source code for the of the project - it's just a matter of interpreting the code...

I just want to be really clear that almost all of XP is a surprise to me (Mar, 2000). I've been researching and interviewing since 1991, and I find little in XP that was predictable from what I've seen elsewhere. That includes PairProgramming, NanoIncrements, TestFirstProgramming, AutomatedRegressionUnitTests?, ContinuousRefactoring, CollectiveOwnership, NoWrittenDocumentation?, and DTSTTWPW [DoTheSimplestThingThatCouldPossiblyWork I guess]. That's a lot of things to be non-obvious. (Ward's Distributed And Continuous Design up above is just as unpredicted for me as anything else about XP.) So congratulations for inventing and documenting it. -- AlistairCockburn

EditText of this page (last edited March 23, 2006)
FindPage by browsing or searching

This page mirrored in ExtremeProgrammingRoadmap as of April 29, 2006