Monday, December 10, 2007

[Arch] Two important new books: two reviews

Recently two interesting books have been published:

1. Andy Oram & Greg Wilson, "Beautiful Code",

OReilly, ISBN-13 978-0596510046

2. Kent Beck, "Implementation Patterns",

Addison-Wesley, ISBN-13: 978-0321413093

Let's have a look at the first one. The second one will be looked at in the next review posting here.

There have been a lot of rumors before "Beautiful Code" has been published. Perhaps because there are not really that much book that cover something like "the art" of coding. So whenever I listen around, all the Gurus I know seem to read that book. So it must be important...?!

What primary stucks is that the book is edited by Oram / Wilson. What they have done is: they have called for chapters. In this way they have been able to attract 33 chapters from famous coders. This means that the book has no golden thread. The chapters are not build upon another. They simply cover the "Beautiful Code" view of the author. This in turn means that the chapters differ entirely and are not connected. So you have chapter that sound more like beautiful design, beautiful architecture or chapters that discuss what beautiful code might look like or what beautiful language design might be.

Let's have some random examples:
  • Brain Kernighan shows us a regular expression and it's power using C code stuffed with lots of pointers.
  • Karl Fogel shows the delta editor that is the basis of subversion. This includes C Code with lots of comments.
  • Jon Bentley is the first who uses 'higher level' languages, compares some quicksorts and even shows a little mathematical background.
  • Alberto Savola introduces JUnit and shows how beautiful tests can cover a binary search algorithm.
  • Image processing code by Charles Petzold.
  • Bryan Cantrill discusses threads in connection with beautiful code.
  • Jeffrey Dean and Janjay Gemawath show you evolving code leading to the map-reduce solution.
  • Andreas Zeller write about beautiful debugging. He doesn't show too much code, but some insights could rarely be found elsewhere.
  • Yukihiro Matsumoto (the brilliant author of ruby) only shows 13 lines of code but is getting into a short philosophical discussion, how a programming language should look like that 'offers' the ability to write even more beautiful code.

There are a lot more topics like:

finding code, XML Verifiers, beautiful frameworks, operator precedence, secure communication, DNA sequencing and gene sorting, beautiful code at CERN or in LINUX, a reliable Enterprise System for NASA's Mars Rover Mission, software transactional memory, audio& emacs and even Logging, REST, are covered.

Most readers might think at first glance that some areas might not be of interest: LINUX code, Bioinformatics or the Architecture of an Enterprise Ressource planning System might not be every ones first choice to read.

But nevertheless: in my opinion, nearly every of this 33 chapters in this book is a wonderful insight into beautiful XXX from different viewpoints where XXX is code or software-engineering, design, problem-solving or whatever.

But one should not get the weight of this book wrong. It is not possible to read the 550 pages like a novel and finish it in a few evenings. The book challenges you to invest hard work in each of the 33 chapters. The problem / challenge is to understand each code and each problem. To my opinion this need 1 hours per chapter and a some sheets of white paper to get the complete insights.

So to summarize, there might be two readers for this great book:

A) Just read the pages and you might have heard about 'map-reduce' or cool 'testing or debugging'. This might work faster.

B) You would like to understand each area covered in the book. This might cost you 33 hours but you will improve your IT knowledge dramatically.

So what type of reader are you?

No comments: