C++ x 2
Herb Sutter came to prominence with his "Guru of the Week" posting to the newsgroup comp.lang.c++.moderated. His Exceptional C++ (Addison-Wesley Longman, 2000; ISBN 0201615622), other books; and a regular column in the C/C++ Users Journal showed that Sutter has what it takes to teach C++ both entertainingly and rigorously.
Rigor is a concept relegated to the minority benches in the modern computer technological publishing stream. Do modern comp-sci and comp-eng students even hear the term? In C++ Coding Standards, Sutter and coauthor Andrei Alexandrescu touch ground on each of 101 suggestions (0100 inclusive) for standardization of ways and means in your current C++ project. Welcome back, Herb.
The problem with trendy concepts such as UML, design patterns, and coding standards is that the clue-pursuing majority of working (more or less) programmers who track these trendy concepts tend to think that they mean something in and of themselves. Earth to programmer: They don't mean anything. They're just conveniences of locution, a way of talking about the abstract aspects of computer programming. It's the old Zen finger-pointing-at-the-moon thing: Do you want to gaze at the moon, or do you want to attend FingerCon 2005?
Sutter and Alexandrescu have reached satori. Standard concepts were made for programming, not programming for standard concepts. Everything they note is genuinely an issue, they're not just trying to scare you. All their didaction is informed by vast experience mingled with profound common sense. Standard concept number one, as it were: If you stay engaged, not becoming a codebot, and think about what you're doing as you're doing it, you're likely to have an idea or two about how you are doing it.
C++ Coding Standards is organized into 101 brief topics, each with a pithy title, summary, discussion, examples, exceptions to the rule, and references. Matters start at the mundane and climb towards the ineffable. The three first topics are "Don't sweat the small stuff," "Compile cleanly at high warning levels," and "Use an automated build system." Later, we're into the kozmik stuff like "Prefer providing abstract interfaces" and "Public inheritance is substitutability. Inherit, not to reuse, but to be reused." The authors' suggestions are, at the very worst, mildly suboptimal, while at best, they are sublime. Essentially, they have no methodology to peddle, no panacea to push. They just want to make life easier for you and your maintainers, and to that end, they raise as many questions in the alert reader's mind than they explicitly answer.
One gripe about this otherwise lovely book: The code examples were foolishly set in a rather loopy variable-width font. May we please have plain old typewriter-style, fixed-width in the next edition, please? The fully functional home page for C++ Coding Standards is at http://www.gotw.ca/publications/c++cs.htm.
C++ Template Metaprogramming, by David Abrahams and Aleksey Gurtovoy, is a really good intermediate C++ programmer's paper mentor as that intermediate programmer begins to plumb (appropriate metaphor) the depths of template programming. Templates, m4, PROLOG, the C preprocessor, and the make command, all share that similar quality of an enigma wrapped in a mystery folded into a puzzle. That quality that makes them baffling is their recursive descent through symbolic truth in pursuit of ground truth, be it the logical truth of an assertion, the expansion of a macro, or the resolution and instantiation of a template.
Abrahams and Gurtovy have written something close to a classic in C++ Template Metaprogramming. This book isn't about learning C++ template programming. This book is about conquering the world, nyah-hah-hah, using templates to perform compile-time computation! I could wax ironic about IMMEDIATE words in Forth accomplishing the same thing circa 1972, but instead offer a cheery "Welcome belatedly aboard!" to our brother and sister compiler jockeys.
C++ Template Metaprogramming is marvelous fun to read. It's nothing you really need to know, nothing that you are obligated to learn, neither in terms of the specification of the C++ language nor with respect to the posted requirements of your job. Instead, it's a refreshing walk through the sylvan glades that sprang up magically of their own accord, above and beyond the intentions of the creators, when a Good and Simple Idea (here, the C++ template language) was gratuitously embedded in a programming regimen. In a professional practice increasingly constrained by formality, herded by integrated development environments, straitjacketed by approbated design patterns, isn't it wonderful that unheralded beauty can push through the cracks in the asphalt?
C++ Template Metaprogramming is wholesome, brilliant, expertly written, well laid out, and incidentally offers a great deal of immensely useful practical tips about using and debugging C++ templates. The section on wading through compile-time error messages, which we all know tell you everything and nothing about what went wrong during template expansion, is alone worth the price of admission to those who have never touched base at that particular Rosetta Stone.
The book comes with a CD containing a wealth of material above and beyond the examples in the book, including three code libraries. The book's home page, with errata and workarounds for nonconforming compilers, is found at http://www.boost-consulting.com/metaprogrammingbook.html. Addison-Wesley's page for the book, including sample chapter and index, is at http://www.awprofessional.com/titles/0321227255.
C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
Herb Sutter and Andrei Alexandrescu
Addison-Wesley, 2005
240 pp., $34.99
ISBN 0321113586
C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond
David Abrahams and Aleksey Gurtovoy
400 pp., $44.99
Addison-Wesley, 2005
ISBN 0321227255
Jack is a DDJ contributing editor. He can be contacted at http://www.softwoehr.com/softwoehr/.
And Still More C++...
Review by Jeffrey L. Taylor
The stated goal of Stephen Dewhurst's C++ Common Knowledge is "what every professional C++ programmer needs to know--pared to its essentials so it can be efficiently and accurately absorbed." There are two parts to what Dewhurst is attempting: what to teach and how to teach. He has chosen well "what to teach." Some of the last items may be considered advanced C++ programming, but maybe they shouldn't be. Long division was once a graduate student topic. Now it is for grade schoolers. On the "how to teach," he has also succeeded. I have read the more advanced items elsewhere and did not get much out of them except stretch marks on my brain. By sticking to just the essentials, Dewhurst conveys the core of the concept. A case of less is more. Too much elaboration too early confuses rather than enlightens. With only 250 pages, there isn't room to go on too long.
Writing is an odd business. You can start in on a subject you know and have it fall apart in your hands. For instance, I liked Dewhurst's previous book, C++ Gotchas, but every draft of a review fell apart. After reading C++ Common Knowledge, I understood why this happened. It is hard to write a review that hangs together if the book does not. C++ Gotchas is a collection of items. With C++ Common Knowledge, however, there is a straightforward progression of items that flow one into the next with no wild leaps. C++ Gotchas is like a seminar series with a new speaker each week. C++ Common Knowledge is like a course organized by one person. Some items contain ideas or quotes from other people, but each item generally connects with the previous and following items.
C++ Common Knowledge is aimed at: C experts with little C++ knowledge, new hires with C++ knowledge but little experience, Java programmers moving to C++, and C++ program maintainers who need more breadth. I would add C++ programmers who used to be proficient, but the state of the practice has advanced from under them while they worked in other areas. All groups share a common trait, that bits of the book will be familiar ground. Don't let familiarity breed complacency. Mixed in with the customary are new ways of looking at old items, for instance: "References are Aliases, Not Pointers" (item 5). I admit to this one, references are just pointers with simpler syntax, right? Not quite. And the differences influence code design choices. The key differences are that pointers can be NULL, references must reference (alias) something, and references cannot change what they refer to. Unless lookups cannot fail, they should return pointers, not references.
Part of the brilliance of C++'s design is that numerous features can be used in ways the original designers never anticipated. (Of course, any language can be abused in ways the designers neither anticipated nor would approve of.) Bjarne Stroustrup admits that the decision to have "private," "protected," and "public" affect access--not visibility--was serendipitous. He now sees that the other way around, changing a function from public to private (or the reverse) could quietly change the semantics of a program. For instance, a different function could be called instead of just refusing to compile.
C++ metaprogramming, the topic of the last dozen or so points, was not anticipated when C++ was initially designed 20 years ago. It has been found that some fairly sophisticated conditional compilation can be done without the preprocessor. A class can be queried for certain properties and appropriate code generated at compile time instead of conditionally executed at runtime. These points are a good introduction to the topic because just the core ideas are covered. Having finally understood the essential ideas, I am ready to return to Andrei Alexandrescu's Modern C++ Design and David Abrahams and Aleksy Gurtovoy's C++ Template Metaprogramming.
The insights gained in familiar topics probably will not need to be reread. I expect to return to items new to me several times as I try them out. C++ Common Knowledge is a good book to advance the state of the practice. There are several others--Herb Sutter's books come to mind--each with its own unique contributions and new slants on old topics. I haven't found just one "desert island" selection, but C++ Common Knowledge would be in my desert island box.
C++ Common Knowledge: Essential Intermediate Programming
Stephen C. Dewhurst
Pearson Education, 2005
250 pp., $29.99
ISBN 0321321928
Jeffrey Taylor worked for 30 years in software development. Currently, he is an independent journalist and editor in Austin, Texas, and can be contacted at [email protected].
Jerry Pournelle Recommends...
The computer book of the month is Roderick W. Smith's Linux in a Windows World (O'Reilly & Associates, 2005). If you have an office full of Windows 2000 and NT 4 systems, you have a problem: Microsoft isn't going to be supporting them any more. It's expensive to upgrade to Windows XP, even assuming you don't need any hardware upgrades. You can hope that there won't be any more security hole exploits in 2000 and NT 4--that Microsoft found and plugged them all before abandoning these operating systems--but that's a pretty daring assumption
with an enormous downside if you're wrong. Another alternative is to upgrade through Linux. Because you'll undoubtedly have Windows XP systems as well, you'll need to know what to do next. This book is a good introduction to the subject.
Linux in a Windows World
Roderick W. Smith
O'Reilly & Associates, 2005
496 pp., $44.95
ISBN 0596007582
Jerry is a science-fiction writer and senior contributing editor to BYTE.com. You can contact him at [email protected].
Recent Releases
The Best Software Writing I
selected and introduced by Joel Spolsky
Apress, 2005
350 pp., $24.99
ISBN 1590595009
Essays from 26 author/engineers dubbed well-written, entertaining, and understandable by Spolsky. Subjects cover a broad range of software topics, covering subjects as diverse as strong typing and outsourcing.
The Semiotic Engineering of Human-Computer Interaction
Clarisse Sieckenius de Souza
MIT Press, 2005
312 pp., $40.00
ISBN 0262042207
An account of human/computer interaction that investigates the relationships between computer user and program designer. Semiotics is the study of signs, and the essence of semiotic engineering is the communication between designers and users at interaction time.
USB Complete: Everything You Need to Develop Custom USB Peripherals, Third Edition
Jan Axelson
Lakeview Research, 2005
572 pp., $49.95
ISBN 1931448027
The author has updated this edition to include information about new USB device controller chips, classes, firmware, and application code for Visual Basic .NET and Visual C++ .NET.
Write Portable Code: An Introduction to Developing Software for
Multiple Platforms
Brian Hook
No Starch Press, 2005
272 pp., $39.95
ISBN 1593270569
A concise volume offering plenty of code and practical, real-world applications for cross-platform development.
Advanced Programming in the UNIX Environment, Second Edition
W. Richard Stevens and Stephen A. Rago
Pearson/Addison-Wesley, 2005
927 pp., $74.99
ISBN 0201433079
A reference book for professional UNIX systems programmers--originally authored by W. Richard Stevens, and now revised and expanded by Stephen A. Rago, one of the Bell Laboratories developers who built UNIX System V Release 4. New chapters on threads and multithreaded programming have been added, as well as coverage of the socket interface and interprocess communication.
Contact Us
To contact Dr. Dobb's Programmer's Bookshelf Newsletter, send e-mail to Deirdre Blake, DDJ Managing Editor, at [email protected].
All content copyright 2005, CMP Media LLC.
