2023Activity reportTeamFOCUS

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:

  Release 1.11 includes almost 500 commits and 14 different contributors and it is one of the biggest releases so far!

  The main changes include: - New call-expressions. You can now call solicit-response operations in expressions, for example (in the condition of a conditional): `if( trim@stringUtils( "Hello " ) == "Hello" ) println@console( "Hooray!" )()` - New if-expressions, for example: `x = if( condition ) expr1 else expr2.` - More modern alternative throw syntax: `throw fault( data )`. - New engine for error reporting. For example, when you misspell a keyword or a type name, Jolie now looks at the context and tries to guess which word you were trying to type by using edit distance. - New templating engine for HTTP. - Improved management of open channels. Jolie services with many interactions with the same clients/services now consume noticeably fewer connections and RAM. - New standard library operations, including a library for assertions, a library for vector manipulation, operations for URL encoding and decoding, an operation for string interpolation, and support for reading lines synchronously from the terminal. - Support for Mustache templates (see packages/mustache.ol). - Improved tracing messages for protocol internals. - Many bugfixes to HTTP, SOAP, XML, and JSON data handling. - is_defined now correctly returns true for defined variables of type void.

• 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.
• 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 was originally envisaged as a cost analyzer 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 analyze program components in complete independence, that is, the analysis is modular and thus scalable.

  In its most recent version, the tool has been completely overhauled. On the one hand, it is capable of reasoning about a broader set of events, through the analysis of expected outcomes. On the other hand, the new version also supports recursive procedures.

• URL:
  http://­www-sop.­inria.­fr/­members/­Martin.­Avanzini/­software/­eco-imp/
• Publications:
  hal-04345663v1, 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 analyze 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 analyze 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:

  Stable release of Tquery, which includes the following operators: Match, Unwind, Project, Group, Join, and Pipeline.

  In 2023 there were no updates.

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

  0.1: APP first release introduced the APP declarative language used to write scheduling policies in serverless platform. The first release also introduced support for the OpenWhisk platform with an alternative Load Balancer for APP scripts.

  0.1-tapp: This release introduces an extension of APP, named tAPP (topology-aware Allocation Priority Policies), that adds the capability to declare topological contraints on function-scheduling. An implementation on top of the OpenWhisk platform is also provided.

  0.1-aapp: Another extension, dubbed aAPP (affinity-aware Allocation Priority Policies), that adds the capability to define affinity and anti-affinity constraints on 2 or more functions, together with an updated implementation on OpenWhisk.

• URL:
  https://­github.­com/­giusdp/­openwhisk
• Contact:
  Saverio Giallorenzo
• Partner:
  University of Southern Denmark

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
• 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: (a) project them on communicating finite state machines representing the behavior of single participants, (b) compute a product c-automaton corresponding to the concurrent execution of two c-automata, (c) synchronize two participants of a c-automaton transforming them into couple gateways, and (d) check well-formedness conditions ensuring that the system of participants obtained via projection behaves well.
• URL:
  https://­github.­com/­lanese/­corinne-3
• Publication:
  hal-03468190
• Contact:
  Ivan Lanese
• Partner:
  Gran Sasso Science Institute

6.1.11 Ranflood

• Keywords:
  Cybersecurity, Ransomware
