Results 11 - 20
of
24
An Optimizing Compiler for Lexically Scoped Lisp
- In Proceedings of the SIGPLAN '82 Symposium on Compiler Construction
, 1982
"... 1 ..."
A Probabilistic Approach to the Problem of Automatic Selection of Data Representations
- In Proceedings of the 1996 ACM SIGPLAN International Conference on Functional Programming
, 1996
"... The design and implementation of efficient aggregate data structures has been an important issue in functional programming. It is not clear how to select a good representation for an aggregate when access patterns to the aggregate are highly variant, or even unpredictable. Previous approaches rely o ..."
Abstract
-
Cited by 6 (3 self)
- Add to MetaCart
The design and implementation of efficient aggregate data structures has been an important issue in functional programming. It is not clear how to select a good representation for an aggregate when access patterns to the aggregate are highly variant, or even unpredictable. Previous approaches rely on compile--time analyses or programmer annotations. These methods can be unreliable because they try to predict program behaviors before they are executed. We propose a probabilistic approach, which is based on Markov processes, for automatic selection of data representations. The selection is modeled as a random process moving in a graph with weighted edges. The proposed approach employs coin tossing at run--time to aid choosing suitable data representations. The transition probability function used by the coin tossing is constructed in a simple and common way from a measured cost function. We show that, under this setting, random selection of data representations can be quite effective. Th...
Fully Persistent Arrays for Efficient Incremental Updates and Voluminous Reads
- 4th European Symposium on Programming
, 1992
"... The array update problem in a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. We devise a very simple, fully persistent data structure to tackle this problem such that ..."
Abstract
-
Cited by 5 (2 self)
- Add to MetaCart
The array update problem in a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. We devise a very simple, fully persistent data structure to tackle this problem such that ffl each incremental update costs O(1) worst--case time, ffl a voluminous sequence of r reads cost in total O(r) amortized time, and ffl the data structure use O(n + u) space, where n is the size of the array and u is the total number of updates. A sequence of r reads is voluminous if r is \Omega\Gamma n) and the sequence of arrays being read forms a path of length O(r) in the version tree. A voluminous sequence of reads may be mixed with updates without affecting either the performance of reads or updates. An immediate consequence of the above result is that if a functional program is single--threaded, then the data structure provides a simple and efficient implementation of funct...
A Randomized Implementation of Multiple Functional Arrays
- In Proceedings of 1994 ACM Conference on Lisp and Functional Programming
, 1994
"... The array update problem in the implementation of a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. Previous approaches have mainly based on the detection or enforcement o ..."
Abstract
-
Cited by 5 (1 self)
- Add to MetaCart
The array update problem in the implementation of a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. Previous approaches have mainly based on the detection or enforcement of single--threaded accesses to an aggregate, by means of compiler--time analyses or language restrictions. These approaches cannot deal with aggregates which are updated in a multi--threaded manner. Baker's shallow binding scheme can be used to implement multi--threaded functional arrays. His scheme, however, can be very expensive if there are repeated alternations between long binding paths. We design a scheme that fragments binding paths randomly. The randomization scheme is on--line, simple to implement, and its expected performance comparable to that of the optimal off--line solutions. All this is achieved without using compiler--time analyses, and without restricting the languages. The ...
The Buried Binding and Dead Binding Problems of Lisp 1.5: Sources of Incomparability in Garbage Collector Measurements
, 1976
"... Lisp has become the language of choice for many applications such as artificial intelligence programs or symbol manipulation. The original implementation of Lisp 1.5 was a concise, elegant statement of the semantics of the language. Although production Lisp systems have undergone significant develop ..."
Abstract
-
Cited by 3 (1 self)
- Add to MetaCart
Lisp has become the language of choice for many applications such as artificial intelligence programs or symbol manipulation. The original implementation of Lisp 1.5 was a concise, elegant statement of the semantics of the language. Although production Lisp systems have undergone significant development and evolution since Lisp 1.5, including the development of sophisticated compilers, there have been few significant theoretical improvements in the implementations of these systems. Most improvements, such as arrays or shallow-binding, have been made more for the sake of speed than for the sake of storage. A notable exception to this is the technique of tail recursion, which can save more than just stack space. We believe that more can be done to reduce the storage requirements of Lisp programs. Although in many instances, the Lisp programmer can reduce the storage requirements of his program by deleting unneeded pointers as soon as possible, there is nothing he can do about systematic ...
Metacircular Semantics for Common Lisp Special Forms
- ACM Lisp Pointers V,4 (Oct-Dec
, 1992
"... this paper. In short, the choice of which "macros" are "special forms" is just as arbitrary as the choice of a axes in a coordinate system for the Cartesian X-Y plane---e.g., some sets of macros are "linearly independent", and some sets of macros "span" the space of special forms. Some of our emulat ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
this paper. In short, the choice of which "macros" are "special forms" is just as arbitrary as the choice of a axes in a coordinate system for the Cartesian X-Y plane---e.g., some sets of macros are "linearly independent", and some sets of macros "span" the space of special forms. Some of our emulations may only be approximate, in the sense that certain syntactic variations are not supported, and certain error conditions are not recognized. These emulations are meant to be only a starting point for a serious effort in pinning down the semantics of Common Lisp, and significant additional effort will be required to complete this task.
Hash Tables in Logic Programming
- Logic Programming --- Proc. Fourth Intl. Conf
, 1987
"... The paper discusses different aspects of hash tables as a data structure in a Horn clause language such as Prolog, e.g., semantics, implementation and applications. Hash tables are a new concept in Prolog since they can not be efficiently implemented in the language itself. We give informal semantic ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
The paper discusses different aspects of hash tables as a data structure in a Horn clause language such as Prolog, e.g., semantics, implementation and applications. Hash tables are a new concept in Prolog since they can not be efficiently implemented in the language itself. We give informal semantics for hash tables as partial functions on logical terms. We are careful to ensure that we can represent the hash tables as logical terms in order to make the ordinary syntactic unification apply. The implementation is a generalisation of the method suggested by Eriksson and Rayner. Their "mutable arrays" are a special case of our multiple version hash tables. The implementation has been used in Tricia, an implementation of Prolog developed at Uppsala University. Hash tables open application areas previously beyond the efficiency limits of Prolog. Application programs taking great benefit from the hash tables have been written in Tricia. An earlier version of this paper was presented at the 4...
Higher-Order Code Splicing
- Proceedings of the Eighth European Symposium on Programming, number 1576 in Lecture
, 1999
"... . Run-time code generation (RTCG) and just-in-time compilation (JIT) are features of modern programming systems to strike the balance between generality and efficiency. Since RTCG and JIT techniques are not portable and notoriously hard to implement, we propose code splicing as an alternative fo ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
. Run-time code generation (RTCG) and just-in-time compilation (JIT) are features of modern programming systems to strike the balance between generality and efficiency. Since RTCG and JIT techniques are not portable and notoriously hard to implement, we propose code splicing as an alternative for dynamically-typed higher-order programming languages. Code splicing combines precompiled pieces of code using higher-order functions. While this approach cannot achieve the performance of compiled code, it can support some intriguing features: -- very fast "compilation" times; -- satisfactory run times, compared with interpretation; -- simple interfacing with compiled code; -- portability. Starting from implementation models for functional languages we develop and evaluate several approaches to code splicing. This leads to some new insights into compilation techniques for functional programming languages, among them a compositional compilation schema to SKI-combinators. The pro...
Marcottage: A Navigational Approach to Object Networks
"... te is preserved, and information is copied only as needed to maintain this illusion. This incremental change operation is useful, for example, in making private annotations to hypermedia networks, counterfactuals in knowledge bases, or incremental redisplay algorithms in computer graphics. 2 Marcot ..."
Abstract
- Add to MetaCart
te is preserved, and information is copied only as needed to maintain this illusion. This incremental change operation is useful, for example, in making private annotations to hypermedia networks, counterfactuals in knowledge bases, or incremental redisplay algorithms in computer graphics. 2 Marcotte: A part of a plant capable of regenerating missing parts, thus propagating a new plant capable of independent growth. from the French Botanical Dictionary Two possibilities for the representation of movement: Move the focus or move the context? Suppose you are driving a car through the streets of a city. Consider two different representations of the movement of the car through the city. The first representation is a map of the city, a static network of connections between streets. The itinerary of the car could be represented by a moving point indicating the instantaneous position of the car at every moment. The other representation is what the driver sees t
Breaking the Complexity Barrier of Pure Functional Programs with Impure Data Structures
"... Abstract. Pure functional programming language offer many advantages over impure languages. Unfortunately, the absence of destructive update, imposes a complexity barrier. In imperative languages, there are algorithms and data structures with better complexity. We present our project for combining e ..."
Abstract
- Add to MetaCart
Abstract. Pure functional programming language offer many advantages over impure languages. Unfortunately, the absence of destructive update, imposes a complexity barrier. In imperative languages, there are algorithms and data structures with better complexity. We present our project for combining existing program transformation techniques to transform inefficient pure data structures into impure ones with better complexity. As a consequence, the programmer is not exposed to the impurity and retains the advantages of purity. 1

