Results 1  10
of
35
On the Expressive Power of Programming Languages
 Science of Computer Programming
, 1990
"... The literature on programming languages contains an abundance of informal claims on the relative expressive power of programming languages, but there is no framework for formalizing such statements nor for deriving interesting consequences. As a first step in this direction, we develop a formal noti ..."
Abstract

Cited by 132 (4 self)
 Add to MetaCart
The literature on programming languages contains an abundance of informal claims on the relative expressive power of programming languages, but there is no framework for formalizing such statements nor for deriving interesting consequences. As a first step in this direction, we develop a formal notion of expressiveness and investigate its properties. To validate the theory, we analyze some widely held beliefs about the expressive power of several extensions of functional languages. Based on these results, we believe that our system correctly captures many of the informal ideas on expressiveness, and that it constitutes a foundation for further research in this direction. 1 Comparing Programming Languages The literature on programming languages contains an abundance of informal claims on the expressive power of programming languages. Arguments in these contexts typically assert the expressibility or nonexpressibility of programming constructs relative to a language. Unfortunately, pro...
A Complexity Theory for VLSI
 TECHNICAL REPORT
, 1980
"... The established methodologies for studying computational complexity can be applied to the new problems posed by very largescale integrated (VLSI) circuits. This thesis develops a “VLSI model of computation” and derives upper and lower bounds on the silicon area and time required to solve the proble ..."
Abstract

Cited by 105 (1 self)
 Add to MetaCart