• Functional Description:

  Ranflood is an anti-crypto-ransomware tool that counteracts the encryption phase by flooding specific folders (e.g., the attacked location, the user's folders) with decoy files and helps users recover their files after an attack.

  This action has a twofold effect.

  First, it confounds the genuine files of the user with decoy files, causing the attacking ransomware to waste time on sacrificial data rather than on the victim's genuine files.

  Second, the file-flooding IO-intensive activity contends with the ransomware to access the victim's computing resources, further slowing down the attack of the malware.

• Release Contributions:

  First release of Ranflood.

  At the moment, Ranflood supports three types of flooding strategies:

  - random: based on the flooding of a given location with randomly generated files.

  - on-the-fly: a copy-based strategy, where the generation of files uses copies of actual files found at a flooding location. File replication adds a layer of defence as it helps to increase the likelihood of preserving the users’ files by generating additional, valid copies that might escape the ransomware. This strategy introduces a new snapshoot action that precedes the flooding one, which saves a list of the valid files with their digest signature (e.g., MD5), so that the flooding operations can use the signature as an integrity verification to skip the encrypted files.

  - shadow: another copy-based strategy that increases the efficiency of the on-the-fly strategy by preserving archival copies of the files of the user.

• URL:
  https://­ranflood.­netlify.­app/
• Contact:
  Saverio Giallorenzo

7.1.1 Foundations and Implementations for Orchestration and Choreography

Communication is an essential element of modern software, yet the programming and analysis of communicating systems are difficult tasks. A reason for this difficulty is the lack of compositional mechanisms that preserve relevant communication properties.

In 12, we present a comprehensive treatment of the case of synchronous communications. We consider both symmetric synchronous communications and asymmetric synchronous communications (where senders decide independently which message should be exchanged). The composition mechanism preserves different properties under different conditions depending on the considered type of synchronous communication. We show here that the preservation of lock freedom requires an additional condition on gateways for asymmetric communication. Such a condition is also needed for the preservation of deadlock freedom, lock freedom or strong lock freedom for symmetric communications. This is not needed, instead, for the preservation of either deadlock freedom or strong lock freedom with asymmetric interactions.

We also worked on formalizations and implementations of choreographic languages.

In 11, we introduce a meta-model based on formal languages, dubbed formal choreographic languages, to study message-passing systems. Our framework allows us to generalize standard constructions from the literature and to compare them. In particular, we consider notions such as global view, local view, and projections from the former to the latter. The correctness of local views projected from global views is characterized in terms of a closure property. We consider a number of communication properties – such as (dead)lock-freedom – and give conditions on formal choreographic languages to guarantee them. Finally, we show how formal choreographic languages can capture existing formalisms; specifically we consider communicating finite-state machines, choreography automata, and multiparty session types. Notably, formal choreographic languages, differently from most approaches in the literature, can naturally model systems exhibiting non-regular behavior.

In the paradigm of choreographic programming, choreographies are programs that can be compiled into executable implementations. Choreographic Programming originated primarily in the context of process calculi, with preliminary work done to establish its foundations and experiment with implementations.

In 16, we present Choral, the first choreographic programming language based on mainstream abstractions. The key idea in Choral is a new notion of data type able to express data distribution over different participants. We use this idea to reconstruct the paradigm of choreographic programming through object-oriented abstractions. Choreographies are classes, and instances of choreographies are objects with states and behaviors implemented collaboratively by the participants. Choral comes with a compiler that, given a choreography, generates an implementation for each of its roles. These implementations are libraries in pure Java, whose types are under the control of the Choral programmer. Developers can then modularly compose these libraries in their programs, to participate correctly in choreographies. Choral is the first incarnation of choreographic programming offering such modularity, which finally connects more than a decade of research on the paradigm to practical software development. The integration of choreographic and object-oriented programming yields other powerful advantages, where the features of one paradigm benefit the other in ways that go beyond the sum of the parts. On the one hand, the high-level abstractions and static checks from the world of choreographies can be used to write concurrent and distributed object-oriented software more concisely and correctly. On the other hand, we obtain a much more expressive choreographic language from object-oriented abstractions than in previous work. This expressiveness supports writing more reusable and flexible choreographies. For example, object passing makes Choral the first higher-order choreographic programming language, whereby one can parametrize choreographies over other choreographies without the need for central coordination. We also extend method overloading to a new dimension: specialization based on data location. The integration of overloading, together with subtyping and generics, allows Choral to elegantly support user-defined communication mechanisms and middleware.

7.1.2 Microservices, Serverless, and Cloud Deployment

The service-oriented programming language Jolie is a long-standing project within Focus.

In 17 we introduce LEMMA2Jolie, a tool for translating domain models of microservice architectures given in LEMMA into concrete APIs of microservices in the Jolie programming language. The tool combines the state of the art for the design and implementation of microservices: developers can use Domain-Driven Design (DDD) for the construction of the domain models of a microservice architecture, and then automatically transition to a service-oriented programming language that provides native linguistic support for implementing the behavior of each microservice. In 28 we formally define and integrate into the LEMMA2Jolie tool a translation of domain and service models. As a result, LEMMA2Jolie now supports a software development process whereby one can design microservice architectures in collaboration with domain experts in LEMMA, and then automatically translate the design into programmable Jolie APIs.

Another work related to Jolie is JoT 29, a testing framework for Microservice Architectures (MSAs) based on technology agnosticism, a core principle of microservices. The main advantage of JoT is that it reduces the amount of work for a) testing for MSAs whose services use different technology stacks, b) writing tests that involve multiple services, and c) reusing tests of the same MSA under different deployment configurations or after changing some of its components (e.g., when, for performance, one reimplements a service with a different technology). In JoT, tests are orchestrators that can both consume or offer operations from/to the MSA under test. The language for writing JoT tests is Jolie, which provides constructs that support technology agnosticism and the definition of terse test behaviors.

