| XP123 → Books → XP Skills |
| 1 Services | 2 Games | 3 XPlorations | Books | ... More |
Categories
Test-Driven Development
 |
Test-Driven Development: A Practical Guide,
Dave Astels. Prentice Hall PTR, 2003.
This book is a natural complement to Kent Beck's Test-Driven Development: By Example. Where Kent's is focused on the background and theory, Dave's book focuses on tools, GUI testing, and an extended example. You'll get overviews of JUnit, JUnitPerf, JFCUnit, PyUnit, EasyMock and many others. The example is long (almost half the book), but it gives you an expert's view on a reasonably large project. The big thing I learned from this book was that I could and should be much more aggressive in refactoring my tests and in keeping them focused on one thing at a time. And I value this book as a quick-reference for the many TDD-related tools. (Reviewed December, '03) |
|
 |
JUnit
Pocket Guide,
Kent Beck. O'Reilly, 2004.
This is a quick intro to using JUnit for testing. It's a quick read. Along with reference information about JUnit, it's got a quick version of the philosophy behind Test-Driven Development. (Reviewed December, '04) |
|
 |
Test-Driven Development: By Example,
Kent Beck. Addison-Wesley, 2002.
Test-driven development is a programming method that says: write a test, write some code, refactor, repeat. For me, the biggest hole in Extreme Programming Explained was the lack of explanation of this technique, and this book fills that in. Kent creates two extended examples: mixed-currency calculations and a testing framework. He describes how paying attention to small steps can affect the design (and comes up with a solution differing from his previous designs). Finally, he includes brief descriptions of a number of testing and coding patterns. I recommend this book, to give a sense of the size of steps and the patterns used. (Reviewed May, '03) |
|
 |
JUnit Recipes, JB Rainsberger. Manning, 2004.
If test-driven development makes sense, but you need help in
particular areas, this book provides it. JB covers everything from
basic object testing to patterns, databases, XML, servlets, and more
J2EE. Well-written and highly recommended. |
Refactoring
 |
Working Effectively with Legacy Code,
Michael Feathers. Prentice Hall, 2004.
Michael has distilled a lot of knowledge about how to safely improve code when you lack the safety net of tests. For example, there are places where you'll take smaller steps or compile more often to be sure that no new problems are introduced. The book is structured with each chapter focused around a major problem you might have. Odds are, you either need this book or know someone who does. (Reviewed Dec., '04) |
|
 |
Refactoring:
Improving the Design of Existing Code,
Martin Fowler et al. Addison-Wesley, 1999.
The best printed source on refactoring. Uses Java for the examples. See also the Refactoring home site. (Reviewed Nov., '02) |
|
 |
Refactoring to Patterns, Joshua Kerievsky. Addison-Wesley, 2005. Design patterns and refactoring have been related for a long time. (Consider that Ralph Johnson, one of the co-authors of Design Patterns, was a sponsor of the work that created the original refactoring browser.) Josh has cataloged a number of refactorings that can lead your code to (or toward) any of the best-known design patterns. The code examples are excellent: realistic, interesting, and showing what was added or deleted. I recommend it for anybody who understands the basic concepts of refactoring, and is ready to further develop their design and refactoring skills. (Reviewed Sept., '05) |
|
 |
Refactoring Workbook, William Wake. Addison-Wesley, 2003.
I won't presume to review my own book. My goals were to create a
workbook that helps people practice recognizing smells (problems) and
learn to apply important refactoring techniques. There's a "smell finder"
inside the covers to help lead you from symptoms to solutions. The table
of contents and the book's home page are
here. |
CRC Cards
The original CRC cards are captured at <http://c2.com/doc/crc/draw.html>; the first training slides about them are at <http://c2.com/doc/firstcrc.pdf>; the original CRC cards paper (OOPSLA '89) is at <http://c2.com/doc/oopsla89/paper.html>. Start with these.
I don't think the ideal "CRC cards for XP" book has been written. The books below tend to be more into the up-front analysis side of things than XP teams will be. But, each has things worth learning.
 |
The CRC Card Book, David Bellin and Susan Suchman Simone.
Addison-Wesley, 1997. CRC cards, and ways to implement them in Smalltalk, C++, and Java. (Reviewed Nov., '02)
|
|
 |
Using CRC Cards: An Informal Approach to Object Development, Nancy
Wilkinson SIGS Books, 1995. (Reviewed Nov., '02) |
|
 |
Designing Object-Oriented Software,
Rebecca Wirfs-Brock, Brian Wilkerson, and Lauren Wiener. Prentice-Hall,
1990. Older, but this is a good introduction to the idea of object design based on responsibilities. It uses a little more elaborate form of CRC cards than I'm used to. (Reviewed Nov., '02) |
Other XP Skills
 |
User Stories Applied, Mike Cohn. Addison-Wesley, 2004. This book is all about user stories, focused on the XP-style customer or the Scrum-style product owner (although programmers and others should know this material as well). Mike describes what stories are, how to generate them, and how to estimate and plan with them. He contrasts them to use cases and IEEE-830 "The system shall" requirements, and includes a catalog of "story smells." The book closes with an example of a system described with 30+ stories, and its tests. A customer needs to know more than stories (including how to manage up-front analysis that might financially justify a product or feature, linkages to outside groups, innovation, and more.) But those aren't this book's topic: this book sets out to provide a clear, very well-written, and concise guide to using stories with a software team. It does a great job: I'm seeding copies with several people! (Reviewed June, '04)
|
|
 |
Designing Information Technology in the Postmodern Age,
Richard Coyne. MIT Press, 1995. Philosophical and a little heavy, but has some good ideas about what metaphors mean in a software context. (Reviewed Nov., '02) |
|
 |
The Pragmatic Programmer, Andrew Hunt and David Thomas. Addison-Wesley, 2000.
Skills and ideas every programmer should know. (Reviewed Nov., '02) |
|
 |
Pair Programming Illuminated, Laurie Williams and Robert Kessler.
Addison-Wesley, 2002. How to program in pairs. Describes problems pairs face when mixing experience levels or personality types. Has suggestions for improving pairing. (Reviewed Nov., '02)
|
I link to Amazon.com as part of their associate program, but don't forget to check half.com and others, especially if you don't mind used books.