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.