The project first-year meeting will be hosted by the University of Catania in Via Santa Sofia 64, Catania. The meeting will be in room 126 on the ground floor (two floors below the entrance level).
15:00-16:30. Aggregate Programming. (Keynote) Ferruccio Damiani (Università degli Studi di Torino)
Abstract. This talk:
This might pave the way towards:
16:30-17:00. Coffee Break.
17:00-17:15. Introduction to WP1: Models and Tools for Language Adaptation. Walter Cazzola (Università degli Studi di Milano)
17:15-17:45. Exceptions all Over the Shop: Modular, Customizable, Language-Independent Exception Handling Layer Luca Favalli (Università degli Studi di Milano)
Abstract. The introduction of better abstractions is at the forefront of research and practice. Among many approaches, domain-specific languages are subject to an increase in popularity due to the need for easier, faster and more reliable application development that involves programmers and domain experts alike. To smooth the adoption of such a language-driven development process, researchers must create new engineering techniques for the development of programming languages and their ecosystems. Traditionally, programming languages are implemented from scratch and in a monolithic way. Conversely, modular and reusable language development solutions would improve maintainability, reusability and extensibility. Many programming languages share similarities that can be leveraged to reuse the same language feature implementations across several programming languages; recent language workbenches strive to achieve this goal by solving the language composition and language extension problems. Yet, some features are inherently complex and affect the behavior of several language features. Most notably, the exception handling mechanism involves varied aspects, such as the memory layout, variables, their scope, up to the execution of each statement that may cause an exceptional event---e.g., a division by zero. In this paper, we propose an approach to untangle the exception handling mechanism dubbed the exception handling layer: its components are modular and fully independent from one another, as well as from other language features. The exception handling layer is language-independent, customizable with regards to the memory layout and supports unconventional exception handling language features. To avoid any assumptions with regards to the host language, the exception handling layer is a stand-alone framework, decoupled from the exception handling mechanism offered by the back-end. Then, we present a full-fledged, generic Java implementation of the exception handling layer. The applicability of this approach is presented through a language evolution scenario based on a Neverlang implementation of JavaScript and LogLang, that we extend with conventional and unconventional exception handling language features using the exception handling layer, with limited impact on their original implementation.
Joint work with Walter Cazzola.
17:45-18:15. ★-piler: Compilers in Search of Compilations. Francesco Bertolotti (Università degli Studi di Milano)
Abstract. Compilers pose significant challenges in their development as software products. Language developers face the complexities of ensuring efficiency, adhering to good design practices, and maintaining the overall codebase. These factors make it difficult to predict the unexpected impact of updates on existing software built on the current compiler stack. Furthermore, software created for a specific compiler often lacks reusability for other compiler environments. In this study, we propose a comprehensive framework for the uniform development of compilers that addresses these issues. Our approach involves developing compilers as a collection of small transpilation units, referred to as deltas. The transpilation infrastructure takes source code written in a particular source language and searches for a path of deltas to generate equivalent source code in the target language. By adopting this methodology, language developers can easily update their languages by introducing new deltas into the system. Existing code remains unaffected as old transpilation paths remain available. To support this framework, we have devised a metric space for efficient delta search. This metric space enables us to define a non-overestimating heuristic function, which proves valuable in solving the search problem. Leveraging the A* search algorithm, we can efficiently transpile programs from a source language to the target language. To evaluate the effectiveness of our approach, we conducted a benchmark comparison between the A* search algorithm and the simpler breadth-first search (BFS) algorithm. The benchmark consisted of over 100 transpilation searches, providing valuable insights into the performance and capabilities of this framework.
Joint work with Walter Cazzola and Luca Favalli.
18:15-18:30. Questions and (Maybe) Answers, Discussion and Brainstorming.
09:00-09:15. Introduction to WP3: Advanced Type Systems for Interacting Entities. Davide Ancona (Università degli Studi di Genova)
09:15-09:45. Multi-graded Featherweight Java. Riccardo Bianchini (Università degli Studi di Genova)
Abstract. Resource-aware type systems statically approximate not only the expected result of a program, but also the way external resources are used, e.g., how many times the value of a variable is needed. In the talk I will show how to bring resource awareness to the realm of object-oriented programming, using Featherweight Java (FJ) as reference model. More in detail, we extend the type system of Featherweight Java to be resource-aware, parametrically on an arbitrary grade algebra modeling a specific notion of resource usage. We also define a resource-aware version of operational semantics, where an environment tracks the current amount of resources, and the reduction is annotated with a grade specifying how many copies of the result are produced. In this semantics, reduction gets stuck if some needed resource is exhausted. We prove resource-aware soundness, meaning that a well-typed program has a reduction sequence which does not get stuck due to either typing errors or resource consumption. We also deal with two other interesting issues. The former is the capability of combining grades of different kinds. To this end, we provide a formal construction yielding a unique grade algebra of heterogeneous grades, starting from a family of grade algebras, by specifying a minimal collection of homomorphisms connecting them. The latter is the possibility of having user-defined grades. For instance, grade annotations could be written themselves in Java, analogously to what happens with exceptions. To this end, the user can define Java classes implementing grade algebras and homomorphisms to combine them.
09:45-10:15. Fair Termination of Multiparty Sessions. Francesco Dagnino (Università degli Studi di Genova)
Abstract. There exists a broad family of multiparty sessions in which the progress of one session participant is not unconditional, but depends on the choices performed by other participants. These sessions fall outside the scope of currently available session type systems that guarantee progress. In this talk, we present a type system ensuring that well-typed multiparty sessions, including those exhibiting the aforementioned dependencies, fairly terminate. Fair termination is termination under a fairness assumption that disregards those interactions deemed unfair and therefore unrealistic. Fair termination, combined with the usual safety properties ensured within sessions, not only is desirable per se, but it entails livelock freedom and enables a compositional form of static analysis such that the well-typed composition of fairly terminating sessions results in a fairly terminating program.
Joint Work with Luca Ciccone and Luca Padovani.
10:15-10:45. Deltas for Functional Programs with Algebraic Data Types. Luca Paolini (Università degli Studi di Torino (Unità di Milano))
Abstract. The development of feature-oriented programming (FOP) and of (its generalization) delta-oriented programming (DOP) has focused primarily on SPLs of class-based object oriented structures. In this paper, we introduce delta-oriented SPLs of functional programs with algebraic data types (ADTs) and pattern matching. To pave the way towards SPLs of multi-paradigm programs, we tailor our presentation to the functional sublanguage of the multi-paradigm modeling language ABS, which already features DOP support for its class-based object-oriented sublanguage. Our main contributions are: (i) we motivate and illustrate our proposal by an example from an industrial modeling scenario; (ii) we formalize delta-oriented SPLs for functional programs with ADTs in terms of a foundational calculus; (iii) we define family-based analyses to check whether an SPL satisfies certain well-formedness conditions and whether all variants can be generated and are well-typed; and (iv) we briefly outline how, in the context of the toolchain of ABS, the proposed delta-oriented constructs and analyses for functional programs can be integrated with their counterparts for object-oriented programs.
Joint Work with Ferruccio Damiani, Eduard Kamburjan and Michael Lienhardt.
10:45-11:00. Questions and (Maybe) Answers, Discussion and Brainstorming.
11:00-11:30. Coffee Break.
11:30-11:45. Resuming WP1: Models and Tools for Language Adaptation. Walter Cazzola (Università degli Studi di Milano)
11:45-12:15. Evaluating a Language Workbench: from Working Memory Capacity to Comprehension to Acceptance. Giovanna Broccia (ISTI-CNR Pisa)
Abstract. Language workbenches are tools that enable the definition, reuse and composition of programming languages and their ecosystem. This breed of frameworks aims to make the development of new languages easier and more affordable. Consequently, the comprehensibility of the language used in a language workbench (i.e., the meta-language) should be an important aspect to consider and evaluate. To the best of our knowledge, although the quantitative aspects of language workbenches are often discussed in the literature, the evaluation of comprehensibility is typically neglected. Neverlang is a language workbench that enables the definition of languages with a modular approach. This paper presents a preliminary study that intends to assess the comprehensibility of Neverlang programs, evaluated in terms of users' effectiveness and efficiency in a code comprehension task. The study also investigates the relationship between Neverlang comprehensibility and the users' working memory capacity. Furthermore, we intend to capture the relationship between Neverlang comprehensibility and users' acceptance, in terms of perceived ease of use, perceived usefulness, and intention to use. Our preliminary results on 10 subjects suggest that the users' working memory capacity may be related to the ability to comprehend Neverlang programs. On the other hand, effectiveness and efficiency do not appear to be associated with an increase in users' acceptance variables.
Joint work with Alessio Ferrari, Maurice ter Beek, Walter Cazzola, Luca Favalli and Francesco Bertolotti.
12:15-12:45. Scrambled Features for Breakfast. Luca Favalli (Università degli Studi di Milano)
Abstract. Modular software development is taken for granted thanks to the abstractions of modern programming languages. However, the programming languages themselves are still often developed as a monolithic whole, despite them being the very foundation our software is based on. Mainstream programming languages are rarely developed incrementally and their evolution and maintenance are a mere afterthought. The growing research field of language workbenches tries to improve language design and development by employing modularization techniques that maximize code reuse up to the language construct granularity. In this paper, we investigate how such an approach fits an agile style of development: agile engineering concepts such as product backlog items and sprint goals can be directly mapped onto language workbench concepts such as language features and language variants. This direct mapping allows for an easier development of modular, extensible and maintainable programming languages. We conceptualized an agile language development style that acknowledges such a mapping and then turned concepts into theory by outlining an agile language development methodology. Then, thanks to our partnership with Tyl, we put theory into practice in an industrial production environment. Now, we share our experience on the agile creation process of a domain-specific language for the enterprise resource planning (ERP).
Joint work with Walter Cazzola
12:45-13:00. Questions and (Maybe) Answers, Discussion and Brainstorming.
13:00-14:30. Lunch.
14:30-16:00. Discussion on T-LADIES.
16:00-16:30. Coffee Break.
16:30-16:45. Introduction to WP2: Interaction for Interoperability and Adaptation. Alessio Ferrari (ISTI-CNR Pisa)
16:45-17:15. RML: a modular language for runtime verification. Davide Ancona (Università degli Studi di Genova)
Abstract. RML is a language for runtime monitoring and verification whose design is based on modularity to allow a strict separation between code instrumentation and specification of the behavior of the system to be monitored or verified. In this way the language is quite flexible to be applied to different application domains and promote the reuse of specifications. In this talk I will show several IoT scenarios where RML can be usefully employed for runtime monitoring or verification of event-driven programming, and correct and safe use of IoT network protocols.
16:45-17:15. Realisability of Global Models of Interaction Maurice ter Beek (ISTI-CNR Pisa)
Abstract. We consider global models of communicating agents specified as transition systems labelled by interactions in which multiple senders and receivers can participate. A realisation of such a model is a set of local transition systems---one per agent---which are executed concurrently using synchronous communication. Our core challenge is how to check whether a global model is realisable and, if it is, how to synthesise a realisation. We identify and compare two variants to realise global interaction models, both relying on bisimulation equivalence. Then we investigate, for both variants, realisability conditions to be checked on global models. We propose a synthesis method for the construction of realisations by grouping locally indistinguishable states. The paper is accompanied by a tool that implements realisability checks and synthesises realisations.
Joint Work with Rolf Hennicker and José Proença.
17:15-17:45. Delayed and Periodic Tasks in Jadescript Federico Bergenti (Università degli Studi di Parma)
Abstract. Software agents are expected to timely act and to dynamically plan their activities, for example, to solve the complex collaboration problems of many real-world applications. The collaboration among agents requires the ability to reason about time to dynamically coordinate and to effectively adjust the frequency of periodic actions and reactions. For these and related reasons, an agent-oriented programming language is demanded to provide the programmer with effective means to schedule the execution of delayed and periodic tasks. This talk will discuss the new datatypes, and the related changes to some language constructs, that have been recently added to the Jadescript programming language to allow agents to effectively manage the dynamic scheduling of delayed and periodic tasks.
17:45-18:00. Questions and (Maybe) Answers, Discussion and Brainstorming.
20:00. Social Dinner at TBD
09:00-09:15. Road to WP4: Application to IoT SW Development. Corrado Santoro (Università degli Studi di Catania)
09:15-09:45. Formal Modelling and Analysis of a Self-Adaptive Robotic System Maurice ter Beek (ISTI-CNR Pisa)
Abstract. Self-adaptation is a crucial feature of autonomous systems that must cope with uncertainties in, e.g., their environment and their internal state. Self-adaptive systems are often modelled as two-layered systems with a managed subsystem handling the domain concerns and a managing subsystem implementing the adaptation logic. We consider a case study of a self-adaptive robotic system; more concretely, an autonomous underwater vehicle (AUV) used for pipeline inspection. In this paper, we model and analyse it with the feature-aware probabilistic model checker ProFeat. The functionalities of the AUV are modelled in a feature model, capturing the AUV's variability. This allows us to model the managed subsystem of the AUV as a family of systems, where each family member corresponds to a valid feature configuration of the AUV. The managing subsystem of the AUV is modelled as a control layer capable of dynamically switching between such valid feature configurations, depending both on environmental and internal conditions. We use this model to analyse probabilistic reward and safety properties for the AUV.
Joint Work with Juliane Päßler, Ferruccio Damiani, S. Lizeth Tapia Tarifa and Einar Broch Johnsen.
09:45-10:15. A Reputation-Based Clustering Framework to Detect Malicious or Malfunctioning IoT Devices. Fabrizio Messina (Università degli Studi di Catania)
Abstract. The pervasive penetration of IoT technology in our daily life has led to the introduction of the paradigm of social IoT (SIoT), where Smart Object can have social interactions in the IoT network. In the SIoT context reputation systems can help IoT software agents to make reliable transactions into a SIoT scenario. In this talk we present a reputation system designed to perform clustering of Smart Objects, in order to group them on the basis of their performance. The reputation system collects feedbacks from software agents in order to compute reputation of Smart Objects. Reputations can be collected by the edge servers, that can send reputation scores to the cloud. A campaign of simulations has allowed us to validate this approach.
10:15-10:30. Questions and (Maybe) Answers, Discussion and Brainstorming.
10:30-11:00. Coffee Break.
11:00-11:15. Introduction to WP4: Application to IoT SW Development. Fabrizio Messina (Università degli Studi di Catania)
11:15-11:45. An Introduction to Indoor Positioning and Its Inherent Problems. Mattia Alex Leoni (Università di Modena e Reggio Emilia)
Abstract. The indoor positioning problem consists in finding the position of a node, called target node, on the basis of the distances between it and other nodes, called anchor nodes, which are fixed at known positions of the considered indoor environment. The positioning problem can be mathematically formalised by the construction of a nonlinear system composed of quadratic polynomial equations which involve the distances measured by the target node. In real-world applications, these measured distances are not equal to the actual distances because measurements are inevitably affected by errors. In these cases, the mathematical problem does not have an exact solution, and it is mandatory to develop techniques that allow obtaining effective approximations of the position of the target node. The classic methods documented in the literature cannot be applied when the anchor nodes are coplanar or nearly coplanar because these arrangements cause mathematical difficulties. Unfortunately, these arrangements are widely employed in real-world applications because the anchor nodes are often positioned near the ceiling of the environment to limit the interference with objects, pieces of furniture, and people. A viable solution to the problems caused by the arrangement of the anchor nodes consists in turning the positioning problem into an equivalent optimization problem. The resulting optimization problem can be solved using metaheuristic algorithms, which have notable advantages with respect to ordinary optimization algorithms in these cases. This talk will discuss the problems caused by the arrangement of the anchor nodes, and it will also describe some experiments that used metaheuristic algorithms to limit the effects of these problems.
11:45-12:15. An Upper Bound of Range-Based Indoor Positioning. Simone Dallospedale (Università di Modena e Reggio Emilia)
Abstract. Real-world indoor positioning applications often require to trade off accuracy with the cost of the localization infrastructure. Given the number and the arrangement of the anchor nodes in the infrastructure, it is often useful to have estimates of the maximum positioning error at each point of the considered environment. If these estimates show that the positioning error exceeds acceptable bounds, the number and the arrangement of the anchor nodes must be changed to achieve the desired accuracy. In order to estimate an upper bound on the positioning error, a position of the target node to be localized is fixed in the environment to obtain a corresponding positioning problem. Then, the obtained positioning problem is turned into a system of nonlinear inequalities which also takes into account the errors caused by the range-based distance measurement. This system of nonlinear inequalities can be used to compute an ellipsoid whose surface tightly bounds the solutions of the nonlinear system, or, in other words, whose surface wraps all the positioning results obtained by varying the measurement errors. Therefore, this ellipsoid can be used to quantify the maximum positioning error for the considered position of the target node. This talk will present the problem of estimating tight bounds for the positioning error, and it will also present some experiments performed using real UWB sensors in real environments.
12:15-12:45. Implementing BDI Agents Running on the Network Edge. Corrado Santoro (Università degli Studi di Catania)
Abstract. With the advent of the 5G technology, the trend is to move computations away from big datacenters and server farms towards the "edge" of the network in the view of splitting the complexity into several cooperating pieces running in small computing platforms placed at the edge of the network. This is the reason why the technology market is currently offering a large number of embedded devices equipped with microcontrollers (MCU), such as Arduino, ESP32 or the STM32 NUCLEO system, that feature very low power consumption, adequate computing resources and, above all, one or more types of wireless connectivity systems (WiFi, LoRA, Bluetooth, BLE, etc.). In this new view of distributed computing, multi-agent systems perfectly fit the concept of having small cooperating computing entities spread over the network, but the main problem is the availability of agent platforms for embedded devices. With these concepts in mind, we present Democle, a multi-agent platform for embedded system able to offer a new way to program logic/declarative agents directly in C++ using a BDI paradigm. This aim is reached by strongly exploiting object orientation, macros, together with some features of recent versions of the language, such as lambdas. The runtime system is particularly light and does not add a sensible overhead both in time and space.
12:45-13:00. Questions and (Maybe) Answers, Discussion and Brainstorming.
13:00-13:00. Closing. Walter Cazzola (Università degli Studi di Milano)
13:00-14:00. Lunch.
