Betti Venneri

The Klaim Project: Theory and Practice

Klaim (Kernel Language for Agents Interaction and Mobility) is an experimental language specifically designed to program distributed systems consisting of several mobile components that interact through multiple distributed tuple spaces. Klaim primitives allow programmers to distribute and retrieve data and processes to and from the nodes of a net. Moreover, localities are first-class citizens that can be dynamically created and communicated over the network. Components, both stationary and mobile, can explicitly refer and control the spatial structures of the network. This paper reports the experiences in the design and development of Klaim. Its main purpose is to outline the theoretical foundations of the main features of Klaim and its programming model. We also present a modal logic that permits reasoning about behavioural properties of systems and various type systems that help in controlling agents movements and actions. Extensions of the language in the direction of object oriented programming are also discussed together with the description of the implementation efforts which have lead to the current prototypes.

Types for access control

KLAIM is an experimental programming language that supports a programming paradigm where both processes and data can be moved across dierent computing environments. This paper presents the mathematical foundations of the KLAIM type system; this system permits checking access rights violations of mobile agents. Types are used to describe the intentions (read, write, execute, :::) of processes relative to the dierent localities with which they are willing to interact, or to which they want to migrate. Type checking then determines whether processes comply with the declared intentions, and whether they have been assigned the necessary rights to perform the intended operations at the specied localities. The KLAIM type system encompasses both subtyping and recursively dened types. The former occurs naturally when considering hierarchies of access rights, while the latter is needed to model migration of recursive processes. c 2000 Elsevier Science B.V. All rights reserved.

Self-Adaptive Monitors for Multiparty Sessions

This paper aims at incorporating the notion of self-adaptiveness in the context of multiparty sessions, by focusing on the issue of ensuring correctness for dynamic adaptations. A formal framework is presented centred around these main ingredients: global types, monitors and global state. A global type represents the overall communication choreography. Its projections are the monitors, which set-up the protocols of the participants. The association of a monitor with a compliant process incarnates a single participant. It is the choreography that is updated at runtime, in response to changing conditions in the global state. Monitors result to be self-adaptive in the sense that they react to these changes by modifying themselves, in order to prescribe new behaviours to the participants.

The "Relevance" of Intersection and Union Types

The aim of this paper is to investigate a Curry-Howard interpre- tation of the intersection and union type inference system for Combinatory Logic. Types are interpreted as formulas of a Hilbert-style logic L, which turns out to be an extension of the intuitionistic logic with respect to provable dis- junctive formulas (because of new equivalence relations on formulas), while the implicational-conjunctive fragment of L is still a fragment of intuitionistic logic. Moreover, typable terms are translated in a typed version, so that ∨-∧- typed combinatory logic terms are proved to completely codify the associated logical proofs.

Coordinating Mobile Object-Oriented Code

Standard class-based inheritance mechanisms, which are often used to implement distributed systems, do not seem to scale well to a distributed context with mobility. In this paper, a mixin-based approach is proposed for structuring mobile object-oriented code and it is shown to fit in the dynamic and open nature of a mobile code scenario. We introduce MoMi (Mobile Mixins), a coordination language for mobile processes that communicate and exchange object-oriented code in a distributed context. MoMi is equipped with a type system, based on polymorphism by subtyping, in order to guarantee safe code communications.

Extending Java to dynamic object behaviors

Class inheritance and dynamic binding are the key features of object-oriented programming and they permit designing and developing complex systems. However, standard class inheritance is essentially static and cannot be directly employed for modeling dynamic object behaviors. In this paper we propose a linguistic extension of Java, called Dec-Java, that is partially inspired by the decorator design pattern. This extension permits easily separating the basic features of objects (that are likely not to change during the application) from their behaviors (that, instead, can be composed dynamically at run-time). Thus, Dec-Java enables a dynamic extension and specialization of object responsibilities.

Hyperformulae, Parallel Deductions and Intersection Types

Abstract We aim at investigating the intersection-type assignment system for lambda calculus, with the Curry-Howard approach. We devise a propositional logic, whose notable characteristic is the presence of the hyperformulae denoting parallel compositions of formulae. As such, this logic formalizes a novel notion of parallel deductions, while forming a simple generalization of the standard natural deduction framework. We prove that the logical calculus is isomorphic to the intersection type system, by mapping logical deductions into typed lambda terms, encoding those deductions, and conversely. In this context the intersection type constructor, which comes out to be a proof-theoretic operator, is now interpreted as a standard propositional connective.

Self-adaptive multiparty sessions

To model the notion of self-adaptiveness for multiparty sessions, we propose a formal framework, where participants can access and modify the global state, in such a way that the whole system can react promptly to unforeseen events by reconfiguring itself. The adaptation strategy is triggered by the overall communication choreography, represented by a global type. When the global type is dynamically updated, its projections define new monitors, which set-up novel communication protocols for the participants. The key result of this paper is that self-adaptations are performed in a type-safe way, while providing a high degree of flexibility. Subject Reduction and Progress properties are proven: any session executes all required communications in a type-safe way and never gets stuck.

Session and Union Types for Object Oriented Programming

In network applications it is crucial to have a mechanism to guarantee that communications evolve correctly according to the agreed protocol. Session types offer a method for abstracting and validating structured communication sequences (sessions). In this paper we propose union types for refining and enhancing the flexibility of session types in the context of communication centred and object oriented programming. We demonstrate our ideas through an example and a calculus formalising the main issues of the present approach. The type system garantees that, in well-typed executable programs, after a session has started, the values sent and received will be of the appropriate type, and no process can get stuck forever.

MOMI: a calculus for mobile mixins

MOMI (Mobile Mixins) is a coordination language for mobile processes that communicate and exchange object-oriented code in a distributed context. MOMIs key idea is structuring mobile object-oriented code by using mixin-based inheritance. Mobile code is compiled and typed locally, and can interact successfully with code present on foreign sites only if its type is subtyping-compliant with the type of what is expected by the receiving site. The key feature of the paper is the definition of this subtyping relation on classes and mixins that enables a significantly flexible, yet still simple, communication pattern. We show that communication by subtyping is type-safe in that exchanged code is merged into local code without requiring further type analysis and recompilation.