has a high "get it" factor. It differs from other concepts, where all anyone needs is often a simple explanation, and where known educational methods exist to provide that simple explanation. Some folks who do "get it" don't like it (at least they are not crazy about it), but many still don't "get it" despite "getting" many other complex concepts.
In this page, we should discuss case histories of people's mindsets moving from no XP awareness thru the first media contacts to some kind of mental or project acceptance. These histories will eventually assist LosTresExtremos?
to learn the mechanics needed to surmount the "get it" problem in their literature.
I admit: I was full for CMM (CapabilityMaturityModel
). I thought to be strong was the capability to follow steps (even if these were written by myself). I guess when in the beginning of year 2000, I listened to a presentation on XP, it was weird. Something told me that was what I wanted to do. But in the other hand, two years of brainwashing myself about written procedures and documents, I had to resist to the change else I would have died!
Nights were full of nightmares. But I continued to read on XP... PairProgramming
, etc. Then XpMailingList
... It was like a drug.
I had to talk to colleagues to tell about my discovery without being ashamed by my changes. Questions were asked, answers were given or doubts and more questions were raised. I found a lot of support. Even the team leader began to think about it (I am considering myself as a very bad salesman, but somehow they listened to me! So that is not me, it is what is in XP ;-).
And then I was sent to XpImmersionTwo
. And now, we are in the exploration phase for the next project. I am not even afraid of trying these new things. A new me was in me! Sure I have fears, but I am able to confront them. I am now being enthusiast and having more answers that logically make sense.
Being voluntary flexible, we (as a team) are transforming ourselves experimenting XP practices one at time taking the time to discuss these transformations.
I had to do some BigDesignUpFront
and started to experience ExtremeHumility
. Luckily after suffering only a few years of ExtremeFrustration
, I found the ExtremeProgrammingRoadmap
. I promptly purchased ChristopherAlexander
's book TheTimelessWayOfBuilding
. A few months latter a book was published about ExtremeProgramming
. I realized that I have been ReFactor
ing. I wasn't good at BigDesignUpFront
, I was good at ReFactor
ing, identifying the EmergingPatterns
, and making those look like a design. XpImmersionTwo
showed me how to apply those principles in a more satisfying way. -- ErikMeade
I returned to news:comp.object
after a few months distracted by working a Spiral project (where each "iteration" was really a big WaterFall
[less the supporting paperwork]), and discovered the eternal raging debate on that group had centered on something called "eXtreme Programming".
At that time I made a mental image of the process, based entirely on the name. I'd have never done anything with this image and got in trouble for jumping to conclusions, but nothing contradicted the image either.
The image was a bunch of college kids had slapped up a Web page and filled it with "Glory of Programming" bull in between skateboard excursions. I figured the threads occurred because the page got popular among other kids, and the old-timers were threading to talk them down. I disregarded the newsgroup for a few weeks.
Then I observed RobertCecilMartin
appeared to take the side of the eXtremos.
I determined from the threads what "RefactorMercilessly
" was, and like many I realized that was my guilty little secret. Everyone knows you follow the Cost Of Change Curve from the most stable to the most volatile elements in your code, and you only retrofit or OpenClosedPrinciple
things - you never just jump in and screw around. I was shocked (even as late as 1999) to see professionals who value their reputations advocating such irresponsible behavior.
Of course I refactored all the time, and of course my two excuses were "I wrote everything so of course I know what I'm doing", and "I'll leave 'assert(false)' everywhere to force me to track thru this new stuff with the debugger and proof it all."
When I figured out that the first was PairProgramming
and the second was UnitTest
s, that's when it all snapped into place.
I was introduced to Extreme Programming in January of 2001 and, although it was not a religious experience, I definitely felt that I was looking at a better way to deliver software. I was working with another developer side by side, with him watching me code and me watching him design. After a few days, he mentioned that this was like something he had heard of called Extreme Programming. A MountainDew
commercial immediately sprung to mind! :) However, we were working very efficiently, so I decided to do some research.
We were working on a Java framework that was to be used by the "army of developers" that was to come on a large development project. However, after a couple of months, the client decided to go to a COTS product (which they still haven't actually bought as of June 2002). Sigh.
We never got to the point of using UserStories
, and never had any official releases, but we did implement unit tests in a big way. Since we were writing middle tier code as well, I set up the unit tests to be run from a web site in conjunction with our app server. One click ran all of the tests, or any of the tests in the hierarchy.
Anyway, it didn't take me very long to be sold on the XP ideals, and I intend never to look back!
Before reading about XP, I was already a Wiki reader, a Smalltalk programmer, a patterns fan, a fan of KentBeck
, and was trying to improve my own software development process.
In other words, I was already a sycophantic brand-loyal yes-man Cunningham/Kent/Hillside groupie.
So naturally as soon as I read about XP, I adopted it without thinking about it or questioning it.
I'm glad I did adopt it. I especially like unit tests, and the "it doesn't have to be fully correct right now" mentality. -- StanSilver
I think I was born a XpSavage?
. undiciplined natural tendency towards XP. Obviously I've never religiously followed it's rules as if set in stone (which doesn't seem to be at the heart of XP at all anyway). I've always worked in a prototyping mode as well as iterative refinement. Start of doing something that does something (anything) and then add the least functionality that makes it do what you want, rinse and repeat.
Where I seriously fail out is the team aspect, as my experience in collaborative programming (even pair) has been limited by the lack of available peers (I've always kept my work off the net).
Is there a possibility for XP-Apprenticeship, where one can join a team, or pair-programming session t osolve a particular task to get into the spirit of things? -- SvenNeumann
Moved from XpLessonsLearned
Lessons learned using XP.
Lessons learned applying XP to the development of an online banking platform:
- If you're coaching, resist all temptation to intervene with technical decisions. Work with team as a peer. (In hindsight, this really doesn't apply well 100% of the time. Coaches should intervene, but with tact.)
- Use XP on small, ground floor projects and build up. Don't expect XP to be a silver bullet for sustainment projects in progress (unless you're willing to scrap it and start over).
- Keep components small and simple. Allow for isolated unit testing of components during design.
The reason it took me so long to start reading about XP, Agile Methods,
Refactoring, & Design Patterns is because of bad experiences with Software
Engineering books in the past. I had come to the conclusion that SE was not
usable for the individual developer. When XP, Agile, Refactoring & Design
Pattern books started to appear I just assumed that they were more SE books
with techniques that I couldn't easily use. I spent my time learning more
about Windows & Linux. What turned me around was finding Extreme
Programming Explained by Kent Beck in the library. This book caused me to
change the way I develop code as well as completely revamping my reading
( from news:comp.object
Let's concentrate on the goal, not the process. The process is just a
vehicle to attain the goal, "good software". Open your minds and look
at the substance of what XP says. Don't just dismiss it as "wrong",
just because it is counter to the recent direction we have taken in the
software development process.
Currently I develop in an environment where we extensively use UML
models to build our system. Since the Class Diagrams are the basis for
automatic code generation of classes it is fairly easy to make the
models "king". Then as the architect, I can control the system design
by having an overall view using the Object Models. Over the last year
I've gotten very comfortable with this point of view.
Then I stumble against XP while playing with VisualWorks
My first reaction was, "Are these guys crazy?". But I continued to
read, and asked myself, "What if they're on to something?". Some of the
points rang so true that it became difficult to dismiss the rest. Once
I got the whole picture, it became hard to dispute that they were on to
something. The real problem was that I had enough real world experience
that validated the arguments XP makes.
". Several of the most productive periods I have
had while programming, was while doing this "duet" style where one
person "drives" for a while and then the other. This allows both people
to be looking at the problem from two points of view at the same time.
One, down in the details of syntax and such, while the other can be a
bit more distant, able to look at the 20,000 ft. view. This can be
critical to good software design, and it helps to pace yourself when you
know that if you "run out of gas" for a while, you can turn the wheel
over to the other person and you're off and running again.
If XP challenges your view of software engineering, take a step back and
see if it is the fact that it shakes up some of your "core beliefs" that
puts you off, or if it truly espouses false principles. It seems to me
that there are too many examples where the process works to believe the
Remember the goal comes first, not the process. Sometimes the process
must change to attain the goal. If XP achieves the goal, then it is a
"good" process by definition.