Extreme Programming Explored / Edition 1

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 93%)
Other sellers (Paperback)
  • All (14) from $1.99   
  • New (5) from $7.81   
  • Used (9) 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
$7.81
Seller since 2005

Feedback rating:

(140)

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
Paperback New Softcover book in excellent condition.

Ships from: Magnolia, TX

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$15.99
Seller since 2008

Feedback rating:

(169)

Condition: New
0201733978 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)
$20.95
Seller since 2007

Feedback rating:

(88)

Condition: New
2001-07-18 Paperback New BRAND NEW COPY, Perfect Shape, MH38-707.

Ships from: La Grange, IL

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$24.68
Seller since 2014

Feedback rating:

(0)

Condition: New
PAPERBACK New 0201733978 Brand New US Edition Book in Perfect Condition. Fast Shipping with tracking number.

Ships from: Houston, TX

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$46.17
Seller since 2014

Feedback rating:

(3)

Condition: New
New

Ships from: Idyllwild, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Page 1 of 1
Showing All
Close
Sort by

Overview

You know what XP is, how to get it up and running, and how to plan projects using it. Now it's time to expand your use of Extreme Programming and learn the best practices of this popular discipline.

In Extreme Programming Explored, you can read about best practices as learned from the concrete experience of successful XP developers. Author and programmer Bill Wake provides answers to practical questions about XP implementation. Using hands-on examples--including code samples written in the Java programming language--this book demonstrates the day-to-day mechanics of working on an XP team and shows well-defined methods for carrying out a successful XP project.

The book is divided into three parts:

  • Part 1, Programming--programming incrementally, test-first, and refactoring.
  • Part 2, Team Practices--code ownership, integration, overtime, and pair programming; how XP approaches system architecture; and how a system metaphor shapes a common vision, a shared vocabulary, and the architecture.
  • Part 3, Processes--how to write stories to plan a release; how to plan iterations; and the activities in a typical day for the customer, the programmer, and the manager of an XP project.

To demonstrate how an XP team uses frequent testing, you'll learn how to develop the core of a library search system by unit testing in small increments. To show how to make code ready for major design changes, the author teaches you how to refactor a Java program that generates a Web page. To see how a system metaphor influences the shape of a system, you'll learn about the effects of different metaphors on customer service and word processing applications. To show how customers and programmers participate in release planning, the book demonstrates writing and estimating stories, and shows how the customer plans a release.

0201733978B07052001

Read More Show Less

Editorial Reviews

From Barnes & Noble
The Barnes & Noble Review
The "12 practices" that define XP are rapidly becoming familiar -- refactoring, collective ownership, continuous integration, 40-hour workweeks, on-site customers, constant testing, small releases, and so forth. But what does this mean in real-life, where nuances loom large, and "received wisdom on stone tablets" doesn't answer every question? In a series of excellent essays, William C. Wake explores the realities of implementing XP.

Wonder what it really means to refactor your code? Wake shows you, by repeatedly iterating two pages of Java code, showing how to dramatically improve performance, reliability, and clarity. If, after a lifetime of solitary programming, you're apprehensive about XP's "pair programming" paradigm, Wake shows what it feels like. How often does the keyboard change hands? How often do you switch partners? Isn't pairing hard? (Yes, at first, but it gets easier.) From coding to teamwork to processes, Extreme Programming Explored makes XP real -- and even more attractive. (Bill Camarda)

Bill Camarda is a consultant, writer, and web/multimedia content developer with nearly 20 years' experience in helping technology companies deploy and market advanced software, computing, and networking products and services. His 15 books include Special Edition Using Word 2000 and Upgrading & Fixing Networks For Dummies®, Second Edition.

Read More Show Less

Product Details

  • ISBN-13: 9780201733976
  • Publisher: Addison-Wesley
  • Publication date: 7/13/2001
  • Series: XP Series
  • Edition number: 1
  • Pages: 192
  • Product dimensions: 7.22 (w) x 9.16 (h) x 0.40 (d)

