Developer Books

This page contains short reviews of programming books I would recommend, and also some I found lacking. Please see .NET Books for books covering Microsoft Windows and the .NET Framework.

The entries in each section are sorted alphabetically by title. Each review contains a rating of 1–4 stars, according to the following scheme:

  • ****— Required reading, best choice for the subject matter
  • ***— Recommended reading but other books may be better
  • **— Sometimes useful but not generally recommended
  • *— Useless by any standard, find another book

As I usually do some research before buying a book, there are currently no one-star ratings here.

General Books

Code Complete — Steve McConnell, 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.

Design Patterns — Erich Gamma, Richard Helm, Ralph Johnson & John Vlissides, 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.

Facts and Fallacies of Software Engineering — Robert L. Glass, 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.

Masterminds of Programming — Federico Biancuzzi & Shane Warden, 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 do 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.

The Mythical Man-Month — Frederick P. Brooks, Jr., 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 the art of building software.

In Search of Stupidity — Merrill R. Chapman, 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!

Structure and Interpretation of Computer Programs — Harold Abelson & Gerald Jay Sussman with Julie Sussman, 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: 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. It’s an archaic language that reflects neither modern computer hardware nor modern software design, whether functional or imperative. SICP is of course an excellent book if you are looking specifically for an introduction to Lisp.)

Algorithm Books

Algorithms — Robert Sedgewick & Kevin Wayne, Addison-Wesley 2011 (4th ed.), ISBN 978-0-321-57351-3

**** This single volume replaces Sedgewick’s two-volume classic Algorithms in C/C++/Java, now without the language designator since Java is used exclusively. The associated booksite offers a chapter overview, excerpts from the printed text, dynamic visualizations, some exercise solutions, and all Java code for download.

The book’s content is largely identical to the previous edition, except rearranged and somewhat enhanced. The total page count shrank from 1,234 to 955 pages, but this is offset by a greater line width (3rd ed. had extremely wide margins). As before, topics include general data structures, sorting & searching, and graph algorithms. Of the originally planned third volume on strings, computational geometry, and advanced algorithms & applications, strings and applications do appear as new chapters, but reuse some existing material such as radix search and B-trees. Computational geometry was dropped altogether, except for a few code samples.

At present I’ve only used the third edition extensively, so my recommendation is based on that and a first impression of the new edition. Algorithms in Java was my standard reference for basic algorithms thanks to Sedgewick’s clear and practical explanations, lavish visualizations of run-time behavior, and of course the ready-to-run code snippets. The extensive mathematical analyses that haunt other algorithmics textbooks are blissfully absent – Sedgewick stays focused on the needs of implementors. Sadly, the fourth edition was published with numerous printing errors so I strongly suggest going through the list of errata before you begin using this book.

Algorithms in a Nutshell — George T. Heineman, Gary Pollice & Stanley Selkow, O’Reilly 2016 (2nd ed.), ISBN 978-1-491-94892-7

**** This fairly slim book covers the basics of algorithmics and benchmarking, and also provides pseudocode and implementations (in C/C++, Java, and Python) for nearly 40 important algorithms. The major drawback is obvious when you consider that this mass of information was crammed into a mere 380 small-format pages: explanations can be abbreviated to the point that understanding suffers, and much implementation code was omitted from the print edition to save space. You’ll need to download the full repository from GitHub to get actual working code.

So while your first choice for a practical guide to algorithms should still be Sedgewick’s classic, the unique strength of Heineman et al. is the sheer number of described algorithms, many of which are poorly covered elsewhere. Aside from the expected standard entries on sorting & searching and graphs, you will find an entire chapter on game AI including turn evaluation (alpha-beta, minimax) and path searches (A*, breadth-first, depth-first), another chapter on network flow algorithms, and two chapters on computational geometry. That field was much enhanced in the 2nd ed. and now comprises convex hulls, line-segment intersections, line-sweep, and Voronoi diagrams, as well as spatial tree structures.

Some other unusual choices include Bloom filters, approximation and probabilistic algorithms, and a parallel quicksort. Most algorithms are helpfully illustrated by graphs on their empirical behavior and runtime performance. All told Algorithms in a Nutshell is a surprisingly well-stocked treasure trove that makes an excellent companion to a more basic introductory book.

Computational Geometry — Mark de Berg, Otfried Cheong, Marc van Kreveld & Mark Overmars, Springer-Verlag 2008 (3rd ed.), ISBN 978-3-540-77973-5

