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 2022 Jolie saw 4 minor releases (1.10.7, 1.10.10, 1.10.12, 1.10.13) and the transition to the alpha and beta major release 1.11.0. The new major release includes many extensions, comprising both the language and its runtime. One main language extension regards the introduction of a new functional notation for operations. This is syntactic sugar for request-response operations so that they behave similarly to functions. For example, instead of writing `contains@StringUtils( ... )( resp ), if ( resp ){ ... }` one can write `if( contains@StringUtils( ... ) ){ ... }`, removing the need for the bypass variable `resp` and resulting in a more concise and easier-to-follow logic. Runtime extensions include advanced, programmer-friendly error messages. This is both from the point of view of error visualisation (e.g., tracing of the flow of faults among services, modulation of the amount of detail the runtime provides on these) and of suggestions to fix errors (e.g., by reporting possible spelling mistakes and their possible fixes). Other runtime updates regarded the transition of more pieces of the standard library from the old module system (`include`) to the new one (`from ... import ...`). Minor releases mainly regarded optimisations (e.g., releasing unused cache memory) or fixing bugs in the runtime or in extensions. Further effort has been put also into the development of the Jolie Package Manager (jpm). Extensions regarded the inclusion of templates to quickly kickstart new Jolie projects and more integrated support for Docker development environments.
• URL:
  http://­www.­jolie-lang.­org/
• Contact:
  Saverio Giallorenzo
• Participants:
  Claudio Guidi, Fabrizio Montesi, Maurizio Gabbrielli, Saverio Giallorenzo, Ivan Lanese, Stefano 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/
• Contact:
  Maurizio Gabbrielli

6.1.3 CauDEr

• Name:
  Causal-consistent Debugger for Erlang
• Keywords:
  Debug, Reversible computing
• Scientific Description:
  The CauDEr reversible debugger for Erlang 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 and distributed 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 2022 the development focused on the integration of imperative primitives to manage maps of atoms to pids. We plan to integrate it into CauDEr in early 2023. Apart from this we did basic maintenance.
• 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.4 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
• Contact:
  Maurizio Gabbrielli

6.1.5 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:
  In 2022, the tool has seen a major overhaul in its inference machinery so as to account for recursive procedures. It has also been extended from a reasoning tool about costs to general expectations.
• URL:
  http://­www-sop.­inria.­fr/­members/­Martin.­Avanzini/­software/­eco-imp/
• Publication:
  hal-03013544
• Contact:
  Martin Avanzini

6.1.6 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 a 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
• Contact:
  Adele Veschetti

6.1.7 Tquery

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

  The adoption of edge/fog systems and the introduction of privacy-preserving regulations compel the usage of tools for expressing complex data queries in an ephemeral way—ensuring the queried data does not persist.

  Database engines partially address this need, as they provide domain-specific languages for querying data. Unfortunately, using a database in an ephemeral setting has inessential issues related to throughput bottlenecks, scalability, dependency management, and security (e.g., query injection). Moreover, databases can impose specific data structures and data formats, which can hinder the development of microservice architectures that integrate heterogeneous systems and handle semi-structured data.

  Tquery is the first query framework designed for ephemeral data handling in microservices. Tquery joins the benefits of a technology-agnostic, microservice-oriented programming language, Jolie, and of one of the most widely-used query languages for semi-structured data in microservices, the MongoDB aggregation framework. With Tquery, users express in a terse syntax how to collect data from heterogeneous sources and how to query it in local memory, defining pipelines of high-level operators. The development of Tquery follows a "cleanroom software engineering process", based on the definition of a theory for querying semi-structured data compatible with Jolie and inspired by a consistent variant of the key operators of the MongoDB aggregation framework.

• 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
• News of the Year:
  In 2022, Tquery transitioned from the 0.x to the 1.x version. This marked the passage from the "research" to the "development" stage of the library. Indeed, the main effort dedicated to the transition has been the optimisation of the query engine, to maximise its performance and the implementation of a thorough test suite to compare Tquery with alternatives, first of all, MongoDB.
• URL:
  https://­github.­com/­jolie/­tquery
• Contact:
  Saverio Giallorenzo
• Partner:
  University of Southern Denmark

6.1.8 APP

• Name:
  Allocation Priority Policies
• Keywords:
  Serverless, Scheduling, Cloud computing, Optimisation
• Scientific Description:
  APP addresses the problem of function execution scheduling, i.e., how to schedule the execution of Serverless functions to optimise their performance against some user-defined goals, by specifying policies that inform the scheduling of function execution.
• 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
• News of the Year:
  In 2022, work on APP mainly regarded the formalisation of the language, both to formally reason on its semantics (e.g., on the complexity of schedulings) and to provide a standard, non-ambiguous definition of policy behaviours. This initiated a beneficial revision process that helped us consolidate APP into a more consistent language — which also lead to refinements of its runtime — and gave us useful insights for its evolution.
