Fabrizio Montesi

Short Bio

My Curriculum Vitae

I am a PhD student at the IT University of Copenhagen, supervised by Prof. Marco Carbone, and a founder of italianaSoftware s.r.l.. My work involves the design and development of programming languages for concurrent systems. In particular, I authored and currently maintain the Jolie programming language, and I am developing strongly-typed languages for safe global programming. You can read more about my research in my research page.
italianaSoftware s.r.l. is an award-winning start-up company that develops service-oriented solutions using Jolie, located in Imola (Italy).
I am also an external collaborator of the FOCUS Research Team, led by Prof. Davide Sangiorgi. The FOCUS Team is the first joint research group formed through a collaboration between INRIA (France) and the University of Bologna (Italy).

Abstract

My research interests cover concurrency theory, distributed systems, service-oriented computing, web technologies, type systems, and most importantly the design and implementation of programming languages.
My current work is focused on the Jolie and Chor languages, explained below.

Publications

You can find my list of publications in my page in DBLP. Here is a list of additional resources:

Jolie

I am a main author and the maintainer of Jolie, the first general-purpose programming language based on the service-oriented programming paradigm. Jolie has led to the winning of some prestigious awards in Italy, both industrial and academic. Jolie is the development language at italianaSoftware s.r.l., a research spin-off start-up company that develops service-oriented solutions.
Jolie mixes the imperative and message-passing programming paradigm for offering an intuitive and expressive solution for programming services.




Its most notable features are:
  • Formal semantics: Jolie is based upon a solid mathematical foundation, the SOCK process calculus. Its semantics is thus formally specified, in contrast with the sometimes ambiguous semantics of other service-oriented solutions (e.g., WS-BPEL in Web Services). The formal basis of Jolie shortens the time needed to bring useful theoretical results into practice, by exploiting the abstraction offered by the Jolie Development API.
  • Safety: Jolie implements static and runtime techniques for ensuring program safety in various aspects, such as the programming of correct session references. These checks are made possible by the fact that Jolie uplifts crucial aspects of service-oriented programming to native language constructs.
  • Simplicity: Jolie provides simple and powerful primitives for handling data trees and structured documents (e.g., XML) that can be implicitly converted to other data formats.
  • Integration: Jolie is compatible with various different techonologies, ranging from Java to Web Services and C++. The most powerful integration feature is communication abstraction: Jolie can seamlessly use different data formats (from SOAP to binary protocols) and communication mediums (local memory, Bluetooth, TCP/IP sockets, etc.). You can take a Jolie program and re-deploy it with different communication technologies changing a single line of code! Jolie supports this mechanism also at runtime, through the usage of dynamic binding.
  • Fault handling: Jolie is the first language offering dynamic and compositional fault handling. Dynamic fault handling is a form of higher-order code composition in which the programmer can update a fault handler at runtime. This is not only more expressive than classical static fault handler definition, but the enhanced expressivity gives direct benefits in the programming of fault recovery procedures in distributed environments.
  • Efficiency: the Jolie interpreter has much lower memory consumption than other similar Web Services technologies and it also performs a lot of optimisations in network resource usage. In practice, this allows for the development of much more modular systems.
Jolie is also open source, and we are always looking for people that want to join us in its development!

Chor

I am currently developing Chor (website), a language for the implementation of concurrent systems in terms of global programs. Chor allows for the specification of protocols as behavioural types and the definition of global programs based upon them. I have developed a development environment in Eclipse for creating and checking Chor programs, which you can download from the Eclipse marketplace here. Once a program is written and checked, a tool is provided to automatically generate Jolie code that correctly implements a Chor program.
Chor provides the following main contributions:
  • Protocol-based verification: in Chor, communication protocol specifications are defined as program terms and can be used to statically verify that a system implementation complies with them.
  • Deadlock analysis: Chor defines a new static analysis for ensuring deadlock-freedom in distributed systems, which is both fast (linear wrt the analysed program) and powerful (Chor improves on the state of the art by detecting new safe programs).
  • Productivity: Chor simplifies the task of prototyping complex concurrent systems by allowing programmers to specify the different behaviours of all entities in a system in a single program, from which the code for each endpoint entity can then be automatically generated.
  • Clarity: Chor programs define the behaviour of a communicating system in a much clearer way than classic approaches. In Chor, communications are atomically described as interactions between two parties, whereas in other languages they are usually the result of executing in parallel separately specified i/o actions.