Classes & TalksInvite Me!SubscribeContact

Recommended BooksBlogsAncient BlogsOld ArticlesClean Code GearA Little Clojure

Fundamental Algorithms

Donald Knuth

Addison Wesley, 1973,1968

This is Volume I of Knuth's series on The Art of Computer Programming.

The book walks through the basics of data structures and computational number theory. Topics covered include stacks, queues, linked lists, doubly linked lists, trees, etc.

These are basics that every programmer needs to know.

The other books in this series include: Sorting and Searching and Seminumerical Algorithms. Each is fascinating in it's own regard and ought to be part of the repertoire of knowledge that every programmer is familiar with.

Structured Programming

O.-J. Dahl, E. W. Dijkstra and C. A. R. Hoare

Academic Press, 1972

This is the book in which Dijkstra told us that goto might not be such a good idea. This is also the book in which Ole-Johan Dahl described the early principles of Object-Oriented Programming. There is much wealth within these pages that all who aspire to Software Craftsmanship should be familiar with.

Structured Analysis and System Specification

Tom DeMarco

Yourdon Press, 1979, 1978

This is a classic of early software system design. DeMarco describes the top-down approach of functional decomposition and introduces the use of Data Flow Diagrams and Data Dictionaries to specify that decomposition.

The book is very approachable, and full of deep insights. Every programmer ought to be familiar with it.

Object Oriented Software Construction

Bertrand Meyer

Prentice Hall, 1988

A classic book on Object Oriented Design, written by one of the founding masters of the technique. This is the book that defines the Open-Closed principle, and so much more. There is a lot of gold in this book. Anyone who aspires to be a master of Object Oriented software design would benefit from a careful read.

Meyer is the author of the Eiffel language, in which the code examples are all written. Eiffel is a beautiful language; which introduced the discipline of Design By Contract to the industry. Sadly the language has passed into obscurity. The discipline, however, remains; and is one that any software craftsman should know.

The second edition, written a decade later, is much larger. I find the size intimidating so I prefer the first edition. But that's just me.

Object Oriented Software Engineering

Ivar Jacboson, et. al.

Addison Wesley, 1992

I remember being at a conference in Europe when this book was released. We had all been eagerly waiting for it to arrive. We lined up at the publisher's booth and bought our copies.

This is the book that introduced Use Cases to the industry. But more than that, this was the book that first showed us the linkage between Use Cases, Object Oriented Design, and Architecture.

The concepts in this book are timeless; and every aspiring software architect should be familiar with them.

Design Patterns

Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

Addison Wesley, 1995

Probably the most important software design book written within the last half decade. This book contains nothing new or revolutionary. Rather it documents a set of tried and true techniques for solving common well-known problems of software design.

The techniques are given cannonical names and cannonical forms so that designers can recognize them and converse about them.

All software developers should know and understand these patterns and be able to apply them in their designs, and converse about them with other developers.

This is minimum critical knowledge.

Structure and Interpretation of Computer Programs (SICP)

Harold Abelson and Gerald Jay Sussman with Julie Sussman

MIT, 1996

This book was life changing. Or at least it was career modifying. It was my first introduction to functional programming; though neither the title, nor the first two chapters mentioned the term.

The book is completely unapologetic in it's approach, giving no quarter to those who want an easy ride. It moves at light speed from one topic to the next, demonstrating concept after concept with clear, concise, and plentiful code.

The language of the book is Scheme; but the reader barely notices because the language is so lightweight, and because the topics are so intense.

I read this book with a kind of ecstatic energy – virtually throwing the pages from one to the next in my enthusiasm. And then at page 217 the authors slammed on the brakes, apologized profusely for what they were about to do to me, and then introduced the first assignment statement.

I was thunderstruck. While reading all the previous code I had not realized that they had not used assignment. I had to go back and check.

It was then – quite late in my career – that I realized that Functional Programming was important for me to learn.

Analysis Patterns

Martin Fowler

