6.1.1 JOLIE

• Name: Java Orchestration Language Interpreter Engine
• Keyword: Microservices
• Scientific Description: Jolie enforces a strict separation of concerns between behaviour, describing the logic of the application, and deployment, describing the communication capabilities. The behaviour is defined using the typical constructs of structured sequential programming, communication primitives, and operators to deal with concurrency (parallel composition and input choice). Jolie communication primitives comprise two modalities of interaction typical of Service-Oriented Architectures (SOAs), namely one-way (sends an asynchronous message) and request-response (sends a message and waits for an answer). A main feature of the Jolie language is that it allows one to switch among many communication media and data protocols in a simple, uniform way. Since it targets the field of SOAs, Jolie supports the main communication media (TCP/IP sockets, Bluetooth L2CAP, Java RMI, and Unix local sockets) and data protocols (HTTP, JSON-RPC, XML-RPC, SOAP and their respective SSL versions) from this area.
• Functional Description: Jolie is a language for programming service-oriented and microservice applications. It directly supports service-oriented abstractions such as service, port, and session. Jolie allows to program a service behaviour, possibly obtained by composing existing services, and supports the main communication protocols and data formats used in service-oriented architectures. Differently from other service-oriented programming languages such as WS-BPEL, Jolie is based on a user-friendly Java-like syntax (more readable than the verbose XML syntax of WS-BPEL). Moreover, the kernel of Jolie is equipped with a formal operational semantics. Jolie is used to provide proof of concepts around Focus activities.
• Release Contributions: There are many fixes to the HTTP extension, improvements to the embedding engine for Javascript programs, and improvements to the support tools jolie2java and wsdl2jolie.
• News of the Year:

  In 2020 Jolie transitioned to version 1.9.x. The new major release includes a more advanced tracing system, forward and backward documentation primitives, the support for configurations with JSON files (useful, for example, in the development of Docker images), and the extension of the support to Java 11+. The release also includes minor fixes like more complete support for the HTTP(S) protocol, runtime checks for infinite alias loops, and other performance optimisations.

  Also the Jolie ecosystem expanded in 2020 with new tools like: Jolier, which aids in the publication of Jolie APIs following the REST style, jolie2openapi, which produces an OpenAPI definition from a Jolie interface, openapi2jolie, which produces a Jolie interface from an OpenAPI definition, jolietraceviewer, which makes use of the updated tracing system to visualise the execution trace of a service, joliedoc, which is a preexisting tool that received major improvements, including support for forward and backward documentation primitives and a facelift to the documents that it generates.

  The documentation of the language received a major restyle, both content-wise but also structure-wise, to distinguish between features that belong to different versions of the language — e.g. so that users do not mistakenly assume the presence of some more modern features in older versions of the language and can access consistent documentation dedicated to the version they are using.

  Development-wise, the Jolie build system has been ported to Maven and now includes continuous-integration routines to expedite the inclusion of new features and fixes in the main development branch.

  During 2019 the Jolie project saw three major actions.

  The first action regards the build system used for the development of the language, which has been transitioned to Maven, the main build automation tool used for Java projects. The move to Maven is dictated by two needs. The first is to streamline the development and release processes of Jolie, as Maven greatly helps in obtaining, updating, and managing library dependencies. The second necessity addressed by Maven is helping in partitioning the many sub-projects that constitute the Jolie codebase, reducing development and testing times. Having Jolie as a Maven project also helps in providing Jolie sub-components (as Maven libraries) to other projects. Finally, the move to Maven is set within a larger effort to expedite the inclusion in the main Jolie development branch of contributions by new members of its growing community.

  The second action regards the transition to Netty as a common framework to support communication protocols and data formats in Jolie. Netty is a widely-adopted Java framework for the development of network applications, and it was used in 2018 to successfully support several IoT communication protocols and data formats in a Jolie spin-off project, called JIoT. The work in 2019 integrated into the Jolie codebase the protocols and data format developed within the JIoT project and pushed towards the integration of the Netty development branch into the main branch of the Jolie project (i.e., re-implementing using Netty the many protocol and data-formats already supported by Jolie). The Netty development branch is currently in a beta phase and it is subject to thorough in-production tests, to ensure that the behaviour remains consistent with the previous implementation.

  The third action regards the development and support for a new official integrated development environment (IDE) for Jolie. Hence, along with the ones already existing for the Atom and Sublime Text text editors, Jolie developers can use the Jolie plugin (based on the Language Server Protocol) for the Visual Studio Code text editor to obtain syntax highlighting, documentation aids, file navigation, syntax checking, semantic checking, and quick-run shortcuts for their Jolie programs.

  In addition to the above actions, in 2019 Jolie transitioned through three minor releases and a major one, from 1.7.1 to 1.8.2. The minor releases mainly fixed bugs, improved performance, and included new protocol/data-format functionalities. The major release included a slim-down of the notation for the composition of statements, types definitions, and tree structures, for a terser codebase. Upgrades to 1.8.2 also introduced: timeouts for solicit-response invocations to handle the interruption of long-standing requests, more user-friendly messages from the Jolie interpreter, including easier-to-parse errors and the pretty-printing of data structures, for a more effective development and debugging experience.

  In 2019 Jolie also saw the development of a new Jolie library, called TQuery, which is a query framework integrated into the Jolie language for the data handling/querying of Jolie trees. Tquery is based on a tree-based instantiation (language and semantics) of MQuery, a sound variant of the Aggregation Framework, the query language of the most popular document-oriented database: MongoDB. Usage scenarios for Tquery are (but not limited to) eHealth, the Internet-of-Things, and Edge Computing, where data should be handled in an ephemeral way, i.e., in a real-time manner but with the constraint that data shall not persist in the system.