7.1.3 Other Important Results Regarding the Programming of Serverless Scheduling Policies.

APP (and variants) is a platform-agnostic declarative language developed within Focus that allows serverless platforms to support multiple scheduling logics. Indeed, proprietary and open-source serverless platforms follow opinionated, hardcoded scheduling policies to deploy the functions to be executed over the available workers. Such policies may decrease the performance and the security of the application due to locality issues (e.g., functions executed by workers far from the databases to be accessed). APP helps in overcoming these limitations. However, defining the “right” scheduling policy in APP is a non-trivial task since it often requires rounds of refinement involving knowledge of the underlying infrastructure, guesswork, and empirical testing. In 32 we present a gentle introduction to APP through an illustrative application developed over several incremental steps to help developers identify and specify relevant properties of their serverless architectures. In 31, we start investigating how one can use static analysis to inform APP scheduling function policies for selecting the best-performing workers at function allocation. We substantiate our proposal by presenting a pipeline able to extract cost equations from functions' code, synthesizing cost expressions through the usage of off-the-shelf solvers, and extending APP allocation policies to consider this information.

7.1.4 Counteracting Ransomeware Aattacks

Ransomware is one of the most infamous kinds of malware, particularly the “crypto” subclass, which encrypts users' files, asking for some monetary ransom in exchange for the decryption key. Recently, crypto-ransomware grew into a scourge for enterprises and governmental institutions. The most recent and impactful cases include an oil company in the US, an international Danish shipping company, and many hospitals and health departments in Europe. Attacks result in production lockdowns, shipping delays, and even risks to human lives. To contrast ransomware attacks (crypto, in particular), in 14 we propose a family of solutions, called Data Flooding against Ransomware (DFaR), tackling the main phases of detection, mitigation, and restoration, based on a mix of honeypots, resource contention, and moving target defence. These solutions hinge on detecting and contrasting the action of ransomware by flooding specific locations (e.g., the attack location, sensitive folders, etc.) of the victim's disk with files. Building on the DFaR approach, in 15 we present an open-source tool, called Ranflood, that implements the mitigation and restoration phases. In particular, Ranflood supports three flooding strategies, apt for different attack scenarios. At its core, Ranflood buys time for the user to counteract the attack, e.g., to access an unresponsive, attacked server and shut it down manually.

7.3.1 Static Complexity Analysis

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. For instance, over the last years we have developed the cost analyser eco-imp 6.1.5, which can derive bounds on the average runtime of probabilistic imperative programs, in a fully automated manner. This year, we have extended the tool along two axes. First, we have extended the capabilities of the language, for instance, the new version is capable of analyzing recursively defined functions. Second, the tool has been extended from reasoning about expected runtime to a broader set of events, through the analyzed notion of expected outcomes. All of this required significant extensions to the underlying inference machinery, described in 10.

7.3.2 Quantitative Relational Reasoning

Another very important research axis within Focus is that about the study of metrics and quantitative reasoning on programs, supported by tools such as relational logic and program metrics. This year there have been a number of contributions in this direction.

