







The Pragmatic Programmer was a shoe-in for this list. It is the definition of short and sweet for a programming book, and every piece of advice contained within it is pure gold. So many concepts that I use every day are contained in these pages. DRY. Tracer bullets. The Broken Window Theory. It's all in here, and now there's the 20th anniversary edition. It's the perfect excuse to go back and read it again for the first time.









Clean Code has a fair amount of overlap with the previous two books, but there's plenty that's unique in here and Robert C. Martin is such a great writer that it's worth it to reread this book, too. This book was surprisingly engaging for how deep it went into the minutiae of writing code. Like Object-Oriented Design Heuristics, it lays out guidelines and heuristics for writing better code, but it focuses a bit more on the specifics of how to name variables, structure functions, and write comments. It may veer more into the list-of-tools arena, but Martin reasons about everything nicely and it just seems to work for me in a way that GoF doesn't. It's always good to periodically refresh the concepts behind writing clean code.









This book covers much more ground than any of the previous three books, and it is subsequently much longer than any of them. It weaves together the topics listed on the cover quite well throughout the book, driving many of the chapters with simple, instructive examples. This book is where the SOLID design principles are laid out, along with a review of most of the standard patterns in GoF. Where this book does things better than the prescriptive GoF is in how the pattern discussions are example-driven and grounded in the design principles covered earlier in the book. The flow is so much better, and the reader comes away with a great understanding of why the patterns work, when to use them, and how to apply them appropriately.









This is such a quick, sharp, and relevant read, that it's definitely worth a reread every now and again. You won't agree with every one of Robert Glass' facts and fallacies, (when does anyone agree with everything in a software engineering book?) but they will make you think and rethink your assumptions, which is always valuable for growth as a developer.









These gems were such a joy to read the first time, there's no way they were not going to make this list. The quirky humor and self-guided Q&A format work perfectly. I can't think of a better way to refresh my basic programming skills with Scheme, and rewrite a Scheme interpreter, than to reread these books. Scheme is essentially a fundamental programming language, so in addition to these books being great to go back to, Scheme is a great language to go back to and polish up any rusty programming skills.









While SICP is the polar opposite of The Little Schemer and The Seasoned Schemer, it's just as good for learning and reviewing Scheme and programming fundamentals. Most introductory programming books are not worth revisiting because they tend to focus on language syntax and mechanics, but that's not true here. Scheme doesn't have much syntax to begin with, so SICP goes deep into fundamental programming concepts and, well, how to structure programs. It goes so deep that it's probably only worth revisiting the first three of its five chapters (how often do you need to review how to build a register machine simulator?), but that still presents a challenging and valuable exercise.









If I had to pick a favorite language, it would be Ruby, and this book exemplifies why. Everything needed to write beautiful Ruby programs is contained in here, and it has none of the boring cruft of an introductory programming language book. Russ Olsen is also an excellent technical writer, so the book is an enjoyable and easy read. This is how all intermediate-to-expert level programming books should be, and it makes it a pleasure to refresh those Ruby programming skills.









This book is like an up-to-date version of Object-Oriented Design Heuristics for Ruby. It's a quick, enjoyable read, with Avdi Grimm writing in an approachable, conversational style. The content is superb, detailing the best ways to write Ruby methods that have a definitive purpose without stumbling over edge cases that often weaken code. It's a great book for reviewing how to write clean, concise, purposeful code, and it would probably work for any programmer, not just the Rubyists out there.









The books on this list are here because they offer timeless advice, and this book is no different. It may seem like it's specifically about Ruby on Rails 3 programming, but the methods of refactoring the example antipatterns covered in the book—and why those antipatterns are bad in the first place—extend well beyond Rails. Bad code sucks for the same reasons no matter which programming language it's written in, and clean code shines in any language for the same reasons. It just so happens that Ruby and Rails are such pleasant vehicles for learning how to write clean code, and this book in particular uses a great style of showing how not to write code and how to fix that ugly code that was written before learning all of this great advice.









This is hands-down the most beautiful technical book I've ever read, and after looking through it, it becomes obvious that this is the best way to present the HTML and CSS syntax. These are the languages of visual design for the web, after all, so it makes sense to show how all of the tags and attributes work with full color pictures and diagrams on every page. It's especially helpful when showing the differences between borders, padding, and margins in CSS, but really most HTML tags and CSS attributes translate well to this kind of presentation. It's also quick to page through every once in a while, and such an enjoyable experience that it's worth doing multiple times.





This book was an easy addition to this list, partly because I already have read it twice. It was just as good the second time around when the updated version came out. Don't Make Me Think (Revisited) is packed with examples of both the right way and the wrong way to design websites, but mostly the right way. Steve Krug has a quick wit and the full color page layouts are great to look through for ideas. All of this makes the book a fast, easy read so there's no excuse to not refresh your knowledge on website design best practices.









This is another set of books that's easy to kick back with and peruse at your leisure, this time with a focus on how to display information in a way that makes insights jump off the page. These books are full of excellent advice and ideas on how to present information in charts, diagrams, and pictures so that the relevant information is clear and obvious instead of confusing and obfuscated. How data is represented is as important as the quality of the data itself, and reviewing these books will help drive your imagination to show that data in the best light for consumption and the spread of ideas.









