6.1.1 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 coupled gateways, and (d) check well-formedness conditions ensuring that the system of participants obtained via projection behaves well.
• Release Contributions:
  Version 4.0 of Corinne improves the usability of the tool and refines the check for connectedness, allowing the so called late join, when a participant participate to a choreography only in some branches, after having been contacted by some other participant.
• URL:
  https://­github.­com/­lanese/­corinne-3
• Publication:
  hal-03468190
• Contact:
  Ivan Lanese
• Partner:
  Gran Sasso Science Institute

6.1.2 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 misbehavior 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.3 QuRA

• Name:
  Quipper Resource Analysis
• Keywords:
  Static analysis, Quantum programming, Programming language
• Functional Description:
  QuRA is a static analysis tool for the verification of the resource consumption of quantum circuit description programs. QuRA takes as input a program written in a variant of Quipper called PQ and outputs two things: a type for the program and an upper bound to the size of the circuit it will build. QuRA is capable of estimating global size metrics of circuits, such as their width and gate count, as well as size metrics that are local to individual wires, such as depth. It does so in an almost fully automatic fashion, with few annotations, thanks to the use of SMT solvers.
• URL:
  https://­github.­com/­andreacolledan/­qura
• Contact:
  Andrea Colledan
• Participants:
  Andrea Colledan, Ugo Dal Lago, Niki Vazou
• Partner:
  The IMDEA Software Institute

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

  In 2024 Ranflood had two main releases, 0.6-beta and 0.7-beta.

  Release 0.6-beta includes new code utilities and features, two new Ranflood flooding strategies based on Shamir's Secret Sharing, and a related restore routine for the FileChecker.

  Release 0.7-beta includes an HTTP and a WebSocket server that clients can use to connect to the Ranflood daemon (useful also to support the connection with the new Ranflood webclient and additional functionalities for a more fine-grained control of the daemon's processes).

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

6.1.5 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.6 JOLIE

• Name:
  Jolie
• 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-concept implementations around Olas activities.
• Release Contributions:

  Release 1.12 is largely a stabilisation release, focusing on bugfixes and improved library support.

  The main changes include: - New transaction API offered by the database library service for fine-grained transaction management. - Improved support for OpenAPI v3. - Re-introduced DELETE body requests. - Updated openapi2jolie and jolie2openapi for: - Better compatibility and error handling, including support for "anyOf" clauses and more HTTP status codes. - Adjusted the handling of regular expressions and JSON schema generation to meet OpenAPI specifications. - Modified how HTTP status codes are parsed and handled, now recognising all 2xx codes as successful. - Addressed various bugs and edge cases in HTTP and OpenAPI integrations. - Improved handling of concurrent HTTP messages, with several bugfixes and support for content negotiation with concurrent HTTP between Jolie services. - Made numerous improvements and bugfixes in database handling. A new connection pool implementation provides improved performance for transactions. - Expanded internal documentation for the Metadata and InvalidIdException classes. - Numerous low-level optimizations and code cleanups for enhanced performance and maintainability.

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

6.1.7 FunLess

• Keywords:
  Serverless, WebAssembly
• Functional Description:
  FunLess is a Function-as-a-Service (FaaS) platform that, unlike traditional FaaS solutions that rely on resource-heavy containerisation technologies, employs WebAssembly (Wasm) as its runtime environment. Using Wasm ensures lightweight execution, reduced cold starts, and enhanced portability, enabling functions to run seamlessly on diverse hardware architectures (particularly useful in cloud-edge environments). The platform supports a consistent function development and deployment process, allowing developers to write functions in multiple supported languages (Rust, Go, and JavaScript), compile them into Wasm binaries, and execute them across heterogeneous devices without requiring additional runtime adjustments. FunLess allows flexible deployments, supporting both bare-metal installations and optional integration with container orchestration tools like Kubernetes.
• URL:
  https://­funless.­dev/
• Publication:
  hal-04826377v1
• Contact:
  Matteo Trentin

6.1.8 JoT

• Name:
  Jolie Testing
• Keywords:
  Microservices, Software testing
• Functional Description:

  JoT is a testing framework for Microservice Architectures 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 microservices that use different technology stacks, b) writing tests that involve multiple services, and c) reusing tests 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 microservice architecture under test. The language for writing JoT tests is Jolie, which provides constructs that support technology agnosticism and the definition of terse test behaviors.

