The current decade doesn’t end until the year ends with a “1.” Society is going to collapse when all of the computers roll over. Remember the things we thought were significant 10 years ago? That’s the problem with looking forward. It’s also why so many of the books in this list are from the early and middle years of the decade: Their influence has already been felt. It’s difficult to make a case that even the hottest subject will be influential for years to come (wipe that smug look off your face, iPhone).

The books in this list—intended to recognize the 10 most significant titles since the debut of SD Times—vary in their technical specificity, but obviously books that are not tied to a specific binary tend to have longer lives. While some are concise and some exhaustive, all are clearly written. These are the books that have fought off contenders for shelf space for years and that we find ourselves returning to, over and over.

Before diving into the Top 10 list, I must give a nod to two others that appeared in 1999: Kent Beck’s “Extreme Programming Explained,” and “The Pragmatic Programmer: From Journeyman to Master,” by Andy Hunt and Dave Thomas. Their impact was felt over the past decade.

#1 Lean Software Development: An Agile Toolkit
Mary Poppendieck, Tom Poppendieck (Addison-Wesley Professional, 2003)

Software development is about people, not technology. Software process management is more complex, and more prone to failure, than any technical aspect. In the 2000s, the industry finally embraced the incremental, quality-oriented, risk-driven practices that had been identified as far back as the 1970s as superior to more formal, front-loaded practices. This sea change led to many excellent software process management books. “Lean Software Development” stands out for the quality of its writing, its conciseness, and its tone, which is perhaps less fervent than some, but is pitched perfectly for those with one foot in the technical world and one foot in the business world.

#2 Practices of an Agile Developer: Working in the Real World
Venkat Subramaniam and Andy Hunt (Pragmatic Bookshelf, 2005)

Want to practice agile development? Of course you do! How could you not? But what, exactly, does that mean? Something about paying attention to client value and quality, but other than that? There are many answers to that, ranging from the “extreme” practice of pair programming to the all-too-common belief that agility means telling your developers to “shut up and code.” For the majority of us, though, “Practices of an Agile Developer” nails it—“delivering what users want” as the job and clarity, in technique and code, as the way. This book is brief, insightful and to-the-point on development techniques to rapidly identify, isolate and evolve change points in your software.

#3 Head First Object-Oriented Analysis and Design
Brett McLaughlin, Gary Pollice and Dave West (O’Reilly Media, 2006)

There was no doubt that there would be a “Head First…” book on this list. The exuberant series, with its quizzes, crosswords and vintage photos, is definitive proof that books can deliver excellent technical information while being as engaging and accessible as the Web. At first glance, the design of these books might seem to be mere window dressing, but in fact the series is an all-too-rare example of modern educational theory. “Head First Object-Oriented Analysis and Design” is not only a fine example of the series, it is the best tutorial ever written on the paradigm that dominates professional software development.

#4 Beautiful Code
Andy Oram and Greg Wilson (O’Reilly Media, 2007)

The very title “Beautiful Code” speaks to an awakening that happened in the 2000s. Instead of viewing code as an unfortunate and somewhat embarrassing side effect, developers have embraced these blocks of human-readable text as objects of pride and worthy of study. Several trends—refactoring, the expansion of open source, and the growth in popularity of more terse languages—have contributed to the newfound interest in “code reading.” Oram and Wilson present more than 30 essays discussing and dissecting “Beautiful Code” in a diversity of languages. The list of contributors is impeccable—not just excellent developers, but excellent writers—and one of the joys of this book is the varying levels of abstraction and rigor that the authors find significant.

#5 Code Complete 2: A Practical Handbook of Software Construction
Steve McConnell (Microsoft Press, 2004)

Code Complete is the definitive guide to software construction. What should you name a variable? How should you structure loops? Given how little these things are discussed, one might think that the answers are trivially obvious. They aren’t, or if the answer is trivial, it’s “do it the way Code Complete says.” McConnell’s advice is clear, straightforward and well-reasoned. McConnell takes a principled stand for a more formal engineering approach to software development. New readers may find the tone and emphasis on C-family languages (and Visual Basic) a trifle unhip, but any developer would be thrilled to work with code that approaches McConnell’s in quality and attention to detail.

