Extreme Programming Twelve Step Program

Twelve steps to ExtremeProgramming:

1. We admitted we were powerless over heavy processes - that our projects had become unmanageable.
2. We came to believe that an AgileProcess could restore us to sanity.
3. Made a decision to turn our will and our lives over to the care of code as we understood it.
4. Made a searching and fearless refactoring of our code.
5. Admitted to our manager, to ourselves and to our pairing partner the exact nature of our wrongs.
6. Were entirely ready to not integrate until our defects of code were removed.
7. Humbly asked our PairProgramming partner to ReFactor our code.
8. Made a list of all the objects we had written, and became willing to refactor them all.
9. Made direct refactoring of such code wherever possible, except when to do so would injure it or others.
10. Continued to write UnitTests and when we were wrong promptly admitted it.
11. Sought through testing and listening to improve our conscious contact with our code, praying only for a green bar and the power to factor out redundancy.
12. Having had a spiritual awakening as the result of attaining agility, we tried to carry this message to programmers and to practice these principles in all our projects.

1. We admitted we were powerless over things we believed worked as expected, and that our systems had become unmanageable and untestable.
2. Came to believe that a new testing process greater than our usual process could restore us to sanity.
3. Made a decision to turn our testing process over to a Higher Power we understood to be Test Driven Development.
4. Made a searching and fearless set of test our developing software must satisfy.
5. Admitted to our Higher Power, to ourselves, and to another human who we pair with the exact nature of our wrongs - our test run red.
6. Were entirely ready to have our pairing partner oversee our removing all these defects of the software.
7. Humbly asked our Higher Power to regularly check that our software shortcomings remain removed.
8. Made a list of all the known defects, wrote tests for them, and became willing to make them all run green.
9. Refactored code wherever possible, except when to do so would cause tests to run red.
10. Continued to run tests and when they run red, promptly admitted it and got them back to green.
11. Sought through reading and research to improve our testing strategy, seeking for better ways to carry that out.
12. Having had a realization of better systems as a result of these Steps, we tried to carry this message to other developers who feel stuck; and to practice these principles in all our future projects.

    God grant me the serenity
    to leave untested things I cannot test; 
    courage to test the things I can; 
    and wisdom to know when to refactor.

This page mirrored in ExtremeProgrammingRoadmap as of April 29, 2006