I have tried reading a couple other Linux clustering books so far, without much success at finding one that I both really liked and found useful, so I was not sure what I would think of this book. At this point, I am still not entirely sure what I think of this book, with my feelings split.

The main them of the book is to walk the reader through the construction of a simple cluster of Linux boxes, and then the creation of a master-slave interface software architecture. The structure of the book in working towards this goal is well organized.

The book is 12 chapters long, and has a feel of being divided into two main parts. The first three chapters introduce clustering and multiprocessor architectures and interprocess communication. The next two involve actually assembling the hardware you have purchased into systems, and then configuring Linux on them. The last chapter in the first half of the book is about configuring an environment in which you can do software development (it discusses, among other things, using a C compiler and make).

The majority of the second half of the book is devoted to the final development and tweaking of the master-slave interface, as well as how to do various types of performance measuring and testing, and some hints at how to make software more robust. The last couple of chapters are summary type chapters, wrapping up what the book has covered, and also glancing at what other people are doing with Linux clustering.

Throughout the book, the underlying thread is the construction of this master-slave interface. Almost every single chapter includes C code that helps the reader work towards this goal. The code samples start in chapter 3, and continue in almost every chapter until the end of the book. Each example is used to introduce the reader to a new idea or topic (subtasking using fork and exec, shared memory, semaphores, to mention a few examples). Throughout chapters three through six, there are a series of short examples which demonstrate many of the ideas that will be covered in the final master-slave interface, including some simpler examples of it. In chapter seven, the final construction of this master-slave interface takes place, with chapters eight through ten giving examples of how to do performance measuring and testing.

I thought that this idea of working towards the construction of a specific example of a cluster-like architecture was interesting, and it tied the book together well, so that the chapters didn't seem disjoint, or like a collection of unrelated material, it flowed well. I enjoyed reading through the code, since I had not really ever done this type of programming before. The code samples were for the most part well commented, and mostly bug free (one or two little things on the system I was working on needed to be fixed, but they were pretty straight-forward fixes, nothing too complicated).

However, I also had the feeling that this wasn't entirely about Linux clustering. While the author sets up a Linux cluster for the reader to develop their software on and for, I think that with a little general Unix programming knowledge, the master-client architecture could be ported to most any Unix with little trouble.

Therein lies the split feelings that I have towards this book -- I thought the material was interesting, but I never got the feeling that I was learning specifically about Linux clustering, other than the fact that Linux is a cheap, yet very viable, alternative to other Unix platforms. Perhaps that is the point the author is trying to make; that there is nothing particularly special about Linux as opposed to other Unixes, except that it is freely available and robust enough to be used in these situations.

In any event, if you are looking for a book that is going to teach you about using Linux to do high performance computing (parallel programming, information about some of the HPC software packages out there, or other related topics), this isn't really going to be the book for you. This book tries to discuss and explain the architecture living below that. If that low level concept explanation is something you'd find interesting, then I think that this book does a good job if helping the reader understand more about that through the tool of actually writing your own programs. In the end, I find the title very appropriate, the book is indeed about the architecture of a Linux cluster.