#6 Programming Ruby
Dave Thomas, with Chad Fowler and Andy Hunt (Pragmatic Bookshelf, 2004)

The Pickaxe Book. When a book achieves “The #{cover_illustration} Book,” you know it’s significant in its community (see also Camel, Dragon, Rhinoceros). What is harder to tell is if a book is significant to the broader field. Is the most popular book on Ruby more significant than the most popular book on Python or PHP? Is it more significant than the most popular book on Rails, the framework that is largely responsible for the growth in Ruby’s acceptance? That is a matter of an individual’s career and values. Ruby really came of age in this decade, though, and its Smalltalk-like commitment to object-orientation puts it in touch with the decade’s dominant paradigm.

#7 Effective Java
Joshua Bloch (Addison-Wesley, 2001/Prentice Hall, 2008)

In the first hour with this book, you can learn more about Java than you can in a year of catch-can programming. From low-level (“For instance control, prefer enum types to readResolve”) to high (“Favor composition over inheritance”), the 78 prescriptions in “Effective Java” are uniformly accurate and valuable. Now that Java programmers are dealing with everything from legacy codebases to new frameworks and form factors, mastery of the platform is more valuable than ever (C# programmers should seek Bill Wagner’s book in the “Effective” series). The form of this book (very brief chapters) has become more and more influential over the decade with the rise of the cookbook/recipe-style book.

#8 Concurrent Programming on Windows/Java Concurrency in Practice
Joe Duffy (Addison-Wesley Professional, 2008); Goetz et al. (Addison-Wesley Professional, 2006)

Moore’s Law has stopped providing a free lunch of performance improvement with every chip generation. If your program takes a long time to load or finish a calculation today, it will take a long time next year. Putting aside for now the question of how to wrangle dozens of execution pipelines, the performance-oriented enterprise developer has no choice but to deal with a concurrency model that is famously challenging. It may be cheating to list two books, but this is no time to be coy: Java programmers should get Goetz’s book and Windows and .NET developers should get Duffy’s. The books have very different styles (Goetz’s book follows the “Effective…” style of short chapters, while Duffy’s is an encyclopedic guide), and the interested developer can benefit greatly from reading both.

#9 Producing Open Source Software: How to Run a Successful Free Software Project
Karl Fogel (O’Reilly Media, 2005)

Free and Open Source Software has been around for a lot longer than a decade, and it played a huge role in the explosive development of the Web in the late 1990s. But until this decade, businesses generally believed “you get what you paid for,” and that depending upon FOSS, much less sponsoring FOSS development, did not make sense. It does (or, at least, it can). Where companies feared that open software meant finding some random file on the Web, what they found was that FOSS has a whole set of organizational patterns, de facto tool sets, and development practices that can result in high productivity and quality. Fogel’s book documents both the social and technical aspects. It provides an excellent managerial overview of the tools, even if some of the specific advice is a little dated (CVS is no longer “the version control system of choice in the free software world”). More importantly, though, it explains cultural and organizational concepts from “benevolent dictators” to managing volunteers that are not part of the traditional business management training.

#10 Patterns of Enterprise Application Architecture
Martin Fowler (Addison-Wesley Professional, 2002)

If you don’t think architecture is important, you haven’t yet experienced how miserable a software project can be. Today we take a lot of technical infrastructure for granted, we use opinionated frameworks, and we develop incrementally, all of which result in far less upfront attention paid to analysis and architecture. That doesn’t make these issues any less important and, indeed, makes the clear diagnoses and advice of this book all the more valuable. The book’s core subjects (distribution, concurrency, persistence patterns) remain spot on with today’s concerns, and one can wish for a second edition incorporating topics such as NoSQL and the evolution of service architectures.