Developer Books

This page contains short reviews of programming books I would recommend, and also of some high-profile books I bought and found lacking. Please see Developer Links for general programming information and Developer Tools for free and commercial software.

The reviews are split into the following sections:

• General Books
• Windows Books
• .NET 4.0 Books
• .NET 3.0/3.5 Books
• .NET 2.0 Books
• .NET 1.0/1.1 Books
• C/C++ Books

The entries in each section are sorted alphabetically by authors. Each review contains a rating according to the following scheme:

• Four stars (****) – required reading, best choice for the subject matter
• Three stars (***) – recommended reading but other books may be better
• Two stars (**) – sometimes useful but not generally recommended
• One star (*) – useless by any standard, find another book

General Books

• Harold Abelson and Gerald Jay Sussman with Julie Sussman, Structure and Interpretation of Computer Programs, The MIT Press 1996 (2nd ed.), ISBN 0-262-51087-1 — (**) My university didn’t use Lisp as a teaching language, so my experience in this area is limited to some dabbling with PC-Scheme. Impressed by the propaganda of Lisp weenies, I eventually picked up this classic introductory text anyway, expecting some sort of mind-altering out-of-body experience. What I found instead was the mathematically amusing but ultimately pointless exercise of building a usable programming language out of primitive operations and many parentheses. Very cute, but I’d rather use a language that doesn’t require me to design my own type system…

  (Note that this criticism targets the book’s claim to offer an introduction to computer programming in general. I don’t believe Lisp is a good choice here since it reflects neither modern computer hardware nor modern mainstream languages. SICP is of course an excellent book if you are looking specifically for an introduction to Lisp programming.)

• Federico Biancuzzi and Shane Warden, Masterminds of Programming, O’Reilly 2009, ISBN 978-0-596-51517-1 — (**) This is a collection of interviews with the creators of 17 programming languages, ranging from APL to C#. Many important languages are missing – Fortran, Cobol, Lisp, Ada, Pascal – so you should not expect a comprehensive historical overview. What the title and back cover suggest, however, are first-hand insights into the design process of each language and its influence of modern computing. Sadly, only a few sections live up to this claim. While all interviewees share some historical anecdotes, many have never looked beyond their narrow niche, and some have left the field altogether. Others merely snipe at their competitors rather than acknowledging tradeoffs. Still, there is enough interesting material here that you might want to get the book at a discount.
• Frederick P. Brooks, Jr., The Mythical Man-Month, Addison Wesley 1995 (Anniversary ed.), ISBN 0-201-83595-9 — (****) The original 1975 edition is one of the oldest classics in the field of software engineering. The title refers to one of its fundamental tenets: software development cannot be arbitrarily spliced into smaller tasks and assigned to a greater number of workers in order to save time. The 20th Anniversary Edition adds the 1986 essay No Silver Bullet, and a 1995 retrospective on the essay and on the original book. While outdated in many technical details, The Mythical Man-Month is still thought-provoking and valuable for anyone seeking a broader and longer view on our discipline.
• Merrill R. Chapman, In Search of Stupidity, Springer-Verlag 2006 (2nd ed.), ISBN 978-1-59059-721-7 — (***) This amusing book covers “over 20 years of high-tech marketing disasters”, as the subtitle says. The author himself had worked at MicroPro when the company self-destructed as WordStar 3.3 and WordStar 2000 cannibalized each other’s sales. Chapman’s copious anecdotes provide great entertainment to anyone who remembers the days of CP/M, dBase, and OS/2. The second edition has been enhanced with some practical advice on avoiding stupidity. Recommended reading for all nostalgic hackers who still can’t believe how Microsoft emerged as the world’s biggest software company!
• Martin Fowler, UML Distilled, Addison-Wesley 2004 (3rd ed.), ISBN 0-321-19368-7 — (****) The Unified Modelling Language (UML) is a fairly comprehensive collection of diagramming methods for object-oriented software systems. Fowler clearly and concisely describes which diagram types are available, what they are good for, and how they should be used in practice. This book is an excellent antidote to the mountain of hype and scams the UML has spawned, and highly recommended as an introduction for all developers who are experienced in object-oriented languages. The revised 3rd edition covers version 2.0 of the UML.
• Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, Design Patterns, Addison-Wesley 1995, ISBN 0-20-163361-2 — (***) Many years after its original publication, this book by the so-called “Gang of Four” remains the standard reference to basic OOP design patterns such as singletons and object factories. Not particularly well-written, encumbered by poorly chosen examples, and muddled by the idiosyncrasies of C++ and the then-popular Smalltalk, Design Patterns is still recommended until somebody has mercy on OOP developers and writes a better presentation of the subject matter.
• Robert L. Glass, Facts and Fallacies of Software Engineering, Addison-Wesley 2003, ISBN 0-321-11742-5 — (***) Glass presents 55 “facts” that developers and managers should know about software engineering, and ten fallacies that should be avoided. Each entry is annotated with possibly differing opinions, sources and references. Most of the topics are discussed in greater detail elsewhere, e.g. in Code Complete or The Mythical Man-Month, but that does not detract from the value of this book as a concise overview of the tricky parts of software engineering.
• Elliotte Rusty Harold and W. Scott Means, XML in a Nutshell, O’Reilly 2004 (3rd ed.), ISBN 978-0-596-00764-5 — (***) I highly recommend this book for its second half, a very thorough reference to XML and related standards, including XML Schemas, XPath, XSLT, DOM, SAX, and character encodings. I subtract one star for its first half, a rambling mess of annoying open source zealotry, outdated observations on browser compatibility, and descriptions of specialized XML applications that are too long if you don’t need them and too short if you do. Still, there’s some important information to be had even there, and the sheer mass of accumulated knowledge makes XML in a Nutshell the best all-in-one guide to XML.
• Steve McConnell, Code Complete, Microsoft Press 2004 (2nd ed.), ISBN 0-7356-1967-0 — (****) The eagerly anticipated update to this classic book (first published in 1993) finally covers object-oriented design. If you (like me) didn’t read the original Code Complete until recently and thought it outdated and overrated, you should still take a look at the new edition. Much of McConnell’s advice may seem obvious to experienced developers, but even so – seeing it all neatly written up is most helpful for keeping a clear mind and making the right decisions.
• James D. Murray and William van Ryper, Encyclopedia of Graphics File Formats, O’Reilly 1996 (2nd ed.), ISBN 1-56592-161-5 — (***) Although rather outdated and now unfortunately out of print, the Encyclopedia is still the only comprehensive printed work on graphics file formats. Over one hundred formats are described in great detail, and the 230 pages devoted to graphics file fundamentals should prove useful even if the format you’re looking for is not in the book. Check the O’Reilly website for a list of errata.
• Chuck Musciano and Bill Kennedy, HTML & XHTML, O’Reilly 2006 (6th ed.), ISBN 978-0-596-52732-7 — (****) The subtitle calls it “The Definitive Guide,” and for once the hype is right. Musciano and Kennedy cover not only the standards in great depth and clarity but also many popular Microsoft and Netscape extensions. Other extras include a brief overview of XML, a table of HTML character codes, and a cardboard pocket reference. The excellent index rounds out the only HTML guide you’ll ever need.
• Dan Pilone with Neil Pitman, UML 2.0 in a Nutshell, O’Reilly 2005, ISBN 0-596-00795-7. — (****) This very useful quick reference describes all the important diagram types and elements in the current UML revision. The text is concise (sometimes a bit too much so), well-organized, and illustrated with numerous sample diagrams as one might expect. UML beginners might want to start with an introductory book such as UML Distilled, though.
• Aaron Skonnard and Martin Gudgin, Essential XML Quick Reference, Addison-Wesley 2002, ISBN 0-201-74095-8 — (***) This 400-page “quick” reference is actually quite thorough in its description of many important XML concepts and standards. Topics covered include XML basics and namespaces, DTDs, XPath/XPointer/XInclude, XSLT, SAX/DOM, XML Schemas, and SOAP. A great index completes this very useful book. However, Harold and Means’ XML in a Nutshell covers the same material and more, so it’s probably a better choice despite its other shortcomings.

