Functions and linguistic style

The goal of the Radian project is to provide the concurrency benefits of a pure functional language inside the syntax and conceptual style of a high-level imperative language. This suggests two questions: what is it about a pure functional language that makes it useful for developing concurrent software, and what is it about an imperative syntax that makes the marriage of these two divergent linguistic styles worth the effort?

A pure functional language is one where functions cannot have side-effects. That is, a function can accept parameter values, perform some computation, and return a value – but it cannot make any change to the state of the machine outside itself. The value returned may be an arbitrarily complex data structure, but everything the function accomplishes must be somehow expressed in it. There is no such thing as a “side effect”, because all potential effects must be part of the function’s explicit interface.

This restriction, onerous as it may seem, has a great deal of value for concurrent programming. Problems of concurrency are all about coordination of access to shared state. In an imperative language, any function may have side effects which alter any piece of shared state at any time. In a functional language, however, pure functions can only touch what you give them, so it is possible to confidently compose pieces of a program without worrying that they will conflict with each other in some hidden way.

This is not an original observation; the combination of pure functions, immutable objects, and transactions has been tried and found useful in several functional languages. My goal with Radian is to present this set of tools in a clean, clear, accessible package suitable for general programming by non-specialists. In syntax, in nomenclature, and in style, therefore, I am trying to create something that will feel clear, straightforward, and familiar. I am not trying to change the way people write software; I am trying to develop a practical tool which will automate away the rat’s nest of difficult problems currently facing anyone trying to write concurrent software.