• URL:
  https://­github.­com/­giusdp/­openwhisk
• Contact:
  Saverio Giallorenzo

6.1.9 Choral

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

  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 follow 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.

• 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.

• Release Contributions:
  First release
• News of the Year:
  In 2022, Choral moved to version 0.1.1. While this is a minor release, it includes many quality-of-life improvements for developers that use the language. These comprise: a revision of the class system of the Choral runtime library into a more consistent set of elements that users can combine (e.g., channels, data structures, etc), the extension of the Choral runtime, mainly importing frequently-used libraries from the Java standard library, better reporting of compilation errors, with additional information on how to fix bugs in Choral classes. The release also includes a consolidation of the codebase and minor bug fixes. 2022 saw also the implementation of a fairly big use-case distributed system in Choral (a clone of Twitter), which suggested some of the extensions and helped us spot the bugs mentioned above.
• URL:
  https://­www.­choral-lang.­org/
• Contact:
  Saverio Giallorenzo
• Participants:
  Saverio Giallorenzo, Fabrizio Montesi
• Partner:
  University of Southern Denmark

6.1.10 Corinne

• Keywords:
  Choreography automata, Communicating finite state machines
• Scientific Description:

  Corinne relies on the theory of choreography automata, which is described in:

  Franco Barbanera, Ivan Lanese, Emilio Tuosto: Choreography Automata. COORDINATION 2020: 86-106

  Franco Barbanera, Ivan Lanese, Emilio Tuosto: Composition of choreography automata. CoRR abs/2107.06727 (2021)

• Functional Description:

  Choreography automata (c-automata) are finite state automata whose transitions are labelled with interactions of the form A -> B : m, representing a communication in which participant A sends a message (of type) m to participant B, and participant B receives it. Corinne allows one to display c-automata represented in the dot format, and:

  - project them on communicating finite state machines representing the behaviour of single participants

  - compute a product c-automaton corresponding to the concurrent execution of two c-automata

  - synchronize two participants of a c-automaton transforming them into couple gateways

  - check well-formedness conditions ensuring that the system of participants obtained via projection behaves well

• News of the Year:
  In 2022 Corinne was not further developed.
• URL:
  https://­github.­com/­lanese/­corinne-3
• Publication:
  hal-03468190
• Contact:
  Ivan Lanese
• Partner:
  Gran Sasso Science Institute

Reversibility

We have continued the study of reversibility started in the past years. As usual, our efforts target concurrent systems and follow the causal-consistent reversibility approach, where any action can be undone provided that its consequences, if any, are undone beforehand. We tackled both theoretical questions and practical applications in the area of debugging of concurrent Erlang programs.

From a theoretical point of view, we considered the impact of time on causal-consistent reversibility 27. More precisely, we defined a causal-consistent reversible extension of the Temporal Process Language by Hennessy and Regan, a CCS with discrete time and a timeout operator. We proved that our extension satisfies the properties expected from a causal-consistent reversible calculus and we showed that it can also be interpreted as an extension of reversible CCS (in particular CCSK from Ulidowski and Phillips) with time.

Reversible debugging of concurrent systems can be tackled using causal-consistent debugging, which exploits causal-consistent reversibility to explore a concurrent execution backward following causality links from a visible misbehavior towards the bug causing it. In the past we exploited this idea to build CauDEr, a Causal-consistent Debugger for Erlang. We extended CauDEr to support the primitives used in Erlang to manage a shared map associating process identifiers to names 38. Notably, these primitives are imperative, while the core of Erlang is functional. We also showcased the application of CauDEr to find a concurrency bug in a small case study in a form accessible to programmers with no previous knowledge of reversibility 45. Finally, to bridge the gap between the theoretical foundations of causal-consistent reversibility and CauDEr, we developped a generator able to take a semantics in Maude (following a pre-defined structure) and automatically generating its causal-consistent extension 34. We applied it to a semantics of Erlang we defined. The resulting executable causal-consistent semantics can be used as an oracle against which one can test CauDEr behavior, while being in a direct match with the theoretical foundations of Erlang and reversibility.

7.3.1 Randomized and Quantum Programs: Termination and Complexity

In FoCUS, we are interested in studying notions of termination and resource analysis for non-standard computing paradigms, like those induced by the presence of randomized and quantum effects. Noticeably, some of the contributions along these lines in 2022 have to do with the Curry-Howard correspondence.

