Results 1  10
of
71
Forms/3: A FirstOrder Visual Language to Explore the Boundaries of the Spreadsheet Paradigm
"... Although detractors of functional programming sometimes claim that functional programming is too difficult or counterintuitive for most programmers to understand and use, evidence to the contrary can be found by looking at the popularity of spreadsheets. The spreadsheet paradigm, a firstorder subs ..."
Abstract

Cited by 88 (40 self)
 Add to MetaCart
Although detractors of functional programming sometimes claim that functional programming is too difficult or counterintuitive for most programmers to understand and use, evidence to the contrary can be found by looking at the popularity of spreadsheets. The spreadsheet paradigm, a firstorder subset of the functional programming paradigm, has found wide acceptance among both programmers and end users. Still, there are many limitations with most spreadsheet systems.
Analysis and Caching of Dependencies
, 1996
"... We address the problem of dependency analysis and caching in the context of the calculus. The dependencies of a  term are (roughly) the parts of the term that contribute to the result of evaluating it. We introduce a mechanism for keeping track of dependencies, and discuss how to use these depend ..."
Abstract

Cited by 70 (6 self)
 Add to MetaCart
We address the problem of dependency analysis and caching in the context of the calculus. The dependencies of a  term are (roughly) the parts of the term that contribute to the result of evaluating it. We introduce a mechanism for keeping track of dependencies, and discuss how to use these dependencies in caching.
Static Type Inference in a Dynamically Typed Language
 In Eighteenth Annual ACM Symposium on Principles of Programming Languages
, 1991
"... We present a type inference system for FL based on an operational, rather than a denotational, formulation of types. The essential elements of the system are a type language based on regular trees and a type inference logic that implements an abstract interpretation of the operational semantics of F ..."
Abstract

Cited by 65 (7 self)
 Add to MetaCart
We present a type inference system for FL based on an operational, rather than a denotational, formulation of types. The essential elements of the system are a type language based on regular trees and a type inference logic that implements an abstract interpretation of the operational semantics of FL. We use a nonstandard approach to type inference because our requirementsusing type information in the optimization of functional programsdiffer substantially from those of other type systems. 1 Introduction Compilers derive at least two benefits from static type inference: the ability to detect and report potential runtime errors at compiletime, and the use of type information in program optimization. Traditionally, type systems have emphasized the detection of type errors. Statically typed functional languages such as Haskell [HWA*88] and ML [HMT89] include type constraints as part of the language definition, making some type inference necessary to ensure that type constraints ...
Adaptive Functional Programming
 IN PROCEEDINGS OF THE 29TH ANNUAL ACM SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 2001
"... An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to ..."
Abstract

Cited by 64 (23 self)
 Add to MetaCart
An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to make any purelyfunctional program adaptive. We show
Implementing Regular Tree Expressions
 In Proceedings of the 1991 Conference on Functional Programming Languages and Computer Architecture
, 1991
"... Regular tree expressions are a natural formalism for describing the sets of treestructured values that commonly arise in programs; thus, they are wellsuited to applications in program analysis. We describe an implementation of regular tree expressions and our experience with that implementation in ..."
Abstract

Cited by 52 (6 self)
 Add to MetaCart
Regular tree expressions are a natural formalism for describing the sets of treestructured values that commonly arise in programs; thus, they are wellsuited to applications in program analysis. We describe an implementation of regular tree expressions and our experience with that implementation in the context of the FL type system. A combination of algorithms, optimizations, and fast heuristics for computationally difficult problems yields an implementation efficient enough for practical use. 1 Introduction Regular tree expressions are a natural formalism for describing the sets of treestructured values that commonly arise in programs. As such, several researchers have proposed using (variations on) regular tree expressions in type inference and program analysis algorithms [JM79, Mis84, MR85, HJ90, HJ91, AM91]. We are not aware of any implementations based on regular tree expressions, however, except for our own work on type analysis for the functional language FL [B + 89]. A p...
Caching and Lemmaizing in Model Elimination Theorem Provers
, 1992
"... Theorem provers based on model elimination have exhibited extremely high inference rates but have lacked a redundancy control mechanism such as subsumption. In this paper we report on work done to modify a model elimination theorem prover using two techniques, caching and lemmaizing, that have reduc ..."
Abstract

