The blue calculus is a variant of Milner's polyadic pi-calculus. The motivation for introducing this variant is the observation that an indirect style of programming - where one has only an indirect access to values, via their names, and one has to explicitly manage ``result channels'' - is enforced in languages based on the pi-calculus, such as Pict, or the Join-Calculus Language. Indeed, it is a common view that the pi-calculus is a low-level, ``assembly language'' for concurrent computations. Typically, one can define a function that maps a given function over the items of a given list, and bind this value to a name, say map; one can then ``apply'' this name to, say, the factorial function, by actually sending the name factorial on the ``channel'' map, but, although this is syntactically correct in the pi-calculus, a ``type-error'' will be raised, because two arguments must be sent on the map channel. In fact, the situation is even worse, since a third argument - the result channel - must be added to any call to map. More generally, we lack in the pi-calculus a direct usage of functions: pi-terms are not functions (abstractions, in the lambda-calculus terminology), and a pi-term cannot be applied, except in a very restricted way (``pseudo-application'', in the paper mentioned above).

The blue calculus attempts at providing a better programming notation for higher-order concurrency. Compared with the polyadic pi-calculus, it is an asynchronous calculus, where replication is restricted to input prefix, and without sum. The main novelty is that any abstraction is also a process, and that any process may be applied to any name. For instance, a message sent on a ``channel name'' is actually an application of this name to a series of (pointers to) arguments. To enforce the intuition that names must not necessarily be regarded as channels, but are just ordinary names, we have modified the syntax of input prefix: an input prefix on some name is a declaration that some value - more generally: some process - is available under that name, either once or in a replicated manner. In the POPL'97 paper, I have shown that the blue calculus contains directly the lambda-calculus and the pi-calculus (without sum). Moreover, it is remarked that the various continuation passing style transformations for lambda-terms, written in our calculus, actually correspond to encodings already given by Milner and others for evaluation strategies of lambda-terms into the pi-calculus. By extending Plotkin's call-by-name CPS transform, I provide an adequate CPS transform from the blue calculus to the pi-calculus, thus showing that the latter is indeed a ``continuation passing style calculus''.

In the paper I also give a simple type system for the blue calculus, to put the usual constraints on forming applications. This type system encompasses both Curry's type inference for the lambda-calculus, and Milner's sorting for the pi-calculus as particular cases. S. Dal Zilio has studied a polymorphic version of this type system, and the ASIAN'97 paper proposes a new, more informative type system where a declaration that a process is available at some name is given a modal type, in the style of Hennessy-Milner Logic.