In 31, a system of session types is introduced as induced by a Curry-Howard correspondence applied to bounded linear logic, suitably extended with probabilistic choice operators and ground types. The resulting system satisfies some expected properties, like subject reduction and progress, but also unexpected ones, like a polynomial bound on the time needed to reduce processes. This makes the system not only capable to characterize notions of efficiency in a randomized setting but also suitable for modeling experiments and proofs from the so-called computational model of cryptography.

We also showed that an intuitionistic version of counting propositional logic (itself introduced and studied within FoCUS in 2021) corresponds, in the sense of Curry and Howard, to an expressive type system for the probabilistic event $\lambda$-calculus, a vehicle calculus in which both call-by-name and call-by-value evaluation of discrete randomized functional programs can be simulated. In this context, proofs (respectively, types) do not guarantee that validity (respectively, termination) holds, but reveal the underlying probability. We also showed how to obtain a system precisely capturing the probabilistic behavior of $\lambda$-terms, by endowing the type system with an intersection operator 21.

We also looked at the nature of time in the context of security protocols. Timed cryptography refers to cryptographic primitives designed to meet their security goals only for a short (polynomial) amount of time, and has not been dealt with in the symbolic model, so far. We introduced a timed extension of the applied $\pi$-calculus, a common formalism to specify cryptographic protocols, and developed a logic for timed hyperproperties capturing many properties of interest, such as timeliness or time-limited indistinguishability. On the automation side, we mechanise proofs of timed safety properties by relying on the Tamarin tool as a backend 26.

Additionally, we achieved major improvements in the study of relational reasoning for higher-order continuous probabilistic programs, viz. higher-order programs sampling from continuous distributions. In 13, in fact, we have isolated a set of natural conditions on the expressive power of a programming language to guarantee full abstraction of bisimulation-based equivalences, viz. event and applicative bisimilarity, this way solving an open problem in the context of higher-order probabilistic reasoning.

Finally, we have also investigated to which extent techniques for reasoning about time (in expectation) and termination extends from classical, probabilistic programs to quantum programs. Specifically, in 22 we introduce a new kind of expectation transformer for a mixed classical-quantum programming language. This semantic approach relies on a new notion of a cost structure, which we introduce and which can be seen as a specialisation of the Kegelspitzen of Keimel and Plotkin. Along the analysis of several quantum algorithms within this new framework, we have shown that our calculus is both sound and adequate with respect to the operational semantics endowed on our quantum language.

7.3.2 Differential Semantics of Programming Languages

Program semantics is traditionally concerned with program equivalence, in which all pairs of programs which are not equivalent are treated the same, and simply dubbed as incomparable. In recent years, various forms of program metrics have been introduced such that the distance between non-equivalent programs is measured as a not necessarily numerical quantity.

By letting the underlying quantale vary as the type of the compared programs become more complex, the recently introduced framework of differential logical relations allows for a new contextual form of reasoning. We showed 16 that all this can be generalised to effectful higher-order programs, in which not only the values, but also the effects computations produce can be appropriately distanced in a principled way. We show that the resulting framework is flexible, allowing various forms of effects to be handled, and that it provides compact and informative judgments about program differences. Moreover, we have introduced 30 a new general categorical construction that allows one to extract differential logical relations from traditional ones, and used such a construction to prove new correctness results for operationally-defined (pure and effectful) differential logical relations.

Mardare et al.'s quantitative algebras represent a novel and nice way of generalizing equational logic to a notion of distance. We explored the possibility of extending quantitative algebras to the structures which naturally emerge from Combinatory Logic and the $\lambda$-calculus 32. First of all, we showed that the framework is indeed applicable to those structures, and give soundness and completeness results. Then, we proved some negative results clearly delineating to which extent categories of metric spaces can be models of such theories. Finally, we gave several examples of non-trivial higher-order quantitative algebras.

Sometimes, the quantitative aspects are in the language itself. This is the case for graded modal types systems and coeffects, which are becoming a standard formalism to deal with context-dependent, usage-sensitive computations, especially when combined with computational effects. We developed 15 a general theory and calculus of program relations for higher-order languages with combined effects and coeffects. The relational calculus builds upon the novel notion of a corelator (or comonadic lax extension) to handle coeffects relationally. Inside such a calculus, we define three notions of effectful and coeffectful program refinements: contextual approximation, logical preorder, and applicative similarity. We prove that all of them are precongruences, thus sound.

7.3.3 On the Space Consumption of Functional Programs

While the amount of time a functional program necessitates when evaluated can be taken as the number of reduction steps the underlying abstract machine or rewriting mechanism performs, the same cannot be said about space. What is a proper notion of working space for a functional program? We introduced 20 a new reasonable space cost model for the $\lambda$-calculus, based on a variant over the Krivine abstract machine. For the first time, this cost model is able to accommodate logarithmic space. Moreover, we study the time behavior of our machine and show how to transport our results to the call-by-value $\lambda$-calculus. We also designed 10 a new system of multi types (a variant of intersection types) and extract from multi type derivations the space used by the KAM, capturing into a type system the space complexity of the underlying abstract machine.

