The C language is time-honored, and I continue to look forward to mastering it. C has survived my desultory flings with C++ whenever a job description has allowed any choice. Contemporary C, albeit not (officially) strongly typed, partakes of typing and of robust, certified, and “safe” compilers that have become sufficiently effective to mitigate at compile-time many data-type and other “static” hazards.

Lu’s book stands out, among the very large number of extant C books, as one of the few arguably indispensable works that promote genuine mastery of this powerful procedural programming language. An erstwhile prominent aerospace colleague and C expert, Dr. (of physics) Graham Frye, came to mind when I initially perused this book: Graham occasionally wore a “Syntax is destiny” shirt, to which I invariably reacted with “Don’t forget semantics!” This book demonstrates consummate craftsmanship in treating both of these pillars of today’s C, as its sturdy and steady focus is, to an extent that I’ve rarely if ever seen, on the language itself. Though the “carrier environment” (my phrase) of the content is Linux, the latter is merely present unobtrusively; the reader’s time and attention are not squandered at C’s expense.

The four parts, comprising 24 chapters, are preceded by an essentially one-page explication of “Rules in Software Development.” I think that, in the proverbial perfect world, every aspiring, experienced, or veteran software developer should read and practice these rules, which alone are worth the price of this book. The first rule is, “99.9% success is failure.” The last is, “No tools replace a clear mind. ... If you want to be a good software developer, then you need to understand every detail.” (The book makes good on that, given the reader’s due diligence.) The rules in between are equally compelling. I say this in my asymptotic state of being a true believer in, and occasional practitioner of, formal methods (FM) of constructing and verifying software; formal methods are generally agnostic with respect to programming languages, though several FM tools “compile into” C as an object language. I am, furthermore, safe in assuming (non-falsifiably) the late E. W. Dijkstra’s forgiveness for some “operational thinking” (also known as “playing computer”) that this book can in places and of necessity induce, the forgiveness presumably stemming from the book’s rigor, precision, and general excellence.

The 11-chapter Part 1, “Computer Storage: Memory and File,” includes chapters and sections on compilation and execution; stack memory; preventing, detecting, and removing bugs; pointers in C; program writing, “make”-ing, and testing; strings, with programming examples in their use; the C Library; heap storage and programming problems engendered by its use; reading and writing files; and exercises (programming problems).

I believe Algol 60 to be the first procedural, application-programming language to have supported recursion, and consequently to have empowered high-level-language application programming immeasurably. (Dijkstra’s impetus figured large in that “feature’s” inclusion in Algol.) The four chapters comprising Part 2, “Recursion,” treat this perennially difficult and subtle algorithmic facility most clearly and completely. Chapter 12, “Recursion,” provides top-level ideas of challenges where recursive solutions could (and should) be applied, whilst Part 2’s remaining three chapters treat these and more somewhat recursively (my bad pun). The stack, a most fundamental data structure for which C supplies almost natural push and pop instructions, is given its due and then some. And the always-tricky Tower of Hanoi is superbly explicated, using well-explained recursive C functions that show the power of C in this area.

Part 3, “Structures,” is composed of six chapters that explicate programmer-defined types; a detailed treatment of linked lists and the binary search-tree; a pleasantly surprising (to me) exposition of parallel programming, featuring multi-tasking and POSIX threads; and Amdahl’s Law: “Adding more threads has diminishing returns.” Part 3 is the best to-the-point and hands-on treatment of practical parallel programming that I’ve encountered.

Part 4, “Applications,” puts the lessons of Parts 1, 2, and 3 together in applying non-trivial, ultra-instructive maze, image-processing, and (Huffman) encoding algorithms that map ubiquitously to real-life problems. It may give me the courage to confront, for example, image compression prior to reading a whole book on the subject. Ditto regarding viable maze-escape “calculations.”

Appendices A, B, and C, respectively “Linux,” “Version Control,” and “Integrated Development Environments” are, like the rest of the book, quintessentially clear and useful (actionable). Appendix C, which features the Eclipse environment that I’ve been procrastinating in learning, may very well be a painless entrée. (Eclipse is, in particular, also the environment for the Event-B formal modeling language.)

Finally, the well-thought-out coding conventions, as displayed in the many C examples, contribute materially to the clarity and high quality of this outstanding book. If, in analogy with the TV series “Lost,” you land on a desert island that has a Linux computer, this is the one book to have with you.

More reviews about this item: Amazon