I recently downsized my technical library and got rid of about 20 brick-sized technical books.
Some of the books covered obsolete technologies, but I got rid of most of them simply because I’d rather access the information that they covered through a search engine on an as needed basis rather than by slogging through a 1000 pages of obscure corner cases up front that I probably will never need or else will forget by the time I actually do need to know it.
If I no longer consider the traditional technical books that I spent obscene amounts of money on as little as 4-5 years ago as even being worthy of collecting dust in my basement, just imagine how reluctant I am to actually spend money on those types of books today and in the foreseeable future.
As far as I can tell, I am not the only one who feels this way. Indeed, I often feel like an out-of-touch old-timer every time I’m greeted with a long silence after asking potential candidates on phone interviews which technical books they have read recently.
Does that mean that the end is near for technical book publishers?
Although it is certainly possible that publishing companies will eventually go the way of many developer magazines like Dr. Dobs, I tend to take the more optimistic viewpoint that the technical publishing landscape will simply shift to more fertile grounds.
Instead of continuing to churn out books that are little more than glorified reference materials, I believe that savvy publishers will start seeking out authors who are able to tell a story and convey a deeper understanding of the underlying principals and technologies in a such a way that the knowledge will not be rendered obsolete as soon the next version comes out, the API changes, or an additional layer of abstraction is added.
I think Jon Skeet’s book, C# in Depth: What you need to master C# 2 and 3, is a perfect example of this new breed of book that will thrive despite the ubiquity of search engines, twitter streams, blog rants, and exhaustive online documentation..
Here are some fundamental aspects of the book that Jon got right:
- Narrow Scope – I can’t say how pleased I was to NOT have to contend with an additional 800 pages of basic information on conditional statements and inheritance just to get to the part of the book that I most cared about, the 2.0 and 3.0 features of the language. Just like a large LOC (Lines of Code) count in methods and classes are code smells that indicate a need for refactoring, an excessive number of pages in a book is a clear indication that the book is trying to do too much. I simply won’t consider buying a book that is over 400 pages anymore and it’s not because I have a short attention span (although I do). If the author doesn’t even know what the essence of the book is, then what hope do I have of gleaning it?
- Cohesive Story – Reading a typical Wrox reference style book often feels like reading a dictionary or encyclopedia because the content is organized along more or less meaningless categories. By contrast, this book is organized along several story-like themes. First Jon chose to order the book chronologically and take pains to describe the perceived shortcomings of earlier versions of the language, thus giving a sense for how and why the language evolved. For example, Generics were added in 2.0 to address the performance implications (boxing and unboxing) and type safety issues of using Object as a universal type for methods or collections that dealt with multiple different types. The book also provides a nice cognitive framework for understanding the hodgepodge of 3.0 features by explaining how they are necessary in laying the groundwork for LINQ. Now when I look at a LINQ query, what I really see is a combination of extension methods, lambda expressions, and anonymous types.
- Why Over How– When I first looked at some of the 3.0 syntax, I had trouble even recognizing it as C#. The foreign feeling of the syntax eventually disappeared after repeated use, but the underlying sense of it being some inexplicable magic remained. This book helps dispel that feeling by explaining the underlying mechanics for all the syntactic sugar. For example, Jon shows output from Reflector to demonstrate how the C# compiler translates LINQ queries into the method calls against the new IList extension methods or how it turns anonymous types and anonymous delegates into concrete types with compiler generated names. It’s amazing how much more comfortable I suddenly felt with the syntax once I had a better understanding of what was actually happening behind the scenes.
- Code Samples As Supporting Evidence – If the thesis is that new syntax represents a fundamental improvement in the language, then there is no proof more persuasive than code. Jon does this particularly effectively by taking the time to implement his samples first in 1.1, then in 2.0, and finally in 3.5 so you can easily see how code grows progressively more concise, readable, and expressive with each iteration. This was particularly helpful in the case of delegates, anonymous methods, and lamdas since they all essentially do the same thing but are expressed in vastly different ways. I was never fully sold on lamdas until I saw how many more lines of code was required to do the exact same thing using good old fashioned delegates.
I’m not saying that the book was a perfect piece of literature or that you will walk away from it an instant C# guru. There are definitely some parts on iterators (the yield keyword) and expression trees that I only partially groked (although I think that has more to do with my own limited processing power than any shortcomings in the book).
However, I would definitely highly recommend this book to any .NET developer. In fact, I would classify it as a must-read for any C# developer.
I would also strongly urge any book authors and publishers out there to take some serious notes on the general approach of this book. The rules of the game have changed. I would rather <insert reader comment here> than spend one more dime on another 1000 page dead tree reference.