A Reading List for Developers
Good morning, folks. It's time for me to create my own List of Books for Programmers. Sure, other folks have come before me and recommended their own list. I'm sure there will be others who'll do the same thing after me, as well.
My intent is not to create a different list from all the others. I just want to create my list.
The Mythical Man-Month
The Mythical Man-Month is Fred Brooks' seminal story about software projects and people. Yes, the 20th Anniversary Edition is itself over 20 years old at this point, but people haven't changed all that much. Our profession has, to be sure, but the truths revealed inside this tome still hold.
The Pragmatic Programmer
The Pragmatic Programmer: From Journeyman to Master by Dave Thomas and Andy Hunt is a great, easy read...And it's chock full of great practices called out and then explained as Tips. These, uh, pragmatic tips are like little nuggets of gold spread throughout the book, but the best part of this book just might be the pull-out Tips Quick Reference Guide in the back. Once your team has read through the book (during Lunch & Learn sessions, of course), the Quick Reference Guide is a great item to hang on the wall in the team area!
Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. "Uncle Bob" Martin is an engaging read by one of the masters of the field. Uncle Bob's true passion for good software craftsmanship practices comes through loud and clear, and he provides realistic, actionable practices that you can start using TODAY to improve your coding, which will lead to improving your job.
Extreme Programming Explained: Embrace Change is Kent Beck's book, er, explaining the practices espoused by Extreme Programming. These practices, such as pair programming, test-driven development, and whole teams, can be used to improve your team's productivity and ability to deliver. Some of these practices will entail a mind-shift for many developers, but once you've made the switch and given these practices a try, they're likely to stick with you.
Refactoring: Improving the Design of Existing Code by Martin Fowler will change the way you think about your code. Prior to reading this book, I rarely (if ever) went back and altered existing code. In reading it, I gained knowledge about how I could safely improve code that I'd previously written, as well as some patterns for how to do it. The new vocabulary provided by this book is now industry-standard, and many of the safer refactorings are provided by default in today's IDEs. In fact, since this book was written, Martin Fowler has created a website dedicated to refactoring.
Working Effectively with Legacy Code
Working Effectively with Legacy Code provides great ideas about how we can best work with "legacy code." Feathers' definition of "legacy code" is basically "any code that isn't covered by automated unit tests." If you're working in a codebase that is riddled with untested code, read this book right now. Using the patterns that Feathers provides will help you gain confidence in your ability to change your legacy code, and when coupled with Fowler's refactorings, you'll be able to more easily wrangle your code into a better state.
Beyond Legacy Code
Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software is the logical successor to Feathers' book above. In this book, David Bernstein provides nine essential practices that you and your team should adopt to make your life easier. This book is written in a manner so that it's consumable by both technical as well as non-technical folks: Buy a copy for yourself, and one for your manager! This is another great lunch-and-learn book.
In Release It!: Design and Deploy Production-Ready Software, Michael T. Nygard shows you how you can design your application for the real world. Using examples, he shows the negative impact that technical decisions can have on the business, and then provides ideas on how to improve the situation. The second edition of this book is about to be released later this year; I read the first version many years ago, and I still reference it.
Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation changed my life. Jez Humble and Dave Farley show how and why we in the tech industry should automate everything as much as possible, from testing to deploying. Ever been on a 3am release call, trying to follow a "run list" of steps to get the latest version of your software out the door...And made a mistake? I've been there, and it's no fun. Read this book. Learn why you shouldn't do that, and how you can take steps to improve the situation. Humble also shows how these practices can be used to show traceability even in heavily-regulated industries such as finance and medicine. Everyone, including non-technical folks, should read at least the first chapter of this book.