• Release Contributions:
  In 2024, JoT underwent some minor updates to fix some issues and integrate its functionalities with container technologies (Docker) and continuous integration platforms (GitHub Actions).
• URL:
  https://­github.­com/­jolie/­jot
• 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:
  In 2024, Choral underwent some minor bug fixes and extensions of its standard libraries.
• URL:
  https://­www.­choral-lang.­org/
• Contact:
  Saverio Giallorenzo
• Participants:
  Saverio Giallorenzo, Fabrizio Montesi
• Partner:
  University of Southern Denmark

7.3.1 Deterministic program analysis

Deterministic programs, following the traditional model of computation, can exhibit quantitative effects and in particular give rise to time and space costs, which should for very good reasons be kept under control. In OLAS, we study how this is possible and we thus deal with semantics and verification of deterministic programs.

The class of basic feasible functionals captures feasibility for type-2 functionals, and thus for functional programs that can take (first-order) functions as arguments. We studied how this class related to higher-order term rewriting 11, and in particular with a recently introduced notion of cost–size interpretations for higher-order term rewriting. We then prove that the class of functionals represented by higher-order terms admitting a certain kind of cost–size interpretation is exactly the class of basic feasible functionals.

The $\lambda$-calculus is the universally accepted model of functional programming. But can the $\lambda$-calculus be considered a reasonable computational model? Can we use it for measuring the space consumption of algorithms? We introduced 1 a new reasonable space cost model for the $\lambda$-calculus, based on a variant of the Krivine abstract machine. This is the first cost model which is able to accommodate logarithmic space.

We also provided a categorical framework to combine fixpoints with derivatives by looking at Cartesian differential categories with a fixpoint operator 16, the former being a semantic setting in which concepts like program differentiation receive a proper treatment. We introduce an additional axiom relating the derivative of a fixpoint with the fixpoint of the derivative. We show how the standard examples of Cartesian differential categories where we can compute fixpoints provide canonical models of this notion.

We finally considered models of linear logic via bicategories, the latter allowing for a finer, more dynamic study, of computation. More specifically, we introduce 5 a bicategorical model of linear logic which is a novel variation of the bicategory of groupoids, profunctors, and natural transformations. Our model is obtained by endowing groupoids with additional structure, called a kit, to stabilize the profunctors by controlling the freeness of the groupoid action on profunctor elements.

7.3.2 Probabilistic program analysis

A class of programs and processes that by their very nature exhibit quantitative effects and are therefore suitable to quantitative analysis are certainly probabilistic programs. In our team, we are interested in studying probabilistic programs from a foundational and from a more applicative viewpoint.

We first of all investigated the termination problem in a calculus of session types with probabilistic choice operators. In this setting, a whole range of termination properties can be defined, from the weaker almost-sure termination to strong almost-sure termination, passing through positive almost-sure termination. We present two similar session type systems  13 closely related to classical linear logic with exponentials that guarantee the two extremal properties in such range. In both type systems, the definitional overhead that deals with the ensured termination property is kept to a minimum.

In the last years, we have also been interested in laying the foundations for a new approach to bridge logic and probabilistic computation. We published a survey paper 2 summarizing the results we obtained, in which we delineate how one can define extensions of classical and intuitionistic propositional logic with counting quantifiers, that is, quantifiers that measure to which extent a formula is true. The resulting systems admit a natural semantics, based on the Borel σ-algebra of the Cantor space, together with a sound and complete proof system. The systems we introduced, despite their logical nature, tightly relate to probabilistic computation: on the one hand, the validity of formulas in prenex form characterizes the corresponding level of Wagner's hierarchy of counting complexity classes. On the other hand, proofs correspond, in the sense of Curry and Howard, to typing derivations for a randomized extension of the $\lambda$-calculus.

7.3.3 Quantum program analysis

