The powerful abstraction mechanisms of functional programming languages provide the means to develop domain-specific programming languages within the language itself. Typically, this is realised by designing a set of combinators (higher-order reusable programs) for an application area, and by constructing individual applications by combining and coordinating individual combinators. This paper is concerned with a successful example of such an embedded programming language, namely Fudgets, a library of combinators for building graphical user interfaces in the lazy functional language Haskell. The Fudget library has been used to build a number of substantial applications, including a web browser and a proof editor interface to a proof checker for constructive type theory. This paper develops a semantic theory for the non-deterministic stream processors that are at the heart of the Fudget concept. The interaction of two features of stream processors makes the development of such a semantic theory problematic: (i) the sharing of computation provided by the lazy evaluation mechanism of the underlying host language, and (ii) the addition of non-deterministic choice needed to handle the natural concurrency that reactive applications entail We demonstrate that this combination of features in a higher-order functional language can be tamed to provide a tractable semantic theory and induction principles suitable for reasoning about contextual equivalence of Fudgets.

Abstract not found

This paper proposes a declarative paradigm in which parallelism is implicit and machine-independent, and the programs so developed are intrinsically parallel. This paradigm is obtained by generalizing the notion of rewriting to make it more widely applicable and capable of expressing not only functional computations but also a wide variety of parallel computations that are highly nonfunctional in nature. The generalization in question is provided by rewriting logic, a logic of change in which the states of a system are understood as algebraically axiomatized data structures, and the basic local changes that can concurrently occur in a system are axiomatized as rewrite rules that correspond to local patterns that, when present in the state of a system, can change into other patterns. Simple Maude, a carefully designed sublanguage of rewriting logic supporting three types of rewriting -- term, graph, and object-oriented --, is then proposed as a machine-independent parallel programming ...

When constructing software systems from existing components, the engineer is faced with the problem of potential conflicts in the interactions among the components. Of particular difficulty is guaranteeing compatibility in the dynamic interaction behavior. Using an architectural description of the system and its intended components, the engineer can reason about the interactions early and at a high level of abstraction. In this paper we give a case study of the Compressing Proxy system, which was first investigated by Garlan, Kindred, and Wing. We present architectural specifications and analyses of two versions of the system. One version is a seemingly obvious melding of the components. The other is a solution to deadlock problems uncovered by formal analyses of the #rst version. We use the Chemical Abstract Machine as an example of an architectural description formalism that can help uncover architectural mismatches in the behavior of components.

Abstract not found

The mobile ambients and the P-systems are models developed in different areas of computer science, based on very similar concepts and structures. Given their resemblance, we point out how to transfer ideas and results from one framework to the other. Along this line, we prove that any P-system can be simulated in ambient calculus. We also introduce the mobile P-systems, well suited to model security features for membrane computing.

The sos formats that ensure that bisimilarity is a congruence fail in the presence of structural axioms on states. Dynamic bisimulation, introduced to characterize the coarsest congruence for ccs which is also a weak bisimulation, reconciles the `bisimilarity is a congruence' property with structural axioms and also with the specification of open ended systems, where states can be reconfigured at runtime. We show that the compositional framework o#ered by tile logic handles structural axioms and specifications of reconfigurable systems successfully. This allows for a finitary presentation of dynamic context closure, as internalized in the tile language. The case study of the #-calculus illustrates the main features of our approach. Moreover, duality is exploited to model a second kind of reconfiguration: dynamic specialization.

We introduce a calculus describing the movement of processes and devices, including movement