Extreme Programming Installed

Book description

  • Software that performs required tasks and meets expectations

  • Accurate estimation of time to completion and cost of development

  • The opportunity to decide which features to include and which to defer

  • Frequent small releases that incorporate continual customer feedback

  • Constant integration and automated testing that insures clean code and robust performance

  • These are some of the many benefits of Extreme Programming (XP), a software development approach especially geared for smaller teams facing vague or rapidly changing requirements. Despite the "extreme" in its name, XP actually reduces risks--the risk of putting out software that is faulty, out of date at its release, over budget, or not fully capable of performing the tasks for which it was intended. Initially considered radical, XP has proven itself successful and is entering the mainstream of software development. The greatest challenge now facing software development managers and engineers is how to implement this beneficial approach.

    Extreme Programming Installed explains the core principles of Extreme Programming and details each step in the XP development cycle. This book conveys the essence of the XP approach--techniques for implementation, obstacles likely to be encountered, and experience-based advice for successful execution.

    You will learn the best approaches to

  • Working with an on-site customer

  • Defining requirements with user "stories"

  • Estimating the time and cost of each story

  • Delivering small, frequent releases

  • Performing constant integration and frequent iterations

  • Running design sessions to help programmers move forward with confidence

  • xUnit automated testing

  • Handling defects in the fast-paced, team-oriented XP environment

  • How to refine estimates and steer the development effort through frequent changes

  • The authors present the personal reflections of those who have been through the eXtreme Programming experience. Readers will benefit from first hand accounts of hard-won wisdom on topics such as the art of estimation, managing development infrastructure, solving problems without finger-pointing, the importance of simplicity, and how to introduce modern development tools into an environment where none existed.


    Table of contents

    1. Copyright
    2. Foreword
    3. Preface
    4. Acknowledgments
    5. Extreme Programming
      1. The Customer Role
      2. The Programmer Role
      3. The Manager Role
      4. Rights and Responsibilities
      5. Project Flow
    6. The Circle of Life
    7. On-Site Customer
      1. On-Site Customers Do Real Work
      2. If the Customer Can't Be There
      3. Summary
    8. User Stories
      1. Starting with Stories
      2. Sample Stories
      3. Stories Are Promises for Conversation
      4. Do Programmers Ever Write Stories?
      5. How Many Stories Do You Need?
      6. Can Stories Be Too Big or Too Small?
      7. What if You Don't Have All the Stories?
      8. What's the Next Step with Stories?
    9. Acceptance Tests
      1. Automating the Tests
      2. Timeliness
    10. Acceptance Test Samples
    11. Story Estimation
      1. During Project Flow, Estimate by Comparison
      2. Early on, Start with Intuitive Time Estimates
      3. Spike Solution
      4. Spiking for Estimation
      5. Estimation Summary
    12. Interlude: Sense of Completion
      1. Programmers Set the Rhythm
    13. Small Releases
      1. Payroll Is All or Nothing
      2. Personnel System
      3. Tax Package
      4. Distributed Manufacturing Control System
      5. Air Traffic Control System
      6. Summary
    14. Customer Defines Release
      1. Release Planning Meeting
    15. Iteration Planning
      1. The Planning Meeting
      2. Customer Presents User Stories
      3. Team Brainstorms Engineering Tasks
      4. Programmer Signs Up for Work and Estimates
      5. Sign Up for Stories
      6. An Iteration Planning Practice
    16. Quick Design Session
    17. Programming
      1. Collective Code Ownership
      2. Simple Design
      3. Refactoring
      4. Continuous Integration
      5. Coding Standard
      6. Forty-Hour Week
      7. Summary
    18. Code Quality
      1. Run All the Tests
      2. Express Every Idea
      3. Say Everything Once and Only Once
      4. Minimize Number of Classes and Methods
    19. Pair Programming
      1. Summary
    20. Unit Tests
      1. Testing Bit by Bit
      2. Summary of Testing Steps
      3. Testing Questions
    21. xUnit
    22. Test First, by Intention
      1. Review Remarks
      2. Summary
    23. Releasing Changes
      1. Code Management Tools
      2. Troubleshooting
      3. Slow Merges
      4. Lost Changes
      5. Conclusion
    24. Do or Do Not
    25. Experience Improves Estimates
    26. Resources, Scope, Quality, Time
      1. Resources
      2. Scope
      3. Quality
      4. Time
      5. Tracking and Reporting Scope
      6. Tracking and Reporting Quality
      7. What About Other Metrics?
      8. You Can't Resist, Can You?
    27. Steering
    28. Steering the Iteration
      1. Get Stories Done
      2. Improve Estimates
      3. Tracking
      4. The Benefits of Tracking
    29. Steering the Release
      1. Summary
    30. Handling Defects
      1. Reporting Problems
      2. Scheduling Corrections
      3. Test and Fix the Problem
      4. Preventing Defects
      5. Summary
    31. Advanced Issue: Defect Databases
    32. Advanced Practice:Tests as Database
    33. Conclusion
    34. Bonus Tracks
    35. We'll Try
      1. It Couldn't Be That Easy!
      2. What if You Don't Have All the Stories?
      3. How Do You Get Estimates?
      4. How Do You Explain Velocity?
      5. We Can't Tell Management Our Real Estimates!
      6. This Can't Possibly Work!
      7. Not with My Management!
    36. How to Estimate Anything
    37. Infrastructure
    38. It's Chet's Fault
    39. Balancing Hopes and Fears
    40. Testing Improves Code
    41. XPer Tries Java
    42. A Java Perspective
      1. Example
      2. Model First
      3. The GUI Connection
      4. Testing Key Widgets
      5. Testing Interconnection
      6. Testing with a Fake Searcher
      7. 0, 1, and Many
      8. Record Our Mental Stack
      9. Adapter Implementation
      10. TestN and More
      11. Testing for Looks
      12. Main
      13. Conclusions
      14. Resources
    43. A True Story
    44. Estimates and Promises
      1. Estimate the Entire Project as Accurately as Possible
      2. Track Estimates to Get Project Velocity
      3. Refine the Picture
      4. Control the Outcome
    45. Everything That Could Possibly Break
      1. Does This Mean to Test Every Object and Every Method?
      2. Test Everything Example
      3. Questions About the Example
      4. Summary Response to the Review Questions
    46. Afterword
    47. Annotated Bibliography

    Product information

    • Title: Extreme Programming Installed
    • Author(s): Ron Jeffries, Ann Anderson, Chet Hendrickson
    • Release date: October 2000
    • Publisher(s): Addison-Wesley Professional
    • ISBN: 0201708426