**** This book has a well-deserved reputation as the best guide to its field. The authors lucidly explain a broad selection of standard algorithms and data structures, including real-world motivations, numerous visualizations, and snippets of pseudocode. There’s just one problem: the cognitive distance between an intuitive understanding of geometric algorithms and their actual programming is enormous. Computers only manipulate numbers, not shapes. Bridging this fundamental gap requires a surprising amount of effort, especially once you consider tricky issues like floating-point imprecision or run-time performance. De Berg et al. provide very little help here, and you might well despair trying to build working implementations of these nicely presented algorithms.

One option is to search the Internet for existing implementations, e.g. in my own Tektosyne library. The other is to obtain two older books, Computational Geometry and Computer Graphics in C++ by Michael J. Laszlo (Prentice-Hall 1996, ISBN 0-13-290842-5) and Computational Geometry in C by Joseph O’Rourke (Cambridge University Press 1998, 2nd ed., ISBN 0-521-64976-5). To my knowledge, these are the last printed books on computational geometry that include concrete working code. They cannot replace de Berg et al. as their coverage is relatively fragmentary, but they are invaluable as a demonstration of how to move geometric algorithms from specification to implementation.

2016-06-21: The second edition of Algorithms in a Nutshell by Heineman et al. (see above) has greatly expanded its coverage of computational geometry and now includes working code for spatial tree structures and Voronoi diagrams, in addition to convex hulls and line-segment intersections. This should now be your starting point if you’re looking for implementations.

Java Books

This section is focused on Oracle’s Java Standard Edition (SE) distribution.

Core Java, Volume I: Fundamentals — Cay S. Horstmann, Prentice Hall (Oracle) 2015 (10th ed. for Java SE 8), ISBN 978-0-13-417730-4
Core Java, Volume II: Advanced Features — Cay S. Horstmann, Prentice Hall (Oracle) 2016 (10th ed. for Java SE 8), ISBN 978-0-13-417729-8

**** These 1000-page tomes originated as Sun’s official guide to the Java platform and continue to serve that role for Oracle’s JDK releases. Readers should have some programming experience, preferably C/C++ as one of Core Java’s strengths is highlighting the semantic differences between these syntactically similar languages. Horstmann (now without previous co-author Gary Cornell) thoroughly covers not only JVM fundamentals and Java language features, but also external aspects ranging from JAR deployment to native interoperation, as well as many important standard library frameworks.

Java 8 features added to the 10th edition include lambda expressions, parallel array algorithms, completable futures, streams, and the new date & time API. One major omission is JavaFX which is completely ignored in favor of the older AWT/Swing framework. Apparently in order to hit the 1000-page limit, volume II has also dropped the previous edition’s chapters on Distributed Objects (RMI) and JavaBeans Components. Moreover, compared to Horstmann’s earlier Impatient books (see below) the new Nashorn JavaScript engine is barely mentioned. I would rather see the 600 pages on AWT/Swing moved into another volume to make room for more essential topics. Was it wise to elide JavaBeans in favor of an extensive tutorial on Swing tree controls?

Regardless, I still recommend Core Java for its wide-ranging yet detailed coverage of most subjects conceivably of interest to Java programmers. The writing is concise and pleasant, abounding with practical examples and helpful advice. Horstmann is to be commended for not just adding sections on Java 8 but revising the book throughout for the new edition. Several topics were rearranged or expanded, the list of errata is moderate for a book of this size, and last not least the previous edition’s bizarre crusading for the obsolete Java browser plugin was finally dropped. Now Horstmann only needs to overcome his irrational fear of Windows file paths with embedded spaces [p.20]…

Note that Horstmann has already published two excellent shorter books on Java SE 8: Java SE 8 for the Really Impatient covering only new features, and Core Java for the Impatient which is essentially a condensed version of Core Java. They provide very useful overviews for those who don’t want to dig through 2,000 pages of material, as well as more material on Nashorn.

Core Java for the Impatient — Cay S. Horstmann, Addison-Wesley 2015 (for Java SE 8), ISBN 978-0-321-99632-9

**** This 480-page book is a compromise between Horstmann’s brief introduction Java SE 8 for the Really Impatient (215 pages) and the traditional monumental Core Java tomes (2092 pages for Java SE 7). Rather than covering virtually the entire standard library and JDK toolset, For the Impatient focuses on essential functionality that should be relevant to any project, whether end-user application or web server component. Specifically, the following Core Java topics are missing entirely: graphics & user interfaces (both AWT/Swing and JavaFX), deployment & security, JavaBeans, XML, networking, databases, distributed objects, and native methods.