• URL: http://www.jolie-lang.org/
• Contacts: Fabrizio Montesi, Claudio Guidi, Saverio Giallorenzo, Ivan Lanese, Stefano Pio Zingaro, Maurizio Gabbrielli
• Participants: Claudio Guidi, Fabrizio Montesi, Maurizio Gabbrielli, Saverio Giallorenzo, Ivan Lanese, Stefano Pio Zingaro

6.1.2 NightSplitter

• Keyword: Constraint-based programming
• Functional Description: Nightsplitter deals with the group preference optimization problem. We propose to split users into subgroups trying to optimize members' satisfaction as much as possible. In a large city with a huge volume of activity information, designing subgroup activities and avoiding time conflict is a challenging task. Currently, the Demo is available only for restaurant and movie activities in the city of Paris.
• URL: http://cs.unibo.it/t.liu/nightsplitter/
• Contacts: Tong Liu, Maurizio Gabbrielli

6.1.3 AIOCJ

• Name: Adaptive Interaction-Oriented Choreographies in Jolie
• Keyword: Dynamic adaptation
• Scientific Description: AIOCJ is an open-source choreographic programming language for developing adaptive systems. It allows one to describe a full distributed system as a unique choreographic program and to generate code for each role avoiding by construction errors such as deadlocks. Furthermore, it supports dynamic adaptation of the distributed system via adaptation rules.
• Functional Description: AIOCJ is a framework for programming adaptive distributed systems based on message passing. AIOCJ comes as a plugin for Eclipse, AIOCJ-ecl, allowing one to edit descriptions of distributed systems written as adaptive interaction-oriented choreographies (AIOC). From interaction-oriented choreographies the description of single participants can be automatically derived. Adaptation is specified by rules allowing one to replace predetermined parts of the AIOC with a new behaviour. A suitable protocol ensures that all the participants are updated in a coordinated way. As a result, the distributed system follows the specification given by the AIOC under all changing sets of adaptation rules and environment conditions. In particular, the system is always deadlock free. AIOCJ can interact with external services, seen as functions, by specifying their URL and the protocol they support (HTTP, SOAP, ...). Deadlock-freedom guarantees of the application are preserved provided that those services do not block.
• URL: http://www.cs.unibo.it/projects/jolie/aiocj.html
• Contacts: Saverio Giallorenzo, Ivan Lanese
• Participants: Ivan Lanese, Jacopo Mauro, Maurizio Gabbrielli, Mila Dalla Preda, Saverio Giallorenzo

6.1.4 CauDEr

• Name: Causal-consistent Debugger for Erlang
• Keywords: Debug, Reversible computing
• Scientific Description: The CauDEr reversible debugger is based on the theory of causal-consistent reversibility, which states that any action can be undone provided that its consequences, if any, are undone beforehand. This theory relies on a causal semantics for the target language, and can be used even if different processes have different notions of time. Replay is based on causal-consistent replay, which allows one to replay any future action, together with all and only its causes.
• Functional Description: CauDEr is a debugger allowing one to explore the execution of concurrent Erlang programs both forward and backward. Notably, when going backward, any action can be undone provided that its consequences, if any, are undone beforehand. The debugger also provides commands to automatically find relevant past actions (e.g., send of a given message) and undo them, including their consequences. Forward computation can be driven by a log taken from a computation in the standard Erlang/OTP environment. An action in the log can be selected and replayed together with all and only its causes. The debugger enables one to find a bug by following the causality links from the visible misbehaviour to the bug.
• News of the Year: In 2020 a main revision of CauDEr has been started, and will be concluded in 2021. Main novelties include moving the debugger from Core Erlang to Erlang, updating of the interface and integration between user-driven and log-driven forward execution. Additional features of the language, in particular related to distribution and error handling have been also considered. The new version (still unstable) is available at: https://github.com/mistupv/cauder-v2
• URL: https://github.com/mistupv/cauder
• Publications: hal-03005383v1, hal-01912894v1, hal-02313745v1
• Contact: Ivan Lanese
• Participant: Ivan Lanese
• Partner: Universitat Politècnica de València

6.1.5 SUNNY-AS

• Name: SUNNY FOR ALGORITHM SELECTION
• Keywords: Optimisation, Machine learning
• Functional Description: SUNNY-AS is a portfolio solver derived from SUNNY-CP for Algorithm Selection Problems (ASLIB). The goal of SUNNY-AS is to provide a flexible, configurable, and usable portfolio solver that can be set up and executed just like a regular individual solver.
• URL: https://github.com/lteu/oasc
• Contacts: Tong Liu, Roberto Amadini, Jacopo Mauro, Maurizio Gabbrielli

6.1.6 eco-imp

• Name: Expected Cost Analysis for Imperative Programs
• Keywords: Software Verification, Automation, Runtime Complexity Analysis, Randomized algorithms
• Functional Description: Eco-imp is a cost analyser for probabilistic and non-deterministic imperative programs. Particularly, it features dedicated support for sampling from distributions, and can thereby accurately reason about the average case complexity of randomized algorithms, in a fully automatic fashion. The tool is based on an adaptation of the ert-calculus of Kaminski et al., extended to the more general setting of cost analysis where the programmer is free to specify a (non-uniform) cost measure on programs. The main distinctive feature of eco-imp, though, is the combination of this calculus with an expected value analysis. This provides the glue to analyse program components in complete independence, that is, the analysis is modular and thus scalable. As a consequence, confirmed by our experiments, eco-imp runs on average orders of magnitude faster than comparable tools: execution times of several seconds become milliseconds.
• News of the Year: The inference procedure has been further optimized, documentation has been added and the experimental results were significantly extended.
• URL: http://www-sop.inria.fr/members/Martin.Avanzini/software/eco-imp/
• Contact: Martin Avanzini