Windows Books

• Raymond Chen, The Old New Thing, Addison-Wesley 2007, ISBN 0-321-44030-7 — (****) An enhanced compilation of material that had previously appeared on Chen’s eponymous weblog, this book contains a cornucopia of amusing and enlightening factoids about the design of Microsoft Windows. Some chapters deal with peculiar low-level APIs that are of little relevance to users of modern programming languages, but every curious geek should delight in Chen’s tales about reserved file names inherited from MS-DOS, the strange behavior of the Windows desktop, or the mind-boggling efforts Microsoft spent on backward compatibility.
• Joe Duffy, Concurrent Programming on Windows, Addison-Wesley 2008, ISBN 0-321-43482-X — (****) Duffy is Microsoft’s resident concurrency expert and maintains an excellent weblog on the subject. This monumental 1,000-page book covers virtually everything you could possibly want to know about multithreading and synchronization, from general principles to the relevant Win32 and .NET APIs. Duffy’s treatment of individual topics within this vast scope is often surprisingly detailed, and always boasts liberal amounts of sample code. The only significant downside is the terrible, or rather nonexistent, editing. Awkward phrases and obvious misprints abound, often distorting the meaning of text and code. Make sure to obtain the (non-exhaustive) list of errata! Regardless, the book is strongly recommended for all Windows developers.
• Sara Ford, Microsoft Visual Studio Tips, Microsoft Press 2008, ISBN 0-7356-2640-5 — (***) As the subtitle says, this relatively thin book contains over 250 tips for Visual Studio 2005 and 2008, not specific to any programming language. All entries are virtually unedited reprints of Ford’s weblog articles, conveniently indexed and grouped by functionality. While certainly not an exhaustive Visual Studio manual, this collection should teach most readers at least a few useful tips they had not known (or already forgotten).
• Lee Holmes, Windows PowerShell Cookbook, O’Reilly 2010 (2nd ed.), ISBN 978-0-596-80150-2 — (****) “Cookbooks” are categorized repositories of useful code snippets. Usually I’m not a big fan of such books as the snippets tend to be obvious or redundant, assuming you know the language and have Internet access. PowerShell is not a usual language, however. Combining a terse and cryptic syntax with numerous built-in keywords, even more library functions, and full access to the .NET Framework, PowerShell offers a multitude of non-obvious approaches to most tasks. That’s why this particular Cookbook makes a great companion to Bruce Payette’s Windows PowerShell in Action.
• Mark Michaelis, COM+ Programming from the Ground Up, Osborne/McGraw-Hill 2000, ISBN 0-07-212045-2 — (***) This book is edited by Herbert Schildt, so you know what to expect: lots and lots of code snippets with the occasional paragraph of text in-between. As a tutorial, COM+ Programming is clearly inferior to Dale Rogerson’s Inside COM (see below). However, I know of no other book that shows how to use the built-in COM support of MS Visual C++ (_com_error and _com_ptr_t). Another strong point is Michaelis’ comprehensive treatment of COM error handling and variant types, making the book a useful reference for specific implementation issues if not a good introduction.
• Bruce Payette, Windows PowerShell in Action, Manning 2007, ISBN 1-932394-90-7 — (****) Payette worked on Unix shells before he went on to co-design Windows PowerShell, Microsoft’s new command-line and scripting environment. As good as PowerShell is, this book is even better. Payette describes a myriad of features without confusing the reader. He writes clearly and entertainingly, provides lots of sensible examples, and his frequent sidenotes on the evolution of the shell’s design contribute greatly to a better understanding of the final result. Mandatory reading for all PowerShell users.
• Charles Petzold, Programming Windows, Microsoft Press 1999 (5th ed.), ISBN 1-57231-995-X — (****) The standard guide to the Win32 API used to be every Windows programmer’s starting point, although raw beginners might prefer a gentler introduction. Today, the majority of new Windows developers will want to use a .NET language, and indeed Petzold’s later books cover .NET technologies exclusively. If you do wish to learn the basic structure of a Windows program written in plain C, Programming Windows should serve as well as ever. However, you should keep the book’s venerable age in mind, and check whether any specific APIs have received updates or replacements in recent Windows versions.
• Jeffrey Richter and Christophe Nasarre, Windows via C/C++, Microsoft Press 2008 (5th ed.), ISBN 978-0-7356-2424-5 — (****) The once more retitled successor to Advanced Windows and Programming Applications for Windows is Microsoft’s second standard guide to the Win32 API and continues where Petzold left off. Richter and Nasarre cover OS fundamentals such as processes and threads, device I/O, memory management, DLL creation, and structured exception handling in great detail. Those who are still using C/C++ today and want to get closer to the system than the .NET Framework allows should find this book invaluable.
• Dale Rogerson, Inside COM, Microsoft Press 1996, ISBN 1-57231-349-8 — (****) This insightful and well-written book is a great introduction to Microsoft’s “Component Object Model.” Rogerson covers the fundamental concepts behind COM as well as important mechanisms such as class factories and dispatch interfaces. He does not go into great detail but he does offer plenty of example code. By and large, Inside COM is probably the best way to get started with COM programming.
• Mark E. Russinovich and David A. Solomon with Alex Ionescu, Windows Internals, Microsoft Press 2009 (5th ed.), ISBN 978-0-7356-2530-3 — (****) The fifth edition of this classic guide to the Windows operating system architecture was updated for Windows Vista and Server 2008. Russinovich is one of the creators of the indispensable Sysinternals utility suite. Accordingly, the book not only describes Windows’ internal mechanisms in great detail, but also shows how to use these and other tools to analyze your own system. If you are curious about any aspect of Windows architecture, this is where to look for answers.

