RE: XP and fruit-picking

["Bullard, Claude L (Len)" <clbullar@ingr.com>]

Just rant, so unit testers should return 
to their RADE tool screens.

After doing some review.  From the XP pages:

"Simplest does, however, mean a minimal solution."

It may be all you can get, but I'm not convinced 
it is always the winning strategy.
 
It may be all you need but you have to know 
the problem well enough to figure that out. 

Simple at the finish isn't always simple to 
do.  Build fast, test often.  That's fine 
but that ain't news.

There is no substitute for testing, but any 
programmer who hasn't figured out why a 
function should ideally do one task hasn't 
built many.  Building in simple 
integratible stages is assuredly good practice, 
but it still pays to know what the stages 
are and when they happen.  

o  Otherwise, the walks around the block 
   become frequent and long.

o  Otherwise, hype takes over and Simple 
   Is Better becomes Listen To Me Only.  

o  Otherwise, when you write the proposal, it 
   reads like a manifesto instead of a business 
   proposition and you lose.

"Everybody wants to rule the world."  Theft 
is a way to do it as long as you can convince 
the jury you had the community interests at 
heart.  On the other hand, Nabster is going 
down.  Gnutella can hear the knock at the door. 
Everything the "info wants to be free" and 
"the web isn't subject to YOUR laws" guys said 
turned out to be dead wrong.   Code talks... 
so do the courts.

XP isn't wrong, just not particularly novel.  I 
don't think I ever worked a project that used 
the capability maturity model or actually used 
the kind of conceptual diagramming techniques 
of CASE.  I've seen hardware designed like that 
because it enables simulation over breadboarding and 
when discussions of conceptual modeling come 
up, it is useful to point out the difference 
between expensive breadboarding and compiling a 
software build.  Still, diagramming has its place if 
for nothing else, keeping notes in a brainstorming 
session.  I don't find UML easier to read 
than code.  I find it easier to use as a document 
when the implementation language is not yet 
chosen.  Merits to both.

XP smacks of too much zedNess, the 
tendancy to grab the latest trend because 
one hasn't done enough or seen enough to 
read the environment and inquire if the 
zed really is required or even matters, 
then proclaim it the final (zed) solution 
and beat the bejeebers out of naysayers. 
That is fanaticism at its worst and it 
is the reason the web isn't the healthy 
business environment it could be.  But 
the web is still a baby, and I suspect 
it has to crawl a little longer.  XP 
may be part of learning to walk.  It like 
any method works if practiced but only 
because Computers Don't USUALLY Lie. 

Some people do it right because they 
already know what has to be done.  They 
have already done it wrong, done the unit 
tests, and are now simply trying to do 
the next generation.  They don't need a new 
religion or even a coding partner.  They 
need to get it done sooner, they know where 
the stumps are and they look like they 
can walk on water.  Truth is, their Bozo 
shoes are inflated as they get off the 
bus and enter the showfloor.  Their noses 
are already red. 

Competition enables products to duke it out.
But don't be so cherry as to think the best code always 
wins or even should.  The sharpest competitor, enshallah,  
usually does.  Or as they say, 
"the race is not always to the swift 
but that is the way to bet".  That is 
why Microsoft continues to cream 
most competitors.  They are simply the best.  
They made hash of Netscape and many others 
because they did not hesitate once they 
understood the rules of the game.  they 
mastered them and executed relentlessly. 
That gets it done.  Regardless of emotions, 
they win on merit time and time again.  It 
keeps the bucks flowing toward Redmond and 
that keeps the code flowing back.  Go ahead 
and pick the low hanging fruit and enjoy 
them.  But if a crew of expert pickers with 
automated ladders shows up and picks faster, 
you may go hungry, and you know, that is life.

The grove guys had the right idea.  The Simple 
Is Better guys didn't know what right was. 
If a simpler better idea has surfaced, do it. 
For now, the incomplete and incompatible data models 
are biting XML and the SimpleFirst guys made that happen. 

Try again. If you think XP is the way, go 
extreme.  But don't think that wins of necessity 
unless you are ready to go where the iron 
crosses grow, to borrow a movie phrase, 
and don't whine.  Complexity is often 
just what one doesn't understand yet. 
That is why we duke it out on this list: 
to help everyone see what it is we 
don't understand yet.

That is community.  Not shared goals, 
but shared understanding.

Len
http://www.mp3.com/LenBullard

Ekam sat.h, Vipraah bahudhaa vadanti.
Daamyata. Datta. Dayadhvam.h