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
languages, explained below.
You can find my list of publications in my page in DBLP
Here is a list of additional resources:
- Compositional Choreographies:
a new programming model (given as a process calculus) that allows to compose choreographies as "black boxes", using
Multiparty Session Types as interfaces.
- Deadlock-Freedom-by-design: Multiparty Asynchronous Global Programming:
reports the theoretical foundations (with proofs) of the Chor language, the first programming
language that unifies the practices of using global descriptions for protocol specifications and system implementations (choreographies).
- Service-oriented Programming with Jolie: a book chapter in the Handbook of Web Services (2012) that gives an overview
of the main features of the Jolie language, commenting its behavioural composition model, deployment primitives, and architectural
- Programming Services with Correlation Sets:
a paper on the formal semantics for session correlation in Jolie; reports definitions, comments on implementation, and a nontrivial example of its application.
- Programming Process-aware Web Information Systems with Jolie:
papers on how to program process-aware web application in Jolie, bridging the world of structured processes to the practical need of writing web-enabled systems.
- My MSc Thesis on the Jolie language: contains
an overview of the formal semantics implemented in Jolie, describes the main constructs of the language,
and provides various examples.
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!
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
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.