BN.com Gift Guide

Extreme Programming Adventures in C#

( 2 )

Overview

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, ...

See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (20) from $1.99   
  • New (3) from $29.27   
  • Used (17) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$29.27
Seller since 2008

Feedback rating:

(172)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
0735619492 BRAND NEW NEVER USED IN STOCK 125,000+ HAPPY CUSTOMERS SHIP EVERY DAY WITH FREE TRACKING NUMBER

Ships from: fallbrook, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$65.00
Seller since 2014

Feedback rating:

(193)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$65.00
Seller since 2014

Feedback rating:

(193)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Close
Sort by
Sending request ...

Overview

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!
Read More Show Less

Product Details

  • ISBN-13: 9780735619494
  • Publisher: Microsoft Press
  • Publication date: 2/4/2004
  • Series: Microsoft Professional Books Series
  • Pages: 560
  • Product dimensions: 7.40 (w) x 9.00 (h) x 1.39 (d)

Meet the Author

Ron Jeffries was the onsite coach for the original eXtreme Programming software development project. He also helped plan and teach the first XP Immersion course. An independent consultant and veteran systems developer, he’s been a leader in the XP movement for more than eight years, speaking at developer events, writing articles, and editing the XProgramming.com Web site.

Read More Show Less

Table of Contents

Foreword;
Introduction;
Code on the Companion Web Site;
System Requirements;
Support;
Acknowledgments;
Extreme Programming;
XP in the Context of This Book;
Extreme Programming Values;
Extreme Programming Practices;
Is It XP?;
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;
NUnit;
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;
Summary;
Chapter 3: A Pressing Matter;
The First Story;
Handling the Enter;
It Didn’t Work!;
What’s Next?;
Chapter 4: Extracting the Model;
Where We Were;
The Basic Plan;
The Refactoring;
What’s Next?;
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;
Do We Need a Customer Test?;
OK, We Need a Test;
The Test Runs!;
Imagine a Long Delay...;
Test from a File;
Test a Lot of Files;
Still to Come;
Chapter 7: Warts and All;
Enhancing the Customer Tests;
Do You Have a Test for That?;
The First Test Worked;
There’s Only One Thing to Do;
We Need an Object;
Conclusions for Today;
Further Reflection;
Upgrading the Code Manager;
Chapter 8: The InputCommand Object;
Recap;
Cleaning the Lines;
Building SelectionStart;
Chapter 9: Story One Is Done!;
Planning Our Next Session;
Cleaning the Code;
InputCommand Refactoring;
Smaller Details;
Conclusions;
Ship It!;
Iteration Planning;
Conclusion;
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;
Conclusions;
Code Summary;
CustomerTest.cs;
InputCommand.cs;
InputCommandTest.cs;
ITestTextBox.cs;
MockTextBox.cs;
Notepad.cs;
TestableTextBox.cs;
TestScroll.cs;
TextTextBox.cs;
TestTextModel1.cs;
TextModel.cs;
XMLNotepad.cs;
Chapter 11: Adding the Section Tag, Part I;
Looking at the Next Few Stories;
A Quick Look Around;
The New Customer Test;
Adding the Programmer Test;
After Lunch Comes a Bit Late;
Adding Ctrl+S—Almost;
Improving the Code;
Removing Duplication;
What’s Next?;
Chapter 12: Adding the Section Tag, Part II;
Reviewing the Code;
The Tests All Run;
The Lesson;
The TextModel Code;
Looking Around;
What Do We See Now?;
Judgment Call;
Enough for Now;
Code Summary;
Chapter 13: Discovering the Menu;
Exploring the Problem;
Other Issues;
Preparing the Ground;
Adding the Menu;
Enough For Now?;
What’s Next?;
Chapter 14: Don’t Try This at Home;
The Idle Brain Is the Devil’s Playground;
Sketching the Solution;
Further Down the Rat Hole;
Real Soon Now;
Don’t Try This at Home;
Chapter 15: Climbing Out of the Rat Hole;
Pairing at a Distance;
What’s a Delegate?;
Converting XMLNotepad to Use Delegates;
Chapter 16: Adding the Tag;
New Stories;
The Tag;
Oops, Here’s a New Story Coming Out!;
Chapter 17: How Do We Do a Test That We Can’t Do?;
We Need Better Customer Acceptance Tests;
Reviewing the Problem;
First Improvements;
Never Give Up...That Ship;
Test the Connection;
Wait! Wait, Wait, Wait!customers business value andExtreme Programming (XP) business value ruleMenuForAccelerator methodAnn Anderson, personal communication.;
Chapter 18: A Simple Feature Teaches Some Lessons;
Shift Return Inside Tags;
Shift+Enter Test;
New Plan;
Lessons Learned;
Enough for Now;
Chapter 19: Dark Clouds on the Horizon;
We’re in Big Trouble, Guys!Ed Anderi, personal communication.;
We Need a Test;
Yellow Bar;
Chapter 20: Finishing the Shift+Enter Story;
Wrapping Up the Job;
What’s to Do?;
It Works—Now Let’s Test It;
Improving the Customer Acceptance Test;
All Done, for Now;
Chapter 21: Some Things We Ought to Do;
Command Pattern;
Adapter Pattern;
Mediator Pattern;
Small Boy with a Patterns Book;
Deriving a File Class;
Rendering the Text More Effectively;
XML Support in .NET;
What’s the Plan?;
Yes, But What’s the Plan?;
Chapter 22: The Delegate from Troy;
Finding a Pair and Something to Do;
A Little Refactoring;
Add Duplication to Reduce Duplication;
Summing Up;
Chapter 23: Planning Interlude;
How Do We Plan to Meet a Deadline;
Proposed Stories;
What About These Estimates?;
Our Plan;
Chapter 24: File Save and Load;
First the Functionality;
Now the Menus;
Show the Bug, Fix the Bug;
My Cunning Plan;
Finishing Up;
Reflection;
The XML Notepad Form;
Chapter 25: Tagging Along;
Setting Direction;
The Basic Approach;
The Actual Work;
Improving the Platform;
sbBegin 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;
Reflection;
Ordered List;
The Code at This Point;
Selected Customer Tests;
Chapter 26: Menu Arrays;
The Pain;
The Plan;
Menu Array;
The Table;
Reviewing Where We Are;
TextModel Code;
Chapter 27: Displaying the Article;
Today’s Process;
Possibilities;
Research and Experimentation;
Serendipity Strikes;
Am I Cheating?;
The Power of Reflection;
Now the Sky Is Clear;
And Then, as if by Magic;
What’s Next?;
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;
Deciding to Begin Again;
Clearing a Space to Work;
A New Idea;
A Minor Setback on the Way to Success;
Further Optimizations Are Possible;
Summing Up Undo;
Chapter 30: The Long Dark Teatime of the Soul;
Recollection;
A Repeated Mistake;
Playing With Pain;
Design Thinking;
Experiments Without Tests;
An Initial Attempt;
A Second Attempt and a Big Mistake;
The Third Attempt;
First-Take Excerpt: The Stench of Death;
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?;
Appendix : Sound Bites;
Are the objects helping us? (Chapter 31, page 482);
Are the tests helping us? (Chapter 31, page 481);
Automated tests record our intelligence for later! (Chapter 5, page 65);
Begin with a test. (Chapter 25, page 323);
Build simple scaffolding and then improve it. (Chapter 17, page 216);
Card, Conversation, Confirmation. (Chapter 6, pages 71-72);
Daily builds are for wimps. (Extreme Programming, page xxix);
Design all the time. (Chapter 1, page 8);
Don’t fall in love with our own work;
End to end is further than you think. (Chapter 13, page 182);
Expressing Intention. (Chapter 4, page 42);
Fake it before you make it. Fake it till you make it. (Chapter 11, page 146);
Find a bug, write a test. (Chapter 5, page 58);
Infrastructure doesn’t please the customer; features do. (Chapter 30, page 472);
Isolate the unknown;
It’s Chet’s fault. (Chapter 11, page 139);
Keep the tests on green. (Chapter 17, page 213);
Make it work; make it right; make it fast. (Chapter 17, page 215);
Outer design should drive inner design, always. (Chapter 30, page 473);
Programming without thinking...what good is that? (Chapter 30, page 473);
Push a little when something seems too hard. (Chapter 17, page 216);
Reflect on how things are going. (Chapter 30, page 469);
Removing duplication is your friend. (Chapter 11, page 151);
Solve what you know; leave the parts you don’t know for later. (Chapter 6, page 78);
Some very simple refactoring...has done most of the job for us. (Chapter 22, page 268);
Start a new path with something abysmally simple. (Chapter 4, page 45);
The story’s not done until the customer tests run. (Chapter 6, page 72);
Twenty lines without a successful test is a pretty big change! (Chapter 4, page 45);
Two Hats. (Chapter 8, page 95);
We don’t need a testing framework; we need tests. (Chapter 6, page 73);
We start new features with large bold strokes. We’re intentionally building from rough toward smooth. (Chapter 4, page 47);
What is the simplest thing that could possibly work? Do the simplest thing that could possibly work. (Chapter 28, page 408);
YAGNI—You Aren’t Gonna Need It. (Chapter 14, page 192);
Bibliography;
Appendix : Ron Jeffries;