Meet the Author

William C. Wake, http://www.xp123.com , is an independent software consultant, coach, and trainer with more than twenty years of programming experience. Bill previously held positions with Capital One Financial, DMR Trecom, and VTLS, Inc. He is the author of the Refactoring Workbook and Extreme Programming Explored (both from Addison-Wesley).

Read More Show Less

Read an Excerpt

Chapter 2: What Is Refactoring?

“Refactoring: Improving the design of existing code.”
—Martin Fowler

Refactoring is the process of improving the design of code without affecting its external behavior. We refactor so that our code is kept as simple as possible, ready for any change that comes along.

See Martin Fowler's book Refactoring (1999) for a full discussion of the subject.

In this chapter, we'll start with some realistic code and work our way through several refactorings. Our code will become more clear, better designed, and of higher quality.

What do we need for refactoring?

  • Our original code
  • Unit tests (to ensure we haven't unwittingly changed the code's external behavior)
  • A way to identify things to improve
  • A set of refactorings we know how to apply
  • A process to guide us

Original Code

The following code was designed to generate a Web page, by substituting strings for %CODE%and %ALTCODE%in a template read from a file. The code works, but a performance test showed that it is too slow; the prime reason is that it creates too many temporary strings. Once our attention is called to it, we see that this code needs a good cleanup as well.
import java.io.*;
import java.util.*;
/**Replace %CODE%with requested id,and
**replace %ALTCODE%w/"dashed"version of id.
*/
public class CodeReplacer {
public final String TEMPLATE_DIR ="templatedir";
String sourceTemplate;
String code;
String altcode;
/**
*@param reqId java.lang.String
*@param oStream java.io.OutputStream
*@exception java.io.IOException The exception description.
*/
public void substitute(String reqId,PrintWriter out)
throws IOException
{
//Read in the template file
String templateDir =System.getProperty(TEMPLATE_DIR,"");
StringBuffer sb =new StringBuffer("");
try {
FileReader fr =new FileReader(templateDir +
"template.html");
BufferedReader br =new BufferedReader(fr);
String line;
while(((line=br.readLine())!="")&&line!=null)
sb =new StringBuffer(sb +line +"\n");
br.close();
fr.close();
}catch (Exception e){
}
sourceTemplate =new String(sb);
try {
String template =new String(sourceTemplate);
//Substitute for %CODE%
int templateSplitBegin =template.indexOf("%CODE%");
int templateSplitEnd =templateSplitBegin +6;
String templatePartOne =new String(
template.substring(0,templateSplitBegin));
String templatePartTwo =new String(
template.substring(templateSplitEnd,
template.length()));
code =new String(reqId);
template =new String(
templatePartOne+code+templatePartTwo);
//Substitute for %ALTCODE%
templateSplitBegin =template.indexOf("%ALTCODE%");
templateSplitEnd =templateSplitBegin +9;
templatePartOne =new String(
template.substring(0,templateSplitBegin));
templatePartTwo =new String(
template.substring(templateSplitEnd,
template.length()));
altcode =code.substring(0,5)+"-"+
code.substring(5,8);
out.print(templatePartOne+altcode+templatePartTwo);
}catch (Exception e){
System.out.println("Error in substitute()");
}
out.flush();
out.close();
}
}

Unit Tests

The first step in refactoring is to create unit tests that verify the basic functionality. If you're doing Extreme Programming (XP) with incremental, test-first programming, those tests exist already as a by-product of that process....
Read More Show Less

Table of Contents

Forward.

Preface.

Acknowledgments.

Introduction.

I. PROGRAMMING.

1. How Do You Write a Program?

Program Incrementally and Test First.

2. What is Refactoring?

“Refactoring: Improving the Design of Existing Code.”—Martin Fowler.

II. TEAM PRACTICES.

3. What Are XP's Team Practices?

“We'll Explore These Practices and Their Alternatives.”

4. What is it Like to Program in Pairs?

Pair Programming is Exhausting but Productive.

