Eric Lippert is a Principal Developer on the C# compiler team at Microsoft and a member of the C# language design team. His blog, Fabulous Adventures in Coding, is mostly about the design and implementation of programming languages, but also makes occasional forays into subjects he knows next to nothing about, like piano tuning, large-scale electrical power system safety, and relationship advice. He’s also a frequent contributor to the C# tag on StackOverflow. When not writing about programming languages he can be found attempting to keep his tiny sailboat upright in the middle of the Puget Sound.
As someone who reads and edits a lot of programming books, I’m often asked for book recommendations. Here are some of my favorites:
Sams Teach Yourself Visual C# 2010 in 24 Hours by Scott Dorman
I’m not thrilled with the title – I strongly agree with Peter Norvig, who once noted that ten years is more like the amount of time it takes to really master a difficult craft. But I am thrilled with the contents; for the money, this is a really solid book for the beginner C# programmer. What I particularly like about Scott Dorman’s book is that he does not make the pedagogical error made by a lot of other “beginner book” writers of introducing the material in the order he learned it; rather, he introduces the material in order of increasing complexity, even if that does not mimic the historical development of the language.
These two are the books I recommend most often for the intermediate-to-advanced C# developer. Though Mark Michaelis’s book does have a fair amount of information for the beginner C# developer, it best serves either somewhat experienced C# developers or developers experienced in other languages who are coming to C#. StackOverflow legend Jon Skeet’s book assumes that the reader is already familiar with the basic features that have been in the language since C# 1.0. Both books are well-named: Essential C# delivers the essential information you need, and C# In Depth really goes into depth on some of the more obscure corners of the language. Both books concentrate heavily on the C# language itself, with occasional forays into describing the broader .NET infrastructure. I also particularly like Jon’s dry British humor laced throughout the book.
Neither of these books are in any way tutorials for the beginner programmer; rather, each delves into fifty specific and often subtle aspects of achieving high-quality C# coding. These books help the reader understand those language specifics at a deep level. Bill Wagner really gets it; he always explains difficult subjects both clearly and accurately. If you want to read even more about the best (and worst!) practices of C# developers, also check out Bill’s articles on the MSDN Developer Center. These books and Bill’s articles help make good C# programmers into great ones.
The C# Programming Language, 4th edition by Anders Hejlsberg, Mads Torgersen, Scott Wiltamuth and Peter Golde
This is of course the one book I cannot live without; it is constantly open on my desk and full of post-it note annotations. It is the definitive specification and explanation of the C# language, containing more information than even the MSDN documentation on the language. Though you can conveniently download the specification for free, I recommend that people also consider buying the print edition. The print edition is annotated by a large number of C# experts, including myself and the aforementioned Jon Skeet and Bill Wagner. The annotations point out, explain and justify some of the trickier points of language design that the specification itself glosses over.
I’m extraordinarily fortunate in that I’ve had Anders, Mads, Scott and Peter sitting down the hall from me for the last six years. You don’t have that benefit, but the next best thing to being able to ask the design team in person for an explanation of how C# works is to have their book within arm’s reach. Get the specification!
Java Puzzlers by Joshua Bloch and Neal Gafter
One might wonder what on earth is this book doing on my list of books for C# programmers, particularly since I’ve never written so much as a line of Java code. I love three things about this book: First, it was written with such an evident sense of fun. Second, every devious trap that Neal Gafter and Joshua Bloch lead the reader into is actually a lesson for language designers; if the developer is falling into a trap, that’s the fault of the language designers for not making the trap easier to avoid. Third, over half of the pitfalls, traps and corner cases described in this book cause the equivalent C# program to produce a warning or error! The best mistakes to learn from, in language design and in life, are other people’s mistakes.
I am extremely fortunate to have worked with Neal on the C# design and implementation team for several years now, and we enjoy presenting similar C# puzzles to our coworkers and customers; perhaps someday we’ll write a C# Puzzlers book.
These last two books have nothing to do directly with C# at all, but nevertheless I consult them frequently. I see Introduction to Algorithms on many bookshelves in Microsoft offices; there is a reason why people are still hauling around this enormously thick and heavy book from their undergraduate days. It is a great reference when you need to refresh yourself on the details of how to balance a binary tree or deduce the asymptotic efficiency of an algorithm from first principles. Many professional developers with CS degrees do not use the theoretical principles they studied on a daily basis, but we on the compiler team certainly do. And line-of-business software developers can also benefit from having a solid understanding of CS principles.
We are in a bit of a functional programming renaissance right now. Functional languages like F# are gaining in popularity, and ideas from purely functional programming languages are making their way into mainstream object-oriented languages. LINQ in C# and Visual Basic, for example, was heavily influenced by Haskell-style monadic query comprehensions. Also, purely functional data structures work well in highly concurrent programs, which we’re seeing more and more of as many-core machines continue to fall in price. The big thick algorithms book is primarily concerned with traditional data structures full of mutable arrays, stacks, queues and so on; Chris Okasaki’s thin, elegant book is a great survey of how to build some pretty complex data structures out of immutable, threadsafe, memory-efficient parts. A lot of the material in the book is also available in his thesis, which is available online. The comparatively terse syntax of the coding examples of his book take some getting used to for C# programmers; F# programmers will have a much easier time.