Project Description

We aim at identifying high level linguistic abstractions for network aware programming. These abstractions should relieve the programmer from the burden of explicitly dealing with low-level events taking place in the underlying system, but still provide him with enough control to manage the distribution and use of resources, the structure of the components, the quality of service and the security issues. Moreover, for these linguistic abstractions, we aim at devising proper foundational models that can be used both to reason about system properties and to evaluate language implementations. Our research will be cast in two areas:

These two lines of research should ultimately lead to the definition of a comprehensive semantic framework that provides both methods and patterns to develop network-aware applications and certify their properties.
In the project, we shall concentrate on a number of specific issues that will help us in achieving our main goals:

1. Linguistic constructs for mobility and network awareness
   A notion that has emerged as a key concept for structuring network applications is that of mobile component: a running execution unit that can migrate among locations. Mobility allows us to use distributed resources and services locally, to overcome network latencies and to enhance the robustnesss of applications. Mobility requires new forms of programming primitives for interaction among mobile components and resources, for binding services to components, for managing security, and so on. Our approach will be that of designing the new programming abstractions together with their foundational counterparts
   
2. Linguistic constructs for quality of services programming
   Quality of Services (QoS) has been generically defined as the set of qualitative and quantitative requirements that a distributed application should meet in order to guarantee an appropriate level of satisfaction to final users. It seems convenient to design/develop new primitives for managing QoS related features at a linguistic level. These primitives will have to refer to both qualitative (security, availability) and quantitative (response time, bandwidth, reliability) aspects. In particular, the language should provide proper mechanisms for resource acquisition, fault tolerance, timeliness and for combining in a flexible way different, even contrasting, QoS requirements.
   
3. Coordination models and constructs
   Complex systems may be designed and developed in a structured way, by software modules that support coordination of basic computational components. These coordinators can be used as a basic mechanism to render components more flexible with respect to environmental changes. However, "static" coordination mechanisms alone are not sufficient. In the project, we shall investigate programmable coordination mechanisms that permit negotiating the cooperation activities of mobile components, services and resources. Coordinators will also be able to negotiate service requests of components having a specific range of values: the minimum level of service components are willing to accept and the maximum level they are able to utilize.
   
4. Monitoring resource usage
   Mobility poses relevant security problems, like hostile components that require resources that are not available, or lock resources and never release them. This may degrade the performance of the host, or even compromise its security. To prevent this kind of damages, a broadly used strategy is that of imposing a strict control on what components can and cannot do by letting them execute inside a "sandbox". However, sandboxes do not allow dynamic allocation of resources and do not monitor the use of "dynamic" resources as heaps and locks. We shall study defensive strategies with a dynamic mechanism for allocation and tracing of resources used by incoming agents.
   
5. Dynamic reconfiguration and run-time code generation
   In the context of network-aware programming it is important to take into account the dynamic changes of the network environment. We shall develop a general framework for supporting generation, separate compilation and linking of fragments, and execution of dynamically generated code. Examples of safety properties we want to express are monotonicity of compilation (result of compilation is preserved by re-compilation of fragments), extended soundness (well-behaviour is guaranteed in presence of binary fragments), and binary compatibility (binary fragments can be safely replaced).
   
6. Types and calculi for distributed programming
   Our aim is to develop type systems, calculi and behavioural equivalences that support reasoning about security aspects of distributed processes, such as trust in migrating code, and safe/authorized resource access. To this purpose, we shall study type (and/or effect) systems and algorithms that, taking into account the highly dynamic nature of processes and their execution environment, permit that programs, or parts of them, be checked at run-time. We shall also investigate to what extent cryptographic techniques and process calculi can be used to enforce/implement security policies in such an evolving execution environment.
   
7. Models for concurrent objects with classes
   Object-oriented programming has long been praised as favouring abstraction, incremental development, and code reuse. Objects can be created by instantiating classes, and in turn complex classes can be built from simpler ones. Whilst this approach is effective in sequential languages, it is rather hard to achieve in a concurrent setting. Indeed, inheritance of code may modify the internal synchronization between the methods, thus breaking crucial invariants of the parent classes. We aim at defining a unified model that permit casting in a single framework classes, objects and processes and to reason about their interaction.
   
8. Virtual machines and mrototypes
   Within the project a few kernel languages for network aware programming, proposed both by internal and by external groups, will be considered. A major objective is the prototype implementation of network-aware programming languages. Our approach will be that of considering programming abstractions together with foundational counterparts based on intensively studied theoretical models. Building on these models, we plan to implement the proposed constructs: this will require defining virtual machines (possibly for several platforms) and correct program transformations for optimizing compilers.