Carlo Montangero

Software process enactment in Oikos

Despite much research work in progress to model the different facets of software process enactment from different approaches, there are no models yet generally recognized as adequate, and there is need for more experimentation. We describe the Oikos environment and its coordination language ESP: they provide an infrastructure in which experiments may be performed and evaluated. Oikos predefines a number of services offering basic facilities, like access to data bases, workspaces, user interfaces etc.. Services are customizable, in a declarative way that matches naturally the way ESP defines and controls the software process. ESP allows to define services, to structure them in a dynamic hierarchy, and to coordinate them according to the blackboard paradigm. The concepts of environment and of software process and their interplay are naturally characterized in Oikos, in terms of sets of services and of the hierarchy. In the paper, an example taken from a real project (the specification of a small language and the implementation of its compiler) shows how Oikos and ESP are effective for software process enactment. As it is, ESP embeds Prolog as its sequential component, and combines it smoothly to the blackboard approach to deal with concurrency and distribution. Anyway, most of the concepts used to model and enact software processes are largely independent of logic programming.

StPowla: SOA, Policies and Workflows

We introduce StPowla , a workflow based approach to business process modelling that integrates a simple graphical notation, to ease the presentation of the core business process, a user---friendly policy language, Appel , to provide the necessary adaptation to the varied expectations of the various business stakeholders, and the Service Oriented Architecture, to assemble and orchestrate available services in the business process. We illustrate the approach with a loan approval process.

Logic-based detection of conflicts in APPEL policies

APPEL is a general language for expressing policies in a variety of application domains with a clear separation between the core language and its specialisation for concrete domains. Policies can conflict, thus leading to undesired behaviour. We present a novel formal semantics for the Appel language based on ΔDSTL(x) (so far APPEL only had an informal semantics). ΔDSTL(x) is an extension of temporal logic to deal with global applications: it includes modalities to localize properties to system components, an operator to deal with events, and temporal modalities à la Unity. A further contribution of the paper is the development of techniques based on the semantics to reason about conflicts.

An Approach to the Optimal Specification of Read-Only Memories in Microprogrammed Digital Computers

This paper illustrates an algorithm for finding a read-only memory (ROM) specification, optimal in the sense that it results in a minimum ROM bit dimension, starting with an instruction set description which employs acyclic directed graphs. The algorithm selects (by a tabular technique) a descriptive graph subset, shown to be sufficient; then it performs a heuristically guided search among possible solutions generated by the graphs in the subset. The algorithm works for instructions which are such that a microevent occurs at most once in a single instruction; some results apply to the general case as well.

Mark, a Reasoning Kit for Mobility

The experience gained to date in the development of network applications has shown the difficulties of using traditional software technologies: reasoning about network applications is subtly different from reasoning about ordinary programs because of stronger requirements on security, different forms of termination, and phenomena like mobility and network-awareness. There are currently no standard methods, techniques and tools to support specification, development and (property) certification of these applications. To support property certification of network applications, we propose to use the network-aware logic Mobadtl and its proof assistant, Mark (Mobadtl Reasoning Kit). In the paper we present the prototype implementation of Mark and, as a validating example, we consider applications where mobile components are allowed to carry some resources with them when moving around the network.

End-to-end integrated security and performance analysis on the DEGAS choreographer platform

We present a software tool platform which facilitates security and performance analysis of systems which starts and ends with UML model descriptions. A UML project is presented to the platform for analysis, formal content is extracted in the form of process calculi descriptions, analysed with the analysers of the calculi, and the results of the analysis are reflected back into a modified version of the input UML model. The design platform supporting the methodology, Choreographer, interoperates with state-of-the-art UML modelling tools. We illustrate the approach with a well known protocol and report on the experience of industrial users who have applied Choreographer in their development work.

Distributed states logic

We introduce a temporal logic to reason on global applications. First, we define a modal logic for localities that embeds the local theories of each component into a theory of the distributed states of the system. We provide the logic with a sound and complete axiomatization. Then, we extend the logic with a temporal operator. The contribution is that it is possible to reason about properties that involve several components in a natural way, even in the absence of a global clock, as required in an asynchronous setting.

For-LySa: UML for Authentication Analysis

The DEGAS project aims at enriching standard UML-centred development environments in such a way that the developers of global applications can exploit automated formal analyses with minimal overhead. In this paper, we present For-LySa, an instantiation of the DEGAS approach for authentication analysis, which exploits an existing analysis tool developed for the process calculus LySa. We discuss what information is needed for the analysis, and how to build the UML model of an authentication protocol in such a way that the needed information can be extracted from the model. We then present our prototype implementation and report on some promising results of its use.

Mobile Agents Coordination in Mobadtl

We present and formalize Mobadtl, a model for network-aware applications, extending the Oikos-adtl temporal-logic based approach to the specification and verification of distributed systems. The model supports strong subjective mobility of agents under the control of stationary guardians. Communications are based on asynchronous message passing. The approach exploits the notions of coordination and refinement to deal separately with the specification of functional issues in the agents, and with the specification of coordination policies, e.g. security, routing, etc., in the guardians. The goal is to specify mobile agents as independently as possible of the requirements related to the other facets of distribution. The specification of an application is obtained by instantiating the general model, refining it along different dimensions corresponding to the different aspects of interest, and finally composing the refinements. The main advantage, besides the increased flexibility of the specification process, is that it is possible to specify rich coordination policies incrementally, while the functional units remain relatively simple. We use Mobadtl to specify a simple electronic commerce application, paying particular attention to the incremental specification of the policies. We show how refined policies lead to stronger system properties.

Two-level control structure for nondeterministic programming

The basic ideas of nondeterministic programming are critically reconsidered to single out a proper attitude and programming style for languages allowing direct control of nondeterministic features. The proposed attitude aims at retaining the purity of the nondeterministic formulation of search processes on one level (the attempt level), deferring the coordination of problem solving efforts to another (the choice level). The feasibility of recognizing these two levels is discussed, stressing that the structure to be managed at the choice level is a tree of contexts. The leaves are computational environments, each holding an alternative under inspection, while the other nodes are associated with choice points. According to the proposed programming style, a generative function is associated with each choice point, which expresses the desired choice strategy. The main advantage of this approach is the localization of the search strategies: Each nonterminal node of the tree keeps track of the state of the computation as it was when the choice point was last interrogated, holding at the same time the strategy to coordinate the available alternatives. Examples are given in term of ND-Lisp, an extension of Lisp designed and implemented according to these guidelines.