Code Reading: The Open Source Perspective (Effective Software Development Series) (v. 1) (Paperback)

by Diomidis Spinellis (Author)

Editorial Reviews

Product Description
This book is a unique and essential reference that focuses upon the reading and comprehension of existing software code. While code reading is an important task faced by the vast majority of students, it has been virtually ignored as a discipline by existing references. The book fills this need with a practical presentation of all important code concepts, form, structure, and syntax that a student is likely to encounter. The concepts are supported by examples taken from real-world open source software projects. The focus upon reading code (rather than developing and implementing programs from scratch) provides for a vastly increased breadth of coverage.

From the Back Cover

If you are a programmer, you need this book.

• You've got a day to add a new feature in a 34,000-line program: Where do you start? Page 333
• How can you understand and simplify an inscrutable piece of code? Page 39
• Where do you start when disentangling a complicated build process? Page 167
• How do you comprehend code that appears to be doing five things in parallel? Page 132

You may read code because you have to--to fix it, inspect it, or improve it. You may read code the way an engineer examines a machine--to discover what makes it tick. Or you may read code because you are scavenging--looking for material to reuse.

Code-reading requires its own set of skills, and the ability to determine which technique you use when is crucial. In this indispensable book, Diomidis Spinellis uses more than 600 real-world examples to show you how to identify good (and bad) code: how to read it, what to look for, and how to use this knowledge to improve your own code.

Fact: If you make a habit of reading good code, you will write better code yourself.

0201799405B02032003

See all Editorial Reviews

Product Details

• Paperback: 528 pages
• Publisher: Addison-Wesley Professional (June 6, 2003)
• Language: English
• ISBN-10: 0201799405
• ISBN-13: 978-0201799408
• Product Dimensions: 9.1 x 7.3 x 1.3 inches
• Shipping Weight: 2 pounds (View shipping rates and policies)
• Average Customer Review: 3.8 out of 5 stars See all reviews (18 customer reviews)
• Amazon.com Sales Rank: #702,557 in Books (See Bestsellers in Books)

  Popular in this category: (What's this?)

  #9 in

  Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Coding Theory

Customer Reviews

Most Helpful Customer Reviews

46 of 49 people found the following review helpful:

3.0 out of 5 stars Cool concept, but disappointing, March 9, 2004

By	Steve R. Hollasch (Redmond, WA USA) - See all my reviews (REAL NAME)

I purchased the book to help me out with the recurring task of quickly understanding the nature of unfamiliar large software projects. Kudos to Mr. Spinellis for tackling this subject, which is a large part of the everyday work of programming.

Unfortunately, I feel that this book was of very limited use to me as an experienced programmer, and suffers from a rather basic flaw (as a topic). The problem is that the art of code reading is really the intersection of a deep and/or broad understanding of programming, in conjunction with a deep and/or broad understanding of the tools and practices employed. One could well assert that this book is about *debugging* unfamiliar codebases as much as it is about *reading* them, since code comprehension is a component of code debugging. This is a rather apt analogy, since many have attempted to describe the black art of debugging just as Mr. Spinellis has attempted with reading, and with no definitive "must-have" coverage to date.

The result is that I felt the book rushed through important programming concepts that were either extremely basic (global variables, while loops, conditionals, blocks), or language-specific (C typedef, arrays, function pointers), or too deep for the book to address adequately (trees, stacks, queues, hashes, graphs). With regard to the latter, I found it odd to be reading a lot of text about basic data structures, when it seemed to me that I should be assumed to already have this knowledge if I wanted to read code that used it. And if I did NOT know about basic data structures, I should be reading a book about data structures rather than a book about code reading. Software patterns are also presented (though not by the name, I think). If I was to encounter a codebase that employed some programming concept I didn't understand fully (for example, red-black trees), then I would first go to a book on data structures -- not a book on code reading.

Following the sections on what I would consider mandatory prerequisite understanding are some brief chapters software engineering concepts (version control, build systems, project organization, packaging, system structures), which might be useful to a reader who had never worked on a large-scale project before.

After all of the coverage of what I would consider prerequisite knowledge, the penultimate chapter finally gets to the topic of tools and techniques for actually reading code. This chapter is in fact what I had hoped Mr. Spinellis would devote the book to. Unfortunately, most of the tools and techniques presented are very basic and quickly encountered by any programmer: regular expressions, the fact that many editors include browsing support, the grep utility, differencing tools, the idea that you could write your own tools, using the compiler to emit warnings and preprocessed code, that beautifiers exist, profiling and annotating printouts. And that's it, in about forty pages, followed by a chapter devoted to an example session.

On the whole, I think this book comes up short. If you have a few years of programming experience under your belt, then you've already encountered the basic tools and techniques presented. If someone resorted to this book to learn about a basic programming construct, then they could read my code, but I'd be nervous about letting them modify it, until they read more focused texts.

I'm rating this book at three stars because there are some good pieces here and the effort was laudable. In the end, though, I really don't think that anybody needs this book on their shelf.

12 of 13 people found the following review helpful:

5.0 out of 5 stars Reading other people's code can teach you a lot, July 21, 2003

By A Customer

Those wishing to understand the various styles of programming and meta-programming that have become common in open source code, as well as those who seek to broaden (if not deepen) their understanding of software engineering, would be smart to pick this up. Not only will this book help you to understand the innards of your favorite or least favorite software, but it provides insight into why the creators made the choices they did. It's not going to teach you about computer science as well as a good textbook will, but it will give you an understanding of and appreciation for what programmers balance in their minds as they shape their complex creations. Think of it as The Story and its Writer (ISBN 0312397291) applied to software.

57 of 73 people found the following review helpful:

3.0 out of 5 stars Unfocused, June 23, 2003

By	Thomas Paul (Plainview, NY USA) - See all my reviews (REAL NAME)

Programmers need to be able to look at code and analyze what it does in order to change it or fix it. The concept behind this book is to use many of the open source code samples to discuss how to read code and how to spot potential trouble areas in code. Unfortunately the book doesn't stay focused on this single goal and that detracts from its overall value. The book spends too much time explaining the basics of programming instead of concentrating on reading code. It also bounces around from one language to another, from C to C++ to Perl to Java, which is very confusing. For example, if you are a Java programmer do you really care how the C compiler optimizes strcmp calls? And what does that have to do with reading code?

Some of the advice is fairly basic such as try to realign indentations properly and replace complex code structures with simple placeholders when doing analysis. Although there are parts of the book that are excellent, too many of these good parts are wrapped under what should be basic concepts to anyone reading code. How can you debug a Java program, for example, if you are unfamiliar with abstract classes, libraries, or polymorphism? Do you really need a book on code reading to explain basic object oriented programming?

Overall, the book seems very unfocused and I really can't recommend it.