6.1.7 PRISM+

• Keyword: Stochastic process
• Functional Description: PRISM is a probabilistic model checker, a tool for formal modelling and analysis of systems that exhibit random or probabilistic behaviour. We extend the language in order to model the Bitcoin system. The tool now supports three dynamic data types: block, ledger and list. As consequence, it is now possible to perform simulations and analyse transient probabilities, i.e. probabilities that are dependent on time, for the Bitcoin protocol. It has been used to understand how the system changes during the execution and to analyse the probabilities of reaching an inconsistent state in different settings.
• URL: https://github.com/adeleveschetti/bitcoin-analysis
• Contacts: Adele Veschetti, Cosimo Laneve

6.1.8 Tquery

• Keywords: Ephemeral Data, Microservices, Big data, Querying
• Functional Description:

  Tquery is a query framework integrated into the Jolie language for the data handling/querying of Jolie trees.

  Tquery is based on a tree-based instantiation (language and semantics) of MQuery, a formalisation of a sound fragment of the Aggregation Framework, the query language of the most popular document-oriented database: MongoDB.

  Tree-shaped documents are the main format in which data flows within modern digital systems - e.g., eHealth, the Internet-of-Things, and Edge Computing. Tquery is particularly suited to develop real-time, ephemeral scenarios, where data shall not persist in the system.

• Release Contributions: first release
• URL: https://github.com/jolie/tquery
• Contacts: Saverio Giallorenzo, Fabrizio Montesi, Larisa Safina, Stefano Pio Zingaro
• Partner: University of Southern Denmark

6.1.9 APP

• Name: Allocation Priority Policies
• Keywords: Serverless, Scheduling, Cloud computing, Optimisation
• Functional Description:

  Serverless computing is a Cloud development paradigm where developers write and compose stateless functions, abstracting from their deployment and scaling.

  APP is a declarative language of Allocation Priority Policies to specify policies that inform the scheduling of Serverless function execution to optimise their performance against some user-defined goals.

  APP is currently implemented as a prototype extension of the Serverless Apache OpenWhisk platform.

• Release Contributions: first release
• URL: https://github.com/giusdp/openwhisk
• Contacts: Saverio Giallorenzo, Gianluigi Zavattaro, Jacopo Mauro, Giuseppe De Palma

6.1.10 Choral

• Keywords: Choreographic Programming, Compilation, Modularity, Distributed programming
• Functional Description:

  Choral is a language for the programming of choreographies. A choreography is a multiparty protocol that defines how some roles (the proverbial Alice, Bob, etc.) should coordinate with each other to do something together.

  Choral is designed to help developers program distributed authentication protocols, cryptographic protocols, business processes, parallel algorithms, or any other protocol for concurrent and distributed systems. At the press of a button, the Choral compiler translates a choreography into a library for each role. Developers can use the generated libraries to make sure that their programs (like a client, or a service) follow the choreography correctly. Choral makes sure that the generated libraries are compliant implementations of the source choreography.

  In essence, Choral developers program a choreography with the simplicity of a sequential program. Then, through the Choral compiler, they obtain a set of programs that implement the roles acting in the distributed system. The generated programs coordinate in a decentralised way and they faithfully following the specification from their source choreography, avoiding possible incompatibilities arising from discordant manual implementations. Programmers can use or distribute the single implementations of each role to their customers with a higher level of confidence in their reliability. Moreover, they can reliably compose different Choral(-compiled) programs, to mix different protocols and build the topology that they need.

  Choral currently interoperates with Java (and it is planned to support also other programming languages) at three levels: 1) its syntax is a direct extension of Java (if you know Java, Choral is just a step away), 2) Choral code can reuse Java libraries, 3) the libraries generated by Choral are in pure Java with APIs that the programmer controls, and that can be used inside of other Java projects directly.

• Release Contributions: First release
• URL: https://www.choral-lang.org/
• Contacts: Saverio Giallorenzo, Fabrizio Montesi
• Participants: Saverio Giallorenzo, Fabrizio Montesi, Marco Peressotti
• Partner: University of Southern Denmark

7.1.1 Service-Oriented Computing

Automata models are well-established in many areas of computer science and are supported by a wealth of theoretical results including a wide range of algorithms and techniques to specify and analyse systems. In 14, we have introduced choreography automata for the choreographic modelling of communicating systems. The projection of a choreography automaton yields a system of communicating finite-state machines. We have considered both the standard asynchronous semantics of communicating systems and a synchronous variant of it. For both, the projections of well-formed automata are proved to be live as well as lock- and deadlock-free.

7.1.2 Cloud Computing

Serverless computing is a paradigm for programming cloud applications in terms of stateless functions, executed and scaled in proportion to inbound requests. In 19 we have revisited SKC, a calculus capturing the essential features of serverless programming. By exploring the design space of the language, we refined the integration between the fundamental features of the two calculi that inspire SKC: the $\lambda$- and the $\pi$-calculus. That investigation led us to a revised syntax and semantics, which support an increase in the expressiveness of the language. In particular, now function names are first-class citizens and can be passed around. These new features have been applied to two non-trivial use cases from artificial intelligence, which model, respectively, a perceptron and an image tagging system into compositions of serverless functions. We have also illustrated how SKC supports reasoning on serverless implementations, i.e., the underlying network of communicating, concurrent, and mobile processes which execute serverless functions in the cloud. To that aim, we have presented an encoding from SKC to the asynchronous $\pi$-calculus and proved it correct in terms of an operational correspondence.

