Customer Reviews

Code Quality: The Open Source Perspective

5 star:		(1)
4 star:		(2)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

First of all, this author is a serious academic. The book is worth reading and probably will be for a long time to come. It's also a fine production typesetting-wise. The previous review's complain about copy-editing errors in the book is really missing the point, because those could be easily overlooked when you read books of such a grand scale.

The good points aside, however, I'm honestly a little surprised that there was only one review prior to the current one. This seems to indicate it's neither that popular, nor that obviously destined to be a classic, as the author probably had in mind when he was composing it.

One drawback, which it shares with its older sister, "Code Reading" (2003), is a pompous writing style. Lots of words and pages are wasted dwelling on the obvious, and in quite a few spots the way too obvious. Just go through one of those end-of-a-chapter points to take home, you'll know what I mean. As couple of more specific examples, take a look at the gratuitous explanation on omitting the constant factor of the big O notations on p.177; the needless yet painstaking attempt at explaining and justifying usages of charts in log scale on p.13.

This is in sharp contrast to the legendary writing of Brian Kernighan, whose "The Practice of Programming" (1999), "The C Programming Language" (1988), and "The UNIX Programming Environment" (1984) are all greats in professional computing, short, sweet, yet with densely packed knowledge content. They are truly time-tested classics, deserving read, and reread.

This book has a great deal of interesting and practical advice. A few people learn much of this advice through years of experience, but from what I have seen, most do not. This book would be most useful to beginning and intermediate software developers who have not yet discovered the wisdom by trial and error, or experienced developers who want to communicate the information to less knowledgable colleagues in an easily digestible format.
Unfortunately, I was disappointed by by the quality of copy editing. I would have given the book 4 stars otherwise. However, I would still recommend the book, even with the errors, because it's worth it.
I wrote an email to the author, using the email address given on his website, giving in detail the errors I found in the book (First Printing, March 2006).
The author kindly emailed me promptly to inform me that he had added to the errata page the errors I had identified. Thanks to the author for the prompt reply and action.
I hope that A-W and other publishers will do a better job with their proofreading quality, like they used to a few years ago.

Code Quality by Diomidis Spinellis is the follow-up volume to Code Reading. Like the first one, there's a lot of wisdom in the writing, but the Unix/C++ and computer majors will get the most out of it.

Contents: Introduction; Reliability; Security; Time Performance; Space Performance; Portability; Maintainability; Floating-Point Arithmetic; Source Code Credits; Bibliography; Index; Author Index

Spinellis uses examples from open source code and software to discuss what makes for quality code. In most cases, the examples are designed to show what's *not* good. This might include buffer overruns, algorithms that don't scale well, and other various and sundry items. Each chapter ends with an Advice To Take Home section, which recaps all the suggestions and practices in a series of one to two line summaries (with references back to the detailed discussion). Because each chapter pretty much stands alone, you can focus on areas that make the most sense to you in your particular area of interest.

While I'd like to recommend the book without reservations, I feel that certain types of programmers will get more out of it than others. A large number of the examples are based on Unix/C++/Assembler code. In those situations, you will likely understand the concept being discussed, but the details may not be as clear. Also, Spinellis' background as a university professor seeps through, as some of the discussions are best reserved for math or computer science majors.

Is it worth reading? Yes. Just be prepared to work at it...

The book is full of hard-won experience cast nicely into prose. It's a very worthwhile read. The author doesn't shy away from explaining difficult or intricate concepts, where necessary, and each point is illustrated with example code from real systems.

For example, the chapter on Maintainability opens with four attributes of a maintainable system (from ISO/IEC 9126-1:2001) that really struck a chord with me.

Analysability: Finding the location of an error or the part of the software that must be analysed
Changeability: Implementing the maintenance change on the system's code
Stability: Not breaking anything through the change
Testability: Validating the software after the change

I know maintainable code when I see it -- it has a certain feel... Up until now though I've often struggled to express that feeling to non-programmers, or perhaps more importantly, to less experienced colleagues.

Highly recommended.