is a Full Professor of Computer Science, Chair of Software Composition at Leiden University, and a senior researcher in the Foundations of Software Technology group at the Dutch national Center for Mathematics and Computer Science (CWI), in Amsterdam, the Netherlands. He received his PhD in computer science from University of California, Los Angeles (UCLA), in 1982. He has previously been a visiting faculty at UCLA, a member of the faculty of the Computer Science department at the University of Southern California (USC) in Los Angeles, and an adjunct professor at the School of Computer Science, University of Waterloo, Canada. He has previously worked in the fields of computer graphics, solid modeling, computer aided design, and constraint programming. His current fields of interest include software composition, coordination models and languages, service oriented computing, component based systems, visual programming, and concurrency theory. He leads the work on the development, implementation, and applications of Reo http://reo.project.cwi.nl
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.
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.
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, 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.
Using Reo for concurrent programming not only has significant software engineering advantages, such as modularity, compositionality, verifiability, scalability, and verbatim reuse, it also allows novel, high-level optimizations that result in efficient executable code on multicore platforms. 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.