Results 1  10
of
33
Environmental bisimulations for higherorder languages
 In TwentySecond Annual IEEE Symposium on Logic in Computer Science
, 2007
"... Developing a theory of bisimulation in higherorder languages can be hard. Particularly challenging can be: (1) the proof of congruence, as well as enhancements of the bisimulation proof method with “upto context ” techniques, and (2) obtaining definitions and results that scale to languages with d ..."
Abstract

Cited by 35 (11 self)
 Add to MetaCart
Developing a theory of bisimulation in higherorder languages can be hard. Particularly challenging can be: (1) the proof of congruence, as well as enhancements of the bisimulation proof method with “upto context ” techniques, and (2) obtaining definitions and results that scale to languages with different features. To meet these challenges, we present environmental bisimulations, a form of bisimulation for higherorder languages, and its basic theory. We consider four representative calculi: pure λcalculi (callbyname and callbyvalue), callbyvalue λcalculus with higherorder store, and then HigherOrder πcalculus. In each case: we present the basic properties of environmental bisimilarity, including congruence; we show that it coincides with contextual equivalence; we develop some upto techniques, including upto context, as examples of possible enhancements of the associated bisimulation method. Unlike previous approaches (such as applicative bisimulations, logical relations, SumiiPierceKoutavasWand), our method does not require induction/indices on evaluation derivation/steps (which may complicate the proofs of congruence, transitivity, and the combination with upto techniques), or sophisticated methods such as Howe’s for proving congruence. It also scales from the pure λcalculi to the richer calculi with simple congruence proofs. 1
A bisimulationbased semantic theory of safe ambients
 ACM Transactions on Programming Languages and Systems
