seems to be pretty independent of OO or any other software technology. It takes a slightly different view of WhatMakesSoftwareFlexible
to traditional OO pitches. If it's correct to say that ExtremeProgramming
devalues the kind of flexibility that OO languages provide, does it devalue the benefit of OO languages in general? -- DaveCleal
I hesitate to post anymore lest the villagers show up at my castle with torches. But you asked. Yes, we believe that XP is to a large degree independent of OO. However, changes that are not pervasive are still easier than pervasive ones. OO gives real benefits in modularity that let you go further and faster. Just my opinion. --RonJeffries
I fully agree that XP is to a large degree independent of OO, from all that I've read in my first WikiWeek. I believe it's significant to ask though CouldExtremeProgrammingHaveArisenWithoutSmalltalk? so hopefully I just did. --RichardDrake
Objects are one way to tackle the ExponentialChangeCostCurve?
, ($1 for a problem in requirements, $10 in analysis, $100 in design, $1000 in implementation, $10000 in test, $100000 in production). Any technology that makes it possible to flatten this curve is amenable to XP. (WardCunningham
discovered that it isn't good for hardware.)
I bet that XP depends more on rapid compilation, good debuggers, and good code browsers than on objects. It depends on being able to make your code easy to read, being able to break it into pieces that can be changed independently of each other, and being able to add functions one at a time. Smalltalk is good at all this, and other OO languages at least let you break your software into pieces that can be changed independently of each other. But that is really a design style, not a programming language feature. --RalphJohnson
I agree with Ralph, and Ron that XP is independent of objects. Object technology, especially Smalltalk, lends itself extremely well to the XP methodology, but does this mean that XP is dependent on objects? No it is not, it is just harder to get where you want to go when you have to use an inferior vehicle. The VcapsProject
, even though written in Smalltalk and GemStone
, was in dire straits. The tools were not the problem, it was the project methodology. It is when the ExtremeProgramming
methodology was adopted that the VcapsProject
really took off. This change had nothing to do with objects it is purely the fact that XP is so superior to traditional techniques. --KevinBradtke
I think I use XP-like techniques even when I'm working on low-level C code. It's harder to do XP in C, but then it's harder to do everything in C! One can still refactor, insert shields in the right places, follow code conventions and so on. -- MartinPool
I agree that XP is independent of objects. It is dependent on the tools and the language supporting XP, e.g. incremental development and expressiveness in order to write and test a little at a time and to make changes quickly. Also a large library and set of frameworks support XP. So a language and system such as Erlang should support XP very well. A simple functional language supports the principle of saying something only once just as a simple object language does. -- PatrickLogan
to Xp and OO in the last five years (last edited in 1999). Have views changed? Are there convergence in thinking between these areas?
If OO objects don't use XP, what other choices are there? Please provide web links to support your views where appropriate --DavidLiu
If it WalksLikeaDuck
, swims like a duck, and quacks like a duck it is
a duck. There seems to be agreement on this page that the XP requires environments with the following attributes:
- Supports incremental development
- Small changes are very fast
- Rapid compilation
- Good debuggers
- Good code browsers
- Source code can be easy to read
- Code can separated into pieces that can be changed independently of each other
- Functions can be added one at a time
We know that several object-oriented environments provide these (it might even be fun to treat each of these as a measurable dimension and rate the various environments). I know of no non-OO environments that come close. Yes, I agree with MartinPool
that XP can be done in CeeLanguage
, but then so can OO -- and the CeeLanguage
shops that I worked in that came close to accomplishing many of the above did so by adding home-brew OO capability to CeeLanguage
(through macros, conventions, and sweat equity).
Let me therefore offer a totally inflammatory proposition:
The ability to support XP DEFINES an Object-Oriented environment.
If XP can be done in a given environment, that environment is object-oriented. If it can't, it is not. In order to determine whether or not an environment is ObjectOriented
, measure the above attributes for that environment, sum them, and plot the result. Environments that lie to the right are more object-oriented than those that lie to the left.
The theoretical exercise of deriving these eight attributes from the basic characteristics of object-oriented systems (encapsulation, abstraction, etc.) is left to the student.