Incremental graph evaluation (attribute grammar)
Incremental graph evaluation (attribute grammar)
Incremental computation via function caching
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A categorized bibliography on incremental computation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Analysis and caching of dependencies
Proceedings of the first ACM SIGPLAN international conference on Functional programming
The SLam calculus: programming with secrecy and integrity
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Term rewriting and all that
JFlow: practical mostly-static information flow control
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Caching function calls using precise dependencies
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
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
Algorithmic issues in modeling motion
ACM Computing Surveys (CSUR)
Information flow inference for ML
ACM Transactions on Programming Languages and Systems (TOPLAS)
Shrinking lambda expressions in linear time
Journal of Functional Programming
Experimental analysis of dynamic all pairs shortest path algorithms
SODA '04 Proceedings of the fifteenth annual ACM-SIAM symposium on Discrete algorithms
A monadic analysis of information flow security with mutable state
Journal of Functional Programming
Adaptive functional programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
A proposal for parallel self-adjusting computation
Proceedings of the 2007 workshop on Declarative aspects of multicore programming
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Imperative self-adjusting computation
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
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
CEAL: a C-based language for self-adjusting computation
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
An experimental analysis of self-adjusting computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Dynamic well-spaced point sets
Proceedings of the twenty-sixth annual symposium on Computational geometry
Parallelism in dynamic well-spaced point sets
Proceedings of the twenty-third annual ACM symposium on Parallelism in algorithms and architectures
EnerJ: approximate data types for safe and general low-power computation
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Lightweight monadic programming in ML
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
Implicit self-adjusting computation for purely functional programs
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
Incoop: MapReduce for incremental computations
Proceedings of the 2nd ACM Symposium on Cloud Computing
Two for the price of one: a model for parallel and incremental computation
Proceedings of the 2011 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
Language-based information-flow security
IEEE Journal on Selected Areas in Communications
Streaming big data with self-adjusting computation
DDFP '13 Proceedings of the 2013 workshop on Data driven functional programming
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Lazy incremental computation for efficient scene graph rendering
Proceedings of the 5th High-Performance Graphics Conference
Lazy stateless incremental evaluation machinery for attribute grammars
Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program Manipulation
Hi-index | 0.00 |
Application data often changes slowly or incrementally over time. Since incremental changes to input often result in only small changes in output, it is often feasible to respond to such changes asymptotically more efficiently than by re-running the whole computation. Traditionally, realizing such asymptotic efficiency improvements requires designing problem-specific algorithms known as dynamic or incremental algorithms, which are often significantly more complicated than conventional algorithms to design, analyze, implement, and use. A long-standing open problem is to develop techniques that automatically transform conventional programs so that they correctly and efficiently respond to incremental changes. In this paper, we describe a significant step towards solving the problem of automatic incrementalization: a programming language and a compiler that can, given a few type annotations describing what can change over time, compile a conventional program that assumes its data to be static (unchanging over time) to an incremental program. Based on recent advances in self-adjusting computation, including a theoretical proposal for translating purely functional programs to self-adjusting programs, we develop techniques for translating conventional Standard ML programs to self-adjusting programs. By extending the Standard ML language, we design a fully featured programming language with higher-order features, a module system, and a powerful type system, and implement a compiler for this language. The resulting programming language, LML, enables translating conventional programs decorated with simple type annotations into incremental programs that can respond to changes in their data correctly and efficiently. We evaluate the effectiveness of our approach by considering a range of benchmarks involving lists, vectors, and matrices, as well as a ray tracer. For these benchmarks, our compiler incrementalizes existing code with only trivial amounts of annotation. The resulting programs are often asymptotically more efficient, leading to orders of magnitude speedups in practice.