What do you think?
Rate this book
Concurrent Programming in ML
Concurrent Programming ML (CML), included as part of the SML of New Jersey (SML/NJ) distribution, combines the best features of concurrent programming and functional programming. This practical, "how-to" book focuses on the use of concurrency to implement naturally concurrent applications. In addition to a tutorial introduction to programming in CML, the book presents three extended examples using CML for practical systems programming: a parallel software build system, a simple concurrent window manager, and an implementation of distributed tuple spaces. This book also illustrates advanced SML programming techniques, and includes a chapter on the implementation of concurrency using features provided by the SML/NJ system. It will be of interest to programmers, students, and professional researchers working in computer language development.
326 pages, Hardcover
First published January 1, 1999
1 person is currently reading
46 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 of 1 review
July 30, 2021
Disclaimer: since this term is popular in different context - this is NOT a book about Machine Learning.
It's a book about building concurrency primitives in a functional paradigm, starting from the most simple blocks - threads and locks. It covers concepts and how-to's of coroutines, channels, selects, locking structures (known eg. from Go programming language), but also IVars (FP equivalent of JS Promises), MVars and cancellations. If you're after building your own concurrency library, you may find them useful. Finally it also extends to a distributed programming by describing protocol and simple implementation of tuple space (you can think of it as of distributed Key/Value store).
Now, keep in mind that this is pretty old book. For this reason, some of the terms used may be confusing even for people feeling comfortable in the subject, as we use different wording or meaning for the same concepts nowadays.
I'd say that first half of the book is the least approachable and applicable in 2021. The chapters closer to the end are more interesting and universal for people who are interested about guts of concurrent systems: especially last chapter covers some implementation considerations like combining preemptive schedulers with uninterrruptible regions and guaranteeing lower latency when executing short and long coroutines together or ensuring fairness of multi-channel selects.
You can find a fair discussion about tradeoffs of synchronous and asynchronous communication, but don't think that you'll go any deeper into actual optimizations on machine level - probably for the better as these would be outdated since the time that book was written.
In summary it's a good piece of literature, but I wouldn't recommend reading it all. IMO the best pieces can be found near the end of the book and they shouldn't take more than 1 or 2 afternoons to read.
It's a book about building concurrency primitives in a functional paradigm, starting from the most simple blocks - threads and locks. It covers concepts and how-to's of coroutines, channels, selects, locking structures (known eg. from Go programming language), but also IVars (FP equivalent of JS Promises), MVars and cancellations. If you're after building your own concurrency library, you may find them useful. Finally it also extends to a distributed programming by describing protocol and simple implementation of tuple space (you can think of it as of distributed Key/Value store).
Now, keep in mind that this is pretty old book. For this reason, some of the terms used may be confusing even for people feeling comfortable in the subject, as we use different wording or meaning for the same concepts nowadays.
I'd say that first half of the book is the least approachable and applicable in 2021. The chapters closer to the end are more interesting and universal for people who are interested about guts of concurrent systems: especially last chapter covers some implementation considerations like combining preemptive schedulers with uninterrruptible regions and guaranteeing lower latency when executing short and long coroutines together or ensuring fairness of multi-channel selects.
You can find a fair discussion about tradeoffs of synchronous and asynchronous communication, but don't think that you'll go any deeper into actual optimizations on machine level - probably for the better as these would be outdated since the time that book was written.
In summary it's a good piece of literature, but I wouldn't recommend reading it all. IMO the best pieces can be found near the end of the book and they shouldn't take more than 1 or 2 afternoons to read.
Displaying 1 of 1 review