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.
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.)
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 and Networking for Computer Games — Jouni Smed & Harri Hakonen, Wiley 2017 (2nd ed.), ISBN 978-1-119-25976-3
**** As the title indicates this book comprises two major parts, with about 220 pages presenting a broad variety of general algorithms, and another 70 pages on architecture and algorithms for networked games. The first part covers just about any game-related algorithm you might expect and then some: generation of random numbers, noise, and game levels; search trees and pathfinding; group movement in flocks or formations; and decision-making based on exact or uncertain information.
The presentation is nothing short of brilliant. Smed & Hakonen give any required theoretical underpinnings without excessive formal baggage before moving on to richly illustrated examples and pseudocode implementations. An extensive appendix provides the necessary minimum of linear algebra, as well as a definition of the book’s pseudocode language. The latter is precise enough to translate directly and almost completely into actual code, with little extra work left to the programmer.
The networking part covers communication layers, compensation for resource limitations, cheating prevention, and online metrics. I can say little about that, as networking is not my area of interest or expertise. My impression was that it is as solid as the rest, though, and I can certainly give my strongest recommendation for the algorithms part. Anyone writing code for computer games should have 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 rich 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.
This section is focused on Oracle’s Java Standard Edition (SE) reference implementations.
Core Java, Volume I: Fundamentals — Cay S. Horstmann, Pearson Education 2018 (11th ed. for Java SE 11), ISBN 978-0-13-516630-7
Core Java, Volume II: Advanced Features — Cay S. Horstmann, Pearson Education 2018 2016 (11th ed. for Java SE 11), ISBN 978-0-13-516631-4
**** These two 900-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 thoroughly covers not only JVM fundamentals and Java language features, but also external aspects ranging from JAR packaging to native interoperation, as well as many important standard library frameworks.
Due to a new release cadence after Java SE 8, this edition covers the next three Java versions including the current long-term support release, Java SE 11. The only substantial new feature in all three versions is the Java 9 module system which got its own 30-page chapter. Nevertheless, Core Java is nearly 250 pages shorter than the previous edition which had already dropped coverage of Distributed Objects (RMI) and JavaBeans components. One obvious cut was the chapter on Deploying Java Applications since Java 11 removed the deployment stack.
For less obvious reasons, Swing/AWT suffered the rest of the damage. Gone are the introduction to Swing’s Look & Feel mechanism – confusingly still referenced elsewhere! – as well as Volume II’s sections on lists, layers, progress indicators, special panes, advanced text components, and platform integration including the clipboard and drag & drop. Given the extent of these cuts, it is unclear why any Swing/AWT chapters remain at all. Ideally the 10th edition’s coverage should be republished as a separate book. Meanwhile all GUI developers should keep Volume II of the 10th edition indefinitely.
There are also some defects regarding Java SE 10 and 11, suggesting a rushed publication. The table “Evolution of the Java Language” omits both versions, the Java 10
@summary comment tag and the very important Java 11 Oracle license change are not mentioned, and Java 11’s removal of the Lucida fonts is ignored. Unrelated but annoying, the section on Java Mail – long since in an external Java EE repository – still directs users to an obsolete Oracle URL.
Regardless, Core Java remains the best comprehensive printed resource for Java programmers, with a wide-ranging yet detailed coverage of subjects relevant to practical development. As usual all material has been revised as needed, with tips for Java 9–11 sprinkled throughout. Horstmann’s writing is ever concise and pleasant, abounding with practical examples and helpful advice. A mandatory investment.
Core Java SE 9 for the Impatient — Cay S. Horstmann, Pearson Addison-Wesley 2017 (2nd ed.), ISBN 978-0-13-469472-6
**** The Impatient series condenses the traditional monumental Core Java tomes (2,072 pages for Java SE 8) into a single book a quarter the size – 538 pages for Java SE 9, 480 pages for the first edition on Java SE 8. Rather than covering most of the 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. Several big Core Java topics are largely or entirely absent, including graphics & user interfaces, networking, security, databases, and native methods. The remaining coverage is abbreviated as well.
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. There are excellent concise explanations of complex issues such as higher-order functions, race conditions, stream operations, and wildcard variance in generics. The second edition was revised throughout and adds a chapter on the new module system – once again the best description of this subject I’ve yet seen.
Effective Java — Joshua Bloch, Pearson Addison-Wesley 2018 (3rd ed.), ISBN 978-0-13-468599-1
**** 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 and library 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.
The third edition adds 50 pages with twelve new or substantially enhanced sections on features introduced by Java SE 7 through 9, as well as some unrelated additions and minor revisions throughout the book. Dustin Marx has compiled all these changes in detail. Coverage is up to the usual high standard, with the exception of Java 9 modules which receive just a single page; Bloch argues that their usefulness beyond the JDK itself is still unclear. All told this is a welcome update of an outstanding book.
Java SE 8 for the Really Impatient — Cay S. Horstmann, Addison-Wesley 2014, ISBN 978-0-321-92776-7
**** As the name implies, this slim 215-page 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, as well as Java SE 9 in the second edition. Since that book is for the most part a superset of For the Really Impatient, I would recommend getting the new book instead.
JavaFX 9 by Example — Carl Dea, Gerrit Grunwald, José Pereda, Sean Philips & Mark Heckler, Apress 2017 (3rd ed.), ISBN 978-1-4842-1960-7
**** For the most part this book does exactly what its title says. Dea et al. walk the reader through all the major features of JavaFX, from simple graphics and property binding to scene layout (including a short Scene Builder demo), standard controls, imaging and printing, audio and video, plus dedicated chapters on interfacing HTML and HTTP, custom UI themes, and the recently added 3D subsystem.
Several chapters you probably wouldn’t expect cover the use of JavaFX with unusual hardware: running JavaFX on mobile phones and embedded devices using JavaFXPorts, gesture input using the Leap Motion 3D controller, and even connecting to the Arduino microcontroller board from a JavaFX application! The latter isn’t entirely frivolous either, as it serves to demonstrate drawing line charts in response to real-time inputs.
Another unexpected but helpful chapter discusses the Java 9 module system, including the new modular structure of JavaFX and building modular applications. The only sections that don’t really have a place in an “intermediate to advanced” book (as per the back cover) are those on installing the JDK and NetBeans, especially as NetBeans is unfortunately the one IDE that still doesn’t have an official release for Java 9. That aside, I recommend this highly readable book to anyone learning about JavaFX in general or one of the covered topics in particular.
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’s Core Java and 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.
CSS: The Definitive Guide — Eric A. Meyer & Estelle Weyl, O’Reilly 2017 (4th ed.), ISBN 978-1-449-39319-9
**** The long expected update to a classic last revised in 2006, this massive tome is certainly definitive in size and detail. More than a thousand pages cover every esoteric wrinkle of CSS anyone might possibly want to know about, including latest additions to the standard that are not yet widely supported.
Unlike McFarland’s CSS: The Missing Manual with its tutorial-oriented approach, CSS: The Definitive Guide acts more as an encyclopedia. Reading it from start to finish would be tedious and pointless; it’s the book to have around when you need to look up some specific CSS behavior. For that purpose it is excellent, thanks to good writing, many examples in both code and output, and of course extremely thorough coverage.
The one substantial downside is pervasive poor editing. Some amusing sections copied from older editions still refer to Windows XP as a “modern” OS, and one section advises against specifying sizes in px because they might map to single screen pixels on high-density screens. That hasn’t been true for a long time, and most of the book correctly uses px for sizing. A confusing habit is stating “this text does not cover X” when X is in fact covered somewhere else in the book, just not in the current chapter. Proper cross-references rarely exist.
There are also a number of erroneous numbers and phrases that are obviously typos but can be quite confusing at first glance. If something doesn’t seem to make sense, check the errata and especially the unconfirmed ones, as the authors rarely bother to confirm reported errors. Still, there is no equivalent book with better editing so it gets my recommendation.
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.
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
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
rem would seem preferable. That aside, I can recommend HTML5: The Missing Manual, at least until Musciano & Kennedy deliver their promised HTML5 guide.
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.
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.