Finally, following previous work on the automated deployment of component based applications, we have presented in 27 a formal model specifically tailored for reasoning on the deployment of microservice architectures. The first result that we have presented is a formal proof of decidability of the problem of synthesizing optimal deployment plans for microservice architectures, a problem which was previously proved to be undecidable for generic component-based applications. Then, given that such proof translates the deployment problem into a constraint satisfaction problem, we have presented the implementation of a tool that, by exploiting state-of-the-art constraint solvers, can be used to actually synthesize optimal deployment plans. We have also evaluated the applicability of our tool on a realistic microservice architecture taken from the literature, namely, the deployment of an email processing pipeline that needs to scale-in or -out depending on the amount of incoming emails.

7.3.1 Probabilistic Program Analysis and Higher-Order Calculi

In the last two decades, there has been much progress on model checking of both probabilistic systems and higher-order programs. Dal Lago, together with Kobayashi and Grellois, have initiated a study 7 on the probabilistic higher-order model checking problem, by giving some first theoretical and experimental results. Interestingly, reachability analysis has been proven to be undecidable already at order two.

Dal Lago, in a joint work with Heijtjes and Guerrieri 18, has introduced a probabilistic lambda-calculus in which the probabilistic choice operator is decomposed into two syntactic constructs, thus recovering a form of confluence which is impossible to achieve without this decomposition.

Avanzini et al. 12 has introduced a novel methodology for the automated resource analysis of probabilistic imperative programs, which gives rise to a modular approach. Program fragments are analysed in full independence, thereby allowing the methodology to scale to larger programs. This methodology has also been implemented in the tool eco-IMP, see Section 6. Ample experimental evidence shows that this tool runs typically at least one order of magnitude faster than existing tools, while retaining their precision.

In joint work with Crubillé and Barak 13, Dal Lago has introduced a new model of complexity-bounded probabilistic higher-order computation in which every algorithm is by construction polynomial time computable, and which is thus perfectly adequate as a language for cryptographic construction. Interestingly, certain cryptographic primitives are shown to be impossible to generalize to an higher-order setting.

7.3.2 Quantum Computational Models and Programming Languages

Martini, together with Guerrini and Masini 6, has proposed a definition of quantum Turing machines more general than the usual ones, at the same time extending and unifying the existing definitions due to Deutsch and Bernstein & Vazirani. In particular, an arbitrary quantum input is allowed, together with meaningful superpositions of computations, some of them being “terminated” with an “output”, some others not.

7.3.3 Differences in Probabilistic and Higher-Order Computatbility

Geoffroy and Pistone 24 have shown that the standard metric on real numbers can be lifted to higher-order types in a novel way, yielding a metric semantics of the simply typed lambda-calculus in which types are interpreted as quantale-valued partial metric spaces. Using such metrics, a class of higher-order denotational models, called diameter space models, has been shown to provide a quantitative semantics of approximate program transformations.

7.4.1 Coinductive Techniques

It is known that proving behavioural equivalences in higher-order languages can be hard, because interactions involve complex values, namely terms of the language. In coinductive (i.e., bisimulation-like) techniques for these languages, a useful enhancement is the 'up-to context' reasoning, whereby common pieces of context in related terms are factorised out and erased. In higher-order process languages, however, such techniques are rare, as their soundness is usually delicate and difficult to establish. In 4 we have adapted the technique of unique solution of equations, that implicitly captures 'up-to context' reasoning, to the setting of the Higher-Order $\pi$-calculus.

In 10 we have studied the formalisation (in the HOL theorem prover HOL4) of the theory of unique solution of equations and contraction, for CCS as well as for the main results in Milner's book on the the Calculus of Communicating Systems (CCS). The formalisation consists of about 24,000 lines (1MB) of code. Some refinements of the theory of `unique solution of contractions' itself have thereby been derived.

Below we summarise other papers that are about applications of the theory of coinduction to various settings.

In 11 we have revisited the Interaction Abstract Machine (IAM), a machine based on Girard's Geometry of Interaction. It is an unusual machine, not relying on environments, presented on linear logic proof nets, and whose soundness proof is convoluted and passes through various other formalisms. Here we have provided a new direct proof of its correctness, based on a variant of Sands's improvements, a form of bisimulation related to the above-mentioned contractions.

In 3 we have introduced a notion of applicative similarity in which not terms but monadic values arising from the evaluation of effectful terms, can be compared. We have proven this notion to be fully abstract whenever terms are evaluated in a call-by-name order.

The $\pi$-calculus has been advocated as a model to interpret, and give semantics to, languages with higher-order features. Often these languages make use of forms of references (viewing a store as set of references). In 25 we have developed coinductive proof techniques to reason about the representation of references in the $\pi$-calculus, investigating both their soundess and their completeness with respect to contextual behavioural equivalences such as barbed congruence.

7.4.2 Deadlock Analysis

In 15 we have discussed how to ensure relevant communication properties of communicating systems such as deadlock freedom in a compositional way. The basic idea is that communicating systems can be composed by taking two of their participants and transforming them into coupled forwarders connecting the two systems. We have investigated how to adaptat the idea to settings with asynchronous and synchronous communications.

7.4.3 Static Analysis of Properties of Concurrent Programs

In 2 we have reviewed techniques, mainly based on the theory of process calculi, that we used over the past twenty years to prove results about the expressiveness of coordination languages and behavioural contracts for Service-Oriented Computing. Then, we have shown how such techniques recently contributed to the clarification of aspects of session types such as asynchronous session subtyping.

In 17 we have presented a type-based analysis ensuring memory safety and object protocol completion in the Java-like language Mungo. Objects are annotated with usages, typestates-like specifications of the admissible sequences of method calls. The type system has been implemented in the form of a type checker and a usage inference tool.

7.4.4 Concurrent Constraint Languages

