Distributed Computing Books

This book is an absolute must for system architects, system engineers, system testers, and developers.

I have been working DoD systems since 2000 and have studied and studied and studied trying to synch DoD's efforts to embrace SOA and distributed systems with commercial concepts, approaches, and practices. I have tried to specify system requirements from architecture views and contrived requirements trees. I have had GOF's book and POSA 1 since 2002 but, by themselves, they only make a certain level of sense. In addition, countless other books and methods only provide parts of the overall distributed system view. I have been very frustrated.

This book, while not the complete picture, provides a wire up of hundreds of different approaches. The authors provide a logical approach and path to defining distributed system architectures. The authors point the reader to dozens and dozens of other references to allow them to dig deeper. When they disagree or choose why they don't implement a pattern a certain way, they provide logical rationale to go with it and provide references for the other ways you could attack the problem.

Requirement developers/managers and system architects should sleep with this under their pillow. To specify system requirements using the right terminology that does not force an implementation is a primary objective. To evaluate a developer's design requires a comprehensive understanding of the forces at play in a distributed system. This book provides a roadmap. I am now much less frustrated. In fact, I am much more motivated.

Ah... now to read all the references...

I found this book more theoretical and I personally would like to read books that have a flow with concepts, examples and practicality. Lot of material to read and if not put in practice you loose it. Some of the books of my taste are like Accelerated C++, Effective STL etc.

I don't have much to add over T. Anderson's review, but wanted to weigh in with a 5-star vote as a practicing distributed-systems architect. In particular I'm irritated by the one-star review from the person who obviously didn't understand what he/she was buying.

This is as close as you're going to get to a one-stop "encyclopedia" of patterns relevant to distributed computing (and other areas as well). I own most of the architecture/design patterns books, but this is the one I'll go to first for ideas, study, and use as a reference.

As for content, the catalogue of patterns is more comprehensive than any other volume I'm aware of and it is well organized. Each chapter describes a group of patterns that address recurrent vertical and horizontal architectural problem spaces. Each group is briefly introduced and described in the context of that. These introductions are pithy, on-target, and along with the complete pattern descriptions almost constitute a good introduction to distributed computing in general.

Most patterns are described in two pages in a format that has been well-honed over time for usefulness and comprehensibility. You find out where and when each pattern is likely to be useful, what motivates it, how it works, pros and cons, and what other patterns might be used with it.

The cross-referencing between patterns both within this book and in other sources is extensive and one of its most valuable features. The authors provide you with 114 pattern descriptions cross-referenced with "over 150" from other sources. That's a pretty extensive language!

Lots of spelling errors and such, but nothing that should confuse anyone.

This book is NOT a true encyclopedia, and you will want or need some of the core volumes that cover the "over 150" patterns that are referenced but not described here. The most notable are:

Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)

Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (The Addison-Wesley Signature Series)

Remoting Patterns: Foundations of Enterprise, Internet and Realtime Distributed Object Middleware (Wiley Software Patterns Series)

Most, if not all, of the material in Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects is covered in Volume 4. If you don't have that book you might want it for deeper discussion of some of the patterns. On the other hand, the current volume contains important updates to a couple of patterns in the earlier volume.

If you're new to patterns, please avoid Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series), also known as the "GoF" (Gang of Four) book. It is a classic and the authors deserve their "props" for introducing design patterns to the broader development community, but it is the worst-written and most misleading book I've ever read on patterns. (In fairness to the authors, it was the "grand-daddy" of them all and perhaps they can be excused for not having the intervening 12 years of experience in pattern documentation to help them.)

I've heard good things about Head First Design Patterns (Head First) and Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition) from people who have read the GoF book, so you might try that. I haven't read either myself.

If you're familiar with patterns and want perhaps the most comprehensive and useful single pattern book to date, especially if you're involved with the architecture of distributed systems, buy this!

It is not for beginners or those looking for boilerplate code!

This is a great book. It pulls together 114 patterns and shows how to use them in the context of distributed software architectures. It also claims to reference 150 patterns in other publications.

The authors did a great job of creating a language composed of patterns for distributed software architectures.

The book does not go into the details of the pattern's implementations, so you should already be familiar with the patterns, or be prepared to spend some time researching. They do provide brief descriptions and a model for each pattern included in the language. If you need to research a pattern a little more, that shouldn't be a problem because they have included an excellent References section that contains sources for all the patterns original resources and they do a great job pointing to them throughout the text.

