Communication in the languages presented so far is synchronous: a sending action blocks the sender until it can interact with a compatible receiving action at the intended receiver. In this chapter, we consider an alternative semantics for interactions: asynchronous communication. Asynchronous communication allows for a sending action to be executed without waiting for the receiver to be ready by storing the sent message in a message queue that the intended receiver can later read.

We introduce our first choreography language, Simple Choreographies, which allows for writing sequences of interactions between processes. The key aspect of the language is that interactions are syntactically manifest in choreographies. A semantics of choreographies is obtained in terms of a labelled transition system.

Before venturing into the study of choreographies, we introduce the formalism of inference systems. Inference systems are widely used in the fields of formal logic and programming languages and they were later applied to theory of choreographies as well.

To model system implementations, we define the language of Simple Processes. In this language, systems are defined in the classical style of giving a separate program for each process. Process programs use send and receive actions that need to match during execution in order to achieve a communication. We discuss how implementations of choreographies from the previous chapter can be written in terms of this language. We also formulate in our setting the key properties of parallelism, communication safety, and starvation-freedom, respectively: the capability of executing independent communications in any order; the property that processes never attempt to interact by performing incompatible actions; and the property that every running process eventually gets to act.

In this chapter, we outline some of the current lines of research on choreographic languages and provide pointers for further reading.

We explore conservative extensions to Recursive Choreographies, which aim at making choreographies easier to read or to write. These extensions are given as syntactic sugar and include constructs for request-reply interactions, message destructuring, and distributed conditions.

We study the properties of Recursive Choreographies and its related notion of EPP in depth. Endpoint projection is proven to guarantee choreography compliance and communication safety in this setting. Starvation-freedom does not hold anymore in general, due to the possibilities opened by general recursion in Recursive Choreographies, but it holds for the tail-recursive fragment of the language. Under some reasonable assumptions, the weaker property of deadlock-freedom holds for any implementation returned by EPP. That is, the EPP of a choreography never gets stuck.

Concurrent and distributed systems based on message passing have become important drivers of our technological advancement. Their programming requires the integration of communicating processes, at the heart of which we find the notion of choreography: a document that prescribes the communications that processes should perform in order to reach a common goal. We say that a system has the property of choreography compliance if the interactions that take place among processes follow the agreed-upon choreography.

We introduce choreographic choice, another construct for choosing between alternative choreographies. Differently from conditionals, choreographic choices are not necessarily resolved by a single process but might require performing interactions instead.

We equip processes with the capabilities of storing values (memory) and performing local computation. The resulting choreographic and process languages are called, respectively, Stateful Choreographies and Stateful Processes. We update the notion of EPP to these new languages.