Concurrent ML (CML) is an extension of the functional language Standard ML (SML). CML was developed by the author in the early 1990s, and an implementation is now included in the Standard ML of New Jersey (SML/NJ) implementation of ML.

The main features of CML are language constructs that make it possible to express concurrency in ML programs explicitly, in addition to the implicit parallelism available in functional languages. The language constructs of CML include the creation of independent processes on the language level and higher-order communication and synchronization mechanisms that allow the application programmer to express a wide range of concurrent program structures required in systems programming and interactive applications. CML is a high-level language, so the concurrency expressed in CML represents the potential parallelism of the application program. The actual execution of concurrent processes depends on the runtime system; they can be interleaved on a single processor or executed in parallel on several processors at once. The current implementation of CML is implemented on top of SML/NJ and is written in SML. The communication concept of CML is synchronous message passing on typed channels, although the underlying concept assumes a shared memory. CML processes have a thread of control and a local state but may share data with other processes. The language is nondeterministic in the sense that a nondeterministic execution order may lead to nondeterministic results.

The book comprises three parts: an introduction to concurrent programming, a description of CML, and a discussion of applications. The first chapter is a short introduction to the idea of concurrent programming within a functional environment and describes the development of CML. The second chapter is about language constructs and program structures in parallel and concurrent programming. It includes message passing and shared memory programming models as well as process models motivated by operating systems. The next three chapters serve as an introduction to CML and are intended to be a tutorial on this language. Chapter 3 describes the main features of CML--threads, channels, and communication operations. Chapter 4 illustrates the CML programming technique, process networks, and client/server programming by applying them to several examples. Chapter 5 shows how to express further synchronization and communication mechanisms within CML, including synchronization variables, buffered channels, multicast channels, and remote procedure calls.

Chapter 6 discusses CML design choices. Chapters 7 through 9 present application programs written in CML: a software build system for concurrent compilation, a toy concurrent window system, and a CML implementation of Linda, a programming model for parallel computing based on a tuple space. The last chapter describes the concurrent features of the base language SML and the implementation of CML using those features. Appendix A is an excerpt from the CML reference manual, and Appendix B is about the semantics of CML.

The book is intended to be an introduction to CML and serves this purpose, thanks to the tutorial presentation that includes many applications. It is not suitable as an introduction to functional languages or concurrent programming. The preface and introduction use many technical terms from both areas, which will be well known to people who are familiar with the fields but will be difficult for the nonexpert. Moreover, the reader is expected to be familiar with the 1997 revision of SML, since SML is the primary notation used throughout the book. The author provides references to an introduction to SML and to the SML/NJ and CML home pages. The chapter on concurrent programming concepts is detailed enough to enable readers to understand the concepts of CML. Altogether, the book is ideal for an audience familiar with functional programming languages in general and interested in language design. It contains relevant references mainly in the area of language design and language constructs for parallel programming.