We first of all looked at Mardare et al.’s quantitative algebras, and at whether they can be adapted to the structures which naturally emerge from Combinatory Logic and the $\lambda$-calculus 25. First of all, we show that the framework is indeed applicable to those structures, and give soundness and completeness results. Then, we prove some negative results, clearly delineating to which extent categories of metric spaces can be models of such theories. We conclude by giving several examples of non-trivial higher-order quantitative algebras.

We then introduced contextual behavioral metrics (CBMs) as a novel way of measuring the discrepancy in behavior between processes in a concurrent scenario, taking into account both quantitative aspects and contextual information. This way, process distances by construction take the environment into account: two (non-equivalent) processes may still exhibit very similar behavior in some contexts, e.g., when certain actions are never performed. We first show how CBMs capture many well-known notions of equivalence and metric, including Larsen's environmental parametrized bisimulation. We then study compositional properties of CBMs with respect to some common process algebraic operators, namely prefixing, restriction, non-deterministic sum, parallel composition and replication 26.

Finally, we also studied higher-order logic and its role in quantitative reasoning. More specifically, we introduce a variation on Barthe et al.’s higher-order logic in which formulas are interpreted as predicates over open rather than closed objects. This way, concepts which have an intrinsically functional nature, like continuity, differentiability, or monotonicity, can be expressed and reasoned about in a very natural way, following the structure of the underlying program. We give open higher-order logic in distinct flavors, and in particular in its relational and local versions, the latter being tailored for situations in which properties hold only in part of the underlying function’s domain of definition 24.

7.3.3 Abstract Machines and their Performances

Another topic of interest in Focus is the study of abstract machines for the implementation of high-level languages and in particular the analysis of their performance. In the last years, we have been concerned with the study of abstract machines derived from Girard's Geometry of Interaction. In a joint work between Dal Lago and Vanoni, we study one of the two formulations of the interaction abstract machine, namely that obtained from the so-called “boring” translation of intuitionistic logic into linear logic. We prove the correctness of the resulting call-by-name machine, at the same time establishing an improved bisimulation with Krivine’s abstract machine. The proof makes essential use of the definition of a novel relational property linking configurations of the two machines 27. This turned out to be a surprising fact, because the “boring” translation is well-known to be related to call-by-value evaluation.

7.3.4 Quantum Programming Languages

In the realm of quantum computing, circuit description languages represent a valid alternative to traditional QRAM-style languages. They indeed allow for finer control over the output circuit, without sacrificing flexibility nor modularity. We introduce in 23 a generalization of the paradigmatic lambda-calculus Proto-Quipper-M, which models the core features of the quantum circuit description language Quipper. The extension, called Proto-Quipper-K, is meant to capture a very general form of dynamic lifting. This is made possible by the introduction of a rich type and effect system in which not only computations, but also the very types are effectful. The main results we give for the introduced language are the classic type soundness results, namely subject reduction and progress.

7.4.1 Unifying semantics

In the area of qualitative semantics, during the past year our efforts have gone mainly in the direction of "unifying semantics", which has been our major direction in the past few years.

In particular we have deepened the study of the comparison between the the $\lambda$-calculus, as a pure model of functions, and the $\pi$-calculus, as a pure model of processes 33. There has been a lot of work in the literature on the representation of $\lambda$-calculus into $\pi$-calculus, since early 1990s, where the process representations always yield (at best) non-extensional lambda-theories (i.e., beta rule holds, whereas eta does not). We have studied how to obtain extensional representations. In particular we have showed how that the representation of functions can be made parametric on certain abstract components called wires (intuitively, processes whose task is to connect two end-point channels). When a few algebraic properties of wires hold, the representation yields a lambda-theory. Further, by varying the shape of wires (exploiting symmetries and dualities of the $\pi$-calculus), we can obtain well-known lambda-theories, both extensional and non-extensional (intuitively, those of Bohm trees with infinite eta, of Levy-Longo trees, and of Bohm trees).

7.4.2 Session Types

