Concurrency: State Models & Java Programs [With CDROM]

This is truly a landmark book, from Kramer and Magee who have been recognised by ACM SIGSOFT with the 2005 Outstanding Research Award for significant and lasting research contributions to the theory or practice of software engineering. That is something to live up to, and the book does so admirably. "Concurrency" is the only book we have found that presents a sound formal approach to the subject in a palatable manner. We have used the book for nearly ten years to teach students from second year upwards how to reason about programs that run concurrently. The main contribution of the book is its use of the FSP notation and the accompanying LTSA state analyser. With these in hand, the student is led through the classical problems of mutual exclusion, monitors, deadlock, safety, liveness, bounded buffers and timed systems. Each chapter has a interesting real-life example, such as cars on a single-lane bridge, or a parcel routing machine, and each of these also runs as a Java applet. Students can interact with the applets to discover the effects of speed, overload and see how race conditions or deadlock can occur - something quite foreign to them in sequential programming. The Java programs are generated from the FSP, not automatically, but in a stylised way that enables students to understand the basic units of threading in any modern language. They do not make use of the latest Java libraries and tools for this specific reason, and are certainly not the main thrust of the book. The programs are described in UML as well as in structure diagrams more suited to concurrency. The second edition has improved the exposition of several of the chapters and also added two more advanced chapters on verification and temporal logic. Together with the notes, further reading and exercises at the end of each chapter, this makes the book into a very useful resource for the practising programmer, as well as the student. Certainly, we have found students resorting to the techniques taught in this book when things get tough with big projects in later years.

This book does not belong with other Java books. This is a real computer science textbook that should be sitting next to Rivest's Algorithms book. The use of Java is incidental and makes the book very accessible without detracting from the issues at hand. It has to be one of the most well conceived computer science books ever written. The material covered is maddeningly difficult to master informally because concurrency errors often manifest themselves as rare, random, and disastrous events that cannot be reproduced. Most of the book is laying down a solid formal foundation in which to reason about concurrency; the only hope for getting it right when things are difficult. It also comes with analysis tools (in Java of course!) to help people who learn by exploration, experimentation, and visualisation.

It was only after reading that book that I was able to really understand the conecepts of interleaved actions, race conditions, semaphores and monitors (as well as other concurrency-related issues). As a newcomer to IT generally, reading this book enabled me to understand better the Operating Systems course at Imperial College. I think the reading of this book should precede any approach to a course on operating systems. As a final note, Jeff Kramer is one of the most popular lecturers at the department of computing of Imperial College. Many other studens I spoke too were convinced that his teaching was by far the most efficient. I strongly recommend the book! I still use it at work as an ever useful reference.

I have also used this book in manuscript form for two years at the University of Pretoria, South Africa, and am now using it in Victoria, Canada. In both cases, the book forms the introductory part to a larger course on object-oriented distributed systems.Without this book the students would be lost in the mire of COM, RMI, CORBA etc and learn no principles to carry them through after graduation. Magee and Kramer package up the classical Hoare CSP in such a way that it is palatable, easy to use, and really illustrates difficult points to students on-line. Students say the course is fun. It is fitting that this book should appear just as Tony Hoare retires from Oxford. Magee and Kramer show how concurrency should be done in the new millenium.Just one word of warning: there are five notations to master in the book: FSP modelling, LTS diagrams, UML diagrams, structure diagrams and Java. I found that being forewarned on this aspect helped me explain the need for all of them to students.

I have used Magee and Kramer's book (or rather their manuscript) twice in the UG programme of the Dept. of Computer Science at University Collge London. I used it to teach a 30 hours course on Concurrency to final year BSc students in Computer Science. The book is very appealing for several reasons:Firstly, it is the only available book that provides an engineering discipline to concurrency. It covers both a sound introduction to the theory of concurrency and practical guidelines how to design concurrent programs using the UML and Java.Secondly, the book is nicely written indeed. The concepts are well motivated, the intriguingly difficult theory of concurrency is well explained and the book is full of examples that show both theory and practice of Concurrency. Thirdly, the book is not only a book; it's a nicely boundled package. It comes with Java demonstration applets that I used to visualize concurrency concepts, such as Monitors, Mutual Exclusion and Fairness in the class room. Moreover, the book includes a CD with a tool that students (and professors) can use for modelling and model checking purposes. The tool implements labelled transition systems analysis and supports visualization of label transition system execution. Finally the web site that accompanies the book is full of exercises and exam questions and model answers are available too.Using this material was a truly positive experience.