Every so often I get asked about what I would recommend as a reading list for developers. I don’t pretend to be an expert in this, nor especially widely read. However I have read some outstanding books in my time, ones that had significant, permanent impact on me as a professional developer. As a result, I find myself regularly recommending them to others who are looking to improve themselves professionally. Of course we also need to read blogs, read code and do other things to improve ourselves, but hard copy books, in my opinion, remain one of the best ways to really dig into a topic.
So without further a due, here is the list of books I am perpetually recommending. More or less in the order that I would recommend reading them.
This book, by Robert C. Martin (a.k.a. Uncle Bob) is an excellent book on object-oriented coding style and was very formative in my perception of what good code looks like. Forget about the word Agile in the title. True, it has an agile focus but the principles and ideas covered are more fundamental and have much broader application that to just agile software. If you are doing object-oriented programming, this book is for you.
I am particularly indebted to this book for introducing me to self-documenting code and the idea that code comments are only to be used in special cases or as a last resort. But it covers the gamut of stylistic concerns from naming conventions to function length, layout and formatting exception handling, etc. More importantly it provides excellent reasons for every recommendation as well as telling you when you might want to ignore them.
Also by Robert C. Martin, this book marked my coming of age as an object-oriented programmer. Again, while ostensibly about Agile development, and there is a lot about agile engineering practices in this book, the book goes far beyond that. It is the best introduction I have found to the SOLID principles (the bedrock of good OO in my humble opinion) and the fundemental OO design patterns.
This book took me beyond my 101 level of OO understanding (inheritance, encapsulation and polymorphism), and showed me how to make these things work in the real world. Before this I was your classic OO neophyte, over using inheritance, neglecting composition, struggling to attain loose coupling and code reuse, etc.
Again Uncle Bob does a great job of explaining why something should be done one way or the other, how to balance the pros and cons of each principle and he makes it an easy, fun read.
After being introduced to design patterns in Agile Software Development, this book, by Eric Gamma, et al, was my next big read. I thoroughly enjoyed it, but I am a bit unusual in that I like dense tomes where every sentence is worth reading twice. Most people, admittedly, find this book a bit unapproachable for just a straight read through. So I often recommend Head First Design Patterns (below) as a alternative introduction to the topic.
Nonetheless, Design Patterns should be part of every professional developer’s personal library. It is the book that invented the term and remains the definitive patterns reference. It covers nearly very major OO design pattern. For each it discussed the pattern itself, the problem(s) it aims to solve, the indications for its use, when it is contraindicated and lists out the pro’s and cons of each. It also lays out the general categories of patterns, the relationships between the patterns, etc.
The only major OO patterns that I am aware of that this book does not cover are the model-view-controller and model-view-presenter patterns.
This book is fabulous for its ability to clearly, convincingly, powerfully set forth the fundamental ideas that need to drive lean/agile projects. This is not a technical book about writing software. It is a book about the core concepts that a person must understand if they are going to successfully conduct a iterative, evolutionary software development effort.
This book is not about Scrum or Kanban or XP. It looks that the fundamental principles and practices that underly all of these. It covers the fascinating history of lean engineering as it was first applied to manufacturing and moves on to explain how it has been and can be successfully applied to software development.
This book is a fast read, focused on increasing the value that business gets from software development, and is highly accessible to the non-technical manager. I consider it a must read for everyone from the agile team lead all the way up to the senior management responsible for the ultimate success of their company’s software development efforts.
This timeless classic by Tom DeMarco is all about how to successfully manage knowledge workers. It sets forth the skills and understanding needed to enable intelligent people and give them the freedom to explore and discover and do the things they do best while at the same ensuring that this activity is fruitful unto the company’s bottom line.
DeMarco goes into everything from office furniture to corporate culture, from how to interview and hire the right people to how to motivate and manage them. The book is probably most famous for its investigation into team dynamics and what makes some teams “gel” into high class profession operations that everyone wants to be a part of while other teams become gulags of low moral and even lower productivity.
Lightweight and easy to read, Peopleware is an excellent book that has its roots in a solid understanding of human nature as well as of business needs. Another must read for anyone who wans to successfully lead intelligent, independent minded professionals.
The following books are not on my must read list but deserve mention for the reasons indicated.
Before I found Clean Code, this book (in its first edition) was my bible for how to write good code and served me well for years in that capacity. In its second edition, it continues as an excellent source of information to that end, and is worth reading or at least having on your shelf as a reference when you want a second opinion. (Believe it or not, I don’t always do things Uncle Bob’s way. : )
As it is, I think Clean Code is shorter, more to the point, and more accessible, even if rather opinionated. Code Complete is well, complete. Its an all encompassing tome and not as accessible. So it has fallen off my must read list.
As noted above, I often recommend this book as an introduction to design patterns in lieu of my preferred book, Design Patterns, because most people find this book more accessible. Personally I find its approach a bit to gimmicky and distracting. I have to read more to get less information. So I actually don’t like this book that much. But I recognize that I am in the minority on this point and humbly bow to the empirical evidence that most people find this to be a great book on the topic.