The book's best attribute is in how they show the relationships between the patterns. At the beginning of each section they include an introduction to a problem area that ties all the patterns in that section together.

They have broken the language up into the following sections:
From Mud To Structure
Distribution Infrastructure
Event Demultiplexing and Dispatching
Interface Partitioning
Component Partitioning
Application Control
Concurrency
Synchronization
Object Interaction
Adaptation and Extension
Modal Behavior
Resource Management
Database Access

Although the book is a pattern language for distributed software architectures, the patterns are definitely usable in other contexts.

I used the search on this page to check out the internals of the book before buying it.

Every Software Architect should own a copy of this book. It is a wealth of information. If you have a Software Architect working for you, you should make this mandatory reading in order for them to keep their job.

Sorry Guys (Melissa & co.)...

After pushing through this one cover to cover and then attempting a big project I felt rather let down.

The book went to great lengths to discuss planning and network toplologies, as well as many repetetive discussions about the benefits of ICA protocols over RDP, not to mention endless pages explaining the difference between NetBIOS, IPX/SPX, TCP/IP etcetera.

Many chapters repeated material already covered and while I did glean some insights into licensing and the diferences between Terminal Server and MetaFrame this was not the information you ultimately need when it comes to deploying the product.

The main areas that are left out are user profile configurations, roaming profiles, group policies and application customisations and installations.

Probably a good book for sales people who want to know what the product can do - but who don't have to actually make it do it.

Only two stars from me.

Svend Petersen,
Sydney,
Australia.

This book does a really great job of explaining the design considerations of deploying Citrix MetaFrame and then explaining the complexities of intallation, configuration, troubleshooting etc. The way the book is written, you get a really good idea of what your network will look like when it's done, which makes it much easier to come up with a plan that works and implement it. Great Job!

This book is perfect for anyone using, looking to use, or having interest in Citrix MF/Win 2000 Terminal Services. Strong coverage of all the essentials- Routing/Remote Access, Design Considerations, Installation, Configuration, etc. This one is a keeper...

Joseph D. Booth does a pretty good job explaining the fundamentals of database designing, most of which i'd already knew, but i wish i had this book when i was learning them. he explains normalization in 4 pages, the no'nonsense way.

he's very objective when talking about database servers.

the only thing i didn't like is that it is based on delphi 2, so he misses to explain some components like decision cubes.

other than that he covers quite well the rest (and more used)of the components, describing every single property and method.

Delphi Client/Server Developer's Guide by Joseph D. Boot

With this book i've entered client/server programming and i can say i've learned a lot. The reason i gave 3 stars is, 1) this book is quite old and only describes delphi 2 and 1 2) it does not give a lot about servers other than interbase 3) the Author is not a delphi expert (he is clipper orianted) so i think the delphi code is not perfect. and... 4) the cd-rom given with the book is rather useless.. it has 5 chapter's code (total 18 chaps.) and you have to edit some of the code in order to make them work..

I bought this book becuse it was the only delphi c/s book i could find.. (another written by Ken Henderson for delphi 3 was out of stock)

I can say you can either try out this book or buy a specific book for your target platform (oracle etc.) and when you finish it find some other source to learn about delphi's components. and you become a c/s hero :)

I have been doing a bit research of my own in this field, and you really have to be there to appreciate the value of this book, which by far provides the most comprehensive review of this "old" but yet challenging field, i.e. how to build reliable distributed systems that actually perform, among all the related topics.

The book covered the subject in both depth and breadth, and in a wide time and scope range. It clarified a lot this confusing area, for both researchers and professionals.

This book is neither a book in distributed applications neither a book about web services. It is true thta the author makes an introduction of both and in the case of the web services he takes a look to the latest standards related to reliability.
From my point of view, the book talks about how to enhace the reliability of a distributed software application using static and dynamic groups.
The author thinks that solving the life cycle problem of the nodes in a distributed aplication (create and destroy nodes, joint and leave groups, heart beat, and so on) is the necessary step towards a reliable distributed application.
I think it is an interesting point, however I am not convinced at all. Perhaps, I should read it again.

I really recommend it. For a more straight forward introduction to the subject perhaps is better to start with the classics Tanenbaum or Colouris books.

Birman gives a lucid explanation of various ideas involved in making a distributed computing system. Some have been around for years, like CORBA. Yet he advises, correctly, that its industry implementations have many difficulties regarding ease of interoperability. Which has greatly constrained CORBA's success.