, 2006
"... We develop a semantics theory for SAP, a variant of Levi and Sangiorgi’s Safe Ambients, SA. The dynamics of SA relies upon capabilities (and cocapabilities) exercised by mobile agents, called ambients, to interact with each other. These capabilities contain references, the names of ambients with wh ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
We develop a semantics theory for SAP, a variant of Levi and Sangiorgi’s Safe Ambients, SA. The dynamics of SA relies upon capabilities (and cocapabilities) exercised by mobile agents, called ambients, to interact with each other. These capabilities contain references, the names of ambients with which they wish to interact. In SAP we generalise the notion of capability: in order to interact with an ambient n, an ambient m must exercise a capability indicating both n and a password h to access n; the interaction between n and m takes place only if n is willing to perform a corresponding cocapability with the same password h. The name h can also be looked upon as a port to access ambient n via port h. In SAP by managing passwords/ports, for example generating new ones and distributing them selectively, an ambient may now program who may migrate into its computation space, and when. Moreover in SAP an ambient may provide different services/resources depending on the port accessed by the incoming clients. Then, we give an ltsbased operational semantics for SAP and a labelled bisimulation equivalence which is proved to coincide with reduction barbed congruence. We use our notion of bisimulation to prove a set of algebraic laws which are subsequently exploited to prove more significant examples.
An abstract machine for the Kell calculus
 IN 7TH IFIP INTERNATIONAL CONFERENCE ON FORMAL METHODS FOR OBJECTBASED DISTRIBUTED SYSTEMS (FMOODS
, 2005
"... The Kell Calculus is a family of process calculi intended as a basis for studying distributed componentbased programming. This paper presents an abstract machine for an instance of this calculus, a proof of its correctness, and a prototype OCaml implementation. The main originality of our abstract ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
The Kell Calculus is a family of process calculi intended as a basis for studying distributed componentbased programming. This paper presents an abstract machine for an instance of this calculus, a proof of its correctness, and a prototype OCaml implementation. The main originality of our abstract machine is that it does not mandate a particular physical configuration (e.g. mapping of localities to physical sites), and it is independent of any supporting network services. This allows to separate the proof of correctness of the abstract machine per se, from the proof of correctness of higherlevel communication and migration protocols which can be implemented on the machine.
A calculus of components with dynamic typechecking
 Electronic Notes in Theoretical Computer Science, 2006. Formal Aspects of Component Software
, 2006
"... We present a simple module calculus modeling software composition in an open environment, where some components can be provided from the outside after execution has started. Operators for combining software components are as in previous module calculi; here, we focus on the new problems posed by the ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
We present a simple module calculus modeling software composition in an open environment, where some components can be provided from the outside after execution has started. Operators for combining software components are as in previous module calculi; here, we focus on the new problems posed by the fact that components are not all available at compile time. In particular, we want to be able to statically check internal consistency of local code, by only specifying a required type for missing components, and then to perform dynamic checks which ensure that code received from the outside, which is assumed to travel with its type, can be successfully accepted, without requiring to typecheck the whole code again. We consider two alternative solutions. The former uses simple dynamic checks based on standard subtyping, that is, a component can be safely combined with local code if it provides the expected features, and all additional features are hidden, thus avoiding conflict problems. The latter preserves the semantics we would get having all components statically available, but requires a more involved type system based on constraints, where dynamic checks prevent conflicts.
LMNtal as a unifying declarative language
 In Schrijvers and Frühwirth (2006), 1–15. Invited talk
, 2006
"... Abstract. LMNtal (pronounced “elemental”) is a simple language model based on hierarchical graph rewriting that uses logical variables to represent connectivity and membranes to represent hierarchy. LMNtal is an outcome of the attempt to unify constraintbased concurrency and Constraint Handling Rul ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. LMNtal (pronounced “elemental”) is a simple language model based on hierarchical graph rewriting that uses logical variables to represent connectivity and membranes to represent hierarchy. LMNtal is an outcome of the attempt to unify constraintbased concurrency and Constraint Handling Rules (CHR), the two notable extensions to concurrent logic programming. LMNtal is intended to be a substrate language of various computational models, especially those addressing concurrency, mobility and multiset rewriting. Another important goal of LMNtal has been to put hierarchical graph rewriting into practice and demonstrate its versatility by designing and implementing a fullfledged, monolithic programming language. In this paper, we demonstrate the practical aspects of LMNtal using a number of examples taken from diverse areas of computer science. Also, we discuss the relationship between LMNtal and CHR, which exhibit both commonalities and differences in various respects. 1
ComponentOriented Programming with Sharing: Containment is not Ownership
 in "4th International Conference on Generative Programming and Component Engineering (GPCE
, 2005
"... Abstract. Componentoriented programming yields a tension between higherorder features (deployment, reconfiguration, passivation), encapsulation, and component sharing. We propose a discipline for componentoriented programming to address this issue, and we define a process calculus whose operationa ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. Componentoriented programming yields a tension between higherorder features (deployment, reconfiguration, passivation), encapsulation, and component sharing. We propose a discipline for componentoriented programming to address this issue, and we define a process calculus whose operational semantics embodies this programming discipline. We present several examples that illustrate how the calculus supports component sharing, while allowing strong encapsulation and higherorder primitives. 1
Normal Bisimulations in Calculi with Passivation
"... Abstract. Behavioral theory for higherorder process calculi is less well developed than for firstorder ones such as the πcalculus. In particular, effective coinductive characterizations of barbed congruence, such as the notion of normal bisimulation developed by Sangiorgi for the higherorder πca ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. Behavioral theory for higherorder process calculi is less well developed than for firstorder ones such as the πcalculus. In particular, effective coinductive characterizations of barbed congruence, such as the notion of normal bisimulation developed by Sangiorgi for the higherorder πcalculus, are difficult to obtain. In this paper, we study bisimulations in two simple higherorder calculi with a passivation operator, that allows the interruption and thunkification of a running process. We develop a normal bisimulation that characterizes barbed congruence, in the strong and weak cases, for the first calculus which has no name restriction operator. We then show that this result does not hold in the calculus extended with name restriction. 1
OZ/K: A Kernel Language for ComponentBased Open Programming
"... Programming in an open environment remains challenging because it requires combining modularity, security, concurrency, distribution, and dynamicity. In this paper, we propose an approach to open distributed programming that exploits the notion of locality, which has been used in the past decade as ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Programming in an open environment remains challenging because it requires combining modularity, security, concurrency, distribution, and dynamicity. In this paper, we propose an approach to open distributed programming that exploits the notion of locality, which has been used in the past decade as a basis for several distributed process calculi such as Mobile Ambients, Dπ, and Seal. We use the locality concept as a form of component that serves as a unit of modularity, of isolation, and of passivation. Specifically, we introduce in this paper OZ/K, a kernel programming language, that adds to the OZ computation model a notion of locality borrowed from the Kell calculus. We present an operational semantics for the language and several examples to illustrate how OZ/K supports open distributed programming.
Modelling the Security of Smart Cards by Hard and Soft Types for HigherOrder Mobile Embedded Resources
 Proceedings of the 5th International Workshop on Security Issues in Concurrency (SecCo'07)
, 2007
"... We provide a type system inspired by affine intuitionistic logic for the calculus of HigherOrder Mobile Embedded Resources (Homer), resulting in the first process calculus combining affine linear (noncopyable) and nonlinear (copyable) higherorder mobile processes, nested locations, and local nam ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
We provide a type system inspired by affine intuitionistic logic for the calculus of HigherOrder Mobile Embedded Resources (Homer), resulting in the first process calculus combining affine linear (noncopyable) and nonlinear (copyable) higherorder mobile processes, nested locations, and local names. The type system guarantees that linear resources are neither copied nor embedded in nonlinear resources during computation.
We exemplify the use of the calculus by modelling a simplistic ecash Smart Card system, the security of which depends on the interplay between (linear) mobile hardware, embedded (nonlinear) mobile processes, and local names. A purely linear calculus would not be able to express that embedded software processes may be copied. Conversely, a purely nonlinear calculus would not be able to express that mobile hardware processes cannot be copied.
Asynchonous Distributed Components: Concurrency and Determinacy
 IFIP World Computer Congress, Springer Science
"... Abstract. Based on the impςcalculus, ASP (Asynchronous Sequential Processes) defines distributed applications behaving deterministically. This article extends ASP by building hierarchical and asynchronous distributed components. Components are hierarchical a composite can be built from other compo ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. Based on the impςcalculus, ASP (Asynchronous Sequential Processes) defines distributed applications behaving deterministically. This article extends ASP by building hierarchical and asynchronous distributed components. Components are hierarchical a composite can be built from other components, and distributed a composite can span over several machines. This article also shows how the asynchronous component model can be used to statically assert component determinism. The advent of components in programming technology raises the question of their formal ground, intrinsic semantics, and above all their compositional semantics. It represents a real challenge as practical component models are usually quite complex, featuring distribution over local or wide area networks. But, few formal models for component were proposed so far [4, 20, 3, 14]. Since the first ideas about software components, usually dated in 1968 [1], the design of a reusable piece of software has technically evolved. From the first offtheshelf