Quantum computation is a promising and emerging computational paradigm which can efficiently solve problems considered to be intractable on classical computers. However, the unintuitive nature of quantum mechanics poses interesting and challenging questions for the design and analysis of quantum programming languages, with functional correctness and complexity analysis being of prime importance.

One may then wonder to which extent reasoning on quantum programs is more difficult than, say, on classical, probabilistic ones. One way to formally address this question is to place corresponding decision problems (e.g., almost sure termination, finite runtime, weakest pre-condition reasoning) within the arithmetical hierarchy, a computability theoretic mean to classify undecidable problems in terms of their relative difficulties. In 10 we have shown that, if we restrict quantum gates to the Clifford+T fragment—known as an approximately universal fragment of quantum mechanics—the above mentioned decision problems can be categorized within the arithmetical hierarchy in the same way as their corresponding problems of probabilistic programs. The main intuition behind this surprising result is that Clifford+T makes it possible to retain quantum states with rational amplitudes, thus restricting the study to a countable domain.

We also managed to extend a minimal Multiparty Session Types (MPST) system with quantum data and operations, this way enabling the specification of quantum protocols 23, 22. The resulting system of Quantum MPSTs (QMPSTs) provides a formal notation to describe quantum protocols, both at the abstract level of global types, describing which communications can take place in the system and their dependencies, and at the concrete level of local types and quantum processes, describing the expected behavior of each participant in the protocol. Beyond usual communication properties, QMPSTs also allow us to prove that qubits are owned by a single process at any time, capturing the quantum no-cloning and no-deleting theorems.

While specific languages ​​for quantum computing can be defined and exist in the literature, most software development in this field occurs through so-called circuit description languages, in which programs are classical and produce a description of a quantum computation, in the form of a quantum circuit. Since these programs can leverage all the expressive power of high-level classical languages, circuit description languages have been successfully used to describe complex and practical quantum algorithms, whose circuits, however, may involve many more qubits and gate applications than current quantum architectures can actually master. We studied how linear dependent type-and-effect systems can be used to derive parametric upper bounds on the width of the circuits produced by a program 12, and proved that both the standard type safety results and that the resulting resource analysis is correct with respect to a big-step operational semantics.

7.3.4 Applications to cryptography and security

We have also become increasingly interested in topics of cryptography and security. Concerning cryptography, in 9 we have been working on the logical foundations of EasyCrypt, a proof assistant designed specifically for the analysis of cryptographic routines. Specifically, we have developed and implemented within EasyCrypt the expectation-based Hoare logic (eHL), a quantitative version of Hoare logic for probabilistic programs with adversarial code. The main distinct feature of this logic is its expressiveness (it is complete in the sense of Cook) whilst retaining usability and modularity. Not confined to cryptographic proofs, as a show-case of expressiveness, we have fully formalized a concrete implementation of skip-lists within EasyCrypt using eHL, a randomized data structure that is exceptionally intricate to analyze formally. In related work 31, a part of the Dilithium signature scheme, submitted to the NIST post-quantum cryptography project, has been proven correct with eHL in a concise and elegant way.

Concerning investigations related to security, in a recent work 14, we have been re-investigating the role of memory layout randomization (e.g. Kernel Layout randomization as employed in the Linux kernel) as an (in)effective mitigation strategy against attacks in the Spectre era. This work encompasses a revised, formal thread model based on the usual multi-tier memory model employed in modern kernels as well as standard defense mechanisms (such as DEP, SMAP/SMEP, etc), but where an attacker can exploit side-channel info leaks and influence speculative execution. We have proven that attacks comprising memory safety such as the blindsight and related attacks are not only possible due to practical limitations of implementations, but are indeed inherent to the attack vectors underlying modern computer architectures. To remedy, we establish speculative memory safety through an adaptation of the notion of constant time, a well established implementation technique to mitigate side-channel attacks. We also investigate program transformations to bridge the gap between memory safety in speculative and classical scenarios.

