Implicit self-adjusting computation for purely functional programs

Abstract

Computational problems that involve dynamic data, such as physics simulations and program development environments, have been an important subject of study in programming languages. Building on this work, recent advances in self-adjusting computation have developed techniques that enable programs to respond automatically and efficiently to dynamic changes in their inputs. Self-adjusting programs have been shown to be efficient for a reasonably broad range of problems, but the approach still requires an explicit programming style, where the programmer must use specific monadic types and primitives to identify, create, and operate on data that can change over time. We describe techniques for automatically translating purely functional programs into self-adjusting programs. In this implicit approach, the programmer need only annotate the (top-level) input types of the programs to be translated. Type inference finds all other types, and a type-directed translation rewrites the source program into an explicitly self-adjusting target program. The type system is related to information-flow type systems and enjoys decidable type inference via constraint solving. We prove that the translation outputs well- typed self-adjusting programs and preserves the source program's input–output behavior, guaranteeing that translated programs respond correctly to all changes to their data. Using a cost semantics, we also prove that the translation preserves the asymptotic complexity of the source program.

An extensible approach to implicit incremental model analyses

“…NMF reuses the notification API that is common in the .NET platform, available through the interfaces INotifyPropertyChanged and INotifyCol-lectionChanged. 9 Because the implementation only uses these two interfaces, it can also be used with model classes that are not generated from a metamodel but written directly. 10 In the formalization, we considered DDG nodes immutable as components of I.…”

“…Dynamic dependency graphs consume a lot of memory and are the main reason why incremental computation has a large memory overhead. Therefore, approaches like the implicit self-adjusting computation by Chen et al [9] argue that constant operations that do not change their value should not go into the functor since they unnecessarily increase the size of the DDG. To solve this problem, their approach generates methods for each combination of an incremental value 15 and constant value.…”

“…This process is transparent to the analysis developer since no changes to the analysis are required. Such systems exist either for general-purpose languages capable of expressing any analysis [9] or for specific classes of analyses such as incremental queries [10,11], incremental pattern matching [12] or even incremental model transformations [13,14]. These specialized incremental approaches limit their applicability to a given class of analyses and use abstractions common to these analyses to make incremental execution more efficient.…”

“…General-purpose incrementalization systems such as the type-directed self-adjusting computation system [9] or Adapton [15,16] typically operate on a Turing-complete calculus (such as the λ-calculus) and are thus able to incrementalize any analysis. To do that, a dynamic dependency graph (DDG) is deduced from the execution of the running analysis.…”

Efficient Parallel Self-Adjusting Computation

“…Self-adjusting computation has also been extended in several directions. Notable works include work on "on-demand" updates with Adapton [32], the CEAL language [30,31], and automatic derivation of self-adjusting programs via information-flow type systems [22,23].…”