Read More Show Less

Customer Reviews

Average Rating 5
( 2 )
Rating Distribution

5 Star

(2)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 2 Customer Reviews
  • Anonymous

    Posted April 11, 2004

    Excellent XP book

    This is a quality book that took a bit of getting used to. This isn't necessarily a bad thing, I read a lot of boring and straightforward trade publications and this was a bit different. Ron does a good job explaining the XP methodology while picking up the basics of the C# language. Initially, I was a bit frustrated as I have been using C# for years; however, the book picks up after the first quarter and becomes genuinely interesting -- a phrase I do not often use in regards to technical publications. Areas I found particularly useful included: Unit Testing, nUnit, refactoring and XP in general. I would recommend this book to anyone who has some experience with C# but is new to extreme programming.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted March 23, 2004

    Great book for learning how to think about programs

    I learned to program back in the dark ages before books came with CDs or websites where you could download the author¿s code. Back then, if you wanted the author¿s code, you typed it in from the book. I typed in the code from many wonderful books and I learned to code that way. As I typed, I was paying attention to the code, not just mindlessly hitting the keys. While this taught me what a great programmer¿s code looked like when it was done, it didn¿t teach me how that programmer arrived at the solution that was in the book. What I always wanted was to see the author¿s thought process as he arrived at the finished code presented in the book. With Ron Jeffries¿ ¿Extreme Programming Adventures in C#¿ I finally have that opportunity to watch over the shoulder of a great programmer and watch not only his code but, more importantly, how he thinks. I love that the author is willing to show his dead ends and false starts. And then how he recovers from them. The book is really language agnostic. It¿s in C# but the lessons are more about programming and thinking about programming than about a specific language. I highly recommend this to all programmers, not just C# programmers.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing all of 2 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)