Concurrent Constraint Programming (CCP) is a declarative model for concurrency where agents interact by telling and asking constraints (pieces of information) in a shared store. Some previous works have developed (approximated) declarative debuggers for CCP languages. However, the task of debugging concurrent programs remains difficult. In 5 we have defined a dynamic slicer for CCP (and other language variants) and we have shown it to be a useful companion tool for the existing debugging techniques. Our slicer allows for marking part of the state of the computation and assists the user to eliminate most of the redundant information in order to highlight the errors. We have shown that this technique can be tailored to several variants of CCP, such as the timed language ntcc, linear CCP (an extension of CCP based on linear logic where constraints can be consumed) and some extensions of CCP dealing with epistemic and spatial information. We have also developed a prototypical implementation freely available for making experiments.

7.4.5 Logical Relations

Logical relations are one of the most powerful techniques in the theory of programming languages, and have been used extensively for proving properties of a variety of higher-order calculi. However, there are properties that cannot be immediately proved by means of logical relations, for instance program continuity and differentiability in higher-order languages extended with real-valued functions. Informally, the problem stems from the fact that these properties are naturally expressed in terms of non-ground type (or, equivalently, on open terms of base type), and there is no apparent good definition for a base case (i.e. for closed terms of ground types). To overcome this issue, in 16 we have studied a generalization of the concept of a logical relation, called open logical relation. Our setting is a simply-typed $\lambda$-calculus enriched with real numbers and real-valued first-order functions from a given set, such as the one of continuous or differentiable functions. We have shown by way of open logical relations the correctness of the core of a recently published algorithm for forward automatic differentiation. Finally, we have defined a refinement-based type system for local continuity in an extension of our calculus with conditionals, and proven its soundness using open logical relations.

7.5.1 Computational Thinking

We have reviewed several definitions of computational thinking 8, finding they share a lot of common elements, of very different nature. We have classified them in mental processes, methods, practices, and transversal skills. Many of these elements seem to be shared with other disciplines and resonate with the current narrative on the importance of 21st-century skills. Our classification helps on shedding light on the misconceptions related to each of the four categories, showing that, not to dilute the concept, elements of computational thinking should be intended inside the discipline of Informatics, being its “disciplinary way of thinking”.

7.5.2 Assessing Dropout Rates

Among the many open problems in the learning process, students dropout is one of the most complicated and negative ones, both for the student and the institutions, and being able to predict it could help to alleviate its social and economic costs. To address this problem we have developed in 28 a tool that, by exploiting machine learning techniques, allows one to predict the dropout of a first-year undergraduate student. The proposed tool allows one to estimate the risk of quitting an academic course, and it can be used either during the application phase or during the first year, since it selectively accounts for personal data, academic records from secondary school and also first year course credits. Our experiments have been performed by considering real data of students from eleven schools of a major University.

SEAWALL

SEAWALL (SEAmless loW latency cLoud pLatforms) is coordinated by a company in Bologna "Poggipolini". M. Gabbrielli is coordinating the University of Bologna unit. The industrial partners are Aetna, Bonfiglioli Riduttori, IMA, Sacmi, Philip Morris, Siemens, CDM, Digital River.

The project started in July 2020, and is expected to take 18 months.

9.1.1 Inria associate team not involved in an IIL

9.3.1 FP7 & H2020 Projects

9.3.2 Collaborations with major European organizations

• Universitat Politecnica de Valencia, Spain (on reversibility for Erlang). Contact person(s) in Focus: Lanese. Active exchange but no research visits due to COVID-19 crisis.
• Max Planck Institute for Security and Privacy, Bochum (on static analysis of probabilistic programs). Contact person(s) in Focus: Avanzini and Dal Lago. Mostly confined to online collaboration due to COVID-19 crisis.

9.4.1 DCore

DCore (Causal debugging for concurrent systems) is a 4-years ANR project that started on March 2019 and that will end in August 2023.

The overall objective of the project is to develop a semantically well-founded, novel form of concurrent debugging, which we call “causal debugging”. Causal debugging will comprise and integrate two main engines: (i) a reversible execution engine that allows programmers to backtrack and replay a concurrent or distributed program execution and (ii) a causal analysis engine that allows programmers to analyze concurrent executions to understand why some desired program properties could be violated.

Participants: Ivan Lanese, Doriana Medic.

9.4.2 REPAS

REPAS (Reliable and Privacy-Aware Software Systems via Bisimulation Metrics) is an ANR Project that started on October 2016 and that finished on October 2020.

The project aims at investigating quantitative notions and tools for proving program correctness and protecting privacy. In particular, the focus was put on bisimulation metrics, which are the natural extension of bisimulation to quantitative systems. As a key application, we developed mechanisms to protect the privacy of users when their location traces are collected.

Participants: Ugo Dal Lago, Francesco Gavazzo, Davide Sangiorgi.

9.4.3 PROGRAMme

PROGRAMme (What is a program? Historical and philosophical perspectives) is an ANR project started on October 2017 and that will finish on October 2022; PI: Liesbeth De Mol (CNRS/Université de Lille3).

The aim of this project is to develop a coherent analysis and pluralistic understanding of “computer program” and its implications to theory and practice.

Participants: Simone Martini.

9.4.4 PPS

PPS (Probabilistic Programming Semantics) is an ANR PCR project that started on January 2020 and that will finish on July 2024.

Probabilities are essential in Computer Science. Many algorithms use probabilistic choices for efficiency or convenience and probabilistic algorithms are crucial in communicating systems. Recently, probabilistic programming, and more specifically, functional probabilistic programming, has shown crucial in various works in Bayesian inference and Machine Learning. Motivated by the rising impact of such probabilistic languages, the aim of this project is to develop formal methods for probabilistic computing (semantics, type systems, logical frameworks for program verification, abstract machines etc.) to systematize the analysis and certification of functional probabilistic programs.

