
Adapton: Programming Language Abstractions for Incremental Computation - jxub
http://adapton.org/
======
kibwen
Neat, I didn't know that the new reference implementation was in Rust. It's
interesting because the Rust compiler developers are themselves writing a
framework for incremental computation, inspired by Adapton, for use in the
compiler itself:
[https://github.com/nikomatsakis/salsa](https://github.com/nikomatsakis/salsa)
(note: WIP)

------
nixpulvis
I've been aware of this kind of thing before, but never really looked into it.
This is pretty interesting, and the Rust docs are pretty good at stepping
through it. Rust specifically can have difficulty with cyclic data, and it
seems this could help with that, though it's bypassing the lifetime analysis
of the type system.

Two thoughts of the top of my head (I haven't yet read any of the literature):

1) how is/could rust's lifetime analysis be applied to these ideas
productively.

2) I wonder if you could map some predefined _names_, or something inside the
system to physical caches or hardware structures.

------
aldanor
Somewhat related and also Rust - I’ve recently put together a crate for frp-
like computation (in terms of streams and all that, but the use case is
somewhat close to adapton, although simpler), for my own use but then figured
I’d share it because why not - [https://github.com/aldanor/reactive-
rs](https://github.com/aldanor/reactive-rs)

------
amelius
I know there has been some research in this area over the decades, but I'm
wondering: how practical is this approach nowadays?

~~~
bcherny
I’m not sure how practical this kind of generalized approach is, but notice
how incremental computation is already all around you: in your build system,
in the way React recomputes its tree and your browser recomputes layout, in
any pull-based protocol where the server keeps state.

~~~
EvilTerran
In spreadsheets, too!

------
nurettin
How is this any different than plain old memoization?

~~~
gnulinux
Memoization is one specific strategy to implement an incremental algorithm.
E.g. ML style on input 1 train and predict, on input N only predict wouldn't
be memoization, but it'd be incremental (in most cases, i.e. when training is
more computationally intensive than prediction). In other words, memoization
is a subset of incremental computation.

