Customer Reviews

Principles of Concurrent and Distributed Programming (Prentice Hall International Series in Computer Science)

5 star:		(5)
4 star:		(0)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

An excellent, rigorous, mathematical introduction to concurrent programming. This book concentrates on principles and theory, providing an excellent background for concurrent programming.

Readers expecting a tutorial on pthreads or win32 threads should look elsewhere.

A calculus for reasoning about concurrent programming is presented, along with problems, solutions, and proofs for common concurrent programming concerns.

A superb academic treatment of the topic, but not for the weak kneed.

A very good introductory text to concurrent programming, using something like pseudo-ada as the example language. It starts introducing the basics concepts, like deadlocks, starvation, contention, etc. There's a entire chapter for Semaphores and Another one for Monitors. So, it explores the folclorical problem of the Dinning Philosophers. Real paralell programming is discused too. There's special chapters for the Languages Linda, Ocan and Ada. It ends with a review of the Spartian Generals problem and a chapter about real time sistems

Used this text at Stanford 5 years ago and was very happy with it. Now recommending to others. Oldie, but goodie.

i have been reading about concurrency and related issues for quite a while now. after reading a few favorable reviews about this book here and elsewhere, i decided to give it a shot. i have read about 50 pages; what i am going to say will not change as i read more (safety property, if you will).

the part where deadlock and starvation freedom is presented and the example algorithms used for clarification is very dubious and makes me doubt the rigor with which this book was written. granted, deadlock seems to enjoy several slightly different semantics. this should not, however, mean that anything resembling deadlock freedom can be classified under deadlock freedom as its definition. there is one algorithm which clearly is not deadlock-free (under no contention, a thread should be always allowed to enter its critical section) and yet is tagged deadlock-free: its progress depends on the other thread's progress where this other thread might be lost somewhere in its remainder code, showing no interest in the critical section.

now, this example is at the beginning of the book and is about a very simple concept. if the author gets this wrong, what does one think about the rest of the book? will the reader be always on the lookout for possible subtle mistakes? it is my understanding that a reader should be able to trust the writer of the text to fully enjoy the text. this lack of trust made me suspend reading the book. i am trying to get the fundamental notions right before i go any further in this book.

at the end, what does this mean? buy and read this book only if you already have some other reference books on concurrency and want to see yet another approach to a still highly unstable research topic.

Overall I think this book is good, but contains a ton of unnecessary imperfections
that could have easily have been avoided. If you are able to ignore those parts
and not let them ruin your mood, I think you will enjoy this book and learn efficiently from it.
I want to add that my grade is closer to 2 stars than to 4 stars. With some improvements,
I think the book could easily deserve 4 or even 5 stars.

MERITS:
It has a nice mathematical/rigorous view of the subject and emphasizes the
important things, which are the principles and concepts of concurrent programing.
I am greatly in favor of this philosophy, because the first thing you want to do
when learning a new subject is to get the panoramic view of what are the problems
and techniques of the field, and how do all the concepts relate to each other.

There is also merit in isolating what is actually unique about concurrent programming,
and avoid bloated 1000-page works that are filled with things you already know
about other subjects, e.g. general programming techniques. Also focusing on pseudocode
instead of cluttering the algorithms with syntax of particular languages is a benefit.

Ben-Ari succeeds in writing a pretty friendly page-turner which will have you understand
what concurrent programming is about, and most of the central constructs, in a matter of a couple of weeks.

DEMERITS:
At the level of details, the book is, unfortunately, not well thought out. There are tons
of sentences that are vague, unnecessarily complicated or ambiguous. In most of these
spots it is possible to rule out all incorrect interpretations, or to fill in the gaps,
given enough time. I found my self "wasting" half an hour or an hour many times, and when I
finally understood what was to be understood, it was clear how the sentence should have
been formulated. I think with a minor (although many) changes in the text, the reader would
save tremendous amounts of time.

A list of parts that could be improved:

- When defining starvation and dead-lock -- some of the most central concepts here --
it would be helpful to say if dead-lock requires at least 2 processes, or if starvation
of 1 process is also deadlock. (According to a word-by-word interpretation, 1 process can
be in dead-lock, and if two processes are in dead-lock, they are both starved. According to
my lecturer, this is not what you usually mean by these things).

- I am missing a discussion of how important freedom of starvation is. It seems that this is
not a big deal since many algorithms are stated, then proven, and lastly there is a comment
that there is starvation in the algorithm.

- I dont remember exactly where in the book, but I found the order of the text suboptimal
in several places. Either there would be an important assumption in the beginning of the text which
was used much later. I would like to reminded of the assumption, or the assumption should be written
later. Alternatively, there would be some example or reasoning, and you would analyze it for some time.
When you continiue to the next paragraph you would find additional information used in the previous
part. Sorry for lack of exact reference.

- Section about Uddings algorithm is just poor, (and also some other sections).

- Section 7.10 about protected objects is partly unclear. There is the notion of entry to
an operation in a protected object. In Ada, which uses protected objects, there are also entries
which are something like operations/methods/functions (what you prefer calling it).
(There is no entry for entry in the index). :D

A passage in the section reads: "[...] it is forbidden for barriers to depend on parameters of the entries.
That way there need be only one queue per entry, not one queue per entry call".
The word "parameters" should be "arguments". Furthermore, the algorithm that was being discussed
didn't even have any arguments for its operations. So even if you understand what entry means,
it is not clear what "parameters of the entries" mean. After this, it gets even worse
(he refers to "the protected operation" without ever mentioning a protected operation before), and the section
ends with the words "A discussion of this topic is beyond the scope of this book." Well, he just DID discuss
the topic...

- There are many more things, I didnt really try to find as many imperfections as possible.

This book is only one that I know where you can really study sinchronization method for parallel computing in deep in its mathametic ant strong logic proofs.

Realy AMAZING book

This book did provide a good method of creating tables to help identify concurrency issues and as a possible method for analysis of concurrent systems. However, the presentation within this book is extremely dry and this newly learned method is truly overkill for most applications. If one wants to learn about the academic perspective on concurrent programming, then this book is absolutely for you, but if you want a book to give you the concepts and then some practical applications within Windows or Linux then you should definitely look elsewhere.

Used at the University of Liege, Belgium as reference for the Parallel System lecture. Everyone found it very useful