.NET 4.0 Books

Note: .NET 4.0 includes a new CLR version (4.0, skipping a version from 2.0), new language versions (C# 4 and VB 10), and also the new F# language which is based on OCaml. VS2010 actually ships with F# 2, as the language has been around for a while as a Microsoft Research project.

• Joseph Albahari and Ben Albahari, C# 4.0 in a Nutshell, O’Reilly 2010 (4th ed.), ISBN 978-0-596-80095-6 — (****) Covering not only the entire C# 4 language but also many fundamental Framework concepts and classes, this 1,000-page “Desktop Quick Reference” requires a rather sturdy desk! C# 4.0 in a Nutshell is a veritable encyclopaedia of almost any task that commonly occurs during practical C# development. Naturally, the book excludes those large self-contained libraries that are well-documented elsewhere, such as ASP.NET, Windows Forms, WCF and WPF. Still, it is amazing just how many technologies the Albahari brothers do cover: besides the C# language proper, the list includes LINQ, XML, stream I/O, basic networking, serialization, reflection, security, threading, interoperation, and regular expressions. These chapters are no mere MSDN Library excerpts, either. Despite the book’s terseness, all topics are treated with surprising thoroughness, featuring a wealth of practical examples and notes on common usage, potential pitfalls, and relevant implementation details. Once you know the basics of C# and .NET, having all this information in one place is incredibly useful.
• Matthew MacDonald, Pro WPF in C# 2010, Apress 2010, ISBN 978-1-4302-7205-2 — (****) This 1,180-page monster covers the Windows Presentation Foundation in excruciating detail, starting from its technical foundations and then working its way up, in ever broadening circles, to the remotest niches of WPF functionality. Along the way, MacDonald gives a wealth of usage examples and warns about any little snag or issue you might encounter. Adam Nathan’s WPF 4 Unleashed is a better introduction for beginners, but I recommend MacDonald’s more comprehensive book as an excellent guide and reference for advanced WPF programmers.

  (Astute readers may notice that I gave a strong recommendation against MacDonald’s similarly sized WinForms book, Pro .NET 2.0 Windows Forms and Custom Controls. I judged each book based on how far the provided information exceeds the free MSDN Library documentation: very little in the case of Pro Windows Forms, a great deal in the case of Pro WPF.)

• Adam Nathan, WPF 4 Unleashed, Sams 2010, ISBN 978-0-672-33119-0 — (****) You wouldn’t expect such a high-quality publication from Sams, otherwise notorious for an endless stream of “Teach Yourself X in Y Minutes” titles. Nathan is a veteran .NET engineer at Microsoft who treats his subject with deep knowledge and great enthusiasm, and easily imparts both to the reader with his concise and crystal-clear writing. The book also profits from a phenomenal use of layout and color that highlights each detail without impeding the coherence of the whole. The pages might look busy at first, but you will soon come to appreciate the skilful interweaving of text paragraphs, syntax-colored code samples, output illustrations, and various sidebars. WPF 4 Unleashed is highly informative and downright exciting to read – the best introduction to WPF and XAML you can buy.
• Tomas Petricek with Jon Skeet, Real-World Functional Programming, Manning 2010, ISBN 978-1-933988-92-4 — (****) Petricek delivers a well-rounded introduction to the F# language, explaining functional idioms and patterns from the ground up, and with the aid of numerous code samples. In a surprising but very welcome departure from other language tutorials, most samples are also provided in idiomatic C# 4 so that the strengths and weaknesses of each language are immediately obvious. The book remains highly readable even while going into considerable detail on the more obscure corners of the F# language. Strongly recommended to anyone interested in functional .NET programming.
• Jeffrey Richter, CLR via C#, Microsoft Press 2010 (3rd ed.), ISBN 978-0-7356-2704-8 — (****) This is the standard guide to the .NET Framework and required reading for all developers, regardless of programming language or application type. Richter lays the indispensable groundwork required to understand .NET programming, going all the way from high-level C# constructs to the resulting IL code, the CLR’s internal memory layout, and the Win32 functions that make it all work. If you haven’t read this book you might still function as a .NET code monkey for a while, but chances are you won’t know what you’re doing and you’ll constantly be baffled by unexpected behavior. One caveat: Richter’s occasional rants about .NET design decisions and best practices should be taken with a grain of salt, but at least they are clearly set apart from the main text.
• Jon Skeet, C# in Depth, Manning 2010 (2nd ed.), ISBN 978-1-935182-47-4 — (****) This outstanding book is just as good as you might expect, given Skeet’s many excellent web articles on C#. There’s just one big drawback that potential readers should be aware of: C# in Depth does not offer a complete introduction to the C# language, but merely points out a few tricky issues with C# 1 before launching into a comprehensive discussion of the new features in C# 2–4. Frankly, this is a shame because it prevents an otherwise well-deserved recommendation as the best available guide to the C# language. Top-notch in every respect, this book matches Skeet’s pleasant writing and thorough technical understanding with a clear logical structure and impeccable layout. Once you know the basics of C# 1, you should turn to C# in Depth for the best presentation of advanced features such as generics, iterators, lambda expressions, or LINQ queries.

.NET 3.0/3.5 Books

Note: If you’re using .NET 4.0 you should also check the .NET 4.0 section for new and revised titles.

The versioning of these two releases caused some confusion. .NET 3.0 equals .NET 2.0 (C# 2 and VB 8) plus several big “Foundation” libraries (WCF, WPF, etc.) whereas .NET 3.5 introduced new language versions (C# 3 and VB 9) and the smaller LINQ library. I’ve put both releases in the same section since .NET 3.0 did not get a dedicated Visual Studio version (VS2008 jumped from 2.0 to 3.5), so I don’t expect many people to use .NET 3.0 libraries without .NET 3.5 languages. Just keep in mind that books on “Foundation” libraries often use the older language versions, C# 2 and VB 8.

• Brad Abrams and Krzysztof Cwalina, Framework Design Guidelines, Addison-Wesley 2008 (2nd ed.), ISBN 0-321-54561-3 — (****) This book collects the design guidelines that are used internally by Microsoft’s .NET Framework team, but its real value lies in the frequently interspersed comments. Usually once or twice per page, the authors and many of their colleagues (Chris Brumme, Chris Sells, Rico Mariani, Jeff Richter, et al.) describe the intentions behind a guideline, its implications, possible exceptions, and even the team’s internal debates and disagreements. Highly recommended if you want to know why the CLR looks the way it does, and for improving your own .NET coding style.

  The second edition adds 90 pages and covers several new .NET 3.x concepts (LINQ, dependency properties, XAML). The high quality of the first edition is generally sustained but I was somewhat disappointed to find virtually no comments on WPF. This library establishes a new framework that works quite differently than the rest of the BCL, and seems to break a number of the presented guidelines. A comparative discussion of the new WPF design concepts should have been enlightening, and I hope to find one in the next edition.

• Joseph Albahari and Ben Albahari, C# 3.0 in a Nutshell, O’Reilly 2007 (3rd ed.), ISBN 0-596-52757-8 — (****) Superseded by the enhanced fourth edition, C# 4.0 in a Nutshell, reviewed under .NET 4.0 Books.
• Sayed Ibrahim Hashimi and William Bartholomew, Using MSBuild and Team Foundation Build, Microsoft Press 2009, ISBN 978-0-7356-2628-7 — (****) Finally, a good introduction to Microsoft’s new build engine! Only about a third of this book is specific to Visual Studio Team System, which is fortunate for those of us who don’t use it. The greater part covers the regular MSBuild 3.5 which comes with the free .NET Framework SDK and all Visual Studio editions. Lots of examples, lots of information, and strongly recommended to anyone who wants to read or edit MSBuild files.
• Anders Hejlsberg, Mads Torgersen, Scott Wiltamuth, and Peter Golde, The C# Programming Language, Addison-Wesley 2008 (3rd ed.), ISBN 0-321-56299-2 — (**) As with previous editions, this book is mostly a printed version of language specification found in subdirectory VC#\Specifications\1033 of every Visual Studio installation. Both documents have been reorganized to remove the annoying split between language versions that encumbered the second edition. Moreover, the book is now a “Special Annotated Edition” that intersperses comments by various C# experts among the reference text. Unfortunately, these comments are not nearly as numerous or interesting as those in the similarly structured Framework Design Guidelines, and I was rather surprised to find that none of the book’s four principal authors had contributed to them. While somewhat more useful than previous editions, the printed version remains non-essential for most developers.
• Adam Nathan, Windows Presentation Foundation Unleashed, Sams 2007, ISBN 0-672-32891-7 — (****) Superseded by the enhanced second edition, WPF 4 Unleashed, reviewed under .NET 4.0 Books.
• Charles Petzold, Applications = Code + Markup, Microsoft Press 2006, ISBN 0-7356-1957-3 — (**) Together with its 3D companion (see below), this eagerly awaited book marks the end of Petzold’s long career as an authority on practical programming. Announcing his shift to historical and theoretical subjects, Petzold blamed rampant piracy and stingy developers. Those who waste their money on this dreary tome will suspect another reason: Petzold no longer cares about ordinary application programming, and is unable or unwilling to properly explain new technologies in this area.

  Applications = Code + Markup covers GUI and 2D graphics programming based on WPF via C# 2 and XAML. The first and worst problem is the partitioning implied by the title: the entire first half of the book completely ignores XAML! This might not sound so bad – until you realize that WPF was designed from the ground up for use with XAML. The C# API is relatively cumbersome, especially without the new C# 3 object initializer syntax, and only rarely used in practice. Petzold’s attempt to explain the WPF control library while shunning its natural API effectively destroys any value the book might have had, either as an introductory text or as a library reference.

  There are other issues. Petzold’s writing is extremely dry and tedious – as if the author himself had trouble staying awake while going through overly familiar motions. At least half of the 1,000 pages are wasted on uninteresting and repetitive code samples that could have been provided as downloads. Conspicuously missing are any kind of illustrations – the output of those numerous code samples is never shown anywhere. On the upside, Petzold is careful and thorough as usual, so if you do manage to fight your way through his grey walls of text you’ll probably know as much as anyone about WPF. But why bother when Adams or MacDonald cover the same ground just as competently, and with so much more élan?

• Charles Petzold, 3D Programming for Windows, Microsoft Press 2008, ISBN 0-7356-2394-5 — (***) This companion book to Applications = Code + Markup exclusively covers 3D graphics via WPF and XAML. Fortunately, all the problems that plagued the earlier title are absent here: XAML is used extensively right from the start; there’s a wealth of illustrations instead of repetitive code blocks; and the lively writing testifies to Petzold’s active interest in the subject matter. Most programmers won’t need to know about 3D graphics in such depth, but if you do this book should serve you well.
• Chris Sells and Ian Griffiths, Programming WPF, O’Reilly 2007 (2nd ed.), ISBN 0-596-51037-3 — (***) Sells and Griffiths are both veteran Windows Forms developers and writers, and their new WPF title measures up to expectations. Unfortunately, Adam Nathan’s WPF 4 Unleashed is a better introduction for beginners, and Matthew MacDonald’s Pro WPF in C# 2010 is both more comprehensive and more detailed – which means that while Programming WPF is by no means bad, I cannot recommend it over these two titles.
• Jon Skeet, C# in Depth, Manning 2008, ISBN 1-9339-8836-3 — (****) Superseded by the enhanced second edition, reviewed under .NET 4.0 Books.

.NET 2.0 Books

Note: If you’re using .NET 3.0 or later you should also check the .NET 4.0 and .NET 3.0/3.5 sections. These Framework releases introduced several important new libraries and language features.

• Brad Abrams and Krzysztof Cwalina, Framework Design Guidelines, Addison-Wesley 2005, ISBN 0-321-24675-6 — (****) Superseded by the enhanced second edition, reviewed under .NET 3.0/3.5 Books.
• Joe Duffy, Professional .NET Framework 2.0, Wrox (Wiley Publishing) 2006, ISBN 0-7645-7135-4 — (**) Wrox has a reputation for oversized tomes of dubious quality, but I was swayed by the name of Joe Duffy, concurrency expert at Microsoft and prolific blogger. Duffy certainly knows his stuff and gives a competent overview of the CLR and selected parts of the BCL. Unfortunately, he tries to do too much with too little direction. CLR fundamentals are still better explained by Jeff Richter (whose books are curiously missing from Duffy’s copious references), and the BCL chapters are simply too brief to provide any valuable insights. The book may be somewhat useful as a handy one-volume reference to .NET topics, however.
• Eric Gunnerson and Nick Wienholt, A Programmer’s Introduction to C# 2.0, Apress (Springer-Verlag) 2005 (3rd ed.), ISBN 1-59059-501-7 — (***) One of the first .NET 2.0 titles rushed to the market, this poorly edited book is an enhanced revision of Gunnerson’s original introduction to C# 1.0. The most obvious goof is the frequent use of obsolete non-generic collection classes in the code examples, even though the authors explicitly state that generic collections should be preferred. Other errors are rampant throughout the book, ranging from typos to botched grammar, incorrect program data, and entire repeated phrases. Sadly, no corrected edition was published to date.

  In the meantime, even in its present sorry state, the book is actually quite useful for C# 2.0 programmers looking for an overview of that language revision. Gunnerson and Wienholt cover their subject competently and comprehensively, with much appreciated brevity and a highly readable style. They also venture into areas that you wouldn’t expect in an introduction, such as multithreading and dynamic code generation. The book closes with a handy comparison of C# to C++, VB6, and Java. Recommended, as long as you don’t mind the numerous minor errors.

• Sayed Y. Hashimi and Sayed Ibrahim Hashimi, Deploying .NET Applications, Apress (Springer-Verlag) 2006, ISBN 978-1-59059-652-4 — (***) MSBuild is now more extensively covered by Using MSBuild and Team Foundation Build,, written by Sayed Ibrahim Hashimi with a different co-author and reviewed under .NET 3.0/3.5 Books. (I can’t comment on the ClickOnce coverage since I don’t use that technology.)
• Anders Hejlsberg, Scott Wiltamuth, and Peter Golde, The C# Programming Language, Addison-Wesley 2006 (2nd ed.), ISBN 0-321-33443-4 — (**) This language reference is the equivalent of Stroustrup’s The C++ Programming Language and just as unsuitable for beginners. Moreover, the book is merely a printed version of the Word files that come with every Visual Studio 2005 installation (look in subdirectory VC#\Specifications\1033). Indeed, the C# 2.0 addenda (a separate file in that folder) weren’t even merged into the C# 1.0 chapters, so you still have to page back and forth to get the full description of any given language feature. Only buy this book if you find yourself using the electronic reference a lot.
• Matthew MacDonald, Pro .NET 2.0 Windows Forms and Custom Controls, Apress (Springer-Verlag) 2006, ISBN 1-59059-439-8 — (*) This hefty tome covers most, but not all, Windows Forms topics (printing is notably absent) but does so in a rather shallow fashion. Whenever I need concrete information on a Windows Forms task that isn’t adequately covered in the MSDN Library, MacDonald merely seems to reiterate the MSDN documentation while Petzold and Sells give me the extra details and practical advice I need. Pro .NET 2.0 Windows Forms isn’t downright bad, it’s just not very useful – except as a printed overview of the System.Windows.Forms namespace.
• Charles Petzold, Programming Microsoft Windows Forms (2005 Edition), Microsoft Press 2005, ISBN 0-7356-2153-5 — (****) This relatively slim book (382 pages) is intended as an addendum to Petzold’s earlier standard work, Programming Microsoft Windows with C#, which covered version 1.0 of the .NET Framework and Windows Forms. After a rather pointless introduction to .NET programming and a rundown of commonly used controls, Petzold covers the most important new features (dynamic layout panels, tool strips) and some topics that were missing from his earlier book (custom controls, data binding). Well-written as usual, this book is recommended for all Windows Forms programmers, but note that you do need Programming Microsoft Windows with C# as a foundation.
• Steven Pratschner, Customizing the Microsoft .NET Framework Common Language Runtime, Microsoft Press 2005, ISBN 0-7356-1988-3 — (***) The lengthy title reveals little about the surprisingly diverse topics covered in this book. Pratschner explains how to start the CLR from unmanaged code, how to create and use application domains, how to load assemblies into extensible applications, how to customize memory management and the CLR security system, and how to encapsulate unmanaged resources (critical finalization, safe handles, CERs). – As of spring 2006, the last subject is also covered in Jeff Richter’s CLR via C# which somewhat limits the usefulness of Pratschner’s book to the average developer. Still, it remains a valuable resource concerning its other fairly esoteric topics.
• Jeffrey Richter, CLR via C#, Microsoft Press 2006 (2nd ed.), ISBN 0-7356-2163-2 — (****) Superseded by the enhanced third edition, reviewed under .NET 4.0 Books.
• Chris Sells and Michael Weinhardt, Windows Forms 2.0 Programming, Addison-Wesley 2006, ISBN 0-3212-6796-6 — (****) Like its .NET 1.0 predecessor, this book emphasizes the role of Visual Studio’s automatic code creation facilities for Windows Forms development. Fortunately for those of us who prefer the Petzold style of manual coding, Sells and Weinhardt continue to show and explain the generated code. An additional 300 pages in this massively enhanced edition have been put to good use, too. The authors carefully note any important changes in Windows Forms 2.0 and provide very helpful discussions of related subjects such as localized resources and user settings. Strongly recommended for all Windows Forms developers, even including Petzold fans.

.NET 1.0/1.1 Books

Note: If you’re using .NET 2.0 or later you should first check the .NET 4.0, .NET 3.0/3.5, and .NET 2.0 sections. Much of the material written for .NET 1.0/1.1 has been updated for, or obsoleted by, the newer Framework releases.

• Tom Archer and Andrew Whitechapel, Inside C#, Microsoft Press 2002 (2nd ed.), ISBN 0-7356-1648-5 — (*) The book’s outdated first edition, based on a prerelease version of C#, was quite handy as a concise language reference. Unfortunately, Archer and his new co-author Whitechapel decided to “improve” upon this style by padding out their text with lengthy ramblings and misleading examples while ignoring many language details that one would expect to find discussed here. Suffering from poor writing and worse editing, Inside C# is only marginally worthwhile for its treatment of some advanced topics such as “unsafe” code and COM interoperation. Make sure to consult other books on .NET and C# so that your code won’t suffer from the errors and omissions in this one!
• Don Box with Chris Sells, Essential .NET Vol. 1: The Common Language Runtime, Addison-Wesley 2003, ISBN 0-201-73411-7 — (**) This highly anticipated book by COM veteran Don Box, here in cooperation with .NET guru Chris Sells, turned out rather disappointing. The style is atrocious, with the clumsy “one” as the subject of far too many sentences (“one does,” “one sees,” etc.). Box and Sells do cover the CLR thoroughly, but in doing so mostly reiterate Jeff Richter’s better-written Applied Microsoft .NET. However, Essential .NET Vol. 1 provides greater detail on advanced topics such as security, unmanaged code, COM interoperation, and domain & thread control, and is recommended on that basis.
• Siva Challa and Artur Laksberg, Essential Guide to Managed Extensions for C++, Apress (Springer-Verlag) 2002, ISBN 1-893115-28-3 — (****) As the name implies, Challa and Laksberg present Microsoft’s C++ language extensions known as “Managed C++” that let you write C++ programs for the .NET Framework 1.0 and 1.1. Both authors are members of the Visual C++ compiler team at Microsoft, and while they can’t make MC++ any prettier they do give a clear and thorough description of its many ugly features. Required reading for anyone unfortunate enough to work on MC++ code.

  Note: Microsoft had mercy on C++ programmers and replaced MC++ with a much-improved dialect called C++/CLI, beginning with .NET 2.0. This book is therefore only of value for legacy applications written in MC++.

• Dino Esposito, Applied XML Programming for Microsoft .NET, Microsoft Press 2003, ISBN 0-7356-1801-1 — (***) This is an overview of the numerous XML programming interfaces provided by the .NET Framework, ranging from DOM and ADO.NET to XmlReader/Writer, attribute-controlled serialization, web services, and so on. Esposito provides quite a few useful tips, although he spends a little too much time explaining basic XML concepts and elaborating on trivial examples. Regardless, the sheer breadth of its subject range – essentially anything related to XML – makes this book a valuable aid for deciding if and how to use XML in your applications.
• Serge Lidin, Inside Microsoft .NET IL Assembler, Microsoft Press 2002, ISBN 0-7356-1547-0 — (***) Lidin, a member of Microsoft’s Common Language Runtime team, presents a thorough and well-written reference to the CLR and its object-oriented assembly language. Not essential for programmers other than compiler developers, this book is a fascinating look behind the curtain nonetheless. Besides, the ability to write IL programs may come in handy at times, as there is currently no high-level language – not even C# – that can use all CLR features.
• Charles Petzold, Programming Microsoft Windows with C#, Microsoft Press 2002, ISBN 0-7356-1370-2 — (****) Basically the C#/.NET version of the standard guide, there are two noteworthy differences besides the obvious change of programming language and API. While the earlier book served as a general reference to the Win32 API, this one explores only the System.Windows.Forms namespace in any depth and just briefly touches other parts of the .NET Framework. You will definitely need a more general guide (e.g. Jeff Richter’s CLR via C#) to go along with this one. On the other hand, Petzold’s subject treatment is considerably more accessible now, making the new edition a good tutorial even for beginning .NET programmers.
• Jeffrey Richter, Applied Microsoft .NET Framework Programming, Microsoft Press 2002, ISBN 0-7356-1422-9 — (****) Superseded by the renamed second edition, CLR via C#, reviewed under .NET 2.0 Books.
• Chris Sells, Windows Forms Programming in C#, Addison-Wesley 2004, ISBN 0-3211-1620-8 — (***) Covering mostly the same ground as Petzold’s Programming Microsoft Windows with C#, Sells’ book differs chiefly in two aspects: there is little space devoted to .NET fundamentals, which is good; and Sells relies on the Visual Studio .NET “designer” for automatic code creation, which is bad. Fortunately, Sells always explains the generated code and generally concentrates on tasks that the “designer” cannot do. He also goes into many details that Petzold skimmed over – inevitably so, given the scope and complexity of the subject matter – and is therefore recommended in addition to Programming Windows, despite the large amount of overlap.
• Mickey Williams, Microsoft Visual C# .NET, Microsoft Press 2002, ISBN 0-7356-1290-0 — (****) Intended as a general introduction to the C# part of Visual Studio .NET, this book greatly profits from Williams’ clear and concise writing and his amazing attention to detail. The first 300 pages offer the best description of the C# language I’ve yet seen, and the tutorial chapters on broad topics such as Windows Forms, ADO.NET, and XML are packed with useful hints despite their brevity. MS Visual C# .NET is a great way to get started with C#, especially if you’re using Visual Studio .NET – or even if you don’t, as Williams focuses on writing code and treats the powerful VS.NET IDE strictly as an optional aid.

C/C++ Books

Note: Since I am no longer actively using these languages, the reviews in this section only cover publications up to 2001.

• Marshall Cline, Greg Lomow, and Mike Girou, C++ FAQs, Addison-Wesley, May 2000 (2nd edition, 4th printing), ISBN 0-201-30983-1 — (****) The C++ FAQs originated on the comp.lang.c++ newsgroup, but the book version is more detailed and comprehensive than the free text file. Like most C++ literature, C++ FAQs was written with large-scale development in mind; but unlike many other authors, Cline et al. are keenly aware that this mindset isn’t somehow inborn or natural. They clearly explain the projects and situations C++ was created to handle and show why a language feature was introduced rather than just describing it. (FAQ 39.08 even compares small projects to large projects, and points out that both may require different tools and methods.)

  While it’s unlikely that any single person will agree with every single suggestion in this book, most C++ programmers will greatly profit from the sum of background knowledge and practical insight presented here. As a welcome surprise, two chapters deal with COM and CORBA, respectively, outlining the concepts of these technologies and how they interoperate with C++. One stylistic criticism remains: some “questions” are so obviously rhetorical that it’s hard to imagine anyone actually “asking” them, let alone “frequently.” Presenting such topics as regular book sections rather than forcing them into the FAQ corset would have reduced redundancy and improved readability even further.

• Samuel P. Harbison and Guy L. Steele Jr., C: A Reference Manual, Prentice-Hall 1995 (4th ed.), ISBN 0-13-326224-3 — (****) The best reference manual for C89, far superior to Kernighan/Ritchie’s The C Programming Language in my opinion. The 5th edition, published in 2002, also covers the new C99 standard – just in case you find a compiler that actually supports it.
• Nicolai M. Josuttis, The C++ Standard Library, Addison-Wesley 1999, ISBN 0-201-37926-0 — (****) The subtitle says “A Tutorial and Reference,” and indeed Josuttis’ book offers not just a comprehensive description of the Standard Library (including the STL) but also a host of invaluable usage hints and snippets of example code. A great desktop reference, only slightly tainted by occasional stylistic hiccups. Make sure to get a recent printing (5th or up) as early printings were full of errors! The author’s website has a list of corrections for each printing.
• Andrew Koenig and Barbara E. Moo, Accelerated C++, Addison-Wesley, August 2000 (1st printing), ISBN 0-201-70353-X — (****) Most introductions to the C++ language slavishly follow the chapter sequence of Stroustrup’s The C++ Programming Language: start out with elements inherited from C, then proceed to new features such as classes and templates. Accelerated C++ inverts this order so as to better explain the use of the C++ language, rather than its lexical properties. For example, Koenig and Moo introduce the use of template functions and classes (from the Standard Library) early on, saving only their creation for later chapters. This means that the reader has already learned why and how these features should be used before he gets to design his own templates and containers.

  This is a welcome departure from Stroustrup and many other C++ authors who rarely bother to clarify what the language’s more advanced features might be good for, leaving the reader confused and overwhelmed. Koenig’s and Moo’s radically different approach provides an introduction to C++ that is highly recommended to anyone baffled or put off by other C++ literature. With lucid style and flawless organization, the authors present a huge treasure of C++ insights that is both easily accessible and surprisingly compact (336 pages, including a reference section). Perhaps the book’s only drawback is the poorly chosen example project: a student grading database is not only deathly dull, it’s also less than intuitive to foreign readers who are unfamiliar with the American school system. However, that should not deter anybody from perusing this exemplary language tutorial.

• Peter van der Linden, Expert C Programming, Prentice Hall (SunSoft Press) 1994, ISBN 0-13-177429-8 — (****) This is the best programming book I’ve ever read. Van der Linden explores the depths of C with equally great insight and humor. This book will tell you everything you ever wanted to know about C, from unscrambling obscure declarations to the exact relationship between pointers and arrays. In addition, a quick overview of C++ explains how the two languages differ in concept and implementation, in spite of their superficial similarities. Despite all the claims made about C++ being a “better” C, many of the criticisms and warnings aimed at C remain unresolved in C++ and still require careful attention. Expert C Programming is only outdated in a few places discussing MS-DOS specifics. Every developer using either C or C++ should own a copy of this extraordinary book.
• Scott Meyers, Effective C++, Addison-Wesley 1998 (2nd ed.), ISBN 0-201-92488-9, and More Effective C++, Addison-Wesley 1996, ISBN 0-201-63371-X — (****) Meyers’ books describe many advanced techniques and dark corners of the C++ language, from initialization order to smart pointers to redefining new/delete. Beginners should note that due to the arcane nature of many topics and Meyers’ rather dense writing style, (More) Effective C++ is not as accessible as Accelerated C++ or C++ FAQs. Also, some recommendations smack of zealotry rather than sound advice, such as Meyers’ dislike of the preprocessor and C-style comments. Nevertheless, both books contain a wealth of in-depth information that every C++ programmer should find useful.
• Scott Meyers, Effective STL, Addison-Wesley 2001, ISBN 0-201-74962-9 — (****) An even better book than (More) Effective C++, Effective STL is both more readable and more relevant to actual programming. C++ is a complex language in its own right, and STL stretches it to the limits. While very convenient when it works, this combination can cause maddening bugs when it doesn’t. Meyers shows how to avoid nasty pitfalls from parsing errors to pointer problems, and even teaches how to decipher STL-related compiler diagnostics. Unless all of your STL programs work at first try, you need this book.
• Bjarne Stroustrup, The C++ Programming Language, AT&T 2000 (special ed.), ISBN 0-201-70073-5 — (***) The “special edition” is the 3rd edition with two new appendices (Locales, Standard Library Exception Safety) and a hardcover binding so that it stays open on your desk. The C++ Programming Language is a necessary reference manual but definitely not recommended as an introduction to the C++ language. See Accelerated C++ for a good introductory book.
• Herb Sutter, Exceptional C++, Addison-Wesley 1999 (1st printing), ISBN 0-201-61562-2 — (***) In his foreword, Scott Meyers calls Exceptional C++ “the first book ever written for people who are already familiar with […] all of C++,” and that’ s not an exaggeration. Sutter’s book is a compilation of C++ programming puzzles and solutions based on the regular “Guru of the Week” feature on Usenet group comp.lang.c++.moderated. Some topics are just too obscure and sometimes the discussion is more opinionated than helpful, but overall this book is a good follow-up to (More) Effective C++, shedding some light on yet more of C++’s many subtleties.