Results 1 
9 of
9
Dynamic structure in software architectures
 In Proceedings of the Fourth ACM SIGSOFT Symposium on the Foundations of Software Engineering
, 1996
"... Much of the recent work on Architecture Description Languages (ADL) has concentrated on specifying organisations of components and connectors which are static. When the ADL specification is used to drive system construction, then the structure of the resulting system in terms of its component instan ..."
Abstract

Cited by 204 (5 self)
 Add to MetaCart
Much of the recent work on Architecture Description Languages (ADL) has concentrated on specifying organisations of components and connectors which are static. When the ADL specification is used to drive system construction, then the structure of the resulting system in terms of its component instances and their interconnection is fixed. This paper examines ADL features which permit the description of dynamic software architectures in which the organisation of components and connectors may change during system execution. The paper outlines examples of language features which support dynamic structure. These examples are taken from Darwin, a language used to describe distributed system structure. An operational semantics for these features is presented in the ncalculus, together with a discussion of their advantages and limitations. The paper discusses some general approaches to dynamic architecture description suggested by these examples. 1
Deriving Bisimulation Congruences for Reactive Systems
 In Proc. of CONCUR 2000, 2000. LNCS 1877
, 2000
"... . The dynamics of reactive systems, e.g. CCS, has often been de ned using a labelled transition system (LTS). More recently it has become natural in de ning dynamics to use reaction rules  i.e. unlabelled transition rules  together with a structural congruence. But LTSs lead more naturally to beha ..."
Abstract

Cited by 116 (14 self)
 Add to MetaCart
