[My first post on the FONC mailing list had a wrong layout. Therefore I retry]
This discussion mentions concurrency, the Meta II parser-compiler, Planner,
and LINDA, which apply such concepts as non-determinism, parallelism and
communication. These concepts are well described by the Algebra of
Communicating Processes (ACP, also known as Process Algebra).
This theory was initially developed in 1982 by Jan Bergstra and Jan Willem
Klop. I find it very elegant, and it deserves much more attention than it
currently gets. ACP treats input events conveniently on the same level as
internal actions and output actions; something that only very few
programming languages match.
There are two links between ACP and lambda calculus:
Stephen Cole Kleene did in the 1930s important work on lambda calculus;
in 1956 he wrote the first paper on finite automata and regular expressions.
I think the paper Brief History of Process Algebra should have mentioned
In 1989 Henk Goeman wrote "Towards a Theory of (Self) Applicative
Communicating Processes: a Short Note". This vastly under-quoted paper
unifies lambda calculus with a mixture of ACP and its close relative CCS.
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.55.8907 (free download)
Shortly thereafter CCS creator Robin Milner et al. presented the pi-calculus,
which does something similar.
I am myself working on an Subscript, a language extension to Scala with ACP.
I claim (blurp) that this eases programming GUI controllers, parsers and
simulations. The current implementation is as a DSL, with about 1700 lines
of code; process communication is not supported yet. An executer gets parse
tree information from "scripts", and uses that to maintain a call graph.
I hope to raise interest here, so that some of you will join the further
development. Code, examples and documentation are at