* Communicating Sequential Processes
* Author: C.A.R. Hoare
* Field: OS/Concurrency
* Reference: Communications of the ACM, August 1978 vol. 21 no. 8

* Theme: Input and Output as basic primitives in concurrent
programming.  In modern terms, this paper describes a language with
built-in mechanisms for message passing.  The paper by Lauer and
Needham [1979] references message passing operating systems existing
long before this paper; perhaps this paper clarified and expanded the
power of message passing as a structuring technique for concurrent
programs.

* Implementation: The language was not meant to be implemented.  The
language itself is a bit obscure, but it's simple enough that this is
not a major concern.  The language uses guarded commands (like switch
statements with arbitrary expression cases and nondeterministic choice
when more than one case applies), a parallel command which runs all
subcommands concurrently (this is how processes are started), and
primitives for message passing ('!' for "send" and '?' for "recv").

* Problems: Hoare's proposal differs from modern message passing
systems in the following ways:

1. No message queues.  Senders block until the receiver can accept the
message; once the message has been received, the sender can continue
running.  Queues can be added to the system but they are not provided
automatically/transparently.

2. CSP allows for input from one of several input processes, but the
the process name must be specified.  In contrast, modern systems don't
explicitly name the processes they can receive messages from.

3. CSP lacks broadcast/multicast.

4. CSP processes are intended to terminate, whereas we typically think
of the processes in message passing systems as large, static, and
associated with a system resource.

In a way, CSP processes are more bound to processors (each processes
implements a piece of a processing task which can be run on separate
processors in parallel), whereas message passing processes are more
bound to other system resources (each processes synchronizes access to
a shared system resource).

* Quote: Where the desire for greater speed has led to the
introduction of parallelism, every attempt has been made to disguise
this fact from the programmer....  However developments opf processor
technology suggest that a multiprocessor machine, constructed from a
number of similar self-contained processors... may become more
powerful, capacious, reliable, and economical than a machine which is
disguised as a monoprocessor.