"Data Driven UIs, Incrementally" by Yaron Minsky

Any discussion about incremental UI should include Yaron Minsky's talk about Jane Street's OCaml framework, incr_dom from 2016: ▶ this video Incremental is essentially an implementation of Adapton from 2014: [link] There is a big upset coming in the UX world as we converge toward a generalized implementation of the "diff & patch" pattern which underlies Git, React, compiler optimization, scene rendering, and query optimization. Two sleeper startups in this space that are going to make a lot of money are Frank McSherry's Materialize Inc. and Nathan Marz's Red Planet Labs. incr_dom source: [link] Differential Dataflow: [link] Declarative Dataflow Client: [link] Crux adapter for Declarative Dataflow: [link]

in “Moxie: Incremental Declarative UI in Rust” · View on HN

Thank you for sharing the write up. I think the model you are describing, has parallels with Yaron Minksy's Data Driven UIs, incrementally ▶ this video Perhaps if you could review the above (if you have not done already), additional ideas/data points might help with your formalization effort.

in “Towards a unified theory of reactive UI” · View on HN

From what I can tell, incremental computation is starting to be used in practice: Jane St has an OCaml library called Incremental: "Data Driven UIs, Incrementally" by Yaron Minsky at Strange Loop 2018: ▶ this video This talk has a pretty impressive live JS table demo! It looks faster and nicer than most JS UIs I've seen. ----- And the Skip language was developed Facebook. Apparently they started to use it for some production stuff, but somehow they decided against it and spun it out: [link] [link] Julien Verlaguet - Reflex: Reactive Programming at Facebook -- [link] Reflex was an earlier name or earlier incarnation of Skip.

in “Adapton: Programming Language Abstractions for Incremental Computation” · View on HN

The author just gave a talk at Strange Loop [0] that provides a better conceptual overview than the talk linked in the docs. Pretty interesting stuff. [0] ▶ this video

in “Incremental – Library for incremental computations” · View on HN

Very interesting! This somehow seems convergent with the model-level incrementalization approach that incr_dom [1] and its successor bonsai [2] are using. Have you had a chance to compare these? [1]: [link] | ▶ this video [2]: [link]

in “Xilem: An Architecture for UI in Rust” · View on HN

Type-driven development, meta languages, specs, provably correct code, and automatic code generation were some of the big overlapping themes at Strange Loop [1] this year. All the talks posted online this week [2], and I've posted links to some of the related videos below [3]. It's a good indicator that the time has come for an idea when multiple lines of research and projects from disparate domains begin converging on the same idea from different directions. Several facets of the puzzle I've been working the last few years have converged towards this area so it's good to see that it's not just me, maybe that means we're all on the right track. But as 'pron and those who have been working in this area have pointed out [4], this part of the puzzle is not yet solved, and one of the primary open issues is how to scale it to the system level (beyond provably correct programs to provably correct systems). One of the questions I've been pondering is how can we combine provably correct software specs with hardware specs identified for any given system to find the optimal data structures and algorithms given the constraints of that architecture. Does something similar already exist? What's the best software currently out there for simulating ideal data flow for a given hardware configuration and a given set of system constraints? [1] Strange Loop [link] [2] Strange Loop 2018 talks (80 videos) [link] [3] Related videos... * Vellvm - Verifying the LLVM, by Steve Zdancewic [link] * All

in “Type-Driven Program Synthesis [video]” · View on HN