Addison Wesley, 1997

An extremely important and vastly under-utilized book. Analysis Patterns is the harbinger of Domain Driven Design and provides a deep look into the most common data and behavior models for real business applications. In this book the author draws from decades of experience with real applications. He shows, with his usual clarity and dexterity, the traps that you can easily fall into during the exploration of a business domain; and how to avoid them using simple models of data and behavior.

This is a must read for any software developer of more than 2 years experience.

Extreme Programming Explained (1st ed.)

Kent Beck

Addison Wesley, 1999

The first edition is better than the second, in my opinion.

This is the book in which Kent Beck introduced Extreme Programming (XP) to the industry. It is simple, direct, and unambiguous. The writing style is friendly and approachable. It is a joy to read.

This is also the book that kicked the Agile movement into high-gear and eventually enabled those of us who favored light-weight software methods to meet in Snowbird to create the Agile Manifesto.

It is hard to imagine, today, how wildly controversial this book was in 1999. It challenged so many cherished beliefs and ideologies; and despite a huge backlash, it won the day.

XP remains the most complete and well-defined of all the Agile methods. You cannot truly understand Agile without understanding XP.


Martin Fowler

Addison Wesley, 1999

When my son was 11, he was on a hockey team. As all hockey parents know, your player will be on the ice for 5 minutes and then cooling down for 10. When my son was on the ice I was cheering for him. When he was off the ice I was cheering for what I was reading in this book.

Refactoring is the first book I ever read that presented code as something malleable. Other books presented code in final form, but this book showed how you could take poorly written code and transform it, step by step, into much better code with a much better design.

The book begins as an extremely effective tutorial, and then transitions into an encyclopedia of code smells and refactorings. It is utterly brilliant.

Martin has written a second edition for those who'd rather read javascript than java. Either way, the book is a must read.

The Pragmatic Programmer

Andrew Hunt, David Thomas

Addison Wesley, 2000

Ward Cunningham gave me a copy of this book and recommended that I read it. What a wonderful experience. Andy and Dave have packed this tome full of good, rock, solid advice about how to be a good programmer. This advice is personal, as opposed to technical. It's about how to behave, and about the mindset of a professional, rather than about coding tips and techniques. As such, the advice it timeless and highly valuable.

Domain Driven Design

Eric Evans

Addison Wesley, 2004

This is the definitive work on domain analysis. It provides both the motivation for, and the techniques that support, the analysis of an automated business domain. The book is deeply technical, and yet covers the behavior of the business and the development team in it's broad scope. The writing style is engaging, and the information content is extremely rich.

This book is an invaluable resource for developers on the path to becoming technical leads and architects. It's the kind of book that you'll come back to over and over as you gain systems experience.

Working Effectively with Legacy Code

Michael Feathers

Prentice Hall, 2005

This is the only book I know of that addresses this topic; and Michael Feathers handles it masterfully. But, be warned, the book does not provide you with a magic wand. Don't come here looking for a quick fix.

However the book is jammed with lots of useful and relevant techniques for getting your arms around a large and unruly code base.

Perhaps the greatest insight in the book is the definition of legacy code.

Legacy code is code without tests.

The Annotated Turing

Charles Petzold

Wiley, 2008

Have you read Alan Turing's 1936 paper: On Computable Numbers, With An Applications to the Entscheidungsproblem? If not, and even if you have, you must read this book.

You may remember the author from the many volumes he wrote in the 90s and 2000s extolling the virtues of Microsoft Windows. But nevermind that. This book is his Magnum Opus and it is, frankly, outstanding.

In the pages of this book you will find the entirety of Alan Turing's ground-breaking paper. However, Petzold surrounds each paragraph of that paper with a depth of history, commentary, and explanation that exposes both Turing's brilliance, and Petzold's diligence.

If it seems like I'm gushing, I am. I've read this book through twice, and I'll likely read it through again. It is an utter joy. It is also invaluable as a means to understand our fascinating profession of computer programming.