To celebrate the 30th edition of EXPRESS (Expressiveness in Concurrency) and the 20th edition of SOS (Structural Operational Semantics) we have produced an overview on how session types can be expressed in a type theory for the standard $\pi$-calculus by means of a suitable encoding 18. The encoding allows one to reuse results about the $\pi$-calculus in the context of session-based communications, thus deepening the understanding of sessions and reducing redundancies in their theoretical foundations. We have also reviewed the practical implications of these results (e.g., refined forms of deadlock analysis, type inference).

7.5.1 Cryptography Education

We designed and tested an interdisciplinary training module on cryptography 13 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.

7.5.2 Primary students education

We co-designed with teachers 22 a learning module to teach iteration to second graders using a visual programming environment and following the Use-Modify-Create methodology. The co-designed learning module was piloted with three second-grade classes. Sharing the different perspectives of researchers and teachers improved the quality of the resulting learning module and constituted a very significant professional development opportunity for both teachers and researchers.

7.5.3 Large Language Models in Education

We studied 20 the problem-solving ability of GPT-3 in solving tasks proposed in the Bebras challenge. GPT-3 was able to answer with a majority of correct answers in about one-third of the Bebras tasks. It provided explanations that sounded correct but often logically wrong. The system was good in applying procedures, but quite bad at synthesis or logically complex tasks.

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.

Participants: Saverio Giallorenzo.

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 Horizon Europe

9.3.2 H2020 projects

9.4.1 FREEDA

FREEDA (Failure-Resilient, Energy-aware, and Explainable Deployment of microservice-based Applications over Cloud-IoT infrastructures) is a PRIN PE6 24-month project started on October 2023.

The evolution of Cloud computing, driven by the demands of smart connected devices, calls for a transition to pervasive distributed environments at the network's Edge. The increasing use of Microservice-based Applications (MSAs) in enterprise settings, along with the expansion of Cloud-IoT infrastructures, needs careful deployment planning. FREEDA aims to facilitate comprehensive MSA deployment over Cloud-IoT infrastructures by analyzing deployment requirements, considering factors like MSA complexity, failure resilience, energy consumption, and compliance with sustainable IT standards. The system utilizes constraint reasoning to effectively balance conflicting deployment requirements and employs continuous reasoning to adapt quickly to changes in the deployed MSA and Cloud-IoT infrastructure.

Participants: Maurizio Gabbrielli, Saverio Giallorenzo, Gianluigi Zavattaro.

9.4.2 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.3 PROGRAMme

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

Participants: Simone Martini.

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

9.4.4 PPS

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

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

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

10.1.1 Scientific events: organisation

10.1.2 Scientific events: selection

10.1.3 Journal

10.1.4 Leadership within the scientific community

• The “Microservices Community” is a European-based, international, non-profit organization purposed to promote the development of microservices by bridging research, education, and innovation within and between businesses, universities, organizations and individuals. Members of Focus have played active roles in the Community since its inception in 2019. The organization 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 organization, 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.1.5 Research administration

• M. Avanzini is member of the "comité NICE" for welcoming external researchers (post-docs, “delegation”).

10.2.1 Teaching

• Martin Avanzini
  • “Advanced Logic”, 12 hours, Université Côte d’Azur, France.
• 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.
  • “On Randomization in (Higher-order) Programming”, 3 hours, Escuela de Ciencias Informáticas (ECI), Universidad de Buenos Aires, Argentina.
• Saverio Giallorenzo
  • “Programming Languages”, 30 hours, 2nd year Bachelor, University of Bologna, Italy.
  • “Network Analysis”, 30 hours, 2nd 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.
  • “Ingegneria del Software Orientata ai Servizi”, 44 hours, 1st year master, University of Bologna, Italy.
• Michael Lodi
  • “Computer Science Education”, 26 hours, 2nd year Master in CS, University of Bologna, Italy.
  • “Programmazione”, 16 hours, 1st year Bachelor in Math, University of Bologna, Italy.
• Simone Martini
  • “Programmazione”, 66 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