The established methodologies for studying computational complexity can be applied to the new problems posed by very largescale integrated (VLSI) circuits. This thesis develops a “VLSI model of computation” and derives upper and lower bounds on the silicon area and time required to solve the problems of sorting and discrete Fourier transformation. In particular, the area A and time T taken by any VLSI chip using any algorithm to perform an $N$point Fourier transform must satisfy $AT^2 \geq c N^2 \log^2 N$, for some fixed $c > 0$. A more general result for both sorting and Fourier transformation is that $AT^{2x} = \Omega(N^{1+x} \log^{2x} N)$ for any $x$ in the range $0 < x < 1$. Also, the energy dissipated by a VLSI chip during the solution of either of these problems is at least $\Omega(N^{3/2} \log N)$. The tightness of these bounds is demonstrated by the existence of nearly optimal circuits for both sorting and Fourier transformation. The circuits based on the shuffleexchange interconnection pattern are fast but large: $T = O(\log^2 N)$ for Fourier transformation, $T = O(\log^3 N)$ for sorting; both have area $A$ of at most $O(N^2 / \log{1/2} N)$. The circuits based on the mesh interconnection pattern are slow but small: $T = O(N^{1/2} \log\log N)$, $A = O(N \log^2 N)$.
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 101 (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.
Rules and Strategies for Transforming Functional and Logic Programs
 ACM Computing Surveys
, 1996
"... We present an overview of the program transformation methodology, focusing our attention on the socalled `rules + strategies' approach in the case of functional and logic programs. The paper is intended to offer an introduction to the subject. The various techniques we present are illustrated via s ..."
Abstract

Cited by 76 (4 self)
 Add to MetaCart
We present an overview of the program transformation methodology, focusing our attention on the socalled `rules + strategies' approach in the case of functional and logic programs. The paper is intended to offer an introduction to the subject. The various techniques we present are illustrated via simple examples. A preliminary version of this report has been published in: Moller, B., Partsch, H., and Schuman, S. (eds.): Formal Program Development. Lecture Notes in Computer Science 755, Springer Verlag (1993) 263304. Also published in: ACM Computing Surveys, Vol 28, No. 2, June 1996. 3 1 Introduction The program transformation approach to the development of programs has first been advocated by [BurstallDarlington 77], although the basic ideas were already presented in previous papers by the same authors [Darlington 72, BurstallDarlington 75]. In that approach the task of writing a correct and efficient program is realized in two phases: the first phase consists in writing an in...
The Incremental Garbage Collection of Processes
, 1977
"... This paper investigates some problems associated with an argument evaluation order that we call "future' order, which is different from both callbyname and callbyvalue. In callbyfuture, each formal parameter of a function is bound to a separate process (called a "future") dedicated to the eval ..."
Abstract

Cited by 76 (4 self)
 Add to MetaCart
This paper investigates some problems associated with an argument evaluation order that we call "future' order, which is different from both callbyname and callbyvalue. In callbyfuture, each formal parameter of a function is bound to a separate process (called a "future") dedicated to the evaluation of the corresponding argument. This mechanism allows the fully parallel evaluation of arguments to a function, and has been shown to augment the expressive power of a language. We discuss an approach to a problem that arises in this context: futures which were thought to be relevant when they were created become irrelevant through being ignored in the body of the expression where they were bound. The problem of irrelevant processes also appears in multiprocessing problemsolving systems which start several processors working on the same problem but with different methods, and return with the solution which finishes first. This parallel method strategy has the drawback that the processes which are investigating the losing methods must be identified, stopped, and reassigned to more useful tasks. The solution we propose is that of garbage collection. We propose that the goal structure of the solution plan be explicitly represented in memory as part of the graph memory (like Lisp's heap) so that a garbage collection algorithm can discover which processes are performing useful work, and which can be recycled for a new task. An incremental algorithm for the unified garbage collection of storage and processes is described.
Embedding as a tool for Language Comparison
, 1994
"... This paper addresses the problem of defining a formal tool to compare the expressive power of different concurrent constraint languages. We refine the notion of embedding by adding some "reasonable" conditions, suitable for concurrent frameworks. The new notion, called modular embedding, is used to ..."
Abstract

Cited by 32 (5 self)
 Add to MetaCart
This paper addresses the problem of defining a formal tool to compare the expressive power of different concurrent constraint languages. We refine the notion of embedding by adding some "reasonable" conditions, suitable for concurrent frameworks. The new notion, called modular embedding, is used to define a preorder among these languages, representing different degrees of expressiveness. We show that this preorder is not trivial (i.e. it does not collapse into one equivalence class) by proving that Flat CP cannot be embedded into Flat GHC, and that Flat GHC cannot be embedded into a language without communication primitives in the guards, while the converses hold. 4 A; C; D; G; M;O;P;R; T : In calligraphic style. ss; ff ; dd: In slanted style. \Sigma; \Gamma; #; oe; ; /; ø; ff. S ; [; "; ;; 2 j=; 6j=; ; 9 +; k; ~ +; ~ k; ! \Gamma! W ; \Gamma! ; ; \Gamma! W ; \Gamma! ; h; i; [[; ]]; d; e ffi; ?; ; 5 All reasonable programming languages are equivalent, since they are Turing...
Pure versus Impure Lisp
, 1996
"... : The aspect of purity versus impurity that we address involves the absence versus presence of mutation: the use of primitives (RPLACA and RPLACD in Lisp, setcar! and setcdr! in Scheme) that change the state of pairs without creating new pairs. It is well known that cyclic list structures can be c ..."
Abstract

Cited by 17 (0 self)
 Add to MetaCart
: The aspect of purity versus impurity that we address involves the absence versus presence of mutation: the use of primitives (RPLACA and RPLACD in Lisp, setcar! and setcdr! in Scheme) that change the state of pairs without creating new pairs. It is well known that cyclic list structures can be created by impure programs, but not by pure ones. In this sense, impure Lisp is "more powerful" than pure Lisp. If the inputs and outputs of programs are restricted to be sequences of atomic symbols, however, this difference in computability disappears. We shall show that if the temporal sequence of input and output operations must be maintained (that is, if computations must be "online "), then a difference in complexity remains: for a pure program to do what an impure program does in n steps, O(n log n) steps are sufficient, and in some cases\Omega\Gamma n log n) steps are necessary. * This research was partially supported by an NSERC Operating Grant. 1. Introduction The programming la...
Scheduling TreeDags Using FIFO Queues: A Controlmemory Tradeoff
"... We study here a combinatorial problem that is motivated by a genre of architectureindependent scheduler for parallel computations. Such schedulers are often used, for instance, when computations are being done by a cooperating network of workstations. The results we obtain expose a controlmemory t ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
We study here a combinatorial problem that is motivated by a genre of architectureindependent scheduler for parallel computations. Such schedulers are often used, for instance, when computations are being done by a cooperating network of workstations. The results we obtain expose a controlmemory tradeoff for such schedulers, when the computation being scheduled has the structure of a complete binary tree. The combinatorial problem takes the following form. Consider, for each integer N =2 n, a family of n algorithms for linearizing the Nleaf complete binary tree in such away that each nonleaf node precedes its children. For each k 2f1 � 2�:::�ng, the kth algorithm in the family employs k FIFO queues to e ect the linearization, in a manner specified later (cf., [1], [5] [7]). In this paper, we expose a tradeoff between the number of queues used by eachofthen algorithms  which we view as measuring the control complexity of the algorithm  and the memory requirements of the algorithms, as embodied in the required capacity ofthe largestcapacity queue. Specifically, we prove that, for each k 2f1 � 2�:::�ng, the maximum perqueue capacity, call it Q k(N), for a kqueue algorithm that linearizes an Nleaf complete binary tree satisfies e
Program Development Schemata as Derived Rules
, 2000
"... This paper makes several contributions towards a clarified view of schemabased program development. First, we propose that schemata can be understood, formalized, and used in a simple way: program development schemata are derived rules. We mean this in the standard sense of a derived rule of infere ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
This paper makes several contributions towards a clarified view of schemabased program development. First, we propose that schemata can be understood, formalized, and used in a simple way: program development schemata are derived rules. We mean this in the standard sense of a derived rule of inference in logic. A schema like Figure i can be formulated as a rule stating that the conclusion follows from the premises defining F, G, and the applicability conditions. By deriving the rule in an axiomatic theory, we validate a semantic statement about it: the conclusion of the rule holds in every model where both the axioms of the theory and the premises of the rule are true. Hence, by selecting a language to work in we control which development schemata are formalizable, and by selecting a theory we determine which schemata are derivable