A lot of space in the book goes over Web Services. These take a radically different approach to making a distributed system. Where there is an emphasis on structured messages that are not in binary, like CORBA. And where the messages are written in XML. Still too early, but Web Services might well overtake CORBA.

Peer to peer networks also get attention in the book. Gnutella, Napster, Chord and others. Yet some like Chord, have mostly been theoretical formulations. Interesting potential, but little market acceptance. Surprisingly, for a book that came out in 2005, there is no mention of BitTorrent. Yet in 2006, BitTorrent is perhaps the most popular p2p network.

I personally don't believe Access is a Client/Server databse, instead it should be a file sharing type of databse. :) SQL is a client/Server databse. I would buy the book, but I don't know if it will really help me to build a real "client/server" db. thanks

This is an excellent book for non idiots managers. Usually thecomputer people think that managers can't understand the trends oncomputer tech. But this book explains everything that we must know to choose the components for build right C/S information solutons systems. So if you are a manager and you want to understand the new comp stuff in order to take some buying decisions, you need to read this book. Also if you are a systems professional and you are not upgraded with the new state of the art on technology you will take a very good sight when you read it.

The accronyms alone will kill you in the first few chapters unless you wear special protective gear while reading this book. If you haven't got the faintest clue about middleware when you start reading, you'll find yourself half-drowned, bedraggled, and nearly as clueless when you finish. A truly "Complete Book of Middleware" ought to at least have a chapter that orients the reader to middleware--that way we know which acronyms to duck and which to glom on to!

This seems to be quite the shotgun approach to middleware. Make that a fully automatic shotgun with a large magazine. From Java to CORBA to specific vendors and program scripts, Ms. Myerson manages to cover a lot of ground, sometimes deeply, sometimes shallowly, and mostly with acronyms. I useful (?) overview, but one that will leave the reader wanting to buy more focused books to solve real life problems--or run out to hire a consultant who knows it all anyway.

I found several chapters quite relevant to a project I'm currently working on--although they mostly describe why current business solutions are inadequate to solve our particular problem. I also found that the relevant chapters demanded that I purchase more books so that I could leverage what I had read into real information.

So, know a bit about middleware _before_ you get this book. Then, if you need a description of (nearly) current systems and approaches that covers vast amounts of acreage, give this one a shot to see where you need to focus your reading--but plan on buying other books.

This is not "The Complete Book of Middleware," it's a modestly broad-based and exhausting introduction to what's out there and what it does.

This collection of papers is divided among eight major topic areas, each on a specific middleware category. The main value of this book is the wide range of technologies and vendor solutions, and the fact that it's up to date (at the time of this review).

I like the complete coverage of both transaction and queuing approaches, and the vendor-specific information that includes Microsoft's .NET and Sun's Java, as well as everything in between. The sections database middleware and middleware performance are especially valuable because they are more generic and applicable to a wider audience than the MS- and Java-centric sections.

While individual papers have a slight vendor bias, the book as a whole is vendor neutral. This is not a book for learning about middleware as much as a good description of what's currently available and their strengths and weaknesses. If you are looking for a more general book I recommend Chris Britton's "IT Architectures and Middleware: Strategies for Building Large, Integrated Systems" for the fundamentals, and David Linthicum's "B2B Application Integration" for a detailed text on how to employ middleware in practice. However, this book will give vendor-specific details and a more up-to-date view of middleware that are missing from Britton's and Linthicum's books. If you're a system architect or consultant this book is an excellent desk reference.

It's a pity that I got my hands on this book so late. It would have been much better if I got it soon after it was published in 1994, when I was in the university. Because the book is largely academic. To quote:

-- QUOTE
This book is an attempt to organize the body of knowledge in the area of software fault tolerance. ... [It] can be used as a textbook for a graduate/senior level course on fault tolerance ... or for a professional course in fault tolerance. It can also be used as a reference by researchers/practitioners ...
-- END QUOTE

The book has a nice systematic approach in that it attempts to clearly define what is a system, what is a failure and so on and so forth.

It takes the route of explaining that the distributed system is built around a set of communicating processes running on a different nodes and how redundancy, anything unnecessary and existing entirely for the ability for tolerating faults, is added.

But the big problem is - the book focuses on the joints, not on the bones, so to speak. It tells you about processes running on different computers and how they talk to each other and what can be done to ensure those conversations have certain properties. It speaks about joints - (network) protocols required for the processes to become a distributed system. In that the book reminds a lot of Tannenbaum and van Steen's "Distributed Systems: Principles and Paradigms".