I enjoyed this book way more than I was expecting to. John Foreman has a great sense of humor that really comes through in his writing, and he's able to take a normally dry topic and make it, dare I say, entertaining. He runs through a bunch of data science algorithms using real data and everyone's favorite spreadsheet program, Excel. Really. He develops all of these algorithms in Excel, and yes I meant entertaining. It's not a typo. A spreadsheet is actually a natural fit for learning about these algorithms because you can see every step in the process all laid out before you in black and white. It was so good, I'm planning to read the book again the next time I need a refresher course on K-Means Clustering or regression models.









This is another great book about data science that teaches the reader how to implement a number of data science algorithms and supported with an excellently dry wit. Instead of using Excel as Data Smart did, this time we're doing everything in Python. More than anything, rereading this book would be for the sake of deliberate practice. It's great for practicing programming, problem solving, and algorithmic knowledge because the book is building up data science from first principles. The more comfortable you are with the fundamentals, the easier everything else gets.









Okay, it may start to be feeling like this list is getting a little data science and machine learning heavy, but there's a reason for that. These are great books for developing analytical thinking and problem solving skills in the context of programming. Most programming books are either introductory books that aren't worth reading again once you know the language, or they're programming craftsmanship books—like the first part of this list—that are definitely worth reading, but don't flex the analytical parts of your brain much. These machine learning books do work your analytical brain more, and that goes for Python Machine Learning, too.









I found multiprocessor parallel programming with CUDA to be fascinating, and this was the best of the three books I read on the subject. It was well organized and understandable with nice, clear writing on a complex topic. It will be excellent practice to work through this book again.









If we're going to talk about the fundamentals, we can't get more fundamental than Alan Turing's paper on computability. Charles Petzold did an amazing job parsing out Turing's paper and making it accessible to more people. This is still a challenging read, but incredibly rewarding and thought provoking. Of all the books on this list, this book will be the one that I get the most out of with a second reading. The topics covered here are so deep and subtle that it would be foolish to think that one reading would be enough to absorb everything sufficiently. I'm looking forward to another round with this book in the near future.





Notable Omissions

People may notice some popular programming books missing from this list. First, I'll say that this is my list, and I'm not making any apologies for it. Wanting to read a book more than once is some of the highest praise I'll give for a book. Reading a book a second time is a rare occurrence. There are so many potential other good books out there yet to be read! Having said that, here are a few books I purposely didn't include.



Code Complete, I felt was too long and dry for my tastes. I much preferred Pragmatic Programmer, Clean Code, and Agile Principles, Patterns, and Practices in C#, and between the three of those books the same topics were covered in a more enjoyable way and even in less pages!



Refactoring was just a slog to get through. I thought it was worse than GoF in its itemized drudgery. Much of the same material is present in other books on the list, but those books teach the reasons and motivations behind good refactorings without listing them out ad nauseum.



Introduction to Algorithms maybe should have been on the list because I did read this book twice, but the second time was such an exercise in tedium with not much reward that I wouldn't recommend it to anyone other than aspiring CS professors. There have got to be more accessible algorithms books out there to brush up on this subject.



Seven Languages in Seven Weeks is a book that I would put on any best tech book list because it's an excellent book that's definitely worth a read, but probably only once. I don't have much desire to read it or any of the other Seven in Seven Weeks books again, even though I thoroughly enjoyed them all on the first read.



Well, there you have it. A complete list of tech books that were so good that I'm planning to read them again. They all have a common thread running through them in that they teach the fundamentals of whatever topic they're covering, and they do it really well. The fundamentals are extremely important in any field, and it's worthwhile to constantly revisit them and refresh your skills. Doing that with books that are engaging and enjoyable to read makes the whole process that much easier, and that is another defining characteristic of the books on this list. I imagine I'll add a few more books over time, but probably not too many. It's a rare thing to find a tech book worth reading multiple times.

I have read a crap-ton of technical books, mostly on software, but some either more general or hardware related so I felt the need to generalize the genre to "technical" books. If you've been following my blog for the last year, you'll agree that especially recently, my reading rate has been arguably excessive. I'm reaching a point where I'd like to slow down and focus on some other things in my free time, but I'm also reflecting on all of the great and not-so-great tech books I've read. One of the defining factors in whether I think a tech book is excellent versus merely good is if I have the urge to read it again. (For anyone wondering, there is no distinction needed for the bad tech books.) This feeling might happen right after I finish it, or even while I'm reading it the first time. It also might take a while to percolate and rise back to the surface as a book I want to go back to. The bottom line is, a mark of a great tech book is that it's worth revisiting, so what follows is a list of tech books I've read that I thought were so great that I'm going to read them again.This is a completely underrated book about software design, not in the sense that it gets poor reviews, because it doesn't, but it's not a very well-known book for how great it is. Other software design books, specifically, the notorious GoF book, steals all of the oxygen in the room, but I strongly prefer. While GoF is heavily prescriptive and mechanical in how it lays out the design patterns to use when writing software, OODH digs into the guidelines and rules-of-thumb that lie underneath those patterns. Instead of attempting to memorize a couple dozen patterns and their various applications, the reader learns why certain ways of organizing code work and naturally make the code easier to understand, debug, and change. It teaches fundamental concepts instead of lists of tools, and in the end knowing the fundamentals is much more valuable. In addition to being able to derive the tools you need without needing to remember them all, you can apply the fundamentals to new situations and invent new tools when the ones you have don't fully meet the requirements. The fundamentals are always worth revisiting.