Ubiquitous Computing refers to the situation in which computing facilities are embedded or integrated into everyday objects and activities. Networks are large-scale, including both hardware devices and software agents. The systems are highly mobile and dynamic: programs or devices may move and often execute in networks owned and operated by others; new devices or software pieces may be added; the operating environment or the software requirements may change. The systems are also heterogeneous and open: the pieces that form a system may be quite different from each other, built by different people or industries, even using different infrastructures or programming languages; the constituents of a system only have a partial knowledge of the overall system, and may only know, or be aware of, a subset of the entities that operate on the system.
A prominent recent phenomenon in Computer Science is the emerging of interaction and communication as key architectural and programming concepts. This is especially visible in ubiquitous systems. Complex distributed systems are being thought of and designed as structured composition of computational units, usually referred to as components. These components are supposed to interact with each other and such interactions are supposed to be orchestrated into conversations and dialogues. In the remainder, we will write CBUS for Component-Based Ubiquitous Systems.
In CBUS, the systems are complex. In the same way as for complex systems in other disciplines, such as physics, economics, biology, so in CBUS theories are needed that allow us to understand the systems, design or program them, analyze them.
Focus investigates the semantic foundations for CBUS. The foundations are intended as instrumental to formalizing and verifying important computational properties of the systems, as well as to proposing linguistic constructs for them. Prototypes are developed to test the implementability and usability of the models and the techniques. Throughout our work, `interaction' and 'component' are central concepts.
The members of the project have a solid experience in algebraic and logical models of computation, and related techniques, and this is the basis for our study of ubiquitous systems. The use of foundational models inevitably leads to opportunities for developing the foundational models themselves, with particular interest for issues of expressiveness and for the transplant of concepts or techniques from a model to another one.
The objective of Focus is to develop concepts, techniques, and possibly also tools, that may contribute to the analysis and synthesis of CBUS. Fundamental to these activities is modeling. Therefore designing, developing and studying computational models appropriate for CBUS is a central activity of the project. The models are used to formalise and verify important computational properties of the systems, as well as to propose new linguistic constructs.
The models we study are in the process
calculi (e.g., the
The main application domain for Focus are ubiquitous systems, broadly systems whose distinctive features are: mobility, high dynamicity, heterogeneity, variable availability (the availability of services offered by the constituent parts of a system may fluctuate, and similarly the guarantees offered by single components may not be the same all the time), open-endedness, complexity (the systems are made of a large number of components, with sophisticated architectural structures). In Focus we are particularly interested in the following aspects.
Linguistic primitives for programming dialogues among components.
Contracts expressing the functionalities offered by components.
Adaptability and evolvability of the behaviour of components.
Verification of properties of component systems.
Bounds on component resource consumption (e.g., time and space consumed).
Today the component-based methodology often refers to Service Oriented Computing. This is a specialized form of component-based approach. According to W3C, a service-oriented architecture is “a set of components which can be invoked, and whose interface descriptions can be published and discovered”. In the early days of Service Oriented Computing, the term services was strictly related to that of Web Services. Nowadays, it has a much broader meaning as exemplified by the XaaS (everything as a service) paradigm: for example, based on modern virtualization technologies, cloud computing offers the possibility to build sophisticated service systems on virtualized infrastructures accessible from everywhere and from any kind of computing device. Such infrastructures are usually examples of sophisticated service oriented architectures that, differently from traditional service systems, should also be capable to elastically adapt on demand to the user requests.
Fabrizio Montesi, external collaborator in Focus, has been awarded the “Innovation Award 2017” from his university (University of Southern Denmark), for his work and contributions in the language Jolie.
Higher-Order Complexity Analysis
Keywords: Ocaml - Verification - Runtime Complexity Analysis
Scientific Description: Over the last decade, various tools for the static analysis of resource properties of programs have emerged. In particular, the rewriting community has recently developed several tools for the time complexity analysis of term rewrite systems. These tools have matured and are nowadays able to treat non-trivial programs, in a fully automatic setting. However, none of these automatic complexity analysers can deal with higher-order functions, a pervasive feature of functional programs. HoCA (Higher-Order Complexity Analyser) overcomes this limitation by translating higher-order programs – in the form of side-effect free OCaml programs - into equivalent first-order rewrite systems. At the heart of our tool lies Reynold’s defunctionalization technique. Defunctionalization however is not enough. Resulting programs have a recursive structure too complicated to be analysed automatically in all but trivial cases. To overcome this issue, HoCA integrates a handful of well established program transformation techniques, noteworthy dead-code elimination, inlining, instantiation and uncurrying. A complexity bound on the resulting first-order program can be relayed back reliably to the higher-order program of interest. A detailed description of HoCA is available on http://arxiv.org/abs/1506.05043.
Functional Description: HoCA is an abbreviation for Higher-Order Complexity Analysis, and is meant as a laboratory for the automated complexity analysis of higher-order functional programs. Currently, HoCA consists of one executable pcf2trs which translates a pure subset of OCaml to term rewrite systems, in a complexity reflecting manner. As a first step, HoCA desugars the given program to a variation of Plotkin's PCF with data-constructors. Via Reynold's defunctionalization, the PCF program is turned into an applicative term rewrite system (ATRS for short), call-by-value reductions of the PCF program are simulated by the ATRS step-by-step, on the ATRS, and various complexity reflecting transformations are performed: inlining, dead-code-elminiation, instantiation of higher-order variables through a call-flow-analysis and finally uncurrying. This results finally in a first-order rewrite system, whose runtime-complexity reflects the complexity of the initial program, asymptotically.
Participants: Martin Avanzini and Ugo Dal Lago
Contact: Ugo Dal Lago
Java Orchestration Language Interpreter Engine
Keyword: Microservices
Scientific Description: Jolie is a service-oriented programming language. Jolie can be used to program services that interact over the Internet using different communication protocols.
Differently from other Web Services programming languages such as WS-BPEL, Jolie is based on a user-friendly C/Java-like syntax (more readable than the verbose XML syntax of WS-BPEL) and, moreover, the language is equipped with a formal operational semantics. This language is used for the proof of concepts developed around Focus activities. For instance, contract theories can be exploited for checking the conformance of a Jolie program with respect to a given contract.
Functional Description: Developments in 2017: 2017 has seen many efforts around the language to increase its usage in industry. These include:
- Organisation of two events. One in Italy, called Meeting on Microservices, organised by italianaSoftware and Monrif SpA in December 2016. The second one in Denmark, organised by Southern Denmark University and Università di Bologna in October 2017. Common aim of both events was presenting the language from a practical, industrial point of view, to illustrate with real-world cases how its abstractions can increase productivity of companies. Both venues contributed in growing the community of companies that have adopted the language or plan to adopt it in the near future.
- Revision of the language documentation, migrating it to GitBook. In this way, Jolie users can access its documentation as HTML pages, as a PDF, and as an eBook. The choice of GitBook has been guided by the need to give a proper tool to users to collaborate, discuss, and request fixes and extensions on the documentation.
- Development of several tools, frameworks, and libraries to ease the management of architectures of microservices. The main ones are:
- the publication of libraries to interact with and orchestrate the Docker containerisation technology. This work, called Jocker, has been the fulcrum of other projects that streamline the creation and management of container-based microservice architectures,
- the publication of a fundamental companion for any industrial-grade language: a packing system. The project, called jpm, automatises the process of publishing, installing, upgrading, configuring, and removing libraries in Jolie software projects,
- the inclusion in the language interpreter of hooks for modular, distributed tracing, a renowned problem of microservices and distributed systems. Developed to output program traces in JSON, this work maintained an open perspective on both output formats and logging deployment, which can be extended in a modular way. The project also includes a visualiser of several distributed traces for debugging purposes,
- the publication of a unit testing framework for microservices, a fundamental building block for continuous integration processes. This framework includes also functionalities to automatically test microservices within a distributed, sandboxed environment, thanks to its integration with Jocker. The framework is also the first step towards a more comprehensive suite to test complete microservice architectures,
- the creation of a deployment framework that automatises the deployment of microservice architectures. This is an important issue in microservice and distributed system deployment, where correctly installing programs on execution nodes and making sure they are properly linked to each other is a daunting and time-consuming task. The framework, given a deployment schema, i) automatises the creation of containers where one or more microservices coexist, ii) deploys the containers into assigned machines, and iii) binds the deployed containers so that microservices within different containers can communicate,
- the creation of the Jiot project, aimed at integrating IoT-related technologies into the Jolie language. The final goal is to provide easy-to-use and flexible communication abstractions to interconnect and make interact disparate IoT islands. Work in 2017 comprised the inclusion of the CoAP/UDP and MQTT/TCP protocols among the communication technologies supported by the language.
Jolie also transitioned from version 1.6 to 1.6.2, which are minor releases, however they contain many performance optimisations and bug fixes.
Release Functional Description: There are many fixes to the HTTP extension, improvements to the embedding engine for Javascript programs, and improvements to the support tools jolie2java and wsdl2jolie.
Participants: Claudio Guidi, Fabrizio Montesi, Maurizio Gabbrielli and Saverio Giallorenzo
Contact: Fabrizio Montesi
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.
Contact: Tong Liu
Adaptive Interaction-Oriented Choreographies in Jolie
Scientific Description: AIOCJ is a framework for programming adaptive distributed systems based on message passing. AIOCJ comes as a plugin for Eclipse, AIOCJ-ecl, allowing to edit descriptions of distributed systems as adaptive interaction-oriented choreographies (AIOC). From interaction-oriented choreographies the description of single participants can be automatically derived. Adaptation is specified by rules allowing to replace predetermined parts of the AIOC with a new behaviour. A suitable protocol ensures that all the participants are updated in a coordinated way. As a result, the distributed system follows the specification given by the AIOC under all changing sets of adaptation rules and environment conditions. In particular, the system is always deadlock-free. AIOCJ can interact with external services, seen as functions, by specifying their URL and the protocol they support (HTTP, SOAP, ...). Deadlock-freedom guarantees of the application are preserved provided that those services do not block.
Functional Description: AIOCJ is an open-source choreography programming language for developing adaptive systems.
Participants: Ivan Lanese, Jacopo Mauro, Maurizio Gabbrielli, Mila Dalla Preda and Saverio Giallorenzo
Contact: Saverio Giallorenzo
Causal-consistent Debugger for Erlang
Keywords: Debug - Reversible computing
Scientific Description: The reversible debugger is based on the theory of causal-consistent reversibility, which states that any action can be undone provided that its consequences, if any, are undone beforehand. This theory relies on a causal semantic for the target language, and can be used even if different processes have different notions of time
Functional Description: CauDEr is a debugger allowing one to explore the execution of concurrent Erlang programs both forward and backward. Notably, when going backward, any action can be undone provided that its consequences, if any, are undone beforehand. This enables one to find a bug by following the causality links from the visible misbehaviour to the bug. The debugger takes an Erlang program but debugging is done on its translation into Core Erlang.
Partner: Universitat Politècnica de València
Contact: Ivan Lanese
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.
Contact: Tong Liu
Microservices represent an architectural style inspired by service-oriented computing that has recently started gaining popularity. As we have discussed in , one of the main advantages of the microservices approach is that it improves scalability of the developed applications. In we have analyzed the impact of microservices on the overall line of research on software architectures, by pointing out specific open problems and future challenges. One of the challenges is concerned with programming languages because microservice systems are currently developed using general-purpose programming languages that do not provide dedicated abstractions for service composition. In we have discussed the limitations of the current practices and we have proposed a novel language-based approach to the engineering of microservices based on the Jolie programming language.
The practice of programming distributed systems is extremely error-prone, due to the complexity in correctly implementing separate components that, put together, enact an agreed protocol. Theoretical and applied research is, therefore, fundamental, to explore new tools to assist the development of such systems. In particular, usage of so-called session types in orchestration languages guarantees correct communication by means of corresponding type system theories. In this context, we carried out studies about: foundations of the classical theory of session types, by providing an encoding into pi-calculus typing ; and subtyping in the context of asynchronous communication, showing it to be an undecidable problem . Choreographies are also an important specification tool in that they can be compiled to obtain projected orchestrations that enjoy deadlock freedom by construction. Moreover they allow one to express dynamic behaviours at the level of the whole system, which then reflect on each involved orchestration. In this context, in we studied the theory and implementation of dynamic choreographies and in we showed how to use them for programming microservice-based applications. Finally, we considered applications in the context of Mobility-as-a-Service (MaaS) scenarios, where solutions of different transportation providers are dynamically composed into a single, consistent interface. We devised the prototype of an enabling software platform for MaaS and we studied MaaS security issues .
We have continued the study of reversibility started in the past
years. In particular, in , we thoroughly
studied causal-consistent reversibility in the coordination language
In we studied how to exploit reversibility to improve client-server interactions. In particular, we defined retractable contracts, namely contracts including the possibility of undoing past agreements, which are more expressive than standard session contracts for binary interactions , yet preserve their nice properties: compliance and the subcontract relation are both decidable in polynomial time, the dual of a contract always exists and has a simple syntactic characterization. Furthermore we showed that the same contracts can also describe speculative interactions.
In Focus, we are interested in studying probabilistic higher-order programming languages and, more generally, the fundamental properties of probabilistic computation when placed in an interactive scenario. One of the most basic (but nevertheless desirable) properties of programs is certainly termination. When probabilistic choice comes into play, termination can be defined in more than one way. As an example, one can stipulate that a probabilistic program terminates if and only if its probability of convergence is 1, this way being almost surely terminating. Alternatively, a probabilistic program can be said to be positively almost surely terminating if its average runtime is finite. The latter condition easily implies the former. Termination, already undecidable for deterministic (universal) programming languages, remains so in presence of probabilistic choice. Actually, it becomes provably harder, being strictly higher in the arithmetical hierarchy. Probabilistic termination has received quite some attention in recent years, but most contributions are concerned either with its abstract nature, or with verification methodologies for imperative programs. Along 2017, we have initiated the study of probabilistic termination in probabilistic higher-order functional languages. Our contribution in this direction is twofold. On the one hand, we have analysed the impact of endowing a strongly normalising typed lambda calculus, namely Godel’s T, with various forms of probabilistic choice operators . Unsurprisingly, the obtained systems are all almost surely terminating, but interestingly, only some of them are positively so. In particular, binary probabilistic choice and the geometric distribution can have dramatically different effects. Another line of work has to do with types, and in particular with sized types, which we have generalised to a higher-order functional language with higher order recursion and binary probabilistic programs. We showed how the obtained system is sound for almost sure termination , but also that it captures interesting examples like various forms of random walks.
Complexity analysis of higher-order functional programs has been one of the core research directions within Focus since its inception. Progressively, however, our interest has shifted from foundations to automation. The latter is indeed the main research direction we have pursued in 2017. More specifically, we have been trying to overcome the main shortcoming of our software tool HoCA, namely the fact that most analysis techniques it implements are not modular, and are thus bound not to scale. We have looked at sized type systems as a way to do complexity analysis of functional programs by performing type inference on a so-called ticking-transformed version of them . The obtained design methodology has been proved to allow the analysis of programs which could not be handled by HoCA.
Building on our knowledge on semantic and coinductive techniques for reasoning about
higher-order programs, we have studied how to reason relationally when the programs at
hand exhibit some form of effect including probabilistic choice, but also algebraic
effects. We have first of all concluded our investigation about metric reasoning about
terms in a probabilistic lambda calculus. We discovered that in the general case of a
fully-fledged probabilistic lambda calculus, any reasonable metric is bound to trivialise
to an equivalence . This negative result convinced us that a
richer and more refined notion of comparison is needed, on which we are currently
investigating. We also looked at how Abramsky’s applicative bisimilarity can be
generalised to a language with algebraic effects. Since the notion of algebraic effect is
abstract, this is best done by injecting concepts from category theory, and in particular
those of a monad and of a relator, into the playground. Mild conditions on the latter
allow one to generalise the classic proof of congruence for applicative bisimilarity, due to
Howe , . This way, conductive proof
techniques for equivalence can be shown sound with respect to context equivalence for
various forms of algebraic effects including probabilistic choice, global state,
exceptions, and combinations. One last line of work we have pursued in 2017 has to do with
geometry of interaction, a dynamic semantic framework which is known to faithfully
model higher-order computation. We have this year managed to show that multitoken
machines, a generalisation of geometry of interaction we introduced three years ago, can
faithfully model quantum lambda calculi , but also process
algebras like the
We analyze sensible properties of concurrent systems, including deadlock freedom and resource usages, and proof techniques for deriving behavioural equalities and preorders on processes.
In order to verify sensible properties of concurrent programs we use a technique consisting of (1) extracting information by means of behavioural type systems and (2) analyzing types by means of ad-hoc tools.
In we study deadlock detection for value-passing CCS
(and for
In we apply the above technique to a language for stateful active objects. This is challenging because active objects use futures to refer to results of pending asynchronous invocations and because these futures can be stored in object fields, passed as method parameters, or returned by invocations. The type system traces the access to object fields by means of effects. For this reason, it is possible to compute behavioural types that express synchronisation patterns in a precise way. The behavioural types are thereafter analysed by a solver that discovers potential deadlocks. The PhD thesis of Vincenzo Mastandrea addresses deadlock detection of stateful active objects.
In we apply the same technique to Java byte-code. In particular gives a practical presentation of JaDA, a static deadlock analyzer for Java that extracts behavioral types and analyzes these types by means of a fixpoint algorithm that reports potential deadlocks in the original Java code. We also present some of the features for customising the analysis: while the main strength of JaDA is to run in a fully automatic way, user interaction is possible and may enhance the accuracy of the results. The whole theory behind JaDa is fully developed in the PhD thesis of Abel Garcia Celestrin .
In we address a concurrent language with explicit acquire and release operations on virtual machines. In our language it is possible to delegate other (ad-hoc or third party) concurrent code to release virtual machines (by passing them as arguments of invocations). In this case, we define (i) a type system associating programs with behavioural types that record relevant information for resource usage (creations, releases, and concurrent operations), (ii) a translation function that takes behavioural types and returns cost equations, and (iii) an automatic off-the-shelf solver for the cost equations. A soundness proof of the type system establishes the correctness of our technique with respect to the cost equations. We have experimentally evaluated our technique using a cost analysis solver. The experiments show that our analysis allows us to derive bounds for programs that are better than other techniques, such as those based on amortized analysis.
Systems need to be updated to last for a long time in a dynamic environment, and to cope with changing requirements. It is important for updates to preserve the desirable properties of the system under update, while possibly enforcing new ones. We consider a simple yet general update mechanism that replaces a component of the system with a new one. The context, i.e., the rest of the system, remains unchanged. We define contexts and components as Constraint Automata interacting via either asynchronous or synchronous communication, and we express properties using Constraint Automata too. Then we build most general updates which preserve specific properties, considering both a single property and all the properties satisfied by the original system, in a given context or in all possible contexts.
In , we study bisimilarity, a behavioural equivalence whose success is much due to the associated bisimulation proof method. In particular, we discuss a different proof method, based on unique solution of special forms of inequations called contractions, and inspired by Milner's theorem on unique solution of equations. The method is as powerful as the bisimulation proof method and its up-to context enhancements. The definition of contraction can be transferred onto other behavioural equivalences, possibly contextual and non-coinductive. This enables a coinductive reasoning style on such equivalences, either by applying the method based on unique solution of contractions, or by injecting appropriate contraction preorders into the bisimulation game.
In we develop the above proof method in a different direction: rather than introducing contractions, we remain within equations, and we investigate conditions that guarantee unique solutions, for bisimilarity as well as for other behavioural equivalences such as trace equivalence. We also consider preorders such as trace inclusion. We finally develop abstract formulations of the theorems, on generic Labeled Transition Systems.
In we introduce a framework for detecting anomalies in the clocks of the different components of a network of sensor stations connected with a central server for measuring air quality. We propose a novel approach, supported by a formal representation of the network using fuzzy-timed automata, to precisely represent the expected behaviour of each component of the network. Using fuzzy logic concepts, we can specify admissible mismatches between the clocks.
We study why and how to teach computer science principles (nowadays often referred to as "computational thinking", CT), in particular in the context of K-12 education (students aged approximately from 5 to 18). We study philosophical, sociological and historical motivations to teach computer science at all school levels. Furthermore, we study what concepts and skills related to computer science are not barely technical abilities, but have a general value for all students. Finally we try to find/produce/evaluate suitable materials (tools, languages, lesson plans...) to teach these concepts, taking into account: difficulties in learning CS concepts (particularly programming); stereotypes about computer science (particularly gender related issues); teacher training (particularly non specialist teachers).
There is no accepted definition of computational thinking. From one hand we tried to find out the main common elements in the most important proposed definitions, and investigate, in a large sample of K-12 teachers, if they have a correct idea about CT. We found the vast majority of them held misconceptions or partial views about it. We argued these may be consequences of a massive use of the term in school context ; we made clear “computational thinking” is not a new subject, but just a name to indicate computer science principles that should be taught to all students .
We analyzed the sentiment of a large sample of teachers participating in the national project “Programma il Futuro” (Program the Future) - an italian version of Code.org with support materials. The sentiment was largely positive. Among other results, we note reported interest is equally distributed between male and female students in primary school, and shifts towards a higher male interest only from secondary school, suggesting a social influence.
Every person holds an idea (mindset) about intelligence: someone thinks it is a fixed trait, like eye color (fixed mindset), while others think it can grow like muscles (growth mindset). The latter is beneficial for students to have better results, particularly in STEM disciplines, and to not being influenced by stereotypes. Computer science is a subject that can be affected by fixed ideas (“geek gene”) and some (small) studies showed it can induce fixed ideas. Teachers’ mindset directly affects students’ one. We propose a line of research to investigate mindset of pre-service primary school teachers before and after a “creative computing course”, to analyze and, in perspective, to change their specific “computer science mindset”.
In Focus, we sometimes make use of constraint solvers (e.g., cloud computing, service-oriented computing). Since a few years we have thus began to develop tools based on constraints. This year, besides refining the work on SUNNY (described elsewhere, see also ) we have developed a new tool, NightSplitter, a scheduling tool to optimize (sub)group activities . Humans are social animals and usually organize activities in groups. However, they are often willing to split temporarily a bigger group in subgroups to enhance their preferences. NightSplitter is an on-line tool that is able to plan movie and dinner activities for a group of users, possibly splitting them in subgroups to optimally satisfy their preferences. We first have modeled and proved that this problem is NP-complete. We have then used Constraint Programming (CP) or alternatively Simulated Annealing (SA) to solve it. Empirical results show the feasibility of the approach even for big cities where hundreds of users can select among hundreds of movies and thousands of restaurants. (More information on NightSplitter is found in the section on tools.)
ELICA (Expanding Logical Ideas for Complexity Analysis) is an ANR project that started on October 2014 and that will finish on September 2018. ELICA focuses on methodologies for the static analysis of programs and their resource consumption. The project's aim is to further improve on logical methodologies for complexity analysis (type systems, rewriting, etc.). More specifically, one would like to have more powerful techniques with less false negatives, being able at the same time to deal with nonstandard programming paradigms (concurrent, probabilistic, etc.). Main persons involved: Avanzini, Dal Lago, Hirschkoff, Martini, Sangiorgi.
REPAS (Reliable and Privacy-Aware Software Systems via Bisimulation Metrics) is an ANR Project that started on October 2016 and that will finish on October 2020. The project aims at investigating quantitative notions and tools for proving program correctness and protecting privacy. In particular, the focus will be put on bisimulation metrics, which are the natural extension of bisimulation to quantitative systems. As a key application, we will develop a mechanism to protect the privacy of users when their location traces are collected. Main persons involved: Dal Lago, Gavazzo, Sangiorgi.
COCAHOLA (Cost models for Complexity Analyses of Higher-Order Languages) is an ANR Project that started on October 2016 and that will finish on October 2019. The project aims at developing complexity analyses of higher-order computations. The focus is not on analyzing fixed programs, but whole programming languages. The aim is the identification of adequate units of measurement for time and space, i.e. what are called reasonable cost models. Main persons involved: Dal Lago, Martini.
ICT COST Action IC1405 (Reversible computation - extending horizons of computing). Initiated at the end of April 2015 and with a 4-year duration, this COST Action studies reversible computation and its potential applications, which include circuits, low-power computing, simulation, biological modeling, reliability and debugging. Reversible computation is an emerging paradigm that extends the standard forwards-only mode of computation with the ability to execute in reverse, so that computation can run backwards as naturally as it can go forwards.
Main persons involved: Lanese (vice-chair of the action).
ICT COST Action IC1402 ARVI (Runtime Verification beyond Monitoring). Initiated in December 2014 and with a 4-year duration, this COST Action studies runtime verification, a computing analysis paradigm based on observing a system at runtime to check its expected behaviour.
Main persons involved: Bravetti, Lanese.
We list here the cooperations and contacts with other groups, without repeating those already listed in previous sections.
ENS Lyon (on concurrency models and resource control). Contact person(s) in Focus: Dal Lago, Martini, Sangiorgi, Vignudelli. Some visit exchanges during the year, in both directions. A joint PhD started in September 2016 (Adrien Durier).
Inria EPI Spades (on models and languages for components, reversibility). Contact person(s) in Focus: Lanese.
Universitat Politecnica de Valencia, Spain (on reversibility for Erlang). Contact person(s) in Focus: Lanese. Some visit exchanges during the year, in both directions.
Laboratoire d'Informatique, Université Paris Nord, Villetaneuse (on implicit computational complexity). Contact person(s) in Focus: Dal Lago, Martini.
Institut de Mathématiques de Luminy, Marseille (on lambda-calculi, linear logic and semantics). Contact person(s) in Focus: Dal Lago, Martini.
Team PPS, IRIF Lab, University of Paris-Diderot Paris 7 (on logics for processes, resource control). Contact person(s) in Focus: Dal Lago, Martini, Sangiorgi. Some short visits in both directions during the year.
IRILL Lab, Paris (on models for the representation of dependencies in distributed package based software distributions). Contact person(s) in Focus: Gabbrielli, Zavattaro. Some short visits in both directions during the year.
LMU Munich (M. Hofmann) (on implicit computational complexity and IntML). Contact person(s) in Focus: Dal Lago.
IMDEA Software, Madrid (G. Barthe) (on implicit computational complexity for cryptography). Contact person(s) in Focus: Dal Lago,Sangiorgi. Some visits during the year.
Facultad de Informatica, Universidad Complutense de Madrid (on web services). Contact person(s) in Focus: Bravetti. Bravetti is an external collaborator in the project “Desarrollo y Análisis formal de sistemas complejos en contextos DistribuidOS: fundamentos, herramientas y aplicaciones (DArDOS)” (Development and formal analysis of complex systems in distributed contexts: foundations, tools and applications) January 2016 - December 2018, funded by the Spanish Ministerio de Economia y Competitividad.
Title: Concurrent, Resourceful and Effectful Computation, by Geometry of Interaction
International Partner (Institution - Laboratory - Researcher):
Tokyo (Japan) - Department of Computer Science, Graduate School of Information Science and Technology - Ichiro HASUO
Start year: 2015
See also: http://
Game semantics and geometry of interaction (GoI) are two closely related frameworks whose strength is to have the characters of both a denotational and an operational semantics. They offer a high-level, mathematical (denotational) interpretation, but are interactive in nature. The formalization in terms of movements of tokens through which programs communicate with each other can actually be seen as a low-level program. The current limit of GoI is that the vast majority of the literature and of the software tools designed around it have a pure, sequential functional language as their source language. This project aims at investigating the application of GoI to concurrent, resourceful, and effectful computation, thus paving the way to the deployment of GoI-based correct-by-construction compilers in real-world software developments in fields like (massively parallel) high-performance computing, embedded and cyberphysical systems, and big data. The presence of both the japanese GoI community (whose skills are centered around effects and coalgebras) and the french GoI community (more focused on linear logic and complexity analysis) will bring essential, complementary, ingredients.
Focus has taken part in the creation of the Microservices Community (http://
U. Dal Lago is “Partner Investigator” in the project “Verification and analysis of quantum programs”, whose Chief Investigator is Prof Yuan Feng, University of Technology Sydney. The project is funded by the Australian Research Council.
The following researchers have visited Focus for short periods; we list them together with the title of the talk they have given during their stay, or the topic discussed during their stay.
German Vidal and Adrián Palacios: “A Reversible Semantics for Erlang." (2 visits, during the year)
Matteo Acclavio: "Proof Diagrams for Multiplicative Linear Logic: Syntax and Semantics."
Ken Sakayori: "A Truly Concurrent Game Model of the Asynchronous pi-Calculus."
Marco Carbone: "Multiparty Session types and Linear Logic."
Beniamino Accattoli: "The Complexity of Abstract Machines."
Ulrich Schoepp, on Complexity analysis of probabilistic programs.
U. Dal Lago has spent two weeks in Japan (University of Kyoto and University of Tokyo). Topics: geometry of interaction for continuous probabilistic programming languages, and categorical models for multitoken machines.
I. Lanese: Scientific coordinator of the International Training School on Reversible Computation (28-31/8/2017, Torun, Poland), organized by the COST Action IC1405 on Reversible Computation - Extending Horizons of Computing
S. Giallorenzo: Publicity Chair for 1st Conference on Microservices 2017 (Microservices 2017)
I. Lanese: Publicity Chair for 12th International Federated Conference on Distributed Computing Techniques (DisCoTec 2017)
M. Bravetti: 15th International Conference on Software Engineering and Formal Methods (SEFM 2017); 2017 IEEE International Conference on Big Data (IEEE BigData 2017); 29th IFIP International Conference on Testing Software and Systems (ICTSS 2017).
U. Dal Lago: 26th Annual Conference of the European Association for Computer Science Logic (CSL 2017); 2nd International Conference on Formal Structures for Computation and Deduction (FSCD 2017).
S. Giallorenzo: 32nd Annual ACM/SIGAPP Symposium On Applied Computing (SAC 2017)
I. Lanese: 14th International Conference on Formal Aspects of Component Software (FACS 2017); 9th Conference on Reversible Computation (RC 2017); 10th Interaction and Concurrency Experience (ICE 2017).
S. Martini: 14th Annual Conference on Theory and Applications of Models of Computation (TAMC 2017); Fourth International Conference on History and Philosophy of Computing (HAPOC 2017); DIDAMATICA - Informatica per la Didattica (DIDAMATICA 2017).
D. Sangiorgi: 11th edition A.P. Ershov Informatics Conference (PSI Conference Series); 11th Int. Conference on Language and Automata Theory and Applications (LATA); 28th International Conference on Concurrency Theory (CONCUR 2017); 18th Italian Conference on Theoretical Computer Science (ICTCS 2017); 45th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL).
G. Zavattaro: 5th International Workshop on Foundations of Coordination Languages and Self-Adaptive Systems (FOCLASA 2017), Trento, Italy, 6–10 September, 2017; 6th European Conference on Service-oriented and Cloud Computing (ESOCC'17), Oslo, Norway, 27–29 September, 2017; 28th International Conference on Concurrency Theory (CONCUR'17), Berlin, Germany, 5–8 September 2017.
U. Dal Lago: Logical Methods in Computer Science; Mathematical Structures in Computer Science.
M. Gabbrielli: Int. Journal Theory and Practice of Logic Programming.
C. Laneve: Frontiers in ICT (Section Formal Methods).
I. Lanese: Editor in chief of the Open Journal of Communications and Software (Scientific Online).
D. Sangiorgi: Acta Informatica, Distributed Computing, RAIRO Theoretical Informatics and Applications.
U. Dal Lago: lecturer at the International School “A Brief Introduction to Probabilistic and Quantum Programming”, Universidade do Minho.
I. Lanese: lecturer at the International Training School on Reversible Computation (28-31/8/2017, Torun, Poland), organized by the COST Action IC1405 on Reversible Computation - Extending Horizons of Computing
D. Sangiorgi: invited talk at the event “Celebrating 20 years of IRAFS (The International Research Area on Foundations of the Sciences)”, Pontifical Lateran University, Rome.
G. Zavattaro: Invited talk at `15th International Workshop on Foundations of Coordination Languages and Self-Adaptative Systems (FOCLASA'17)”.
U. Dal Lago has been elected member of the Scientific Council of the Italian Chapter IC-EATCS (November 2017).
S. Martini is a member of the Executive Board of EQANIE (European Quality Assurance Network for Informatics Education); he has been nominated vice-president, starting 1 January 2018.
S. Martini is a member of the Council of the Commission on History and Philosophy of Computing, an organism of the International Union for History and Philosophy of Science, 2017-2021.
S. Martini is a member of the Board of CINI (Italian National Interuniversity Consortium for Informatics), designated by the Ministry for Semplificazione e Pubblica Amministrazione, from 2015.
Mario Bravetti
Master: “Linguaggi, Compilatori e Modelli Computazionali”, 120 hours, 1st year, University of Bologna, Italy.
Ugo Dal Lago
Undergraduate: “Introduction to Programming in Python”, 20 hours, 1st year, University of Bologna, Italy.
Undergraduate: “Optimization”, 36 hours, 2nd year, University of Bologna, Italy.
Master: “Foundations of Logic for Computer Science”, 24 Hours, 2nd year. University of Bologna, Italy.
Master: “Cryptography”, 36 Hours, 2nd year, University of Bologna, Italy.
Maurizio Gabbrielli
Undergraduate: “Programming languages”, 40 hours, 2nd year, University of Bologna, Italy.
Master: “Artificial Intelligence”, 60 hours, 2nd year, University of Bologna, Italy.
Saverio Giallorenzo
Undergraduate: “Laboratorio di Operating Systems”, 40 hours, 2nd year, University of Bologna, Italy.
Ivan Lanese
Undergraduate: “Architettura degli Elaboratori”, 56 hours, 1st year, University of Bologna, Italy.
Master: “Ingegneria del Software Orientata ai Servizi”, 22 hours, 2nd year, University of Bologna, Italy.
Cosimo Laneve
Undergraduate: “Programmazione”, 70 hours, 1st year, University of Bologna, Italy.
Master: “Analisi di Programmi”, 42 hours, 1st year, University of Bologna, Italy.
Simone Martini
Undergraduate: “Introduction to programming in Python”, 78 hours, 1st year, University of Bologna, Italy.
Undergraduate: “Programming in Python”, 72 hours, 1st year, University of Bologna, Italy.
Undergraduate: “Computer abilities for biologists”, 8 hours, 1st year, University of Bologna, Italy.
Davide Sangiorgi
Undergraduate: “Operating Systems”, 110 hours, 2nd year, University of Bologna, Italy.
Gianluigi Zavattaro
Undergraduate: “Computer Architectures”, 60 hours, 1st year, University of Bologna, Italy
Undergraduate: “Algoritmi e strutture dati”, 60 hours, 2nd year, University of Bologna, Italy
PhD thesis completed in 2016:
Abel Garcia Celestrin, “Analysis of Cloud Computing Systems”. Supervisor C. Laneve.
Vincenzo Mastandrea, “Deadlock analysis in ASP”. Supervisors: Cosimo Laneve and Ludovic Henrio (CNRS Sophia Antipolis).
Valeria Vignudelli, “Behavioral Equivalences for Higher-Order Languages with Probabilities”. Supervisor D. Sangiorgi.
Below are the details on the PhD students in Focus: starting date, topic or provisional title of the thesis, supervisor(s). These are all PhDs in progress.
Raphaelle Crubillé, October 2015, “Bisimulation Metrics and Probabilistic Lambda Calculi”, Université Denis Diderot and University of Bologna. Supervisors Thomas Ehrhard and Ugo Dal Lago.
Adrien Durier, September 2016, "Proving behavioural properties of higher-order concurrent languages", ENS de Lyon and University of Bologna. Supervisors: Daniel Hirschkoff and Davide Sangiorgi.
Francesco Gavazzo, October 2015, “Coinductive Techniques for Effectful Lambda Calculi”. Supervisors U. Dal Lago and D. Sangiorgi.
Michael Lodi, January 2017, “Growth Mindset and Computational Thinking”. Supervisor: S. Martini.
Tong Liu, November 2015, “Constraint based languages for Software Defined Networks”. Supervisor: Maurizio Gabbrielli.
Stefano Pio Zingaro, November 2016, “High level languages for Internet of Things applications”. Supervisors: Maurizio Gabbrielli and Ivan Lanese.
M. Bravetti has been member of the PhD jury of Federica Panarotto, University of Verona, Italy, May 2017. U. Dal Lago has been member of the PhD jury of Pierre Vial, Université Denis-Diderot, December 2017. D. Hirschkoff has been member of the PhD evaluation committee for Yannick Zakowski, ENS Rennes, December 2017.
Michael Lodi and Simone Martini have carried out extended work of scientific popularization, including the following.
They are members of the technical committee of Olimpiadi del Problem Solving
(at Italian Ministry of Education),
http://
S. Martini has given various talks at institutes and workshops on the teaching methods for Computer Science, including a talk on “Educare all'informatica nella scuola?’’, working day on “La cultura informatica come fattore di sviluppo’' Roma, Camera dei Deputati, December 2017.
S. Martini is coordinator of some initiatives for the `Hour of Code' (see e.g.,
http://
M. Lodi is in charge of preparing material “unplugged” to teach the principles of computational thinking in elementary schools.
M. Lodi has been involved in meetings aimed at forming teachers of elementary and high schools in the Bologna province. These include a 15-hour course “Coding e robotica: tecnologie e metodologie per una didattica integrata nella scuola secondaria di I grado”, and a 12-hour course “Scratch avanzato: funzionalità e applicazione alla didattica”, both organised by Fondazione Golinelli (Bologna).
M. Lodi has given talks on computational thinking and programming
languages for teaching computer science to children, including:
“Coding - Che cosa è e perché?” and
“Coding con Scratch”, at Mathesis Piacenza;
“CoderDojo: Pensiero computazionale e informatica
creativa... anche a scuola?”, Convention Diesse;
introduction to computer science for high school students,
as part of an event of introduction to
management (“Giardino delle imprese”), Fondazione Golinelli,
Bologna;
“L'illusione del coding” and
“TeacherDojo”, at the contest “CoderDojo Coolest Projects Milano”,
Milan;
“Ragazze, siate coraggiose: la vostra intelligenza puo'
crescere (ma il “coding” non basta!)”, at “Festival della Cultura
Tecnica 2017”, Bologna; a talk and
youtube
video “Quattro domande sul pensiero
computazionale”
(https://
M. Lodi has has been member of the evaluation commission for the awards “Programma le Regole”, set by Italian Ministry of Education and Research (MIUR) and “Programma il Futuro”.
D. Hirschkoff takes part in several popularization activities in schools, in Lyon (association "Maths en Jeans").
S. Martini is Head of the Department of Computer Science and Engineering, University of Bologna, for the term 2015-2018.
G. Zavattaro is coordinator of undergraduate studies at the Department of Computer Science and Engineering, University of Bologna (Informatica per il Management).