Participants: Martin Avanzini, Ugo Dal Lago, Davide Sangiorgi.

10.1.1 Scientific events: organisation

10.1.2 Journal

10.1.3 Invited talks

• BUsec, the security seminar at Boston University, on “Higher-Order Cryptography”, May 2020 (U. Dal Lago)

10.1.4 Leadership within the scientific community

• I. Lanese is chair of the IFIP (International Federation for Information Processing) WG6.1 on Architectures and Protocols for Distributed Systems.
• U. Dal Lago is a member of the scientific councils of the Italian Chapter of the EATCS, and of the Italian Association on Logic and its Applications.
• S. Martini is a member of the Council of the Commission on History and Philosophy of Computing, an organism of the International Union for History and Philosophy of Science, 2017-2021.

10.1.5 Research administration

• M. Gabbrielli is Deputy Head of the Department of Computer Science and Engineering, University of Bologna, since May 2018.
• D. Sangiorgi is coordinator of postgraduate studies at the Department of Computer Science and Engineering, University of Bologna.
• G. Zavattaro is coordinator of undergraduate studies at the Department of Computer Science and Engineering, University of Bologna.

10.2.1 Teaching

• Martin Avanzini
  • “Introduction to Theoretical Computer Science”, 30 hours, 1st year, University of Innsbruck, Austria.
• Mario Bravetti
  • “Linguaggi, Compilatori e Modelli Computazionali”, 120 hours, 1st year Master, University of Bologna, Italy.
  • “Models and Languages for Service-Oriented and Cloud Computing”, 16 hours, PhD program, University of Bologna, Italy.
• Ugo Dal Lago
  • “Algorithms and Data Structures for Biology”, 60 hours, 2nd year, University of Bologna, Italy. 20 hours, 1st year, University of Bologna, Italy.
  • “Optimization”, 36 hours, 2nd year, University of Bologna, Italy.
  • “Foundations of Logic for Computer Science”, 24 hours, 2nd year Master, University of Bologna, Italy.
  • “Cryptography”, 40 hours, 2nd year Master, University of Bologna, Italy.
  • “Languages and Algorithms for AI: Machine Learning Theory”, 32 hours, 1st year Master, University of Bologna, Italy.
• Ivan Lanese
  • “Architettura degli Elaboratori”, 66 hours, 1st year, University of Bologna, Italy.
  • “Ingegneria del Software Orientata ai Servizi”, 22 hours, 2nd year Master, University of Bologna, Italy.
  • “Algorithms and Data Structures for Computational Biology”, 28 hours, 1st year Master, University of Bologna, Italy.
  • “Computational Methods for Bioinformatics”, 36 hours, 1st year Master, University of Bologna, Italy.
• Michael Lodi
  • “Computer Science Education”, 18 hours, 2nd year Master, University of Bologna, Italy.
• Simone Martini
  • “Programmazione”, 78 hours, 1st year, University of Bologna, Italy.
  • “Introduction to Algorithms and Programming”, 40 hours, 1st year Master, University of Bologna, Italy.
• Davide Sangiorgi
  • “Operating Systems”, 110 hours, 2nd year undergraduate program, University of Bologna, Italy.
  • “Computer abilities”, 16 hours, 2nd year Master in Medicine, University of Bologna, Italy.
• Gianluigi Zavattaro
  • “Algoritmi e Strutture di Dati”, 70 hours, University of Bologna, Italy.
  • “Algoritmi e Strutture di Dati”, 32 hours, undergraduate program in Comperuter Science and Management, University of Bologna, Italy.
  • “Scalable and Cloud Programming”, 50 hours, Master, University of Bologna, Italy.
  • “Languages and Algorithms for Artificial Intelligence”, 32 hours, Master in Artificial Intelligence, University of Bologna, Italy.

10.2.2 Supervision

Below are the details on the PhD students in Focus: starting date, topic or provisional title of the thesis, supervisor(s).

• Melissa Antonelli, November 2019. “Probabilistic Arithmetic and Almost-sure Termination”. Supervisor Ugo Dal Lago.
• Gabriele Vanoni, November 2018. “Optimal Reduction, Geometry of Interaction, and the Space-Time Tradeoff”. Supervisor Ugo Dal Lago.
• Enguerrand Prebet, Sept 2019, “The pi-calculus model of programming languages”. Supervisors Daniel Hirschkoff and Davide Sangiorgi.

PhD theses completed in 2020:

• Michael Lodi, April 2020, “Introducing Computational Thinking in K-12 Education: Historical, Epistemological, Cognitive and Affective Aspects” 31. Supervisor Simone Martini.
• Adrien Durier, June 2020, “Proving behavioural properties of higher-order concurrent languages”, ENS de Lyon and University of Bologna. Supervisors: Daniel Hirschkoff and Davide Sangiorgi.

10.2.3 Juries

• G. Zavattaro has been member of the PhD evaluation committee at the Department of Computer Science, University of Pisa, Italy.
• I. Lanese has been member of the PhD evaluation committee of Kyriaki Psara, supervisor Anna Philippou, University of Cyprus, Cyprus.

History of Programming Languages

Apart from the above mentioned contributions, Martini has taken steps in a larger project—reflecting and tracing the interaction between mathematical logic and programming (languages), identifying some of the driving forces of this process.

