Student review: Introduction to Concurrency in Programming Languages

Authors: Matthew J. Sottile, Timothy G. Mattson and Craig E. Rasmussen

Edition: First

Publisher: CRC Press/Taylor and Francis

Pages: 344

Price: £49.99

ISBN 9781420072136

With the advent of multicore central processing units in desktops and laptops, as chip manufacturers try their best to keep Moore's Law in play, concurrency and parallel programming are becoming hot topics in mainstream computing. The question is: "Now that we've got all these cores, what are we going to do with them?" This book introduces the opportunities and issues that a programmer can expect to encounter upon entering this domain, with a focus on the programming language features that help to make it happen.

The book starts with a review of concurrency in general, with standard topics you would find in an operating systems textbook such as race conditions and deadlock, and various supporting programming language features such as semaphores, monitors and transactional memory. Then it covers the historical context - how programming languages and machine architectures have evolved, from a concurrency perspective. The last half gets down to the nitty-gritty, describing some key parallel programming techniques and patterns, and offering lots of examples - all fairly low level and mainly using OpenMP, Clik and Erlang, for each of which there is a quick appendix.

In the second half, it becomes clear that this is really a book on parallel programming, in the grand tradition of scientific computing where speed-up is king. While this is reasonable, I was disappointed, given the title: concurrency and parallelism are different things and concurrency has relevance beyond fast number crunching. Languages that support concurrency as an integrated and explicit feature make it easier to handle and can change how we think about programming; the book briefly mentions work of this kind and Erlang is one of its example languages, but the problems attacked with it here are still, nonetheless, traditional parallel programming ones.

That small grumble aside, there is no doubt about the quality of the book. It is well written, easy to read and virtually free of error, and what it covers, it covers well. It sometimes feels repetitive, but that is reasonable for a technical undergraduate textbook, which is what this is. Repetition both reinforces learning and supports dipping into the book. Overall, the coverage is wide rather than deep, but as an introduction to concurrency and programming languages, with a focus on traditional techniques for parallel programming and a taste of exciting things to come, I would recommend it.

Who is it for? Programmers and computer science undergraduates.

Presentation: Technical.

Would you recommend it? Yes, but don't expect anything revolutionary.