5. Where's the Architecture?

Architecture Shows Up in Spikes, the Metaphor, the First Iteration, and Elsewhere.

6. What is the System Metaphor?

“The System Metaphor is a Story that Everyone—Customers, Programmers, and Managers—Can Tell About How the System Works,”—Kent Beck.

III. PROCESS.

7. How Do You Plan a Release? What are Stories Like?

Write, Estimate, and Prioritize Stories.

8. How Do You Plan an Iteration?

Iteration Planning Can be Thought of as a Board Game.

9. Customer, Programmer, Manager: What is a Typical Day?

Customer: questions, tests, and steering.

Programmer: testing, coding, and refactoring.

Manager: Project Manager, Tracker, and Coach.

10. Conclusion.

Bibliography.

Index.

Read More Show Less

Preface

Extreme Programming (XP) defines a process for developing software: it addresses the problem from early exploration through multiple deliveries. We'll explore XP from the inside to the outside.

First, XP is a programming discipline. We'll look at a core innovation: how "test-first" changes the programming process itself. We'll also discuss refactoring--the way XP programmers improve their code.

Second, XP is a team discipline that has developed practices that help produce a high-performing team. We'll compare XP to alternative practices and see XP's team practices in action.

Finally, XP is a discipline for working with customers. XP has specific processes for planning and daily activity. We'll see how a team might schedule a release or iteration and what the team does all day.

Why Read This Book?

If you've heard anything about XP, you probably have had questions about the mechanics or the purposes of various aspects of XP. I've tried to capture the questions I've had, along with answers I've found.

Several things about XP were surprises to me, particularly the tight cycle of test-first programming (only a couple minutes long), the use of a metaphor, and the starkness of the division of labor between customer and programmer. We'll look at these and many other topics.

You, the reader, may have several areas of interest that bring you to this book:

  • Java and object-oriented programming. The first section of the book uses Java programming language examples to focus on test-first programming and refactoring. Programmers may find the discussion of team practices useful as well, particularly the ideas about metaphors and simple design.
  • Extreme programming, from the perspectives of programmer, customer, and manager. We'll explore several areas more deeply or from a different perspective than the rest of the XP literature, especially the team-oriented practices, the metaphor, the planning process, and daily activities.
  • Software process in general. XP is one of several so-called agile, lightweight, adaptive processes that have been introduced in the last few years. By taking an in-depth look at XP's process, we can more clearly delineate where XP fits in with these related processes.

Who Is the Author? Why This Book?

I'm "just a programmer," with about 15 years of experience, about half in compiler development and the rest in library, telecom, and financial services.

I attended the first XP Immersion class in December 1999. Although I had read Extreme Programming Explained, and much of the XP material on the Web, I was surprised by how test-first programming really worked (a much quicker cycle than I'd expected).

The question of testing user interfaces came up in the class; Kent Beck said he didn't usually develop user interfaces test-first, but asked, "Could you?" That inspired me to write an essay on the topic.

I write to learn, so as I explored various XP topics, I wrote a series of articles I called "XPlorations" and made them available on the Web. With the encouragement of my peers, I've adapted some of those essays for this book in order to give a coherent view of the issues surrounding XP.

What Is the Philosophy of This Book?

Be concrete. Use real (or at least realistic) examples. When code appears, it is Java code.

Answer questions. Because most of the chapters originally were written as essays for myself as I learned or taught others, each chapter begins with a question and a short answer. Many chapters include a Q&A (question and answer) section as well.

Be focused. Make each chapter focus on one topic. Tie it to other chapters where possible.

Be precise but informal. I use "I," "we," and "you" a lot. For the most part, "you" is addressed to a programmer, but, in some sections, the word may be addressed to managers or customers.

Bring experiences to bear. I relate this material to real experiences.

0201733978P07122001

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

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 1 Customer Reviews
  • Anonymous

    Posted November 8, 2008

    No text was provided for this review.

Sort by: Showing 1 Customer Reviews

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