We also studied 20 a $\lambda$-calculus in which all programs can be evaluated in probabilistic polynomial time and in which there is sufficient structure to represent sequential cryptographic constructions and adversaries for them, even when the latter are oracle-based. A notion of observational equivalence capturing computational indistinguishability and a class of approximate logical relations have also been defined, showing that the latter represents a sound proof technique for the former.

Separation logic is a substructural logic which has proved to have numerous and fruitful applications to the verification of programs working on dynamic data structures. In a recent work, Barthe, Hsu and Liao have proposed a new way of giving semantics to separation logic formulas in which separating conjunction is interpreted as exact, information theoretic probabilistic independence. There is however a literature on weaker notions of independence which are computational in nature, i.e. independence holds only against efficient adversaries and modulo a negligible probability of success. We explored the nature of computational independence in a cryptographic scenario, in view of the aforementioned advances in separation logic. In a recently published paper 19, we show on the one hand that the semantics of separation logic can be adapted so as to account for complexity bounded adversaries, and on the other hand that the obtained logical system is useful for writing simple and compact proofs of standard cryptographic results in which the adversary remains hidden.

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.

Enhancing Situational Awareness: Real-Time Monitoring and Replanning with Collaborative Unmanned Vehicles and Onboard Sensing

Zavattaro and Giallorenzo participate in a two-year project collaboration, called “Enhancing Situational Awareness: Real-Time Monitoring and Replanning with Collaborative Unmanned Vehicles and Onboard Sensing”, started in December 2023, between Leonardo Company S.p.A., Thales Alenia Space Italia S.p.A., and the University of Bologna. The collaboration regards the analysis of techniques for managing the development and deployment of software applications in the context of multi-drone systems in disaster scenarios.

Participants: Gianluigi Zavattaro, 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.4.1 DCore

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

The overall objective of the project was to develop a semantically well-founded, novel form of concurrent debugging, which we call “causal debugging”. Causal debugging comprises and integrates 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 PPS

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

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

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

9.4.3 SmartCloud

SmartCloud (Smart dynamic adaptivity for cloud computing systems) is an ANR project that started on January 2024 and that will end in July 2027.

It aims at studying techniques for cloud computing systems which can be updated in a smart, dynamic and coordinated way to cope with changing requirements and environment conditions. The project will define a new framework for adaptation combining a model of both platform and application aspects and heuristics for online optimization.

Participants: Gianluigi Zavattaro, Saverio Giallorenzo, Ivan Lanese.

10.1.1 Scientific events: organisation

10.1.2 Journal

10.1.3 Invited talks

• 20th Latin American Symposium on Mathematical Logic (D. Sangiorgi)
• 16th Workshop on Games for Logic and Programming Languages (U. Dal Lago)

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 OLAS 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 (Switzerland). 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 council of the Italian Chapter of the EATCS.
• U. Dal Lago is involved since September 2022 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.

10.1.5 Research administration

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

10.2.1 Juries

• G. Zavattaro has been member of the evaluation committee of the PhD thesis of Valentino Picotti at the Southern Denmark University (SDU)
• G. Zavattaro has been member of the evaluation committee of the Habilitation à diriger des recherches (HDR) of Simon Bliudze at INRIA, Lille, France.

International journals

• 1 articleB.Beniamino Accattoli, U. D.Ugo Dal Lago and G.Gabriele Vanoni. Reasonable Space for the Lambda-Calculus, Logarithmically.Logical Methods in Computer Science204November 2024HALDOIback to text
• 2 articleM.Melissa Antonelli, U.Ugo Dal Lago and P.Paolo Pistone. Towards logical foundations for probabilistic computation.Annals of Pure and Applied Logic1759October 2024, 103341HALDOIback to text
• 3 articleL.Laura Bocchi, I.Ivan Lanese, C. A.Claudio Antares Mezzina and S.Shoji Yuen. revTPL: The Reversible Temporal Process Language.Logical Methods in Computer ScienceVolume 20, Issue 1January 2024HALDOIback to text
• 4 articleU.Ugo Dal Lago and A.Alexis Ghyselen. On Model-Checking Higher-Order Effectful Programs.Proceedings of the ACM on Programming Languages8POPLJanuary 2024, 2610 - 2638HALDOIback to text
• 5 articleM.Marcelo Fiore, Z.Zeinab Galal and H.Hugo Paquet. Stabilized profunctors and stable species of structures.Logical Methods in Computer ScienceVolume 20, Issue 1February 2024HALDOIback to text
• 6 articleP.Pietro Lami, I.Ivan Lanese, J.-B.Jean-Bernard Stefani, C.Claudio Sacerdoti Coen and G.Giovanni Fabbretti. Reversible debugging of concurrent Erlang programs: Supporting imperative primitives.Journal of Logical and Algebraic Methods in Programming138April 2024, 100944HALDOIback to text
• 7 articleI.Ivan Lanese, I.Iain Phillips and I.Irek Ulidowski. An Axiomatic Theory for Reversible Computation.ACM Transactions on Computational Logic252April 2024, 1-40HALDOIback to text