. The dynamics of reactive systems, e.g. CCS, has often been de ned using a labelled transition system (LTS). More recently it has become natural in de ning dynamics to use reaction rules  i.e. unlabelled transition rules  together with a structural congruence. But LTSs lead more naturally to behavioural equivalences. So one would like to derive from reaction rules a suitable LTS. This paper shows how to derive an LTS for a wide range of reactive systems. A label for an agent a is de ned to be any context F which intuitively is just large enough so that the agent Fa (\a in context F ") is able to perform a reaction. The key contribution of this paper is a precise de nition of \just large enough", in terms of the categorical notion of relative pushout (RPO), which ensures that bisimilarity is a congruence when sucient RPOs exist. Two examples  a simpli ed form of action calculi and termrewriting  are given, for which it is shown that su cient RPOs indeed exist. The thrust of thi...
The Polymorphic Picalculus: Theory and Implementation
, 1995
"... We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped concurrent programming language. The first half of the dissertation examines whether the πcalculus supports a simple type system which is flexible enough to provide a su ..."
Abstract

Cited by 95 (0 self)
 Add to MetaCart
We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped concurrent programming language. The first half of the dissertation examines whether the πcalculus supports a simple type system which is flexible enough to provide a suitable foundation for the type system of a concurrent programming language. The second half of the dissertation considers how to implement the πcalculus efficiently, starting with an abstract machine for πcalculus and finally presenting a compilation of πcalculus to C. We start the dissertation by presenting a simple, structural type system for πcalculus, and then, after proving the soundness of our type system, show how to infer principal types for πterms. This simple type system can be extended to include useful typetheoretic constructions such as recursive types and higherorder polymorphism. Higherorder polymorphism is important, since it gives us the ability to implement abstract datatypes in a typesafe manner, thereby providing a greater degree of modularity for πcalculus programs. The functional computational paradigm plays an important part in many programming languages. It is wellknown that the πcalculus can encode functional computation. We go further and show that the type structure of λterms is preserved by such encodings, in the sense that we can relate the type of a λterm to the type of its encoding in the πcalculus. This means that a πcalculus programming language can genuinely support typed functional programming as a special case. An efficient implementation of πcalculus is necessary if we wish to consider πcalculus as an operational foundation for concurrent programming. We first give a simple abstract machine for πcalculus and prove it correct. We then show how this abstract machine inspires a simple, but efficient, compilation of πcalculus to C (which now forms the basis of the Pict programming language implementation).
Polymorphic Type Inference and Assignment
, 1991
"... We present a new approach to the polymorphic typing of data accepting inplace modi cation in MLlike languages. This approach is based on restrictions over type generalization, and a re ned typing of functions. The type system given here leads to a better integration of imperative programming sty ..."
Abstract

Cited by 49 (1 self)
 Add to MetaCart
We present a new approach to the polymorphic typing of data accepting inplace modi cation in MLlike languages. This approach is based on restrictions over type generalization, and a re ned typing of functions. The type system given here leads to a better integration of imperative programming style with the purely applicative kernel of ML. In particular, generic functions that allocate mutable data can safely be given fully polymorphic types. We show the soundness of this type system, and give a type reconstruction algorithm.
Compiling JoinPatterns
 Electronic Notes in Computer Science
, 1998
"... The joincalculus is both a name passing calculus and a core language for concurrent and distributed programming. An essential part of its implementation is the compilation of joinpatterns. Joinpatterns define new channels and all the synchronizations they take part to at the same time. Relying on ..."
Abstract

Cited by 17 (3 self)
 Add to MetaCart
The joincalculus is both a name passing calculus and a core language for concurrent and distributed programming. An essential part of its implementation is the compilation of joinpatterns. Joinpatterns define new channels and all the synchronizations they take part to at the same time. Relying on the experience based on our two implementations, we study the translation of joinpatterns into deterministic finitestate automata as well as some related optimizations. 1 Introduction Joinpattern is the distinctive feature of the joincalculus, seen both as a process calculus and as a programming language. On the calculus side, joincalculus can roughly be seen as a functional calculus plus joinpatterns, thus achieving the same expressive power as previous namepassing process calculi [11]. Joindefinitions are made of several clauses, each clause being a pair of a joinpattern and of a guarded process. A joinpattern expresses a synchronization between several names (or channels). When...
Semantics for a RealTime ObjectOriented Programming Language
 In Int. Conf. on Computer Languages
, 1994
"... This paper presents a framework to define a semantics for a realtime objectorientation programming language and to verify programs written in the language. The semantics is defined as the collection of translation rules that map the syntactic constructions of the language into expressions in a pro ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
This paper presents a framework to define a semantics for a realtime objectorientation programming language and to verify programs written in the language. The semantics is defined as the collection of translation rules that map the syntactic constructions of the language into expressions in a process calculus extended with the notion of time. By using the expressive capabilities of the calculus, the semantics can appropriately capture temporal features of the language such as timeout exception and execution time, and concurrent objectoriented features such as concurrency, class, and object creation. Particularly, since it can restrict the number of concurrent activities which take place simultaneously, it allows to analyze and predict temporal and behavioral properties of programs executed even with a number of processors smaller than the number of active objects. Through an example, we illustrate a method of analyzing realtime programs. 1 Introduction Realtime systems are gett...
CLL: A concurrent language built from logical principles
, 2005
"... We present CLL, a concurrent programming language that symmetrically integrates functional and concurrent logic programming. First, a core functional language is obtained from a proofterm assignment to a variant of intuitionistic linear logic, called FOMLL, via the CurryHoward isomorphism. Next, w ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
We present CLL, a concurrent programming language that symmetrically integrates functional and concurrent logic programming. First, a core functional language is obtained from a proofterm assignment to a variant of intuitionistic linear logic, called FOMLL, via the CurryHoward isomorphism. Next, we introduce a Chemical Abstract Machine (CHAM) whose molecules are typed terms of this functional language. Rewrite rules for this CHAM are derived by augmenting proofsearch rules for FOMLL with proofterms. We show that this CHAM is a powerful concurrent language and that the linear connectives ⊗, ∃, ⊕, ⊸ and & correspond to processcalculi connectives for parallel composition, name restriction, internal choice, input prefixing and external choice respectively. We also demonstrate that communication and synchronization between CHAM terms can be performed through proofsearch on the types of terms. Finally, we embed this CHAM as a construct in our functional language to allow interleaving functional and concurrent computation in CLL.
A Methodology For Statically Clustering Active Objects In Distributed Systems
, 1994
"... The complexity inherent in large scale distributed systems accounts for the difficulty in engineering applications on such platforms. The difficulty primarily arises from having to partition an application to exploit concurrency and minimize the overhead due to communication across the network. The ..."
Abstract
 Add to MetaCart
The complexity inherent in large scale distributed systems accounts for the difficulty in engineering applications on such platforms. The difficulty primarily arises from having to partition an application to exploit concurrency and minimize the overhead due to communication across the network. The challenge in building a powerful development environment which simplifies the task of application development therefore lies in the degree to which application partitioning and distribution can be automated or made transparent. Transparency requires powerful static semantic analysis that can massage any given application into a state which an appropriate run time model can then execute efficiently on a distributed architecture. The object model with it's software engineering advantages presents an attractive alternative to the task/process based computational model for distributed systems. A fine grained active object model presents a powerful computational paradigm to engineer a wide variet...
Author:
"... This paper describes a new automata which is Turing Complete. These algorithms use a data structure which can be described as an abstract graph representation. The construction of this machine can be desribed as a matrix machine performing operations on the data set. This outlines both a determinist ..."
Abstract
 Add to MetaCart
This paper describes a new automata which is Turing Complete. These algorithms use a data structure which can be described as an abstract graph representation. The construction of this machine can be desribed as a matrix machine performing operations on the data set. This outlines both a deterministic and nondeterministic operation of the machine. Also a possible implementation of the Blum Shub Smale machine is created utilizing this architecture. Keywords: Graph Theory, Hilbert Spaces, Turing machines, Automata 2.