That accounts for about 1,100 pages, so the remaining coverage shrank by half to reach the new 480-page size – and that’s ignoring the new Java SE 8 features. While For the Impatient is neither a beginner’s tutorial nor an exhaustive reference, the covered subjects are for the most part sensibly selected and treated with surprising thoroughness. Horstmann crams an incredible amount of essential knowledge and useful tips into the available space. The discussion of streams nicely elucidates this powerful but unconventional new API, and Horstmann delivers the best concise explanation of wildcard variance in Java’s obscure generics I’ve seen yet. Lambda expressions are treated as a special case of interfaces, which is unusual but makes perfect sense: both are contractual specifications for behavior, and Java even defines lambdas in terms of “functional interfaces.”

I was a bit baffled by the extensive coverage of annotations and the new Nashorn JavaScript engine. Typically only specialist tool creators write their own annotations, and only web developers integrating existing JS code would care about Nashorn. The contents of these chapters are as good as the rest, though. Editing is solid as well: I found only a handful of typos in the sample code, none in the text. A good overview before moving on to the full Core Java.

Effective Java — Joshua Bloch, Addison-Wesley 2008 (2nd ed.), ISBN 978-0-321-35668-0

**** This is not just the best book on Java, but one of the best I’ve read on any programming subject. Every Java developer will benefit from Bloch’s solid advice and thorough exploration of language quirks, on a par with classic namesake Effective C++. Unlike that collection of arcana, however, Bloch’s lucid writing and broad coverage of essentials also make Effective Java a great introduction for users of other languages. Buy this book as soon as possible, even if you don’t buy any other Java books.

Java SE 8 for the Really Impatient — Cay S. Horstmann, Addison-Wesley 2014, ISBN 978-0-321-92776-7

**** As the name implies, this rather slim book gives a compact overview of new features in Java SE 8, as well as some of the more obscure changes in Java SE 7. Horstmann is as thorough and readable here as in his Core Java tomes. He describes not just marquee features like lambdas that have been widely covered elsewhere, but also small important additions such as methods for unsigned arithmetic that I had been quite unaware of. The wisdom of compressing JavaFX into 30 pages is debatable, but Horstmann did take the opportunity to mention root em sizing.

What’s more, he finally admits that the Java browser plugin is a security risk whose time has passed. If anything he swings too far in the opposite direction, recommending HTML5 for targeting “a general audience” because “Java is no longer a viable platform for widespread distribution of client applications over the Internet.” True for mobile users but private JRE deployment still works fine for desktop users. Be that as it may, every Java programmer upgrading to SE 8 should benefit from this very useful book.

2015-03-10: Horstmann has now published the more extensive Core Java for the Impatient, also covering Java SE 8. Since that book is for the most part a superset of For the Really Impatient, I would recommend getting the new book instead.

The Well-Grounded Java Developer — Benjamin J. Evans & Martijn Verburg, Manning 2012, ISBN 978-1-617290-06-0

** A strange hodge-podge of chapters on wildly different subjects, this book isn’t outright bad as much as mistitled and unfocused. Read Horstmann & Cornell’s Core Java and Joshua Bloch’s Effective Java if you want to become a “well-grounded Java developer.” What Evans & Verburg offer instead is a brief tour of Java 7 innovations, low-level JVM features, alternative JVM languages, and some popular frameworks.

There’s no discernible rhyme or reason to the selection of chapter topics, giving the strong impression that the authors simply pooled whatever articles they had already lying around. Those articles themselves are quite readable and informative, but due to the random spread of topics only a few may be useful to any particular reader. You’ll want to get this book at a discount, if at all.

HTML Books

This section covers HTML itself as well as related technologies, in particular CSS and JavaScript.

CSS: The Missing Manual — David Sawyer McFarland, O’Reilly 2015 (4th ed.), ISBN 978-1-491-91805-0

**** McFarland’s eminently practical book explains the structure and features of CSS from the perspective of a raw beginner. This does lead to some amusing baby steps, such as the introductory section on “mouse clicks,” but don’t let that deter you. McFarland quickly proceeds to in-depth discussions of selectors, spacing, float-based layout, responsive design, and any other CSS topic of importance, including plenty of good advice on unexpected behavior and browser compatibility.

