Software Development Reading List

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.

General

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.

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.