This is awesome! I've been working on a projectional lisp editor lately, and I've been thinking how the approach to visualising AST and then transforming it from the UI components could be generalised to handle any type of data/UI - like visual bi-directional lenses - it's great to see something like this alive - can't wait to dig in!

This looks interesting. What I understand so far is how root does does data-driven graphical display. But UIs also require interaction leading to state updates. There is such interaction e.g. in the Notion clone, but I don't see how it works.

Konrad Hinsen look at the top of the source for the notion-clone code. root wraps some data-declared events and dispatches them to a transaction function. You should be able to find it, the source is quite small: only two files, really. root.impl.core and root.impl.resolver contain most of the functionality.

one caveat, I’ve currently disabled the auto-wrapping of event-handlers because it led react to re-render on anonymous handler-fn-redefinitions (no function equality). However, I realized this is easy to fix with: https://github.com/reagent-project/reagent/blob/ea42671d832be77acabe012df6386cd5d34d5ac1/src/reagent/core.cljs#L348-L351

To update on this, I have been using CLion today (it is totally awesome, FWIW). And the feature I mentioned is actually implemented in CLion - they call it 'Search Everywhere', and it is accessible with <SHIFT><SHIFT>. It works exactly like the VC one as far as I can tell.

I love this!! If someone has an open-source project w/ the basics, I’d love to see it!

non-symbolic 3D esolang sounds good. I always struggled with removing text, Horizon's final scripting language was mostly still a text language. I really wanted to add more tools to represent spatial quantities visually (direction, volume, rotation, etc.)

They added some rough block documentation which might give folks a better understanding of the affordances of the language. It's a relatively simple block language inspired by the scratch VM. A lot of features are "missing" on purpose to allow for performance guarantees including lists, loops, etc. I wanted to add bounded loops and had some prototype code for it. It's interesting to see what got added after I left (button presses and string concatenation, apparently) and what I had working that didn't ship. Movement with collision checks, useful for creating character controller like objects, raycasts, shapecasts and overlaps

I understand why they didn't want to ship those however, performance implications can be rough

Documentation is here https://support.oculus.com/723716528207264/

One thing that was added that I persistently said should have a permission system is the ability to get a player's position. Scripts don't run in public spaces like they do in Second Life, but it still gives scripters a lot of ways to abuse players

[moved from top level, originally by @François-René Rideau]

Especially wrt transactional models.

This could be a start? https://link.springer.com/chapter/10.1007/978-3-662-44202-9_13https://link.springer.com/chapter/10.1007/978-3-662-44202-9_13

Instant pickles: generating object-oriented pickler combinators for fast and extensible serialization https://dl.acm.org/doi/abs/10.1145/2509136.2509547

the references on this paper look interesting https://dl.acm.org/doi/10.1145/174675.178047

Unsurprisingly, Oleg has some prior art in this area:

http://okmij.org/ftp/continuations/#shift-cgi

Pickling and unpickling isn't enough unless you also reify continuations so they are (un)picklable.

Similarly, delimited control isn't enough unless it's also picklable.

I know some prior art in the Scheme, Smalltalk and CL communities on serializing continuations, though I'm not sure how they handled transactionality.

But thanks for all the links. I'll read and re-read.

@François-René Rideau From the linked paper: "The captured delimited continuations can be stored on disk, to be later loaded and resumed in a different process." 🙂

Doing it is harder than saying it. Issues like how to represent closures, and how to hack your compiler to generate those serializable representations, etc.

there was a pretty practical explanation complete with working code on how to serialize clojure functions in this article: https://tech.redplanetlabs.com/2020/01/06/serializing-and-deserializing-clojure-fns-with-nippy/

If your continuations are "just functions" perhaps it is relevant 🙂 Seems like a hard problem

@François-René Rideau Of course! I just wanted to be clear that I was pointing you to actual prior art on persisting continuations and not merely a general resource about delimcc. When I've done this in the past, I've had to handroll it every time. How hard it is to make it work efficiently depends how much access you have to the innards of your runtime, obviously. Are you doing this with Gerbil?

Yes doing this with Gerbil.

More like, building the runtime and compiler in Gerbil my own language on top, probably.

