Results 1  10
of
15
Imperative selfadjusting computation
 In POPL ’08: Proceedings of the 35th annual ACM SIGPLANSIGACT symposium on Principles of programming languages
, 2008
"... Recent work on selfadjusting computation showed how to systematically write programs that respond efficiently to incremental changes in their inputs. The idea is to represent changeable data using modifiable references, i.e., a special data structure that keeps track of dependencies between read an ..."
Abstract

Cited by 28 (16 self)
 Add to MetaCart
Recent work on selfadjusting computation showed how to systematically write programs that respond efficiently to incremental changes in their inputs. The idea is to represent changeable data using modifiable references, i.e., a special data structure that keeps track of dependencies between read and writeoperations, and to let computations construct traces that later, after changes have occurred, can drive a change propagation algorithm. The approach has been shown to be effective for a variety of algorithmic problems, including some for which adhoc solutions had previously remained elusive. All previous work on selfadjusting computation, however, relied on a purely functional programming model. In this paper, we show that it is possible to remove this limitation and support modifiable references that can be written multiple times. We formalize this using a language AIL for which we define evaluation and changepropagation semantics. AIL closely resembles a traditional higherorder imperative programming language. For AIL we state and prove consistency, i.e., the property that although the semantics is inherently nondeterministic, different evaluation paths will still give observationally equivalent results. In the imperative setting where pointer graphs in the store can form cycles, our previous proof techniques do not apply. Instead, we make use of a novel form of a stepindexed logical relation that handles modifiable references. We show that AIL can be realized efficiently by describing implementation strategies whose overhead is provably constanttime per primitive. When the number of reads and writes per modifiable is bounded by a constant, we can show that change propagation becomes as efficient as it was in the pure case. The general case incurs a slowdown that is logarithmic in the maximum number of such operations. We use DFS and related algorithms on graphs as our running examples and prove that they respond to insertions and deletions of edges efficiently. 1.
The Expressive Power of Higherorder Types or, Life without CONS
, 2001
"... Compare firstorder functional programs with higherorder programs allowing functions as function parameters. Can the the first program class solve fewer problems than the second? The answer is no: both classes are Turing complete, meaning that they can compute all partial recursive functions. In pa ..."
Abstract

Cited by 24 (1 self)
 Add to MetaCart
Compare firstorder functional programs with higherorder programs allowing functions as function parameters. Can the the first program class solve fewer problems than the second? The answer is no: both classes are Turing complete, meaning that they can compute all partial recursive functions. In particular, higherorder values may be firstorder simulated by use of the list constructor ‘cons’ to build function closures. This paper uses complexity theory to prove some expressivity results about small programming languages that are less than Turing complete. Complexity classes of decision problems are used to characterize the expressive power of functional programming language features. An example: secondorder programs are more powerful than firstorder, since a function f of type [Bool]〉Bool is computable by a consfree firstorder functional program if and only if f is in PTIME, whereas f is computable by a consfree secondorder program if and only if f is in EXPTIME. Exact characterizations are given for those problems of type [Bool]〉Bool solvable by programs with several combinations of operations on data: presence or absence of constructors; the order of data values: 0, 1, or higher; and program control structures: general recursion, tail recursion, primitive recursion.
Lazy rewriting on eager machinery
 ACM Transactions on Programming Languages and Systems
, 2000
"... The article introduces a novel notion of lazy rewriting. By annotating argument positions as lazy, redundant rewrite steps are avoided, and the termination behaviour of a term rewriting system can be improved. Some transformations of rewrite rules enable an implementation using the same primitives a ..."
Abstract

Cited by 23 (1 self)
 Add to MetaCart
The article introduces a novel notion of lazy rewriting. By annotating argument positions as lazy, redundant rewrite steps are avoided, and the termination behaviour of a term rewriting system can be improved. Some transformations of rewrite rules enable an implementation using the same primitives as an implementation of eager rewriting. 1
The Complexity of Satisfiability Problems: Refining Schaefer’s Theorem
 J. COMPUT. SYS. SCI
"... ... problem for a given constraint language is either in P or is NPcomplete, and identified all tractable cases. Schaefer’s dichotomy theorem actually shows that there are at most two constraint satisfaction problems, up to polynomialtime isomorphism (and these isomorphism types are distinct if and ..."
Abstract

Cited by 17 (7 self)
 Add to MetaCart
... problem for a given constraint language is either in P or is NPcomplete, and identified all tractable cases. Schaefer’s dichotomy theorem actually shows that there are at most two constraint satisfaction problems, up to polynomialtime isomorphism (and these isomorphism types are distinct if and only if P ̸ = NP). We show that if one considers AC 0 isomorphisms, then there are exactly six isomorphism types (assuming that the complexity classes NP, P, ⊕L, NL, and L are all distinct). A similar classification holds for quantified constraint satisfaction problems.
On the Complexity of OrParallelism
, 1999
"... We formalize the implementation mechanisms required to support orparallel execution of logic programs in terms of operations on dynamic data structures. Upper and lower bounds are derived, in terms of the number of operations n performed on the data structure, for the problem of guaranteeing correc ..."
Abstract

Cited by 9 (9 self)
 Add to MetaCart