Cited by 49 (2 self)
 Add to MetaCart
Theorem provers based on model elimination have exhibited extremely high inference rates but have lacked a redundancy control mechanism such as subsumption. In this paper we report on work done to modify a model elimination theorem prover using two techniques, caching and lemmaizing, that have reduced by more than an order of magnitude the time required to find proofs of several problems and that have enabled the prover to prove theorems previously unobtainable by topdown model elimination theorem provers.
Selective Memoization
"... We present a framework for applying memoization selectively. The framework provides programmer control over equality, space usage, and identification of precise dependences so that memoization can be applied according to the needs of an application. Two key properties of the framework are that it ..."
Abstract

Cited by 44 (19 self)
 Add to MetaCart
We present a framework for applying memoization selectively. The framework provides programmer control over equality, space usage, and identification of precise dependences so that memoization can be applied according to the needs of an application. Two key properties of the framework are that it is efficient and yields programs whose performance can be analyzed using standard techniques. We describe the framework in the context of a functional language and an implementation as an SML library. The language is based on a modal type system and allows the programmer to express programs that reveal their true data dependences when executed. The SML implementation cannot support this modal type system statically, but instead employs runtime checks to ensure correct usage of primitives.
Deriving incremental programs
, 1993
"... A systematic approach i s g i v en for deriving incremental programs from nonincremental programs written in a standard functional programming language. We exploit a number of program analysis and transformation techniques and domainspeci c knowledge, centered around e ective utilization of cachin ..."
Abstract

Cited by 39 (21 self)
 Add to MetaCart
A systematic approach i s g i v en for deriving incremental programs from nonincremental programs written in a standard functional programming language. We exploit a number of program analysis and transformation techniques and domainspeci c knowledge, centered around e ective utilization of caching, in order to provide a degree of incrementality not otherwise achievable by a generic incremental evaluator. 1
Tupling Calculation Eliminates Multiple Data Traversals
 In ACM SIGPLAN International Conference on Functional Programming
, 1997
"... Tupling is a wellknown transformation tactic to obtain new efficient recursive functions by grouping some recursive functions into a tuple. It may be applied to eliminate multiple traversals over the common data structure. The major difficulty in tupling transformation is to find what functions are ..."
Abstract

Cited by 33 (18 self)
 Add to MetaCart
Tupling is a wellknown transformation tactic to obtain new efficient recursive functions by grouping some recursive functions into a tuple. It may be applied to eliminate multiple traversals over the common data structure. The major difficulty in tupling transformation is to find what functions are to be tupled and how to transform the tupled function into an efficient one. Previous approaches to tupling transformation are essentially based on fold/unfold transformation. Though general, they suffer from the high cost of keeping track of function calls to avoid infinite unfolding, which prevents them from being used in a compiler. To remedy this situation, we propose a new method to expose recursive structures in recursive definitions and show how this structural information can be explored for calculating out efficient programs by means of tupling. Our new tupling calculation algorithm can eliminate most of multiple data traversals and is easy to be implemented. 1 Introduction Tupli...
Accelerating MultiMedia Processing by Implementing Memoing in Multiplication and Division Units
 International Conference on Architectural Support for Programming Languages and Operating Systems
, 1998
"... This paper proposes a technique that enables performing multicycle (multiplication, division, squareroot...) computations in a single cycle. The technique is based on the notion of memoing: saving the input and output of previous calculations and using the output if the input is encountered again. ..."
Abstract

Cited by 27 (5 self)
 Add to MetaCart
This paper proposes a technique that enables performing multicycle (multiplication, division, squareroot...) computations in a single cycle. The technique is based on the notion of memoing: saving the input and output of previous calculations and using the output if the input is encountered again. This technique is especially suitable for MultiMedia (MM) processing. In MM applications the local entropy of the data tends to be low which results in repeated operations on the same datum. The inputs and outputs of assembly level operations are stored in cachelike lookup tables and accessed in parallel to the conventional computation. A successful lookup gives the result of a multicycle computation in a single cycle, and a failed lookup doesn't necessitate a penalty in computation time. Results of simulations have shown that on the average, for a modestly sized memotable, about 40 % of the floating point multiplications and 50 % of the floating point divisions, in MultiMedia applications, can be avoided by using the values within the memotable, leading to an average computational speedup of more than 20%.