I feel like a bit of a change of pace, and trying a bit of an experiment.

Re-reading Backus’s old FP work reminds me of what I was doing the last time I read it, which

was back in grad school. At the time, I was working on some stuff involving parallel computation,

and I discovered Robin Milner’s π-calculus as a tool for describing parallel computation. You

can think of π-calculus as being a sort of parallel (pun intended) for the λ-calculus: in

sequential, single-threaded computation, λ-calculus can be a great tool for describing what

things mean. But λ-calculus has absolutely no way of describing the concept of multiple

things happening at once. π-calculus is fundamentally built on the concept of multiple threads

which can only share information by passing messages.

There’s a reason that reading Backus made me think of this, beyond just the temporal coincendence of the fact that I was working with π-calculus the last time I read Backus’s

FP paper. One of the major points that Backus made was how poorly the vonNeumann model was

at describing many computations; that has become *far* more true in recent years. Even my laptop now has multiple processors; computation just isn’t single-threaded anymore. But most programming languages are basically deeply single-threaded. Even Haskell, for all of its functional

purity, isn’t particularly good at multi-threaded execution. But I’ve always thought it would be

a great idea to build a language around π-calculus the way that ML is built around λ-calculus.

So my experiment, such as it is, is to see if I can work through how to create an actual, useful, non-pathological programming language based on the π-calculus; and not just do that,

but do it publicly, here on the blog.

Continue reading →

### Like this:

Like Loading...