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.