Despite the insight of some of the pioneers (Turing, von Neumann, Curry, Böhm), programming the early computers was a matter of fiddling with small architecture-dependent details. Only in the sixties some form of “mathematical program development” will be in the agenda of some of the most influential players of that time. A “Mathematical Theory of Computation” is the name chosen by John McCarthy for his approach, which uses a class of recursively computable functions as an (extensional) model of a class of programs. It is the beginning of that grand endeavour to present programming as a mathematical activity, and reasoning on programs as a form of mathematical logic. An important part of this process is the standard model of programming languages-the informal assumption that the meaning of programs should be understood on an abstract machine with unbounded resources, and with true arithmetic. In 22 we present some crucial moments of this story, concluding with the emergence, in the seventies, of the need of more “intensional” semantics, like the sequential algorithms on concrete data structures.

International journals

• 1 articleMartinM. Avanzini, UgoU. Dal Lago and AkihisaA. Yamada. On probabilistic term rewritingScience of Computer Programming185January 2020, 102338
  HALDOI
• 2 articleMarioM. Bravetti and GianluigiG. Zavattaro. Process calculi as a tool for studying coordination, contracts and session typesJournal of Logical and Algebraic Methods in Programming112April 2020, 100527
  HALDOIback to text
• 3 articleUgoU. Dal Lago, FrancescoF. Gavazzo and RyoR. Tanaka. Effectful applicative similarity for call-by-name lambda calculiTheoretical Computer Science813April 2020, 234-247
  HALDOIback to text
• 4 articleAdrienA. Durier, DanielD. Hirschkoff and DavideD. Sangiorgi. Towards 'up to context' reasoning about higher-order processesTheoretical Computer Science8072020, 154-168
  HALDOIback to text
• 5 articleMorenoM. Falaschi, MaurizioM. Gabbrielli, CarlosC. Olarte and CatusciaC. Palamidessi. Dynamic slicing for Concurrent Constraint LanguagesFundamenta Informaticae1773-4December 2020, 331-357
  HALDOIback to text
• 6 article StefanoS. Guerrini, SimoneS. Martini and AndreaA. Masini. Quantum Turing Machines: Computations and Measurements Applied Sciences 10 16 August 2020
  HAL DOI back to text
• 7 article NaokiN. Kobayashi, UgoU. Dal Lago and CharlesC. Grellois. On the Termination Problem for Probabilistic Higher-Order Recursive Programs Logical Methods in Computer Science October 2020
  HAL DOI back to text
• 8 articleMichaelM. Lodi. Informatical ThinkingOlympiads in Informatics: An International Journal14September 2020, 113-132
  HALDOIback to text
• 9 articleDorianaD. Medić, Claudio AntaresC. Mezzina, IainI. Phillips and NobukoN. Yoshida. A parametric framework for reversible π-calculiInformation and Computation275December 2020, 104644
  HALDOIback to text
• 10 articleChunC. Tian and DavideD. Sangiorgi. Unique solutions of contractions, CCS, and their HOL formalisationInformation and Computation275December 2020, 104606
  HALDOIback to text

International peer-reviewed conferences

• 11 inproceedingsBeniaminoB. Accattoli, UgoU. Dal Lago and GabrieleG. Vanoni. The Machinery of InteractionPPDP '20 - 22nd International Symposium on Principles and Practice of Declarative ProgrammingBologna, ItalySeptember 2020, 1-15
  HALDOIback to text
• 12 inproceedings MartinM. Avanzini, GeorgG. Moser and MichaelM. Schaper. A Modular Cost Analysis for Probabilistic Programs Proceedings of OOPSLA 2020 OOPSLA 2020 - Conference on Object-oriented Programming, Systems, Languages, and Applications part of SPLASH 2020 Chicago / Online, United States November 2020
  HAL back to text
• 13 inproceedings BoazB. Barak, RaphaëlleR. Crubillé and UgoU. Dal Lago. On Higher-Order Cryptography ICALP 2020 - 47th International Colloquium on Automata, Languages, and Programming Saarbrucken, Germany July 2020
  HAL DOI back to text
• 14 inproceedingsFrancoF. Barbanera, IvanI. Lanese and EmilioE. Tuosto. Choreography AutomataCOORDINATION 2020 - 22nd International Conference on Coordination Models and LanguagesValletta, Malta2020, 86 - 106
  HALDOIback to text
• 15 inproceedings FrancoF. Barbanera, IvanI. Lanese and EmilioE. Tuosto. Composing Communicating Systems, Synchronously ISoLA 2020 - 9th International Symposium On Leveraging Applications of Formal Methods, Verification and Validation Rhodes, Greece October 2020
  HAL back to text
• 16 inproceedings GillesG. Barthe, RaphaëlleR. Crubillé, UgoU. Dal Lago and FrancescoF. Gavazzo. On the Versatility of Open Logical Relations: Continuity, Automatic Differentiation, and a Containment Theorem Programming Languages and Systems - 29th European Symposium on Programming, ESOP 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, {ETAPS} 2020, Dublin, Ireland, April 25-30, 2020, Proceedings ESOP 2020 - 29th European Symposium on Programming. Held as Part of the ETAPS 2020 - European Joint Conferences on Theory and Practice of Software Dublin, Ireland April 2020
  HAL back to text
• 17 inproceedings MarioM. Bravetti, AdrianA. Francalanza, IaroslavI. Golovanov, HansH. Hüttel, Mathias SM. Jakobsen, Mikkel KM. Kettunen and AntónioA. Ravara. Behavioural Types for Memory and Method Safety in a Core Object-Oriented Language APLAS 2020 - 18th Asian Symposium on Programming Languages and Systems Fukuoka / Virtual, Japan https://conf.researchr.org/home/aplas-2020 November 2020
  HAL back to text
• 18 inproceedingsUgoU. Dal Lago, GiulioG. Guerrieri and WillemW. Heijltjes. Decomposing Probabilistic Lambda-CalculiFOSSACS 2020 - Foundations of Software Science and Computation Structures - 23rd International ConferenceDublin, IrelandApril 2020, 136-156
  HALDOIback to text