7.4.1 Unifying semantics

This direction has to with comparing, and possibly unifying two major approaches to the semantics of higher-order languages. One is the operational approach stemming from process calculi (such as the $\pi$-calculus), whereby an expressive algebraic model, rooted on the notion of process, is used to give semantics, by means of embedding, of the source language into the model. The other is the denotational approach stemming from game semantics, whereby the semantics of the language makes use of category theory. In 37, we establish a tight connection between existing process-calculus semantics and game semantics for both call-by-name and call-by-value $\lambda$-calculus. These connections allow us to transfer results and techniques between the process model and the game model.

In other works, we investigate the kind of models that pure process calculi such as $\pi$-calculus allow us to obtain in the case of functions, notably the $\lambda$-calculus. In 17 we consider the $\pi$-calculus encoding of call-by-value $\lambda$-calculus. We show that the equivalence on $\lambda$-terms induced by the encoding coincides with Lassen's eager normal-form bisimilarity, extended to handle $\eta$-equality. A crucial technical ingredient in the proofs is the recently-introduced technique of unique solutions of equations, further developed in the paper. We have continued work initiated in previous years where we try to tune existing proof techniques for pure process calculi so to be able to give sound, and possibly also complete, semantics to languages including references. In particular, 41 exhibit and proves a fully abstract encoding of a call-by-value $\lambda$-calculus with references, into the $\pi$-calculus. The encoding is then used to derive proof techniques for the source language stemming from the target language. These and other results are summarised in Prebet's PhD thesis 44.

7.4.2 Type-based techniques

In 11 we report on a tool that verifies Java source code with respect to typestates. A typestate defines the object's states, the methods that can be called in each state, and the states resulting from the calls. The tool statically verifies that when a Java program runs: sequences of method calls obey to object's protocols; objects' protocols are completed; null-pointer exceptions are not raised; subclasses' instances respect the protocol of their superclasses.

