|
Code Reading: The Open Source Perspective
 |
Author: Diomidis Spinellis
List Price: $49.99
Our Price: Click to see the latest and low price
ISBN: 0201799405
Publisher: Addison-Wesley Pub Co (27 May, 2003)
Edition: Paperback
Sales Rank: 64,822
Average Customer Rating: 4.09 out of 5
|
Customer ReviewsRating: 5 out of 5
Valuable resource of Information and good practices
A valuable resource for best practices, do's and don'ts, what works and why, what you should do in various situations of project, code, and architecture evaluation, and everything in between. In one phrase, this book depicts Software Engineering's best practices for the real world. No heavy-duty processes to follow, no reading of Software Engineering text books that are over a 1000+ pages. More importantly, everything in this book is REAL. References are given to open source projects where the author took the examples from, and the CD-Rom includes the complete code examples given in the text. The author starts off by giving a background on the most popular programming languages used in the open-source community such as C/C++ and Java. Some scripting languages such as a PHP and Perl are also covered, but the main focus of the book is on C and C++. Data types, data structures and control flow are covered respectively and various best practiced of "what to-do" is given for each topic. These topics are somewhat basic, and if you are an advanced programmer, you can read thru these chapters in an hour or so. Even though these chapters are basic, they contain valuable to-do's and best practices that everyone of us will surly benefit from. They style of the book and its structure is nothing like I have seen before and it takes a couple of chapter to get used to it. Chapter 4 is one of my favorite chapters in this book. It talks about C Data Structures. Towards the end of the chapter, the author talks about Graphs and Trees. These two rather complex topics (books have been written on these two topics) are covered so well that with about 20 pages, the reader can get a very good understanding of the topics at hand. Concrete examples from various open-source projects are used again to get the point across, and the source code that is on the CD-Rom is reusable with little effort. The fun begins with chapter 5, Advanced Control Flow. Recursion, exception handling, parallel programming and non-local jumps are the main topics covered in this section. Again, the sample codes really help the reader to understand the topic better, and they also can be refereed to in your next project - something I found very beneficial. Another interesting thing about this chapter is the part that compares the different thread implementation in various languages and platforms - Java, Win32 and POSIX. Example from each implementation is given to show the reader the difference in practices and to get the point across more clearly. If you have ever been bored to death by reading books on Software Engineering and Software Processes and just wanted to be able to have a very light and proven process to help you out with your next project, then Chapter 6 - Tackling Large Projects, is for you. The author starts the chapter by going over some of the design and implementation techniques used widely in large projects such as:
·The need for a software process
·Complex Architecture
·The need to support multiple platforms
·The use of OO techniques
·Operator overloading techniques when appropriate
·The need for Libraries, Components and Processes
·The need for custom languages and tools
·The use of pre-processing for portability and other reasons Some or all of these methods are needed in large software projects, and author goes into detail in chapter 6 to cover how these tasks can be accomplished efficiently and proactively throughout the project life cycle. The author starts by going over Project Organization such as directory structure and source tree organization to the build process to revision control for future releases and end the chapter with a topic on testing of software applications. The next two chapters, Coding Standards and Documentation are simply priceless. In about 40 or so pages, the author is able to cram over twenty years of best practices in coding standards and documentation techniques. I have never read a book that covered these two topics so well. If you are a project lead, you can simply take these two chapters and use them in your next project because you will not find anything better elsewhere. The biggest and the most imperative chapter in this book is Chapter 9, Architecture. Various architectural patterns are covered. Each pattern includes a list of projects in the open-source community where it was applied and was proven successful. The author then goes into various Control Models that are used in the industry such as:
·Event Driven Systems
·System Manager
·State Transition
And examples of each of these Control Models along with code samples are given. Various packaging methods and schemes such as namespaces, modules, objects, generic programming, Abstract Data Types and libraries are also depicted in this chapter. Chapter 9 is the longest chapter in this book, but also the most informative one. D. Spinellis did a great job putting this book together. This book is packed with examples, best practices and information that are useful to developers, project leads and managers. Now you can have all the experience of the open-source community, the people that developed Linux, Apache and other popular software applications, at the tip of your finger.
Rating: 5 out of 5
Easy to read, worth checking out for some
I stumbled upon this book when I was at the book store and picked it up without ever reading a review or seeing any kind of Internet press about it and was very surprised at what I found. Writing a book about disecting code and getting the most out of it could be very useful to some, invaluable to the novice programmer. Although some techniques in the book are a bit over emphasized, I felt that the writing and the organization of the book was excellent. This book leaned on C code and Unix/Linux environments quite heavily so if you are unfamiliar with them then you may find it difficult to understand. It's a book about the process of reading code and not so much a book about teaching you how to code. Which is probably why it's called Code Reading.
Rating: 4 out of 5
great insights from practical experience
i like this book a lot. by touring various pieces of source code (focusing on NetBSD, an open source version of BSD), we get to see what's happening and why. yes, this is a collection of fragments of code, and it's not going to teach you anything about the language. but what it will teach you is how to write better code. this comes through observing what others have done, how it works and why it works, and how things stand up to the test of time (and lots of eyes). i would say that this book is a good complement to the classic "the practice of programming", also on addison-wesley. in both you'll learn how to go beayond just laying down what you learned from a C textbook and actually develop as a programmer. this one takes a far more practical approach, and highlights a lot of things that TPoP glosses over (in order to focus on other material). i've been writing a lot of code for projects large and small, and i found i learned some things from this book. definitely a good book for someone looking to improve their development efforts beyond just knowing how to write code.
Similar Products
· Facts and Fallacies of Software Engineering
· The Pragmatic Programmer: From Journeyman to Master
· Debugging: The Nine Indispensable Rules for Finding Even the Most Elusive Software and Hardware Problems
· Test Driven Development: By Example
· The Art of UNIX Programming
|