We formalize the implementation mechanisms required to support orparallel execution of logic programs in terms of operations on dynamic data structures. Upper and lower bounds are derived, in terms of the number of operations n performed on the data structure, for the problem of guaranteeing correct semantics during orparallel execution. The lower bound \Omega\Gammand n) formally proves the impossibility of achieving an ideal implementation (i.e., parallel implementation with constant time overhead per operation). We also derive an upper bound of ~ O( 3 p n) per operation for orparallel execution. This upper bound is far better than what has been achieved in the existing orparallel systems and indicates that faster implementations may be feasible.
Realtime Garbage Collection of a Functional Persistent Heap
, 1999
"... Traditional database management systems perform updatesinplace and use logs and periodic checkpointing to efficiently achieve atomicity and durability. In this Thesis we shall present a different method, Shades, for achieving atomicity and durability using a copyonwrite policy instead of updates ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Traditional database management systems perform updatesinplace and use logs and periodic checkpointing to efficiently achieve atomicity and durability. In this Thesis we shall present a different method, Shades, for achieving atomicity and durability using a copyonwrite policy instead of updatesinplace. We shall also present index structures and the implementation of Shines, a persistent functional programming language, built on top of Shades. Shades includes realtime generational garbage collection. Realtimeness is achieved by collecting only a small part, a generation, of the database at a time. Contrary to previously presented persistent garbage collection algorithms, Shades has no need to maintain metadata (remembered sets) of intrageneration pointers on disk since the metadata can be reconstructed during recovery. This considerably reduces the amount of disk writing. In conjunction with aggressive commit grouping, efficient index structures, a design specialized to a main memory environment, and a carefully crafted implementation of Shines, we have achieved surprisingly high performance, handsomely beating commercial database management systems.
A Functional Language for Logarithmic Space
 In APLAS
, 2004
"... More than being just a tool for expressing algorithms, a welldesigned programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore of importance to understand how such choices effe ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
More than being just a tool for expressing algorithms, a welldesigned programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore of importance to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a firstorder function algebra BC # that captures exactly LF, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. Moreover, it can be useful for the automatic analysis of programs' resource usage and the separation of complexity classes. The important technical features of BC # are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (courseofvalue recursion). Unlike formulations LF via Turin Machines, BC # makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LFcomputable functions (not just predicates). The proof that all BC #programs can be evaluated in LF is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.
Expressive Power of Declarative Programming Languages
, 1998
"... The thesis investigates several aspects of the expressive power of declarative programming languages. There seems to be no widely accepted definition of expressive power of programming languages. In the literature expressiveness may mean power to describe algorithms, or to describe computations, or ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
The thesis investigates several aspects of the expressive power of declarative programming languages. There seems to be no widely accepted definition of expressive power of programming languages. In the literature expressiveness may mean power to describe algorithms, or to describe computations, or to check types, etc. Presenting a clearer idea of the expressiveness of programming languages is a part of the aim of the research. We concentrate on the expressive power of declarative languages because these languages are at the highest level of abstraction. People argue about relative expressiveness between declarative languages. Besides, there are two declarative paradigms: logic and functional programming. How can we define and compare expressive power of languages belonging to these two different paradigms ? In order to compare expressive power of logic and functional languages, several translation schemes from subsets of Prolog to Haskell are defined. During the translation we aim to ...
Confluently Persistent Tries for Efficient Version Control
"... Abstract. We consider a datastructural problem motivated by version control of a hierarchical directory structure in a system like Subversion. The model is that directories and files can be moved and copied between two arbitrary versions in addition to being added or removed in an arbitrary version ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. We consider a datastructural problem motivated by version control of a hierarchical directory structure in a system like Subversion. The model is that directories and files can be moved and copied between two arbitrary versions in addition to being added or removed in an arbitrary version. Equivalently, we wish to maintain a confluently persistent trie (where internal nodes represent directories, leaves represent files, and edge labels represent path names), subject to copying a subtree between two arbitrary versions, adding a new child to an existing node, and deleting an existing subtree in an arbitrary version. Our first data structure represents an nnode degree ∆ trie with O(1) “fingers ” in each version while supporting finger movement (navigation) and modifications near the fingers (including subtree copy) in O(lg ∆) time and space per operation. This data structure is essentially a localitysensitive version of the standard practice—path copying— costing O(d lg ∆) time and space for modification of a node at depth d, which is expensive when performing many deep but nearby updates. Our second data structure supporting finger movement in O(lg ∆) time and no space, while modifications take O(lg n) time and space. This data structure is substantially faster for deep updates, i.e., unbalanced tries. Both of these data structures are functional, which is a stronger property than confluent persistence. Without this stronger property, we show how both data structures can be sped up to support movement in O(lg lg ∆), which is essentially optimal. Along the way, we present a general technique for global rebuilding of fully persistent data structures, which is nontrivial because amortization and persistence do not usually mix. In particular, this technique improves the best previous result for fully persistent arrays and obtains the first efficient fully persistent hash table. 1
Numerical Representations as Purely Functional Data Structures: a New Approach
, 2001
"... Abstract. This paper is concerned with design, implementation and verification of persistent purely functional data structures which are motivated by the representation of natural numbers using positional number systems. A new implementation of randomaccess list based on redundant segmented binary ..."
Abstract
 Add to MetaCart
Abstract. This paper is concerned with design, implementation and verification of persistent purely functional data structures which are motivated by the representation of natural numbers using positional number systems. A new implementation of randomaccess list based on redundant segmented binary numbers is described. It uses 4 digits and an invariant which guarantees constant worstcase bounds for cons, head, and tail list operations as well as logarithmic time for lookup and update. The relationship of randomaccess list with positional number system is formalized and benefits of this analogy are demonstrated. Key words: data structures, purely functional language, randomaccesss list, program derivation, recursive slowdown. 1.