The fourth edition is largely unchanged in content and structure from the third edition (called CSS3: The Missing Manual), with the exception of page layout coverage: two chapters on CSS grids and flexbox are new, the chapter on styling for print is gone. Most web developers probably won’t miss it. Editing has improved dramatically: while there are still a number of errata, as expected in a 700-page book, this does not compare to the flood of obvious errors in the third edition.

One factual mistake left over from that edition is the claim that “web browsers don’t know how to hyphenate long words” (p.164) which is currently only true for Google’s browsers. That minor point aside, I recommend CSS: The Missing Manual for anyone who needs to style HTML content.

Effective JavaScript — David Herman, Addison-Wesley 2012, ISBN 978-0-321-81218-6

**** Herman’s slim but excellent book easily holds its own next to Effective… classics by Joshua Bloch (Java) or Scott Meyers (C++). He expects some JavaScript experience but covers that language’s many perversions so lucidly and thoroughly that I would also recommend his book as an introduction for programmers versed in other “curly braces languages.” All the seemingly absurd patterns in professional JavaScript code, like anonymous functions that are immediately executed, will finally make sense. Read this book if you have to deal with JavaScript in any capacity whatsoever.

HTML & XHTML — Chuck Musciano and Bill Kennedy, 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, a cardboard pocket reference, and last not least an excellent index.

Note: The current edition only covers HTML up to version 4. A new edition for HTML5 was once announced for July 2014, but at the time of this writing (May 2016) it has yet to be published.

HTML5: The Missing Manual — Matthew MacDonald, O’Reilly 2013 (2nd ed.), ISBN 978-1-449-36326-0

*** This is not a complete HTML5 reference, which would be difficult anyway for a “living standard” comprising many disparate technologies. Instead, MacDonald assumes his readers already know HTML 4 and focuses on new features introduced since then, whether in HTML5/CSS3 or as JavaScript libraries. His coverage usually takes the form of overviews with extensive tutorials and usage tips, plus numerous links to related articles and tools. Such overview books often are too brief and vague to be useful, but refreshingly that’s not the case here. MacDonald’s writing is certainly concise, but also densely packed with relevant and often surprising information.

I did notice two strange omissions that readers should be aware of. First, MacDonald briefly mentions RDFa but not its extremely widespread OpenGraph derivative. Second, MacDonald advises using normal ems instead of CSS3 “root ems” on grounds of IE7/8 compatibility. Jonathan Snook’s trick of combining px with rem would seem preferable. That aside, I can recommend HTML5: The Missing Manual, at least until Musciano & Kennedy deliver their promised HTML5 guide.

JavaScript: The Good Parts — Douglas Crockford, O’Reilly 2008, ISBN 978-0-596-51774-8

** Until David Herman’s Effective JavaScript, Crockford’s 150-page overview was the standard primer on the language’s unusual capabilities and shocking defects. Unfortunately, Crockford wastes much of his limited space on pointless grammar diagrams, excessive code samples, and overly specific API references. While he does eventually get around to explaining JavaScript’s distinctive features (for good or bad), Herman does a far better job there and has essentially obsoleted Crockford’s classic.

C/C++ Books

Archive Note: I haven’t updated my C/C++ bookshelf since 2001, so these reviews are rather old.

Accelerated C++ — Andrew Koenig & Barbara E. Moo, Addison-Wesley, August 2000, 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.

C++ FAQs — Marshall Cline, Greg Lomow & Mike Girou, 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.

The C++ Programming Language — Bjarne Stroustrup, 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.

C: A Reference Manual — Samuel P. Harbison & Guy L. Steele Jr., 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.

The C++ Standard Library — Nicolai M. Josuttis, 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.

Effective C++ — Scott Meyers, Addison-Wesley 1998 (2nd ed.), ISBN 0-201-92488-9
More Effective C++ — Scott Meyers, 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.

Effective STL — Scott Meyers, 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.

Exceptional C++ — Herb Sutter, 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.

Expert C Programming — Peter van der Linden, 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.

Other Books

Essential XML Quick Reference — Aaron Skonnard & Martin Gudgin, 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.

UML 2.0 in a Nutshell — Dan Pilone with Neil Pitman, 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.

UML Distilled — Martin Fowler, 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.

XML in a Nutshell — Elliotte Rusty Harold & W. Scott Means, 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.