While I graduated with a Master’s degree in Computer Science in the early ’90s, I didn’t start seriously studying software design and development practices until the mid- to late-90’s. I followed the rise of Extreme Programming (XP) and other Agile methodologies pretty closely, and still use them in my day-to-day work.

There are a number of books and other writings that have shaped my thinking over the years, and it may be that you’re not familiar with some of them, so I thought I’d share a list of some of my favorites. Maybe you’ll be reminded of an old gem, or maybe there will be something here that’s new to you.


  • Ward’s Wiki: Ward Cunningham’s original wiki is an incredible resource of knowledge. It was here (and the old OTUG mailing list) where I really learned about XP and other agile methods. There’s also a lot of material about design patterns, object-oriented design, and the like.

  • The Pragmatic Programmer by Andy Hunt and Dave Thomas. This is an awesome book about being a programmer. Well worth reading every few years.

Agile Development

  • Extreme Programming Explained by Kent Beck. This is the first book about XP and contains really great ideas, many of which were revolutionary at the time. This is the “what” book: What is XP and Why should I care? I consider the second edition to be a different book and I’d recommend reading both.

  • Extreme Programming Installed by Ron Jeffries, Ann Anderson, and Chet Hendrickson. This is one of a series of books about how to actually apply XP. If Kent’s book was the “what” and “why”, this book is the “how”. The authors were on the original XP team at Chrysler.

  • Planning Extreme Programming by Kent Beck and Martin Fowler. This book expands on the planning practices in XP. Another “how” book that focuses more on the wider team practices than the development practices.

  • Extreme Programming Applied by Ken Auer and Roy Miller. This is another “how” book that didn’t enjoy as much popularity as the books above, but is still valuable. There’s some good information here that I didn’t get from the other XP books. The authors were not on the original Chrysler team, so this is an interesting take on XP as it started to spread.

  • Test-Driven Development: By Example by Kent Beck. This was one of several books that dove into an individual XP practice. I thought I was getting a pretty good grip on TDD before I read this book, but the author blew my mind several times. If you really want to understand TDD as it was originally intended, this is the book to read.

  • Refactoring by Martin Fowler et al. This is the canonical resource on refactoring. It describes what refactoring is (and isn’t) and how to do it well. It contains a catalog of refactorings along with advice about when and how to apply them.

  • Working Effectively With Legacy Code by Michael Feathers. If you have to work with any code that’s been around for a while and doesn’t have good test coverage, you need this book. It gives great advice about how to start getting legacy code under control. How do you test code that wasn’t designed to be testable? How do you safely make changes? It’s all here.

  • The Art of Agile Development by James Shore and Shane Warden. This is a newer (2008) book that distills a lot of the lessons learned from the first ten years or so of XP and other agile methods without watering down the message.

  • Specification by Example by Gojko Adzic. This book is about using automated examples as a specification for software, or as it was originally called in XP, acceptance testing. This book and the next really shaped my thinking about the best way to write these tests. If you’re using Cucumber, Fitnesse, or any other tool that allows you to write tests for your software in a “business-friendly” way, this book will help you write them so that they are understandable and maintainable.

  • Fit for Developing Software: Framework for Integrated Tests by Rick Mugridge and Ward Cunningham. While this book is mostly about the Fit/Fitnesse/FitLibrary family of acceptance testing tools, it contains a lot of good advice about how to write good, maintainable acceptance tests. The naive use of these tools (and Cucumber) results in slow, tedious, unmaintainable tests. This book and the previous one both show you how to move beyond the naive use and get to the place where this kind of test can really help your project.

Object-Oriented Design

  • Object Mentor Articles. There are numerous articles here by Uncle Bob Martin and many others covering a variety of topics about object-oriented design, XP and agile, and other topics. I learned a lot here.

  • Agile Software Development: Principles, Patterns, and Practices by Uncle Bob Martin. I consider this book to be a distillation of the Object Mentor articles I just mentioned along with a lot of other material. Lots of good information.

  • Design Patterns by the “Gang of Four”. The patterns movement had a huge influence on the software world. Much of what we now understand about object-oriented development came out of this community as did XP. This book is the canonical reference book for design patterns; it talks about what patterns are and how to use them, and includes a catalog of design patterns. Many of these patterns are now just part of our vocabulary. There are other patterns books that are worth reading as well.

  • Object-Oriented Software Construction by Bertrand Meyer. This is classic book and introduces a lot of really interesting ideas that you’ve probably heard of, such as Design by Contract and the Command-Query Separation Principle.

  • Smalltalk Best Practice Patterns by Kent Beck. This is a brilliant book that gives great guidance about the low-level structure of your code. While it is targeted at Smalltalk, don’t let that keep you from reading this book. There is so much good information in here that applies to any language.

  • Growing Object-Oriented Software, Guided by Tests by Steve Freeman and Nat Pryce. This book really started to change my thinking about how to write object-oriented software. If you want to understand the original intent behind mock object-based testing, this is the book.

  • Practical Object-Oriented Design in Ruby by Sandi Metz. I’ve mentioned this book many times here, and it continues to be one of my favorites. It is worth reading even if you’re not a Ruby programmer. While the GOOS book started to change my thinking, this book really brought it home and showed me how to apply these new ideas to my code.

I hope you find something interesting in this list. It’s been a trip down memory lane to go back through my book collection, and I find that I need to go back and re-read some of these books again.