The six best books every developer should read
By Andrew Binstock
August 16, 2011
URL : http://www.drdobbs.com/joltawards/jolt-awards-the-best-books/231500080
Every year for the past 20 years, we've recognized the best products in the main classes of software development tools. No category gets more entrants than books, and this year was no exception with 51 nominees submitted by publishers, vendors, and readers. The award covers all books published from July 1 of last year to June 30th of this year.
Due to the large number of candidates, the Jolt judges decided to do a first pass that would cut the field to 15 worthy entrants; then a second pass that chose their top six picks ranked in order. The top book of the year receives the Jolt Excellence Award, the two runners up receive a Jolt Productivity award, and the remaining three books are known as Jolt Finalists. The separation between these six and the remaining nine that made the cut was felt by most judges to be somewhat artificial. Many of those remaining titles were found to be good works, worthy of attention. We will discuss them in later articles.
In years past, the comment I just made about how closely bunched the books were is made about the top winners, but this year was different. The Jolt Excellence Award winner led by a wide margin. In many ways, this validates my original review of the book (prior to my coming to Dr. Dobb's) in which I called it the "most important book of 2010." I've included that review in the reviews of the six award winners and finalists that follow.
The judges for this category included Alan Zeichick, Chris Minnick, Robert DelRossi, David Dossot, Gary Evans, Gary Pollice, Jon Kurtz, Larry O'Brien, Mike Riley, Peter Westerman, Roberto Galoppini, Rick Wayne, Scott Ambler, and me. Given the large number of experienced judges, you can have high confidence that the award winners really represent the best of the available books.
We thank Rackspace, a Jolt sponsor, for providing virtual machines for the judges' use to the extent they were needed for judging books and the software that comes with them.
If you want to nominate products for consideration in upcoming categories, you can view the calendar and get the (very short) nomination form here.
And now the envelopes…
Martin Fowler's Domain Specific Languages is a big book. Weighing in at over 600 pages, this book attempts to cover the broad field of domain specific languages (DSLs). Unlike other books that attempt to cover a broad field, there is a lot of code in this book.
DSLs receive considerable coverage today as an approach to bring computing closer to users. A DSL is a specialized language where someone familiar with a particular domain, or area of expertise, can create software by expressing computation using familiar terms. If you are new to DSLs or want to understand the mechanics of how to implement your own DSL this book is for you.
Fowler makes liberal use of examples to illustrate deep concepts. He organizes the book into six parts beginning with a survey of the DSL neighborhood and then proceeds into the technical details. A reader who wants to understand what a DSL is and what it is good for need only read part I to gain a conversational knowledge of DSLs. His example in the first chapter of a Gothic security system is entertaining and informative and sets the stage for the rest of the book. Part I leads the reader on a journey through DSL land that winds through different types of DSLs, alternatives to DSLs, and some engineering details on how to implement DSLs.
Fowler divides DSLs into two categories: internal and external. External DSLs use a programming language to create a different executable language. Internal DSLs use stylistic variants of a programming language to make it easier to create executable programs in that language. Three parts follow, containing the basic patterns one should understand when constructing either type of DSL. After Part I, the reader should understand the basics of how to create a DSL. However, the devil is in the details. These three sections provide those details. Fowler presents the details as patterns, with each chapter illustrating a single pattern.
Part II provides patterns needed for any type of DSL, including the all-important Semantic Model. Parts III and IV offer the patterns needed to construct external and internal DSLs. Readers familiar with language translation technology such as compilers will feel at home in Part III that focuses on external DSLs. External DSLs require more core computer science knowledge, such as parsing theory. Someone without an understanding of compilers should probably skip Part III on first reading.
The book does not use one specific language for its examples. In fact, Fowler uses common languages like Java, Ruby, and C# as well is widely available tools such as the ANTLR parser generators. Many readers will learn something about languages and tools that they have not experienced before as a side effect of reading this book.
The final parts of the book are relatively short. Part V presents alternative computational models, such as decision tables, production rule systems, and other models that into the DSL space. Part VI covers code generation. One might skip these two parts on the first reading.
This book omits details about engineering a DSL. If you want to understand how to organize a project and determine the process needed to engineer a DSL, you should refer to the ample body of software reuse literature. Domain Specific Languages does not address these issues, nor is that Fowler's intent. He is focusing on the nitty-gritty decisions and details and there are plenty of them that will help the software developer produce a robust DSL. If you are such a developer, get this book. Read it lightly at first and then refer to it often.
Written by a man who has lived through all the major milestones of modern computing, computer science rock star Donald Knuth has completed his 4th volume on The Art of Computer Programming 30 years after the third volume was released.
This latest opus is as densely packed a title as the previous TAOCP books have been; and given the density of both the content and presentation, Volume 4A is one of the few computer books these days that demands to be read in traditional ink on paper format. The sheer amount of mathematical notation in the book would make all electronic editions sans a PDF version just a collection of non-reflowable JPEGs interspersed with a sprinkling of text.
Staying true to form, Volume 4A begins with Chapter 7: Combinatorial Searching, with only two subsections (Zeros and Ones, and Generating All Possibilities). Nearly half the book is dedicated to describing and presenting problems for classroom and self-study execution while the remainder provides detailed answers to the questions and four appendixes covering numerical quantities and indexes to notations, algorithms and theorems, and combinatorial problems.
Like all of Knuths's other "Art" books, Volume 4A is not intended for light reading. It may take days to work through a problem and reviewing the answer may take a few more. Because the book also assumes a high degree of comfort with mathematics, statistics, and logic transforms, readers who lack a formal mathematics background will need to devote even more time to digesting the book's contents while they brush up on the formulae and theorems used extensively throughout the book. Yet for those who persist, the payoff is significant. Reading and understanding the material in Art of Computer Programming will be a mental workout that will flex your mind muscle to take on even more strenuous real-world problems in your own work. Those who are impatient or not prepared to invest the time and effort required to grok the 800+ pages of intelligence need not apply. For everyone else dedicated to perfecting their computer science craft, Volume 4A should simply be considered part of the job requirement.
Combined with Knuth's 70+ years and the fact that this latest book is only Part 1 of Volume 4A from Knuth's proposed seven volume set with (Volumes 4B, 4C, and perhaps even a 4D and 4E as part of the plan), it is unlikely that he will be the sole author for the remaining volumes. That would be a shame, given how his voice has guided a generation of programmers to building more sophisticated systems.
Like Knuth's prior volumes, The Art of Computer Programming, Volume 4A, is a must-have book for any serious student of computer science. Regardless of the number of years of programming experience you have, you will acquire lifelong, career-boosting algorithmic insights by digesting this volume slowly.
I consider myself more of a Scala person than a Clojure person, but this book persuaded me to become an even bigger fan of Clojure, the new Lisp-like language that runs on the JVM. Authors Michael Fogus and Chris Houser, both contributing members to the Clojure language project, have crafted a Clojure book unlike any other Clojure title I have read. Rather than pursue the plain path of a language reference, The Joy of Clojure examines the language from a deeper perspective. As such, it expands the reader's thinking with the possibilities (and some limitations) that the current 1.2 release has to offer.
The book is delivered in five parts. The first, Foundations, covers the Clojure philosophy and sets the stage of the tone and topics to come. The basic constructs like scalars, collections, functions, vars, loops, blocks, quoting, exceptions, and namespaces are also discussed. Part II, Data Types, goes deeper into understanding how to best utilize scalars and composite data types in Clojure by considering symbolic resolution, regular expressions, persistence, complexity, queues, and sequential evaluations. Part III explores the hot topic of functional programming, a category that Clojure excels and made its name in. While only two chapters long, the working lazy quick sort and pathfinding examples do the job of showcasing Clojure's power in the functional programming space.
Part IV features another top strength of Clojure: large-scale design. This scaling need is truly why languages like Scala and Clojure exist, and the authors do an excellent job of distilling their knowledge of the subject into four chapters. This section is also the heart of the book and covers the use of macros to control, combine and change forms and manage resources, using the "Universal Design Pattern" with Clojure's multimethods and the Java-Clojure. Chapter 11 on Mutation is a must-read, filled with best practices on the use of agents, atoms, futures, locks, promises, refs, vars and dynamic binding. There's a lot to digest in this chapter and will prove invaluable toward advancing your Clojure experience.
The last part of the book, titled Tangential Considerations, contains chapters on performance issues (type hints, transients, chunking, memoization, and coercion) and a final catch-all chapter on the design considerations behind DSL's, testing, design patterns, error handling, and debugging. It's hard to believe that Fogus and Houser were able to pack so much excellent advice into a 350+ page book.
Readers unfamiliar with the mechanics of the language should first read the other basic tutorial Clojure books on the market, play with the language, and port a few simple programs to it before checking out this book. And while the book's Web page assures that no Lisp experience is necessary, I disagree. Readers who will get the most out of the book and Clojure itself need to have some awareness of Lisp due to Clojure's reliance on that language's main principles. So while it may not be necessary to have Lisp experience, the philosophy and principles expounded upon in The Joy of Clojure will take Lisp (and other functional programming-aware developers) readers further and resonate more deeply with this background experience at the ready.
Additionally, while the book can certainly provide insights to the first-time Clojure student, it will be best appreciated by those who have gained some appreciation for (and frustration with) using the language. It is a book crafted for intermediate Clojure developers seeking to hone their skills and reveal the more graceful subtleties the language has to offer. So while I am still likely to remain a Scala user by day, reading this book has made me a Clojure convert by night.
Ever wonder what the attraction is to those programming languages that have built up ardent followers? Have you wanted to have the time to compare and contrast these languages with a fair and honest approach? Bruce Tate, author of Seven Languages in Seven Weeks, asked these questions and took the time to find the answers. His answers make up this chapter.
Unlike Andrew Binstock's editorial, which condemns books that hope to teach languages to naïve readers in 24 hours, this book proposes only an overview of the languages to give the experienced reader a sense of each language. In this sense, Seven Languages in Seven Weeks offers a tapas of modern language analysis; small portions offering just enough of a taste to decide whether the selection is good enough for a second helping or even a main dish. Each language is presented with its history (along with an interview with its creator); a quick tour of interesting syntax, conditionals, operators, and features; and a summary of the language's core strengths and weaknesses along with author's final thoughts on his experience. You will have to buy the book to find out which languages the author found most to his liking.
Each chapter's introduction begins with the featured languages being matched with popular movie characters:
These character analogies are spot on, and had a profound effect on orienting my mind on how to interact with the syntax and capabilities of each of the languages analyzed in the book. Personally, the book helped me gain a deeper understanding of Prolog and Haskell, enough to prompt me to warrant a closer look. I have also been tracking Scala closely, and Haskell is one of those "when I'm stranded on a desert island" languages to learn. As for Io, I don't anticipate having a need for that language any time soon, but at least now I know what its strengths and weaknesses are and how to write a simple Io coroutine.
Perhaps the reason for Ruby's inclusion into this exclusive club of languages (with otherwise-limited market awareness/penetration, like Io and Haskell) had to do with Pragmatic Bookshelf's heavy bias toward the language. After all, the majority of Pragmatic's titles are Ruby-centric. For those who are already Ruby fans, this chapter is a wash. As for fans of other popular dynamic languages like Python or Perl, they won't find them mentioned anywhere in the book. However, I contend that anyone who feels strongly about such and such language that didn't get included in the book is missing the point of the author's experiment. This isn't a book about cheering on the winners and sneering at the losers. It's about one developer's quest to understand those languages that are making waves in the computing ocean of established, well-marketed languages like Java and C#.
I enjoyed exploring the insights that Seven Languages had to offer, and I commend the author for taking the time to delve into up-and-comers like Clojure and Scala; doing so helped me decide which of these are worth my time to pursue further. The book offers an engaging travelogue with highlights of what to see and what to avoid. Mr. Tate, who wrote several Java books before undertaking Seven Languages in Seven Weeks, should consider writing a sequel, perhaps "Another Seven Weeks with Another Seven Languages" that will examine another batch of languages, perhaps even those suggested in the book's discussion forum (Ada, PL/I ,and Google's Go for starters).
There is a new gold rush happening today. The gold is not the a mineral, rather it is data data we can mine and turn into valuable information. Instead of digging into the earth or panning rivers, we need to mine the Web, specifically the Social Web. If you are planning to find fame and fortune from this gold rush, make sure to pack Matthew Russell's Mining the Social Web in your toolkit.
The Social Web has a wealth of data waiting to be discovered, analyzed, and turned into valuable information. Huge companies, such as Google and Facebook, depend upon this information in order to remain profitable. But you don't have to be a big company in order to mine it. Russell gives you everything you need to dig in and get started.
Mining the Social Web serves up 10 bite-sized chapters that will take you from tenderfoot to a knowledgeable social Web hacker. Spend an hour working through the first chapter and you'll be hooked. Russell takes you through the steps necessary to analyze the latest trends on Twitter, see who's tweeting about the trends, organize the data, and visualize it with tools such as Graphviz.
While Russell shows you exactly how to perform each step, and provides plenty of ideas for you to try, he also encourages you to explore on your own. His style reminds one of a great teacher. He poses a problem, shows you how to solve that problem, and then expands on it and challenges you to reinforce your learning by going further on your own.
In order to take advantage of this book, you must understand Python. All of the examples are written in Python and many external modules are used. Russell makes it as easy as possible for you to understand what is happening, even if you aren't Python-fluent, but this only goes so far. If you really want to get the most out of this book, you should have a working knowledge of the Python language.
Don't read this book when you have no Internet connection. This book reads better in electronic form than the printed page, and makes liberal use of hyperlinks to reference information. In the preface, Russell says that he does this in order for the reader to look at reliable, current information rather than out-of-date material. Without the links, material would need to be included directly in the text, making the book larger and less direct.
Once Russell sets the hook with Twitter hacking in the first chapter, he reels you in with a series of fascinating chapters beginning with capturing information using micro-formats (such as geo, XFN, and others). He shows you how to build graphs that express relationships between pages including microformat notation. While the book is not a tutorial on analytics, it contains plenty of examples of data analysis techniques with reference for more. It also shows you how to use many other tools for massaging data and extracting informational nuggets.
a significant portion of the book is devoted to different sources of data that is ready to be mined. These include mail messages, Twitter, LinkedIn, blogs, Google Buzz, and Facebook. The Google Buzz chapter indicates how quickly things change (today, that chapter would focus on Google+).
The final short chapter discusses the Semantic Web. There isn't much code, simply because the Semantic Web vision has yet to materialize. What is clear, however, is that Mining the Social Web can position you to take advantage of the Semantic Web when it arrives.
I have reviewed many books as part of my work on the Jolt Awards, but it's been a very long time since I've read a book as useful and likely game-changing as Continuous Delivery.
The basic premise of the book is that we need to move past continuous integration into a fuller cycle of activities that go beyond build and test. Specifically, this new orientation calls for building and testing on all platforms, creating and deploying the final deliverables for all platforms with every check-in. The benefit of this approach is that the development organization at any given moment always has: 1) immediate feedback on deployment issues, 2) a deployable binary; 3) a completely automated process to build, test, and deploy on all platforms.
This simple concept a kind of continuous integration on mega steroids has profound repercussions, all of which make your process better. The first and most important is that you have to automate everything downstream from the coding. And the authors mean everything. The most common point where people hem and haw about automation is deployment. But Humble and Farley make it clear you have to "bring that pain forward," and fix the process so it can be automated. (If you don't have any idea how you might refine and automate deployment, think virtualization. Can you emulate your current systems on virtual machines and then progressively simplify deployment of the software to the point of automation? Good, you're on your way.)
But the mechanics of deployment may be the least of your challenges (And here, the book's name could be viewed as misleading: Deployment is only one aspect it covers.) You also have to build, run, and test the software on every platform you ship on. You're not reasonably going to be able to do that if you have to change configurations and manually reset values for different platforms. The authors guide you to finding the one path that gets you across the river Jordan without spending 40 years in the desert of bit twiddling. The key is to use a single codebase and move the platform dependent stuff into configuration files. This is non-trivial, but the authors offer plenty of good advice.
Testing is another topic Humble and Farley explore in great depth. Testing in the context of continuous delivery is not just running unit tests and a regression suite. No , this is running all tests unit, integration, UAT, and so on. How to automate them effectively occupies probably the largest chunk of the book. Even if you don't accept the continuous delivery concept, this section is worth the price of admission. It's mind-expanding in ways that the hundreds of articles we've all read about agile testing on Digg and Reddit never touch on. You see very quickly how much more automation you could do and how to get from your miserable semi-manual existence to the smooth flow of full and continuous automation.
What impresses about the book is how the authors consistently work through hard problems. They are not daunted by them and there is no attempt to pass over them with hand waving. Hard things are examined in detail with a perspective that derives from the authors' own extensive experience.
I have literally never read a better book on process. I believe that going forward, Continuous Delivery book will redefine agile process and CI; and it will have as much influence as I have to go back to 1999, here Fowler's book on Refactoring did on code.
Copyright © 2012 UBM Techweb