Tuesday Wednesday Thursday Friday
09:00 Registration Registration
09:20 Opening
09:30 Tutorial - Farhad Keynote - David Keynote - Catuscia Session 4
10:30 Coffee break Coffee break Coffee break Coffee break
11:00 Tutorial - Farhad Session 1 Session 3 Session 5
12:30 Lunch (13:00) Lunch Lunch Lunch
14:30 Doctoral track Session 2
16:00 Coffee break Reception Social event (15:30)
16:30 Doctoral track
Evening Social dinner (20:00)

Online proceedings

Accepted papers

Session 1

(Chair: Kyungmin Bae)

Session 2

(Chair: Simon Bliudze)

Session 3

(Chair: Olga Kouchnarenko)

Session 4

(Chair: Heike Wehrheim)

Session 5

(Chair: Eric Madelaine)

Bring the schedule on your phone

This year you can bring the schedule for the sessions and events, together with some extra information, by installing the free EventBase App on your phone:

Once you install the App, you just need to search for the FACS conference, which will be automatically downloaded and kept on your phone for off-line use.

Invited speakers

Catuscia Palamidessi

Catuscia Palamidessi


Catuscia Palamidessi is the Director of Research at INRIA Saclay, where she leads the team COMETE. She got her PhD from the University of Pisa in 1988. She held Full Professor positions at the University of Genova, Italy (1994-1997) and at the Pennsylvania State University, USA (1998-2002). Catuscia Palamidessi's research interests include Privacy, Secure Information Flow, and Concurrency. Her past achievements include the proof of expressiveness gaps between various concurrent calculi, and the development of a probabilistic version of the asynchronous pi-calculus. More recently, she has contributed to establish the foundations of probabilistic secure information flow, she has proposed an extension of differential privacy, and geo-indistinguishability, an approach to location privacy.

Enhancing Security via Protocol Composition

(Get the slides)
  • Setting: Quantitative Information Flow. Inference attacks using correlation between secret observables.
  • Defense: The system designer can reduce the correlation secret-observables via protocol composition (typically randomized).
  • Active Adversary: may interact with the system and increase the correlation secret-observables.
  • We formalize the interplay between defender and attacker in Game Theory.
  • Optimal strategy for composition: Saddle points / Nash equilibria. Convex analysis.

David Costa

David Costa


David Costa is the CTO at NewMotion in Amsterdam, and a research member at CWI in Amsterdam at the Foundations of Software Engineering group. He has a Software Engineering and Computer Science education background and received his PhD in Computer Science in 2010 from Vrije Universiteit, Netherlands. His research interests include areas of large scale distributed systems, Immutable infrastructure design, loosely coupled architectures, and cloud computing. Furthermore, David has 10 years of large-scale systems engineering experience, and 5 years of business management responsibilities as the CTO and Head of R&D at Fredhopper in Amsterdam.

Unfortunately this keynote talk was cancelled the day before. The speaker was unable to fly to Portugal because of a large strike in France, affecting all flights flying over France.

Invited Lecturer

Farhad Arbab

Farhad Arbab


Farhad Arbab 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

Interaction Centric Programming

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.