Results 11  20
of
339
Formal Specification and Analysis of Software Architectures Using the Chemical Abstract Machine Model
 IEEE TRANSACTIONS ON SOFTWARE ENGINEERING
, 1995
"... We are exploring an approach to formally specifying and analyzing software architectures that is based on viewing software systems as chemicals whose reactions are controlled by explicitly stated rules. This powerful metaphor was devised in the domain of theoretical computer science by Banatre and L ..."
Abstract

Cited by 118 (16 self)
 Add to MetaCart
We are exploring an approach to formally specifying and analyzing software architectures that is based on viewing software systems as chemicals whose reactions are controlled by explicitly stated rules. This powerful metaphor was devised in the domain of theoretical computer science by Banatre and Le M'etayer and then reformulated as the Chemical Abstract Machine, or CHAM, by Berry and Boudol. The CHAM formalism provides a framework for developing operational specifications that does not bias the described system toward any particular computational model. It also encourages the construction and use of modular specifications at different levels of detail. We illustrate the use of the CHAM for architectural description and analysis by applying it to two different architectures for a simple, but familiar, software system, the multiphase compiler.
Continuations: A Mathematical Semantics for Handling Full Jumps
, 1974
"... Abstract. This paper describes a method of giving the mathematical semantics of programming languages which include the most general form of jumps. 1. ..."
Abstract

Cited by 112 (0 self)
 Add to MetaCart
Abstract. This paper describes a method of giving the mathematical semantics of programming languages which include the most general form of jumps. 1.
Equivalence in Functional Languages with Effects
, 1991
"... Traditionally the view has been that direct expression of control and store mechanisms and clear mathematical semantics are incompatible requirements. This paper shows that adding objects with memory to the callbyvalue lambda calculus results in a language with a rich equational theory, satisfying ..."
Abstract

Cited by 111 (13 self)
 Add to MetaCart
Traditionally the view has been that direct expression of control and store mechanisms and clear mathematical semantics are incompatible requirements. This paper shows that adding objects with memory to the callbyvalue lambda calculus results in a language with a rich equational theory, satisfying many of the usual laws. Combined with other recent work this provides evidence that expressive, mathematically clean programming languages are indeed possible. 1. Overview Real programs have effectscreating new structures, examining and modifying existing structures, altering flow of control, etc. Such facilities are important not only for optimization, but also for communication, clarity, and simplicity in programming. Thus it is important to be able to reason both informally and formally about programs with effects, and not to sweep effects either to the side or under the store parameter rug. Recent work of Talcott, Mason, Felleisen, and Moggi establishes a mathematical foundation for...
The Discoveries of Continuations
, 1993
"... We give a brief account of the discoveries of continuations and related concepts by, A. Van Wijngaarden , A. W. Mazurkiewicz , F. L. Morris , C. P. Wadsworth , J. H. Morris , M. J. Fischer , and S. K. Abdali. ..."
Abstract

Cited by 110 (2 self)
 Add to MetaCart
We give a brief account of the discoveries of continuations and related concepts by, A. Van Wijngaarden , A. W. Mazurkiewicz , F. L. Morris , C. P. Wadsworth , J. H. Morris , M. J. Fischer , and S. K. Abdali.
Compiling with Types
, 1995
"... Compilers for monomorphic languages, such as C and Pascal, take advantage of types to determine data representations, alignment, calling conventions, and register selection. However, these languages lack important features including polymorphism, abstract datatypes, and garbage collection. In contr ..."
Abstract

Cited by 103 (14 self)
 Add to MetaCart
Compilers for monomorphic languages, such as C and Pascal, take advantage of types to determine data representations, alignment, calling conventions, and register selection. However, these languages lack important features including polymorphism, abstract datatypes, and garbage collection. In contrast, modern programming languages such as Standard ML (SML), provide all of these features, but existing implementations fail to take full advantage of types. The result is that performance of SML code is quite bad when compared to C. In this thesis, I provide a general framework, called typedirected compilation, that allows compiler writers to take advantage of types at all stages in compilation. In the framework, types are used not only to determine efficient representations and calling conventions, but also to prove the correctness of the compiler. A key property of typedirected compilation is that all but the lowest levels of the compiler use typed intermediate languages. An advantage of this approach is that it provides a means for automatically checking the integrity of the resulting code. An important
LambdaCalculus Schemata
, 1993
"... A lambdacalculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constan ..."
Abstract

Cited by 100 (1 self)
 Add to MetaCart
A lambdacalculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constant and operator symbols, certain schemata, called lambda abstractions, naturally define partial functions over the domain of interpretation. Two implementation strategies are considered: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbagecollected store) and the deletion strategy, modeled after the usual stack implementation of ALGOL 60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Not all lambda abstractions evaluate correctly under the deletion strategy. Nevertheless, both strategies are equally powerful in the sense that any lambda abstraction can be mechanically translated into another that evaluates correctly under the deletion strategy and defines the same partial function over the domain of interpretation as the original. Proof is by translation into continuationpassing style.
Proving Properties of Programs by Structural Induction
 Computer Journal
, 1969
"... This paper discusses the technique of structural induction for proving theorems about programs. This technique is closely related to recursion induction but makes use of the inductive definition of the data structures handled by the programs. It treats programs with recursion but without assignments ..."
Abstract

Cited by 90 (0 self)
 Add to MetaCart
This paper discusses the technique of structural induction for proving theorems about programs. This technique is closely related to recursion induction but makes use of the inductive definition of the data structures handled by the programs. It treats programs with recursion but without assignments or jumps. Some syntactic extensions to Landin's functional programming language ISWIM are suggested which make it easier to program the manipulation of data structures and to develop proofs about such programs. Two sample proofs are given to demonstrate the technique, one for a tree sorting algorithm and one for a simple compiler for expressions. (First received April 1968 and in revised form August 1968) Since the problem of proving that computer programs really do what their inventors allege them to do was discussed by McCarthy (1963), there has been considerable progress and proofs have been produced for nontrivial programs such as a simple compiler (Painter, 1967;
Recursion and Dynamic Datastructures in Bounded Space: Towards Embedded ML Programming
 In Proceedings of the 1999 ACM SIGPLAN International Conference on Functional Programming
, 1999
"... We present a functional language with a type system such that well typed programs run within stated spacebounds. The language is a strict, firstorder variant of ML with constructs for explicit storage management. The type system is a variant of Tofte and Talpin's region inference system to wh ..."
Abstract

Cited by 76 (0 self)
 Add to MetaCart
We present a functional language with a type system such that well typed programs run within stated spacebounds. The language is a strict, firstorder variant of ML with constructs for explicit storage management. The type system is a variant of Tofte and Talpin's region inference system to which the notion of sized types, of Hughes, Pareto and Sabry, has been added.