• 19 inproceedings SaverioS. Giallorenzo, IvanI. Lanese, FabrizioF. Montesi, DavideD. Sangiorgi and Stefano PioS. Zingaro. The Servers of Serverless Computing: A Formal Revisitation of Functions as a Service Recent Developments in the Design and Implementation of Programming Languages Recent Developments in the Design and Implementation of Programming Languages, Italy November 2020
  HAL DOI back to text
• 20 inproceedings IvanI. Lanese and DorianaD. Medić. A General Approach to Derive Uncontrolled Reversible Semantics CONCUR 2020 - 31st International Conference on Concurrency Theory Wien / Online, Austria September 2020
  HAL DOI back to text
• 21 inproceedingsIvanI. Lanese, IainI. Phillips and IrekI. Ulidowski. An Axiomatic Approach to Reversible ComputationFoSSaCS 2020 - 23rd International Conference on Foundations of Software Science and Computation StructuresDublin, Ireland2020, 442 - 461
  HALDOIback to textback to text
• 22 inproceedings SimoneS. Martini. The Standard Model for Programming Languages: The Birth of a Mathematical Theory of Computation Recent Developments in the Design and Implementation of Programming Languages Bologna, Italy November 2020
  HAL DOI back to text
• 23 inproceedings DorianaD. Medić, ClaudioC. Antares Mezzina, IainI. Phillips and NobukoN. Yoshida. Towards a formal account for software transactional memory RC 2020 - 12th International Conference on Reversible Computation Oslo, Norway July 2020
  HAL back to text

Conferences without proceedings

• 24 inproceedings GuillaumeG. Geoffroy and PaoloP. Pistone. A Partial Metric Semantics of Higher-Order Types and Approximate Program Transformations Computer Science Logic, CSL 2021 Lubjana, Slovenia January 2021
  HAL DOI back to text
• 25 inproceedings DanielD. Hirschkoff, EnguerrandE. Prebet and DavideD. Sangiorgi. On the Representation of References in the Pi-Calculus CONCUR 2020 - 31st International Conference on Concurrency Theory Vienna / Virtual, Austria 2020
  HAL DOI back to text

Scientific book chapters

• 26 inbookBogdanB. Aman, GabrielG. Ciobanu, RobertR. Glück, RobinR. Kaarsgaard, JarkkoJ. Kari, MartinM. Kutrib, IvanI. Lanese, Claudio AntaresC. Mezzina, ŁukaszŁ. Mikulski, RajagopalR. Nagarajan, IainI. Phillips, Giovanni MicheleG. Pinna, LucaL. Prigioniero, IrekI. Ulidowski and GermánG. Vidal. Foundations of Reversible Computation12070Reversible Computation: Extending Horizons of Computing - Selected Results of the COST Action IC14052020, 1 - 40
  HALDOIback to text
• 27 inbook MarioM. Bravetti, SaverioS. Giallorenzo, JacopoJ. Mauro, IacopoI. Talevi and GianluigiG. Zavattaro. A Formal Approach to Microservice Architecture Deployment * Microservices, Science and Engineering 2020
  HAL back to text
• 28 inbookFrancescaF. Del Bonifro, MaurizioM. Gabbrielli, GiuseppeG. Lisanti and Stefano PioS. Zingaro. Student Dropout PredictionArtificial Intelligence in EducationJune 2020, 129-140
  HALDOIback to text
• 29 inbookJamesJ. Hoey, IvanI. Lanese, NaokiN. Nishida, IrekI. Ulidowski and GermánG. Vidal. A Case Study for Reversible Computing: Reversible Debugging of Concurrent ProgramsReversible Computation: Extending Horizons of Computing - Selected Results of the COST Action IC14052020, 108 - 127
  HALDOIback to text
• 30 inbookClaudio AntaresC. Mezzina, RudolfR. Schlatte, RobertR. Glück, TueT. Haulund, JamesJ. Hoey, MartinM. Holm Cservenka, IvanI. Lanese, Torben ÆT. Mogensen, HarunH. Siljak, Ulrik PU. Schultz and IrekI. Ulidowski. Software and Reversible Systems: A Survey of Recent ActivitiesReversible Computation: Extending Horizons of Computing - Selected Results of the COST Action IC14052020, 41 - 59
  HALDOIback to text

Doctoral dissertations and habilitation theses

• 31 thesis MichaelM. Lodi. Introducing Computational Thinking in K-12 Education: Historical, Epistemological, Pedagogical, Cognitive, and Affective Aspects Dipartimento di Informatica - Scienza e Ingegneria, Alma Mater Studiorum - Università di Bologna April 2020
  HAL back to text

Reports & preprints

• 32 misc DanielD. Hirschkoff, EnguerrandE. Prebet and DavideD. Sangiorgi. On the Representation of References in the pi-calculus July 2020
  HAL DOI
• 33 report IvanI. Lanese and DorianaD. Medić. A General Approach to Derive Uncontrolled Reversible Semantics (TR) INRIA Sophia Antipolis - Méditerranée; Universita di Bologna September 2020
  HAL

Scientific popularization

• 34 inbook M. Lodi, R. Davoli, R. Montanari and S. Martini. Informatica senza e con computer nella Scuola Primaria Coding e oltre: l'Informatica nella scuola https://www.liscianiscuola.it/prodotto/coding-e-oltre-linformatica-nella-scuola/ September 2020
  HAL
• 35 inproceedings M. Lodi, S. Martini, M. Sbaraglia and S. Zingaro. (Non) parliamo di pensiero computazionale Proceedings of XXXIV Convegno Nazionale “Incontri con la Matematica” XXXIV Convegno Nazionale “Incontri con la Matematica” Castel San Pietro Terme / Online, Italy November 2020
  HAL