Abstract: Programming language constructs and abstractions, along with techniques for their efficient compilation,
have dramatically advanced in the last half-century, to the extent that today we can program at the level of
(parametric) types, classes, objects, mathematical functions, monads, or Horn clauses, when appropriate, and obtain
executable code whose performance competes with---indeed often beats---that of code written by competent
programmers in some low-level language. Protocols constitute an equally significant abstraction in specification of
concurrent applications as do functions, types, and other computational constructs, and their concrete implementation
has an equally significant impact on performance and scalability of an application as that of any high-level
computational construct.
In spite of significant advances in concurrency theory, constructs and models for programming of concurrent
applications have essentially stagnated in the past half-century. In contrast to advances in abstractions and
constructs for sequential programming, no real abstract protocol constructs have evolved. Consequently,
programmers today use the same cumbersome, error-prone concurrency constructs to express protocols in
modern software as they did 50 years ago: processes, threads, locks, semaphores, monitors, rendezvous, etc.
The unavailability of high-level protocol constructs in contemporary programming languages hampers full
utilization of the enormous potential offered by massively parallel hardware platforms in real-life applications.
In this course, we describe an interaction-centric model of concurrency that turns interaction protocols into
concrete first-class mathematical objects, expressed as relations that constrain communication actions of their
engaged processes. This model serves as the formal foundation for a domain-specific language (DSL), called
Reo, for programming concurrency protocols. A protocol in Reo manifests itself as a connector. Complex
connectors result from direct composition of simpler ones, which in turn comprise of a network of primitive
binary connectors, called channels. In Reo, interaction protocols become explicit, concrete, tangible pieces
of software that can be specified, verified, composed, and reused, independently of the actors that they may
engage in various applications. We explore different formal semantics of Reo, its various software
development support tools, and discuss compilation and optimization techniques for generating efficient
executable code from high-level protocol specifications in Reo.
Short Bio: Farhad Arbab is Emeritus Professor of computer science, at Leiden University (LIACS), and a former
senior researcher at the Dutch national research Center for Mathematics and Computer Science (CWI) in Amsterdam,
the Netherlands. Dr. Arbab received his PhD in Computer Science from the University of California, Los Angeles
(UCLA) in 1982, and is internationally known as a leader in coordination models and languages, concurrency theory,
component-based and service oriented software engineering.
