Two algorithms for maintaining order in a list
STOC '87 Proceedings of the nineteenth annual ACM symposium on Theory of computing
Making data structures persistent
Journal of Computer and System Sciences - 18th Annual ACM Symposium on Theory of Computing (STOC), May 28-30, 1986
Incremental computation via function caching
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Introduction to algorithms
Incremental reduction in the lambda calculus
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
INC: a language for incremental computations
ACM Transactions on Programming Languages and Systems (TOPLAS)
The revised report on the syntactic theories of sequential control and state
Theoretical Computer Science
A categorized bibliography on incremental computation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Parametricity and local variables
Journal of the ACM (JACM)
Analysis and caching of dependencies
Proceedings of the first ACM SIGPLAN international conference on Functional programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
Static caching for incremental computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Caching function calls using precise dependencies
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
An indexed model of recursive types for foundational proof-carrying code
ACM Transactions on Programming Languages and Systems (TOPLAS)
Incremental evaluation for attribute grammars with application to syntax-directed editors
POPL '81 Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Monads for incremental computing
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Optimal-time incremental semantic analysis for syntax-directed editors
POPL '82 Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Observable Properties of Higher Order Functions that Dynamically Create Local Names, or What's new?
MFCS '93 Proceedings of the 18th International Symposium on Mathematical Foundations of Computer Science
Reasoning about local variables with operationally-based logical relations
LICS '96 Proceedings of the 11th Annual IEEE Symposium on Logic in Computer Science
Dynamic Programming
Dynamizing static algorithms, with applications to dynamic trees and history independence
SODA '04 Proceedings of the fifteenth annual ACM-SIAM symposium on Discrete algorithms
A step-indexed model of substructural state
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Small bisimulations for reasoning about higher-order imperative programs
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An experimental analysis of self-adjusting computation
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Adaptive functional programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Kinetic algorithms via self-adjusting computation
ESA'06 Proceedings of the 14th conference on Annual European Symposium - Volume 14
A novel SoC design methodology combining adaptive software and reconfigurable hardware
Proceedings of the 2007 IEEE/ACM international conference on Computer-aided design
A Library for Self-Adjusting Computation
Electronic Notes in Theoretical Computer Science (ENTCS)
A consistent semantics of self-adjusting computation
ESOP'07 Proceedings of the 16th European conference on Programming
Relational reasoning in a nominal semantics for storage
TLCA'05 Proceedings of the 7th international conference on Typed Lambda Calculi and Applications
Relational reasoning for recursive types and references
APLAS'06 Proceedings of the 4th Asian conference on Programming Languages and Systems
Step-Indexed syntactic logical relations for recursive and quantified types
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
Memory management for self-adjusting computation
Proceedings of the 7th international symposium on Memory management
Compiling self-adjusting programs with continuations
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Robust Kinetic Convex Hulls in 3D
ESA '08 Proceedings of the 16th annual European symposium on Algorithms
Caching and incrementalisation in the java query language
Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications
A cost semantics for self-adjusting computation
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Self-adjusting computation: (an overview)
Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
Proceedings of the 4th workshop on Declarative aspects of multicore programming
CEAL: a C-based language for self-adjusting computation
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Lazy Composition of Representations in Java
SC '09 Proceedings of the 8th International Conference on Software Composition
An experimental analysis of self-adjusting computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Partial memoization of concurrency and communication
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Semantic foundations for typed assembly languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
A verified framework for higher-order uncurrying optimizations
Higher-Order and Symbolic Computation
Self-adjusting computation with Delta ML
AFP'08 Proceedings of the 6th international conference on Advanced functional programming
Specifying and implementing refactorings
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Provenance as dependency analysis
Mathematical Structures in Computer Science - Programming Language Interference and Dependence
Type-directed automatic incrementalization
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Efficient patch-based auditing for web application vulnerabilities
OSDI'12 Proceedings of the 10th USENIX conference on Operating Systems Design and Implementation
Streaming big data with self-adjusting computation
DDFP '13 Proceedings of the 2013 workshop on Data driven functional programming
Asynchronous functional reactive programming for GUIs
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Exploring optimization and caching for efficient collection operations
Automated Software Engineering
Warranties for faster strong consistency
NSDI'14 Proceedings of the 11th USENIX Conference on Networked Systems Design and Implementation
Hi-index | 0.00 |
Self-adjusting computation enables writing programs that can automatically and efficiently respond to changes to their data (e.g., inputs). The idea behind the approach is to store all data that can change over time in modifiable references and to let computations construct traces that can drive change propagation. After changes have occurred, change propagation updates the result of the computation by re-evaluating only those expressions that depend on the changed data. Previous approaches to self-adjusting computation require that modifiable references be written at most once during execution---this makes the model applicable only in a purely functional setting. In this paper, we present techniques for imperative self-adjusting computation where modifiable references can be written multiple times. We define a language SAIL (Self-Adjusting Imperative Language) and prove consistency, i.e., that change propagation and from-scratch execution are observationally equivalent. Since SAIL programs are imperative, they can create cyclic data structures. To prove equivalence in the presence of cycles in the store, we formulate and use an untyped, step-indexed logical relation, where step indices are used to ensure well-foundedness. We show that SAIL accepts an asymptotically efficient implementation by presenting algorithms and data structures for its implementation. When the number of operations (reads and writes) per modifiable is bounded by a constant, we show that change propagation becomes as efficient as in the non-imperative case. The general case incurs a slowdown that is logarithmic in the maximum number of such operations. We describe a prototype implementation of SAIL as a Standard ML library.