Tentative Programme

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

Accepted papers

Session 1

  • Component-Based Modeling in Mediator
    Yi Li and Meng Sun
  • A Component-oriented Framework for Autonomous Agents
    Tobias Kappé, Farhad Arbab and Carolyn Talcott
  • Correct Composition of Dephased Behavioural Models
    Juliana Küster Filipe Bowles and Marco B. Caminati

Session 2

  • A Formal Model of Parallel Execution on Multicore Architectures with Multilevel Caches
    Shiji Bijo, Einar Broch Johnsen, Ka I Pun and Silvia Lizeth Tapia Tarifa
  • Guarded Terms for Rewriting modulo SMT
    Kyungmin Bae and Camilo Rocha
  • On Weighted Configuration Logics
    Paulina Paraponiari and George Rahonis

Session 3

  • Compositional Model Checking is Lively
    Sander de Putter and Anton Wijs
  • Safety analysis of software components of a dialysis machine using model checking
    Michael Harrison, Michael Drinnan, Jose Creissac Campos, Paolo Masci, Leo Freitas, Costanzo di Maria and Michael Whitaker
  • TOM: a Model-Based GUI Testing framework (tool paper)
    Miguel Pinto, Marcelo Gonçalves, Paolo Masci and José Creissac Campos

Session 4

  • Correctness-by-learning of infinite-state component-based systems
    Mohamad Jaber, Haitham Bou Ammar and Mohamad Nassar
  • The Implementation of Object Propositions: the Oprop Verification Tool
    Ligia Nistor and Jonathan Aldrich

Session 5

  • Certification of Workflows in a Component-Based Cloud of High Performance Computing Services
    Allberson Dantas, Heron Carvalho and Luis Barbosa
  • Fault Localization in Service Compositions
    Heike Wehrheim
  • Coordination of dynamic software components with JavaBIP
    Anastasia Mavridou, Valentin Rutz and Simon Bliudze

Invited speakers

Catuscia Palamidessi

Catuscia Palamidessi

Biography

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.

David Costa

David Costa

Biography

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.

Invited Lecturer

Farhad Arbab

Farhad Arbab

Biography

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 http://reo.project.cwi.nl.

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.