Is this close to defunctionalization?

Jack Rusher it is indeed an understatement, but that is a major part of why this project is interesting to me.

Computers haven't had the impact on maths/physics we might think they should have. Most "naievly", one might have said, in 1960: "computers have incredible raw computing power. They will surely outperform mathematicians and physicists with mathematical breakthroughs". But the Poincare conjecture, Fermat's last theorem, and the superstring revolutions were (?) all old-school no-computer maths. People are now talking about AI revolutionizing maths and physics, and maybe that'll happen, but it hasn't happened yet.

With that in the background, consider the following question: "Why do people not use GA?" The answer is not mathematical; the mathematical breakthroughs that should have convinced people to adopt it have already happened. The gap is "soft", i.e. it's in the domain of psychology (or even philosophy if you like Charles Gunn). That creates a "cultural" challenge, and you are precisely right that getting cultural change is hard (certainly harder than "hey, here's algorithm X, it is 30% faster than algorithm Y). I think most people who understand the issue agree that this is the case. It's a hard problem, and it's an important one too, because GA really is a lot better than vector algebra.

Alright, we've got two questions: "can computers actually change physics?" and "what needs to be done to bring about the revolution in physics that is GA's destiny?". And I'm betting my farm on the idea that the first is the answer to the second. That with computer visualization and a well-thought-out "coding" "environment" (mathland!), you can get exactly the cognitive revolution/cultural change you want in physics. To me, everything said by our great "philosophers of computer visualization and psychology", i.e. Alan Kay, Seymour Papert, Bret Victor and Jonathan Blow, can be applied quite well to propagating GA.

But to be clear, I was interested in Blow/Victor/Papert before I was interested in GA. I might almost (almost) say that I am not, as such, interested in GA 😄 the main thing I am interested in is proving that computers visualization can revolutionize physics. So, yes, it's a challenge, and that's the point. If it works, nobody will be able to deny the power of the Papertian program.

Hamish Todd You might get in touch with physicist-turned-programmer Sam Ritchie, who has ported Sussman and Wisdom's SICM to our Maria.cloud environment with an eye toward better physics pedagogy:

https://twitter.com/sritchie/status/1299093958904160257?s=20

He has some grant money on offer for writing curriculum and such, might be able to help you in your mission. 🙂

Thank you very much for this!

Think you might have hung around here, but sharing this ICYMI: https://bivector.net/doc.html

oo we kept talking about building something like this at my last job (I used to work for an online learning platform focused on data science and we taught pandas a lot)

we wanted to help lower the ramp from “I can’t code” -> “pandas”

but this is neat b/c so much of databases, spreadsheets, and pandas dataframes are just simple groupbys, counts, etc

we have the same ideas & transforms repeated everywhere / inevery tool!

I haven’t tried them yet but 2 peer products in this space (some form of GUI wrapper around data ops that lets you export the generated code are https://bamboolib.8080labs.com/ for Python and https://exploratory.io/ for R). I like their focus on the familiar spreadsheet metaphor. I’m reminded of the google

I haven’t done a head to head comparison of this type of tool, so I’m hoping this post gets them some early users + surfaces related projects people have heard of/and or presently find useful.

Separately, I’m hoping to see more of these visual abstraction tools let people edit some underlying generated code with more options that may not necessarily be exposed/inferred - I see the google sheets “smart fill” feature’s decision to let users edit the generated formula as a good step in that direction. https://9to5google.com/2020/06/30/google-sheets-smart-fill/

Nice! Around 30 years ago there was a movement called https://en.wikipedia.org/wiki/Programming_by_example (PBE) that tried to find a generalization of this pattern for a variety of programming tasks. I'd love to see people revisit that work with modern compute power and neural network architectures. (An early 90s history of the word can be found http://acypher.com/wwid/WWIDToC.html, a sequel by a different researcher http://web.media.mit.edu/~lieber/Your-Wish/. Many familiar names contributed essays: Larry Tesler, Brad Myers, &c.)

Off-topic Joshua Horowitz, but I just watched your demo video for PANE and thought it was fantastic. Very thought provoking.

Thanks @larry! I appreciate the kind words. 🙂