The paper 33 is a retrospection on our earlier work on session types, where we show that session types are encodable into standard $\pi$-types, relying on linear and variant types. Besides being an expressivity result, the encoding: (i) removes the redundancies in the syntax and semantics (when session types and session processes are added to the syntax of standard $\pi$-calculus, and (ii) the properties of session types are derived as straightforward corollaries, exploiting the corresponding properties of standard $\pi$-types.

7.4.3 Coinduction

There exist a rich and well-developed theory of enhancements of the coinduction proof method, widely used on behavioural relations such as bisimilarity. In 19, we study how to develop an analogous theory for inductive behaviour relations, i.e., relations defined from inductive observables. Similarly to the coinductive setting, our theory makes use of (semi)-progressions of the form R->F(R), where R is a relation on processes and F is a function on relations, meaning that there is an appropriate match on the transitions that the processes in R can perform in which the process derivatives are in F(R). For a given preorder, an enhancement corresponds to a sound function, i.e., one for which R->F(R) implies that R is contained in the preorder; and similarly for equivalences. We isolate a subclass of sound functions that contains non-trivial functions and enjoys closure properties with respect to desirable function constructors, so to be able to derive sophisticated sound functions (and hence sophisticated proof techniques) from simpler ones. We test our enhancements on a few non-trivial examples.

7.5.1 Cryptography Education

We have designed and tested activities to teach the basic concepts of cryptography to high school students, creating both digital environments that simulate unplugged activities (for distance learning) and task-specific block-based programming languages in order to learn by manipulating computational objects 39. The course focuses on the big ideas of cryptography, and the introduction of a cryptosystem is motivated by overcoming the limitations of the previous one.

We also designed and tested an interdisciplinary training module on cryptography 42 for prospective STEM teachers that leveraged some “boundary objects” between Math and CS (e.g., adjacency matrices, graphs, computational complexity, factoring) in an important social context (the debate on the benefits and risks of end-to-end cryptography). The module proved useful in making students mobilize concepts, methods, and practices of the two disciplines and making them move between semiotic representations of the interdisciplinary objects involved.

SEAWALL

(SEAmless loW latency cLoud pLatforms) is an industrial project financed by the Italian Ministry of Industry and Economical Development dedicated to the digital innovation of manufacturing companies. In particular, methods and techniques have been investigated in order to manage the development of cloud applications having low-latency constraints. The proposed solution is based on a platform, deployed on the edge-cloud continuum, in which latency-critical tasks are dynamically and automatically moved from cloud to edge and vice-versa. In this way, automatic workload mobility can be managed at run time following user desiderata constraints and preferences.

SEAWALL 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, and Digital River. The project started in July 2020, and ended in January 2022.

Ranflood

Giallorenzo co-leads a three-year project collaboration, called “Ranflood”, started in July 2021, between the “Regional Environmental Protection and Energy Agency” of Emilia-Romagna (ARPAE Emilia-Romagna) and the “Department of Computer Science and Engineering” (DISI) at the University of Bologna. The collaboration regards the development of techniques and software to combat the spread of malware by exploiting resource contention.

9.1.1 Associate Teams in the framework of an Inria International Lab or in the framework of an Inria International Program

9.2.1 Visits of international scientists

9.2.2 Visits to international teams

9.3.1 H2020 projects

9.4.1 DCore

DCore (Causal debugging for concurrent systems) is an ANR project that started on March 2019 and that will end in March 2024.

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.

9.4.2 PROGRAMme

PROGRAMme (What is a program? Historical and philosophical perspectives) is an ANR project started on October 2017 and that will finish on October 2023 (extension of one year granted);

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.3 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, Gabriele Vanoni.

10.1.1 Scientific events: organisation

10.1.2 Journal

10.1.3 Leadership within the scientific community

• The “Microservices Community” is a European-based, international, non-profit organisation purposed to promote he development of microservices by bridging research, education, and innovation within and between businesses, universities, organisations and individuals. Members of Focus have played active roles in the Community since its inception in 2019. The organisation includes members from the Innopolis University (Russia), the Dortmund University of Applied Sciences and Arts (Germany), SINTEF and the University of Oslo (Norway), the University of Pisa and the University of Sassari (Italy), WSO2 (U.S.A.), and the Zurich University of Applied Sciences (Swiss). Montesi is the president of the organisation, Guidi is a board member, Lanese and Giallorenzo are respectively part of the research and communication Community groups.
• 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.
• U. Dal Lago is involved since September 1st in an Italian National initiative called CN HPC, namely a new research center about high-performance computing. U. Dal Lago is responsible for topics related to quantum computing inside the University of Bologna.
• 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-2023.

10.2.1 Teaching

• Martin Avanzini
  • “Advanced Logic”, 17 hours, Université Côte d’Azur, France.
  • “Probabilistic Rewriting”, 6 hours, International Summer School on Rewriting, Tiblisi, Georgia
• Mario Bravetti
  • “Linguaggi, Compilatori e Modelli Computazionali”, 120 hours, 1st year Master, University of Bologna, Italy.
  • “Programming, Algorithms and Data Structures” module of “Programming and Computer Architectures”, 36 hours, 1st year Master, University of Bologna, Italy.
• Saverio Giallorenzo
  • “Programming Languages”, 30 hours, 2nd year Bachelor, University of Bologna, Italy.
  • “Social Network Analysis”, 30 hours, 2nd year Master, University of Bologna, Italy.
• Ugo Dal Lago
  • “Optimization”, 36 hours, 2nd year, 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”, 34 hours, 1st year, University of Bologna, Italy.
  • “Computational Methods for Bioinformatics”, 58 hours, 1st year Master, University of Bologna, Italy.
• Michael Lodi
  • “Computer Science Education”, 26 hours, 2nd year Master, University of Bologna, Italy.
• Simone Martini
  • “Programmazione”, 82 hours, 1st year, University of Bologna, Italy.
  • “Languages and Algorithms for Artificial Intelligence, module 1’’, 25 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, Bachelor in Computer Science, University of Bologna, Italy.
  • “Scalable and Cloud Programming”, 50 hours, Master in Computer Science, University of Bologna, Italy.
  • “Architectures and Platforms for Artificial Intelligence”, 24 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.
• Andrea Colledan, November 2021. “Complexity Analysis of Quantum Functional Programs”. Supervisor: Ugo Dal Lago.
• Davide Davoli, October 2020, “Complexity Analysis of Higher-Order Randomized and Cryptographic Definitions”. Supervisor: Tamara Rezk (INDES); Co-Supervisors: Martin Avanzini and Ugo Dal Lago.
• Enguerrand Prebet, September 2019, “The pi-calculus model of programming languages”. Supervisors Daniel Hirschkoff and Davide Sangiorgi.

10.2.3 Juries

• S. Martini has been member of the PhD evaluation committee of Alice Martin, supervisors Stéphane Conversy and Mathieu Magnaudet, ISAE-SUPAERO, Institut Supérieur de l'Aéronautique et de l'Espace, Toulouse.
• M. Lodi has been both external reviewer for the thesis and member of the PhD evaluation committee of Emanuele Scapin, supervisor Alberto Policriti, co-supervisor Claudio Mirolo, Università degli Studi di Udine, Italy.

10.3.1 Internal or external Inria responsibilities

• M. Avanzini is member of the "comite NICE"

10.3.2 Education

Michael Lodi and Simone Martini have carried out extended work of scientific popularization, including the following.

• They are members of the technical committee of Olimpiadi del Problem Solving (at Italian Ministry of Education); this involves preparation of material and supervision and jury during the finals.
• S. Martini gave the lecture “Perché scrivere codice è importante, per tutti”, Software Heritage event–Bologna Big Code Lab, March 2022.

International journals

• 10 articleB.Beniamino Accattoli, U.Ugo Dal Lago and G.Gabriele Vanoni. Multi types and reasonable space.Proceedings of the ACM on Programming Languages6ICFPAugust 2022, 799-825
  HALDOIback to textback to text
• 11 articleL.Lorenzo Bacchiani, M.Mario Bravetti, M.Marco Giunti, J.João Mota and A.António Ravara. A Java typestate checker supporting inheritance.Science of Computer Programming221September 2022, 102844
  HALDOIback to text
• 12 articleL.Lorenzo Bacchiani, G.Giuseppe de Palma, L.Luca Sciullo, M.Mario Bravetti, M.Marco Di Felice, M.Maurizio Gabbrielli, G.Gianluigi Zavattaro and R.Roberto Della Penna. Low-Latency Anomaly Detection on the Edge-Cloud Continuum for Industry 4.0 Applications: the SEAWALL Case Study.IEEE Internet of Things Magazine53September 2022, 32-37
  HALDOIback to text
• 13 articleG.Gilles Barthe, R.Raphaëlle Crubillé, U.Ugo Dal Lago and F.Francesco Gavazzo. On Feller continuity and full abstraction.Proceedings of the ACM on Programming Languages6ICFPAugust 2022, 826-854
  HALDOIback to text
• 14 articleD.Davide Berardi, S.Saverio Giallorenzo, J.Jacopo Mauro, A.Andrea Melis, F.Fabrizio Montesi and M.Marco Prandini. Microservice security: a systematic literature review.PeerJ Computer Science72022, e779
  HALDOIback to text
• 15 articleU.Ugo Dal Lago and F.Francesco Gavazzo. A relational theory of effects and coeffects.Proceedings of the ACM on Programming Languages6POPLJanuary 2022, 1-28
  HALDOIback to text
• 16 articleU.Ugo Dal Lago and F.Francesco Gavazzo. Effectful program distancing.Proceedings of the ACM on Programming Languages6POPLJanuary 2022, 1-30
  HALDOIback to text
• 17 articleA.Adrien Durier, D.Daniel Hirschkoff and D.Davide Sangiorgi. Eager Functions as Processes (long version).Theoretical Computer Science2022
  HALDOIback to text
• 18 articleS.Saverio Giallorenzo, F.Fabrizio Montesi, L.Larisa Safina and S. P.Stefano Pio Zingaro. Ephemeral data handling in microservices with Tquery.PeerJ Computer Science82022, e1037
  HALDOIback to text
• 19 articleD.Davide Sangiorgi. From enhanced coinduction towards enhanced induction.Proceedings of the ACM on Programming Languages6POPLJanuary 2022, 1-29
  HALDOIback to text

International peer-reviewed conferences

• 20 inproceedingsB.Beniamino Accattoli, U.Ugo Dal Lago and G.Gabriele Vanoni. Reasonable Space for the λ-Calculus, Logarithmically.LICS 2022 - 37th Annual ACM/IEEE Symposium on Logic in Computer ScienceHaifa, IsraelACMAugust 2022, 1-13
  HALDOIback to text
• 21 inproceedingsM.Melissa Antonelli, U.Ugo Dal Lago and P.Paolo Pistone. Curry and Howard Meet Borel.LICS 2022 - 37th Annual ACM/IEEE Symposium on Logic in Computer ScienceHaifa, IsraelIEEEAugust 2022
  HALDOIback to text
• 22 inproceedingsM.Martin Avanzini, G.Georg Moser, R.Romain Péchoux, S.Simon Perdrix and V.Vladimir Zamdzhiev. Quantum Expectation Transformers for Cost Analysis.Symposium on Logic In Computer Science LICS ’22Haifa, IsraelAugust 2022
  HALback to text
• 23 inproceedingsL.Lorenzo Bacchiani, G.Giuseppe de Palma, L.Luca Sciullo, M.Mario Bravetti, M.Marco Di Felice, M.Maurizio Gabbrielli, G.Gianluigi Zavattaro, R.Roberto Della Penna, C.Corrado Iorizzo, A.Andrea Livaldi, L.Luca Magnotta and M.Mirko Orsini. SEAWALL: Seamless Low Latency Cloud Platforms for the Industry 4.0.CIoT 2022 - 5th Conference on Cloud and Internet of ThingsMarrakech, MoroccoIEEEMarch 2022, 90-91
  HALDOIback to text
• 24 inproceedingsF.Franco Barbanera, I.Ivan Lanese and E.Emilio Tuosto. Formal Choreographic Languages.Coordination Models and Languages : 24th IFIP WG 6.1 International Conference, COORDINATION 2022, Held as Part of the 17th International Federated Conference on Distributed Computing Techniques, DisCoTec 2022, Lucca, Italy, June 13-17, 2022, ProceedingsCOORDINATION 2022 - 24th International Conference on Coordination Models and LanguagesLNCS - 13271Lecture Notes in Computer ScienceLucca, ItalySpringer International PublishingJune 2022, 121-139
  HALDOIback to text
• 25 inproceedingsF.Franco Barbanera, I.Ivan Lanese and E.Emilio Tuosto. On Composing Communicating Systems.ICE 2022 - 15th Interaction and Concurrency Experience365Lucca, ItalyAugust 2022, 53-68
  HALDOIback to textback to text
• 26 inproceedingsG.Gilles Barthe, U.Ugo Dal Lago, G.Giulio Malavolta and I.Itsaka Rakotonirina. Tidy: Symbolic Verification of Timed Cryptographic Protocols.CCS 2022 - 2022 ACM SIGSAC Conference on Computer and Communications SecurityLos Angeles, CA, United StatesACMNovember 2022, 263-276
  HALDOIback to text
• 27 inproceedingsL.Laura Bocchi, I.Ivan Lanese, C. A.Claudio Antares Mezzina and S.Shoji Yuen. The Reversible Temporal Process Language.Formal Techniques for Distributed Objects, Components, and Systems :42nd IFIP WG 6.1 International Conference, FORTE 2022, Held as Part of the 17th International Federated Conference on Distributed Computing Techniques, DisCoTec 2022, Lucca, Italy, June 13–17, 2022, ProceedingsFORTE 2022 - 42nd IFIP WG 6.1 International Conference on Formal Techniques for Distributed Objects, Components, and SystemsLNCS-13273Lecture Notes in Computer ScienceLucca, ItalySpringer International PublishingJune 2022, 31-49
  HALDOIback to text
• 28 inproceedingsA.Antonio Bucchiarone, C.Claudio Guidi, I.Ivan Lanese, N.Nelly Bencomo and J.Josef Spillner. A MAPE-K Approach to Autonomic Microservices.ICSA-C 2022 - IEEE 19th International Conference on Software Architecture CompanionHonolulu, United StatesIEEEMarch 2022, 100-103
  HALDOIback to text
• 29 inproceedingsA.Alex Coto, F.Franco Barbanera, I.Ivan Lanese, D.Davide Rossi and E.Emilio Tuosto. On Formal Choreographic Modelling: A Case Study in EU Business Processes.Leveraging Applications of Formal Methods, Verification and Validation. Adaptation and Learning : 11th International Symposium, ISoLA 2022, Rhodes, Greece, October 22–30, 2022, Proceedings, Part IIILeveraging Applications of Formal Methods, Verification and ValidationLNCS13701Lecture Notes in Computer ScienceRhodes (Grèce), GreeceSpringer International PublishingOctober 2022, 205-219
  HALDOIback to text
• 30 inproceedingsF.Francesco Dagnino and F.Francesco Gavazzo. A Fibrational Tale of Operational Logical Relations.FSCD 2022 - 7th International Conference on Formal Structures for Computation and DeductionHaifa (Israël), IsraelAugust 2022
  HALDOIback to text
• 31 inproceedingsU.Ugo Dal Lago and G.Giulia Giusti. On Session Typing, Probabilistic Polynomial Time, and Cryptographic Experiments.CONCUR 2022 - 33rd International Conference on Concurrency TheoryWarsaw, PolandSeptember 2022
  HALback to text
• 32 inproceedingsU.Ugo Dal Lago, F.Furio Honsell, M.Marina Lenisa and P.Paolo Pistone. On Quantitative Algebraic Higher-Order Theories.FSCD 2022 - 7th International Conference on Formal Structures for Computation and DeductionHaifa, IsraelAugust 2022
  HALback to text
• 33 inproceedingsO.Ornela Dardha, E.Elena Giachino and D.Davide Sangiorgi. Session Types Revisited: A Decade Later.PPDP 2022 / 24th International Symposium on Principles and Practice of Declarative ProgrammingTbilisi, GeorgiaACMSeptember 2022, 1-4
  HALDOIback to text
• 34 inproceedingsG.Giovanni Fabbretti, I.Ivan Lanese and J.-B.Jean-Bernard Stefani. Generation of a Reversible Semantics for Erlang in Maude.Formal Methods and Software Engineering : 23rd International Conference on Formal Engineering Methods, ICFEM 2022, Madrid, Spain, October 24–27, 2022, ProceedingsICFEM 2022 - 23rd International Conference on Formal Engineering MethodsLNCS13478Lecture Notes in Computer Science.Madrid, SpainSpringer International PublishingOctober 2022, 106-122
  HALDOIback to text
• 35 inproceedingsL.Lorenzo Gheri, I.Ivan Lanese, N.Neil Sayers, E.Emilio Tuosto and N.Nobuko Yoshida. Design-By-Contract for Flexible Multiparty Session Protocols.ECOOP 2022 - European Conference on Object-Oriented Programming222Berlin (DE), GermanyJune 2022
  HALDOIback to text
• 36 inproceedingsS.Saverio Giallorenzo, F.Fabrizio Montesi, M.Marco Peressotti and F.Florian Rademacher. Model-Driven Generation of Microservice Interfaces: From LEMMA Domain Models to Jolie APIs.24th IFIP WG 6.1 International Conference, 17th International Federated Conference on Distributed Computing Techniques (DisCoTec 2022)13271Lecture Notes in Computer ScienceLucca, ItalySpringer International PublishingJune 2022, 223-240
  HALDOIback to text
• 37 inproceedingsG.Guilhem Jaber and D.Davide Sangiorgi. Games, mobile processes, Dfunctions.CSL 2022 - 30th EACSL Annual Conference on Computer Science LogicGöttingen, Germany2022, 1-35
  HALback to text
• 38 inproceedingsP.Pietro Lami, I.Ivan Lanese, J.-B.Jean-Bernard Stefani, C.Claudio Sacerdoti Coen and G.Giovanni Fabbretti. Reversibility in Erlang: Imperative Constructs.Reversible Computation : 14th International Conference, RC 2022, Urbino, Italy, July 5–6, 2022, ProceedingsRC 2022 - 14th International Conference on Reversible ComputationLNCS-13354Lecture Notes in Computer ScienceUrbino, ItalySpringer International PublishingJune 2022, 187-203
  HALDOIback to text
• 39 inproceedingsM.Michael Lodi, M.Marco Sbaraglia and S.Simone Martini. Cryptography in Grade 10: Core Ideas with Snap! and Unplugged.ITiCSE '22: Proceedings of the 27th ACM Conference on on Innovation and Technology in Computer Science Education Vol. 1ITiCSE 2022 - Innovation and Technology in Computer Science Education1Dublin, IrelandAssociation for Computing MachineryJuly 2022, 456-462
  HALDOIback to text
• 40 inproceedingsG.Giuseppe de Palma, S.Saverio Giallorenzo, J.Jacopo Mauro, M.Matteo Trentin and G.Gianluigi Zavattaro. A Declarative Approach to Topology-Aware Serverless Function-Execution Scheduling.2022 IEEE (Institute of Electrical and Electronics Engineers) International Conference on Web Services (ICWS)Barcelona, SpainIEEEJuly 2022, 337-342
  HALDOIback to text
• 41 inproceedingsE.Enguerrand Prebet. Functions and References in the Pi-Calculus: Full Abstraction and Proof Techniques.ICALP 2022 - 49th International Colloquium on Automata, Languages, and ProgrammingParis, FranceJuly 2022
  HALDOIback to text

Conferences without proceedings

• 42 inproceedingsE.-I.Evmorfia-Iro Bartzia, S.Simon Modeste, M.Michael Lodi, M.Marco Sbaraglia and V.Viviane Durand-Guerrier. Conception et organisation d'une situation didactique en cryptographie.Didapro 9 – DidaSTIC – 9ème colloque francophone de didactique de l’informatiqueLe Mans, FranceMay 2022
  HALback to text

Scientific book chapters

• 43 inbookL.Lorenzo Bacchiani, M.Mario Bravetti, M.Maurizio Gabbrielli, S.Saverio Giallorenzo, G.Gianluigi Zavattaro and S. P.Stefano Pio Zingaro. Proactive-Reactive Global Scaling, with Analytics.13740Service-Oriented ComputingLecture Notes in Computer ScienceSpringer Nature SwitzerlandNovember 2022, 237-254
  HALDOIback to text

Doctoral dissertations and habilitation theses

• 44 thesisE.Enguerrand Prebet. Typed Behavioural Equivalences in the Pi-Calculus.Ecole normale supérieure de lyon - ENS LYON; Università degli studi (Bologne, Italie)September 2022
  HALback to text

Scientific popularization

• 45 articleI.Ivan Lanese, U.Ulrik Schultz and I.Irek Ulidowski. Reversible Computing in Debugging of Erlang Programs.IT Professional241January 2022, 74-80
  HALDOIback to text