But where it concerns the bones, the processes, all it says is "the process saves its state to persistent storage" or "the process recovers to the most recently established checkpoint". Uh-huh, sounds great, thanks. Needs hell lot of work to build a process in such a way that its state as a whole can be saved and restored from a stable storage. There are other problems for sure.

Eight out of nine book's chapters keep going around like that, telling you about all sorts of protocols for negotiations, clock synchronization, such and such broadcast, distributed snapshots, distributed transactions, voting and duplicating running processes. To be fair, there are quite a few interesting protocols that are nice to be familiar with, just in case.

The ninth and the last chapter in 40 pages touches writing fault-tolerant processes. It explains how redundancy can be added to the code and suggests a specific approach to cutting and wrapping all your code to special small boxes to ensure certain behaviour. Although it's difficult to argue with that, it's definetely not the only possible way.

Throughout the book, nearly everything of use quickly gets so complicated, that it's impractical for every use, and the author frequently admits that. I can see it working in calculations, numerical algorithms, even in the ever so proudly sounding aircraft control, in other words - where there is a single simple input, single simple output, simple logic, totally deterministic, no concurrency or shared state.

-- QUOTE
The schemes discussed above [...] require each process to be deterministic, i.e. given the same inputs, the process performs the same actions. Both of these assumptions do not hold, for example, in languages like CSP and Ada ...
-- END QUOTE

I'd say, it'not just CSP and Ada which do not have total determinism, but a lot of real systems too, no matter which language.

The book has next to none practical examples, you hardly ever get a name of the system which implements this or that, and may be a couple of times you get a brief description of a specific implementation. Most of the time such referencing is done in a scientific way, like "Aristole has shown this in [Ars/1378BC]". Good if you have access to the sources and/or time to look it up.

The book indeed makes a nice textbook for a course, but less so a practical reference. Although the matters discussed in it are unlikely to become obsolete, there probably are a lot of newer books on the subject. Will go look for them.

This book is already somewhat outdated (six years) in relation to the cutting edge of fault tolerance research but it's a good and comprehensive introduction to the subject, and great to programmers looking for some understaning of fault tolerance, as commercial tools still have much to go before catching up with what is in this book. This field is getting more and more important as business systems are being moved to the internet and need to remain operarional 24/7.

I finished reading on this book in September 1996. As a developer, system analyst and team leader among various Oracle projects since 1990, this is the best Oracle book I ever read. It is very easy to understand but deep enough to give you a clear concept about how Oracle 7 fits for Client/Server applications. I bought another Oracle book written by the same author, Oracle 8 Architecture, in December 1997. I have been waiting for the third edition, something like 'Mastering Oracle 8 & Client/Server Computing (and/or Data Warehousing) in the near future', written by the same author. Please !

Material is a dated by the pace of Oracle releases. I have not reviewed the new edition (June 1996).

As the title suggests, this book is a practical guide to Microsoft OLAP Server. It is not a reference (refer to MSDN for a detailed documentation) nor is it a theoretical book. It gives concrete advices on a wide range of subjects from planning to implementation. This book will save you time if you develop or manage an OLAP solution. I give 5 stars because it succeeds at what it was supposed to deliver.

It certainly is a good book to have for real project implementations using Microsoft OLAP Services. ALthough I had different expectations from the book. I expected it to have more tips involving technical details about OLAP Services projects. But, this is a good book not only for anybody who is new to OLAP Services but also for project managers or team leads who are planning to implement an OLAP project in real life. I liked chapter 4(has good breakup of task lists) and chapter 13(good technical tips).

As cellphones become ever more popular, and computational costs continue to fall, the prospect of ASR over wireless networks is attractive. So too is the use of ASR over the Internet (VoIP). The book describes the current state of understanding of both these ideas.

A common configuration is for the speech to be captured and digitised on a client machine [eg. cellphone], and the signal then sent over a network to a server on which runs the ASR. Several speech recognition standards have arisen over the years, to quantify the digitising and the ASR effectiveness.

For the ASR, Hidden Markov Models appear to be commonly used. The efficacy is described.

Maybe the most advanced topic is speech to speech translation, via handheld devices. Seriously difficult. Not only are there the problems of ASR accuracy for the input speech, but then the well known problems of Machine Translation of that to text in another language.