Extreme Programming Adventures in C#
Please login to add notes
- Contents at a Glance
- Table of Contents
- Extreme Programming
Chapter 1. XML Notepad Stories
- Building an Application Extreme-Programming Style
- Initial Vision
- Learn from the Best
- Petzold Notepad Version 1
- Handling Keyboard Events
- Shaping the Release
- Stories for Initial Release
- Subsequent Iterations and Releases
- The XProgramming Format
Chapter 2. Testing with NUnit
- Testing: A Core Practice
- Setting Up NUnit
- Finding a Simple Pattern
- Paired Tags
- Paired Unknown Tags
- Unmatched Tags
- What’s Left?
- A Short Look at Debugging Under NUnit
- The Debug Startup Program
- Attach to the NUnit Process
- Choosing a Technique
- + Chapter 3. A Pressing Matter
- + Chapter 4. Extracting the Model
Chapter 5. Expressing Ideas
- Something to Do
- Commenting for “Clarity”
- Commenting Means “Not Done”
- We Need Some Tests Here!
- Some Additional Tests
- The Starting Code
- The Current Code
- What’s Next?
- A Little Refactoring: That Ugly Get
- Get Rid of the Text Copy
- Observations and Conclusions
- Reflecting Back
- Current Code
- + Chapter 6. The First Customer Acceptance Test
- + Chapter 7. Warts and All
- + Chapter 8. The InputCommand Object
- + Chapter 9. Story One Is Done!
Chapter 10. Find a Bug, Write a Test
- Oh No, There’s a Bug!
- Find a Defect, Write Tests
- Mock the TextBox
- Extract Method
- The Scroll Test
- Build an Interface
- Lessons: Lots of Learning, Not Much Testing
- Code Summary
- + Chapter 11. Adding the Section Tag, Part I
- + Chapter 12. Adding the Section Tag, Part II
- + Chapter 13. Discovering the Menu
- + Chapter 14. Don’t Try This at Home
- + Chapter 15. Climbing Out of the Rat Hole
- + Chapter 16. Adding the <pre> Tag
- + Chapter 17. How Do We Do a Test That We Can’t Do?
- + Chapter 18. A Simple Feature Teaches Some Lessons
- + Chapter 19. Dark Clouds on the Horizon
- + Chapter 20. Finishing the Shift+Enter Story
- + Chapter 21. Some Things We Ought to Do
- + Chapter 22. The Delegate from Troy
- + Chapter 23. Planning Interlude
- + Chapter 24. File Save and Load
Chapter 25. Tagging Along
- Setting Direction
- The Basic Approach
- The Actual Work
- Improving the Platform
- Begin with a Test
- Enter the List Item
- What’s the Opposite of Simple?
- We Have to Do Something
- Some Starting Ideas
- Removing the Duplication
- Moving Responsibility
- A Bit More Cleanup
- Ordered List
- The Code at This Point
- Selected Customer Tests
- + Chapter 26. Menu Arrays
- + Chapter 27. Displaying the Article
Chapter 28. Oh No! Undo!
- The Final Exam
- The Requirement
- Possible Solutions
- What About Tests?
- Begin with a Test
- Using TextModel as the Saved Object
- Snapshot Every Time
- Building It In
- Removing the Experiments
- It Gets Weird for a Moment
- Are We There Yet?
- Review of What Has Happened So Far
- The Big Picture
- Does This Prove Anything?
- + Chapter 29. The Final Optimized Undo
- + Chapter 30. The Long Dark Teatime of the Soul
Chapter 31. Project Retrospective
- Learning from the Past
- Could We Put This Program into Production?
- The Value of Real Customers
- Customer Tests
- Pair Programming
- Trends over Time
- Are the Tests Helping Us?
- Are the Objects Helping Us?
- Did Our Tests and Objects Help Us Enough?
- Eat Your Own Dog Food
- Code Manager
- Coding Standard
- Be Ready to Use Advanced Facilities
- Is TextModel Too Large?
- Premature Optimization
- Responding to Pressure
- Pressure and Productivity
- Pressure and Quality
- Debugging Techniques
- Design and Code Quality
- Would “More Design” Have Helped?
- Smaller Questions
- The Effect of Illness
- Does Incremental Development Work?
- Sound Bites
See eXtreme Programming (XP) in action at the hands of an XP master—and learn Microsoft .NET and C# programming in the process! In this fast-paced, hands-on exposition, Ron Jeffries—one of the leading voices and practitioners in the XP community—demonstrates that you can write well-designed, resilient code incrementally and safely, while minimizing your investment in speculative up- front design. As Jeffries builds his sample application, you get firsthand insights into what successful XP development looks like, complete with real- world challenges such as the eleventh-hour change order. For further practice and study, you can download all the author’s code—including the missteps—so you can see XP and agile concepts in action and assess how they fit into your own work.
Pair program with an XP master, discovering how to:
Streamline and simplify the software development process
Work more effectively as part of an XP development team
Reduce missteps by designing, testing, and refining code in increments
Receive clearer specifications and feedback from customers
Write cleaner, more expressive code—and weed out more bugs
Conserve resources by planning and reassessing progress as you go
Maintain a sustainable work pace—and avoid burnout
Step up delivery dates, shipping the most crucial features first
Improve customer satisfaction!
Test the closed alpha on paperc.com