• Davide Davoli, October 2022, On Kernel Address Space Layout Randomization. Supervisors: Tamara Rezk, Ugo Dal Lago, Martin Avanzini.
• Pietro Lami, October 2021, Reversible Semantics of Programming Languages and Transactions. Supervisor: Jean-Bernard Stefani (SPADES, INRIA Grenoble), co-supervisor: Ivan Lanese.
• Sourabh Pal, November 2022, Choreographies for Healthcare Management. Supervisors: Ivan Lanese and Luca Cisbani.

10.2.3 Juries

• Fabio Zanasi was external examiner for the following PhD VIVAs:
  • Cole Comfort, October 31, 2023, University of Oxford; and
  • Guillaume Boisseau, July 5, 2023, University of Oxford.
• Martin Avanzini was member of the CSD (Commission de suivi des doctorants – doctoral student monitoring committee) of Guillaume Combette, June 19, 2023, UniCA.

10.3.1 Education

• Michael Lodi and Simone Martini 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.
• Michael Lodi gave three lectures titled “Informatics is (not) magic” and participated in the “graduation cerimony” of UniJunior, an outreach initiative for kids between 8 and 13 years old.
• Michael Lodi has been the scientific responsible for the project "Ragazze digitali" (a two week long informatics summer camp for high school girls, funded by Emilia Romagna Region) for Bologna and Imola, and the educational manager and teacher for the Bologna course.
• Maurizio Gabbrielli , Michael Lodi , Simone Martini and Stefano Zingaro organized and taught a week-long summer school for Bologna Business School, teaching informatics, creative computing and artificial intelligence principles to kids from 8 to 12 years old.

International journals

• 10 articleM.Martin Avanzini, G.Georg Moser and M.Michael Schaper. Automated Expected Value Analysis of Recursive Programs.Proceedings of the ACM on Programming Languages7PLDIJune 2023, 1050-1072HALDOIback to text
• 11 articleF.Franco Barbanera, I.Ivan Lanese and E.Emilio Tuosto. A Theory of Formal Choreographic Languages.Logical Methods in Computer Science193August 2023HALDOIback to text
• 12 articleF.Franco Barbanera, I.Ivan Lanese and E.Emilio Tuosto. Composition of synchronous communicating systems.Journal of Logical and Algebraic Methods in Programming135October 2023, 100890HALDOIback to text
• 13 articleE.-I.Evmorfia-Iro Bartzia, M.Michael Lodi, M.Marco Sbaraglia, S.Simon Modeste, V.Viviane Durand-Guerrier and S.Simone Martini. An Unplugged Didactical Situation on Cryptography between Informatics and Mathematics.Informatics in EducationJuly 2023HALDOIback to text
• 14 articleD.Davide Berardi, S.Saverio Giallorenzo, A.Andrea Melis, S.Simone Melloni, L.Loris Onori and M.Marco Prandini. Data Flooding against Ransomware: Concepts and Implementations.Computers and Security131August 2023, 103295HALDOIback to text
• 15 articleD.Davide Berardi, S.Saverio Giallorenzo, A.Andrea Melis, S.Simone Melloni and M.Marco Prandini. Ranflood: A mitigation tool based on the principles of data flooding against ransomware.SoftwareX25February 2024, 101605HALDOIback to text
• 16 articleS.Saverio Giallorenzo, F.Fabrizio Montesi and M.Marco Peressotti. Choral: Object-Oriented Choreographic Programming.ACM Transactions on Programming Languages and Systems (TOPLAS)November 2023HALDOIback to text
• 17 articleS.Saverio Giallorenzo, F.Fabrizio Montesi, M.Marco Peressotti and F.Florian Rademacher. LEMMA2Jolie: A tool to generate microservice APIs from domain models.Science of Computer Programming228June 2023, 102956HALDOIback to text

Invited conferences

• 18 inproceedingsI.Ilaria Castellani, O.Ornela Dardha, L.Luca Padovani and D.Davide Sangiorgi. EXPRESSing Session Types.Electronic Proceedings in Theoretical Computer ScienceEXPRESS / SOS 2023 - Combined 30th International Workshop on Expressiveness in Concurrency and 20th Workshop on Structural Operational SemanticsEPTCS-387Proceedings Combined 30th International Workshop on Expressiveness in Concurrency and 20th Workshop on Structural Operational SemanticsAnvers (Antwerpen), BelgiumSeptember 2023, 8-25HALDOIback to text