Invited conferences

• 8 inproceedingsI.Ivan Lanese and G.Gregor Gössler. Causal Debugging for Concurrent Systems.RC 2024 - 16th International Conference on Reversible ComputationLNCS-14680Reversible Computation : 16th International Conference, RC 2024, Toruń, Poland, July 4–5, 2024, ProceedingsTorun, PolandSpringer Nature SwitzerlandMay 2024, 3-9HALDOIback to text

International peer-reviewed conferences

• 9 inproceedingsM.Martin Avanzini, G.Gilles Barthe, B.Benjamin Grégoire, G.Georg Moser and G.Gabriele Vanoni. Hopping Proofs of Expectation-Based Properties: Applications to Skiplists and Security Proofs.ACM Digital LibraryOOPSLA 2024 -ACM Conference on Object Oriented Programming Systems Languages and Applications8Proceedings of the ACM on Programming LanguagesOOPSLA1Pasadena (CA), United StatesApril 2024, 784-809HALDOIback to text
• 10 inproceedingsM.Martin Avanzini, G.Georg Moser, R.Romain Péchoux and S.Simon Perdrix. On the Hardness of Analyzing Quantum Programs Quantitatively.Lecture Notes in Computer ScienceESOP 2024 - 33rd European Symposium on ProgrammingLecture Notes in Computer ScienceProgramming Languages and Systems : 33rd European Symposium on Programming, ESOP 2024, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2024, Luxembourg City, Luxembourg, April 6–11, 2024, Proceedings, Part IILNCS-14577Luxembourg, Luxembourg2024, 28HALDOIback to text
• 11 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 - 27th International Conference on Foundations of Software Science and Computation StructuresLNCS-14575Foundations of Software Science and Computation Structures : 27th International Conference, FoSSaCS 2024, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2024, Luxembourg City, Luxembourg, April 6–11, 2024, Proceedings, Part IILuxembourg, LuxembourgSpringer Nature SwitzerlandApril 2024, 70-91HALDOIback to text
• 12 inproceedingsA.Andrea Colledan and U.Ugo Dal Lago. Circuit Width Estimation via Effect Typing and Linear Dependency.Lecture notes in computer scienceESOP 2024 - 33rd European Symposium on ProgrammingLNCS-14577Programming Languages and Systems - 33rd European Symposium on Programming, ESOP 2024, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2024, Luxembourg City, Luxembourg, April 6–11, 2024, Proceedings, Part IILuxembourg, LuxembourgSpringer Nature Switzerland2024, 3 - 30HALDOIback to text
• 13 inproceedingsU.Ugo Dal Lago and L.Luca Padovani. On the Almost-Sure Termination of Binary Sessions.ACM Digital LibraryPPDP 2024 - 26th International Symposium on Principles and Practice of Declarative ProgrammingPPDP '24: Proceedings of the 26th International Symposium on Principles and Practice of Declarative ProgrammingMilano, ItalyACMSeptember 2024, 1 - 12HALDOIback to text
• 14 inproceedingsD.Davide Davoli, M.Martin Avanzini and T.Tamara Rezk. On Kernel's Safety in the Spectre Era (And KASLR is Formally Dead).CCS '24: ACM SIGSAC Conference on Computer and Communications SecuritySalt Lake City, United StatesACMOctober 2024, 1091-1105HALback to text
• 15 inproceedingsG.Giovanni Fabbretti, I.Ivan Lanese and J.-B.Jean-Bernard Stefani. Reversibility with Holes.Lecture notes in computer scienceRC 2024 - 16th International Conference on Reversible ComputationLNCS-14680Reversible Computation : 16th International Conference, RC 2024, Toruń, Poland, July 4–5, 2024, ProceedingsTorun, PolandSpringer2024, 69 - 74HALDOIback to text
• 16 inproceedingsZ.Zeinab Galal and J.-S.Jean-Simon Pacaud Lemay. Combining fixpoint and differentiation theory.ACM Digital LibraryLICS 2024 - 39th Annual ACM/IEEE Symposium on Logic in Computer ScienceLICS '24: Proceedings of the 39th Annual ACM/IEEE Symposium on Logic in Computer ScienceTallinn, EstoniaACMJuly 2024, 1-14HALDOIback to text
• 17 inproceedingsS.Saverio Giallorenzo, J.Jacopo Mauro, A.Andrea Melis, F.Fabrizio Montesi, M.Marco Peressotti and M.Marco Prandini. Choreography-Defined Networks: a Case Study on DoS Mitigation.Lecture notes in computer scienceICSOC 2024 - 22nd International Conference on Service-Oriented ComputingLNCS-15405Service-Oriented Computing : 22nd International Conference, ICSOC 2024, Tunis, Tunisia, December 3–6, 2024, Proceedings, Part IITunis, Tunisia2024, 243–259HALDOIback to text
• 18 inproceedingsS.Saverio Giallorenzo, F.Fabrizio Montesi, M.Marco Peressotti, F.Florian Rademacher, S.Sabine Sachweh and P.Philip Wizenty. A Toolchain for Checking Domain-and Model-driven Properties of Jolie Microservices.Lecture notes in computer scienceICSOC 2024 - 22nd International Conference on Service-Oriented ComputingLNCS-15405Service-Oriented Computing : 22nd International Conference, ICSOC 2024, Tunis, Tunisia, December 3–6, 2024, Proceedings, Part IITunis, TunisiaDecember 2024HALDOIback to text
• 19 inproceedingsU. D.Ugo Dal Lago, D.Davide Davoli and B.Bruce Kapron. On Separation Logic, Computational Independence, and Pseudorandomness.CSF 2024 6 IEEE 37th Computer Security Foundations Symposium151942024 IEEE 37th Computer Security Foundations Symposium (CSF)Enschede, NetherlandsIEEEOctober 2024, 80-95HALDOIback to text
• 20 inproceedingsU. D.Ugo Dal Lago, Z.Zeinab Galal and G.Giulia Giusti. On Computational Indistinguishability and Logical Relations.APLAS 2024 - 22nd Asian Symposium on Programming Languages and Systems15194Lecture Notes in Computer ScienceKyoto, JapanSpringer Nature SingaporeOctober 2025, 241-263HALDOIback to text
• 21 inproceedingsP.Pietro Lami, I.Ivan Lanese and J.-B.Jean-Bernard Stefani. A Small-Step Semantics for Janus.Lecture notes in computer scienceRC 2024 - 16th International Conference on Reversible ComputationLNCS-14680Reversible Computation : 16th International Conference, RC 2024, Toruń, Poland, July 4–5, 2024, ProceedingsTorun, PolandSpringer2024, 105 - 123HALDOIback to text
• 22 inproceedingsI.Ivan Lanese, U.Ugo Dal Lago and V.Vikraman Choudhury. Towards Quantum Multiparty Session Types.Lecture notes in computer scienceSEFM 2024 - 22nd International Conference on Software Engineering and Formal MethodsLNCS-15280Software Engineering and Formal Methods : 22nd International Conference, SEFM 2024, Aveiro, Portugal, November 6-8, 2024, ProceedingsAveiro (Portugal), PortugalSpringer Nature SwitzerlandNovember 2024, 385-403HALDOIback to text
• 23 inproceedingsI.Ivan Lanese, U.Ugo Dal Lago and V.Vikraman Choudhury. Towards Quantum Multiparty Session Types.PLanQC 2025 - Fifth International Workshop on Programming Languages for Quantum ComputingDenver (Colorado), United StatesJanuary 2025HALback to text
• 24 inproceedingsI.Ivan Lanese and G.Germán Vidal. Reversible Debugging of Erlang Programs in CauDEr.ACM Digital LibraryDEBT 2024 - 2nd ACM International Workshop on Future Debugging TechniquesDEBT 2024: Proceedings of the 2nd ACM International Workshop on Future Debugging TechniquesVienna, AustriaACMSeptember 2024, 30-31HALDOIback to text
• 25 inproceedingsS.Sourabh Pal, I.Ivan Lanese and M.Massimo Clo. Choreographic Automata: A Case Study in Healthcare Management.Lecture notes in computer scienceCOORDINATION 2024 - International Conference on Coordination Models and LanguagesLNCS-14676Coordination Models and Languages 26th IFIP WG 6.1 International Conference, COORDINATION 2024, Held as Part of the 19th International Federated Conference on Distributed Computing Techniques, DisCoTec 2024, Groningen, The Netherlands, June 17–21, 2024, ProceedingsGroningen, NetherlandsSpringer Nature SwitzerlandJune 2024, 3-19HALDOIback to text
• 26 inproceedingsG.Giuseppe de Palma, S.Saverio Giallorenzo, J.Jacopo Mauro, M.Matteo Trentin and G.Gianluigi Zavattaro. An OpenWhisk Extension for Topology-Aware Allocation Priority Policies.Lecture Notes in Computer ScienceCOORDINATION 2024 - 26th IFIP WG 6.1 International Conference on Coordination Models and Languages - 26th IFIP WG 6.1 International ConferenceLNCS-14676Coordination Models and Languages : 26th IFIP WG 6.1 International Conference, COORDINATION 2024, Held as Part of the 19th International Federated Conference on Distributed Computing Techniques, DisCoTec 2024, Groningen, The Netherlands, June 17–21, 2024, ProceedingsGroningen, NetherlandsSpringer Nature SwitzerlandJune 2024, 201-218HALDOIback to text
• 27 inproceedingsG.Giuseppe de Palma, S.Saverio Giallorenzo, J.Jacopo Mauro, M.Matteo Trentin and G.Gianluigi Zavattaro. FunLess: Functions-as-a-Service for Private Edge Cloud Systems.IEEE XploreICWS 2024 - IEEE International Conference on Web Services2024 IEEE International Conference on Web Services (ICWS)Shenzhen, ChinaIEEEJuly 2024, 961-967HALDOIback to text
• 28 inproceedingsG. D.Giuseppe De Palma, S.Saverio Giallorenzo, J.Jacopo Mauro, M.Matteo Trentin and G.Gianluigi Zavattaro. Function-as-a-Service Allocation Policies Made Formal.Leveraging Applications of Formal Methods, Verification and Validation. REoCAS Colloquium in Honor of Rocco De Nicola - 12th International Symposium, ISoLA 202415219Lecture Notes in Computer ScienceCrete, FranceSpringer Nature SwitzerlandOctober 2025, 306-321HALDOIback to text
• 29 inproceedingsD.Davide Sangiorgi. An Abstract Account of Up-to Techniques for Inductive Behavioural Relations.12th International Symposium Leveraging Applications of Formal Methods Verification and Validation, ISoLA 2024, REoCAS Colloquium in Honor of Rocco De Nicola15219Lecture Notes in Computer ScienceCrete Island, GreeceSpringer Nature SwitzerlandOctober 2025, 62-74HALDOIback to text

Scientific book chapters

• 30 inbookL.Lorenzo Bacchiani, M.Mario Bravetti, S.Saverio Giallorenzo, J.Jacopo Mauro and G.Gianluigi Zavattaro. Integrated Timed Architectural Modeling/Execution Language.LNCS-14360Active Object Languages: Current Research TrendsLecture Notes in Computer ScienceSpringer Nature SwitzerlandJanuary 2024, 169-198HALDOIback to text