International peer-reviewed conferences

• 19 inproceedingsP.Patrick Baillot, U.Ugo Dal Lago, C.Cynthia Kop and D.Deivid Vale. On Basic Feasible Functionals and the Interpretation Method.Lecture Notes in Computer ScienceFoSSaCS 2024 - International Conference on Foundations of Software Science and Computation StructuresLuxembourg City, LuxembourgSpringerApril 2024HAL
• 20 inproceedingsC.Carlo Bellettini, M.Michael Lodi, V.Violetta Lonati, M.Mattia Monga and A.Anna Morpurgo. Davinci Goes to Bebras: A Study on the Problem Solving Ability of GPT-3.SCITEPRESS digital libraryCSEDU 2023 - 15th International Conference on Computer Supported Education2Proceedings of the 15th International Conference on Computer Supported Education - Volume 2: CSEDUPrague, Czech RepublicSCITEPRESS - Science and Technology PublicationsApril 2023, 59-69HALDOIback to text
• 21 inproceedingsM.Marco Bernardo, I.Ivan Lanese, A.Andrea Marin, C.Claudio Mezzina, S.Sabina Rossi and C.Claudio Sacerdoti Coen. Causal Reversibility Implies Time Reversibility.Lecture notes in computer scienceQEST 2023 - International Conference on Quantitative Evaluation of SystemsLNCS-14287Quantitative Evaluation of Systems 20th International Conference, QEST 2023, Antwerp, Belgium, September 20–22, 2023, ProceedingsAntwerp, BelgiumSpringer Nature SwitzerlandSeptember 2023, 270-287HALDOIback to text
• 22 inproceedingsS.Sara Capecchi, M.Michael Lodi, V.Violetta Lonati and M.Marco Sbaraglia. Castle and Stairs to Learn Iteration: Co-designing a UMC Learning Module with Teachers.ACM digital libraryITiCSE 2023: Innovation and Technology in Computer Science EducationITiCSE 2023: Innovation and Technology in Computer Science EducationTurku, FinlandACMJune 2023, 222-228HALDOIback to text
• 23 inproceedingsA.Andrea Colledan and U.Ugo Dal Lago. On Dynamic Lifting and Effect Typing in Circuit Description Languages.Leibniz International Proceedings in Informatics (LIPIcs). International Conference on Types for Proofs and Programs (TYPES)TYPES 2022 - 28th International Conference on Types for Proofs and ProgramsLIPIcs-26928th International Conference on Types for Proofs and Programs (TYPES 2022)Nantes, FranceSchloss Dagstuhl - Leibniz-Zentrum für InformatikJuly 2023HALDOIback to text
• 24 inproceedingsU.Ugo Dal Lago, F.Francesco Gavazzo and A.Alexis Ghyselen. Open Higher-Order Logic.Leibniz International Proceedings in Informatics (LIPIcs)CSL 2023 - 31st EACSL Annual Conference on Computer Science LogicLIPIcs-25231st EACSL Annual Conference on Computer Science Logic (CSL 2023)Warsaw, PolandSchloss Dagstuhl - Leibniz-Zentrum für Informatik2023HALDOIback to text
• 25 inproceedingsU.Ugo Dal Lago, N.Naohiko Hoshino and P.Paolo Pistone. On the Lattice of Program Metrics.Leibniz International Proceedings in Informatics (LIPIcs)FSCD 2023 - 8th International Conference on Formal Structures for Computation and DeductionLIPIcs-2608th International Conference on Formal Structures for Computation and Deduction (FSCD 2023)Rome, ItalySchloss Dagstuhl - Leibniz-Zentrum für Informatik2023HALDOIback to text
• 26 inproceedingsU.Ugo Dal Lago and M.Maurizio Murgia. Contextual Behavioural Metrics.Leibniz International Proceedings in Informatics (LIPIcs)CONCUR 2023 - 34th International Conference on Concurrency TheoryLIPIcs-27934th International Conference on Concurrency Theory (CONCUR 2023)Antwerp, BelgiumSchloss Dagstuhl - Leibniz-Zentrum für Informatik2023HALDOIback to text
• 27 inproceedingsU.Ugo Dal Lago and G.Gabriele Vanoni. (Not So) Boring Abstract Machines.CEUR workshop proceedingsICTCS 2023 - Italian Conference on Theoretical Computer Science 2023CEUR-3587Proceedings of the 24th Italian Conference on Theoretical Computer SciencePalermo, Italy2023HALback to text
• 28 inproceedingsS.Saverio Giallorenzo, F.Fabrizio Montesi, M.Marco Peressotti and F.Florian Rademacher. Model-Driven Code Generation for Microservices: Service Models.Open Access Series in Informatics (OASIcs)Microservices 2020/2022 - Joint Post-proceedings of the Third and Fourth International Conference on MicroservicesOASIcs-111Joint Post-proceedings of the Third and Fourth International Conference on Microservices (Microservices 2020/2022)Paris, FranceSchloss Dagstuhl – Leibniz-Zentrum für Informatik2023HALDOIback to text
• 29 inproceedingsS.Saverio Giallorenzo, F.Fabrizio Montesi, M.Marco Peressotti, F.Florian Rademacher and N.Narongrit Unwerawattana. JoT: A Jolie Framework for Testing Microservices.Lecture notes in computer scienceCOORDINATION 2023 - 25th International Conference on Coordination Models and LanguagesLNCS-13908Coordination Models and Languages 25th IFIP WG 6.1 International Conference, COORDINATION 2023, Held as Part of the 18th International Federated Conference on Distributed Computing Techniques, DisCoTec 2023, Lisbon, Portugal, June 19–23, 2023, ProceedingsLisbon, PortugalSpringer Nature SwitzerlandJune 2023, 172-191HALDOIback to text
• 30 inproceedingsR.Robert Glück, I.Ivan Lanese, C. A.Claudio Antares Mezzina, J. A.Jarosław Adam Miszczak, I.Iain Phillips, I.Irek Ulidowski and G.Germán Vidal. Towards a Taxonomy for Reversible Computation Approaches.15th International Conference, RC 2023, Giessen, Germany, July 18–19, 2023, ProceedingsReversible Computation - RC 2023LNCS-13960Lecture Notes in Computer ScienceGiessen, GermanySpringer Nature SwitzerlandJuly 2023, 24-39HALDOIback to text
• 31 inproceedingsG.Giuseppe de Palma, S.Saverio Giallorenzo, C.Cosimo Laneve, J.Jacopo Mauro, M.Matteo Trentin and G.Gianluigi Zavattaro. Serverless Scheduling Policies based on Cost Analysis.Electronic Proceedings in Theoretical Computer ScienceTiCSA 2023 - First Workshop on Trends in Configurable Systems Analysis - TiCSA@ETAPS 2023EPTCS-392Paris, FranceOctober 2023, 40-52HALDOIback to text
• 32 inproceedingsG.Giuseppe de Palma, S.Saverio Giallorenzo, J.Jacopo Mauro, M.Matteo Trentin and G.Gianluigi Zavattaro. Custom Serverless Function Scheduling Policies: An APP Tutorial.Open Access Series in Informatics (OASIcs)Joint Post-proceedings of the Third and Fourth International Conference on Microservices (Microservices 2020/2022)OASIcs-111Joint Post-proceedings of the Third and Fourth International Conference on Microservices (Microservices 2020/2022)Paris, FranceSchloss Dagstuhl – Leibniz-Zentrum für Informatik2023HALDOIback to text
• 33 inproceedingsK.Ken Sakayori and D.Davide Sangiorgi. Extensional and Non-extensional Functions as Processes.38th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS)Boston, United StatesJune 2023HALDOIback to text

Conferences without proceedings

• 34 inproceedingsM.Melissa Antonelli. Two Remarks on Counting Propositional Logic.CEUR workshop proceedingsBEWARE 2022 - 1st Workshop on Bias, Ethical AI, Explainability and the Role of Logic and Logic ProgrammingCEUR-3319Udine, Italy2023HAL