[throwawayoaky]

Treating a document like a 2d text buffer is the root of all evil. Treating a document like a string is even worse. Emacs does both, so does everybody else. The big idea is mapping the doc to a tree of nested structures whose schemas define constraints, which constraints define the editing and viewing semantics of the parts of the tree you're looking at. Also lisp should have won the 70s and we're not done relitigating that. Also he has a 5 year plan to prove this all.

Still deciding if I buy it. only wants 1000 bucks a month to work on it full time, I think exploring the area is worth that at least.

[Syntonicles]

I understand the argument for it, but I can't make heads or tails of the implementation article discussing constraints. How do constraints help us at all? For context, I wrote a graph-based CSP-solver and I'm still completely lost.

I hit page-down 40 times and wasn't even halfway through. I feel like billing $1000 to skim the proposal.

[maydup-nem]

Seems like the argument is in the "Rune" part even more down below. I think it boils down to having specialized editors which you embed, and to a common interface that you may define over that. The point on ambiguity localization is kind of curious too.

I don't think there's an argument to be had for all structures, just that you can do it for each custom structure, and that's the point.

Maybe the editors of the old tried to bite off too much when they attempted embedded structures, and they didn't have the right abstractions in place. If you look at https://tylr.fun it shows that things that weren't being done back then, there are interesting approaches now.

[some-mthfka]

Hey, I just wrote a general reply on structure editing here in this thread, please do check it out. Also, I have added a notice in the article to skip the Fern section, as it's, indeed, probably best left for last, in case you are interested in the platform as a whole. I should have really done that before.

As for constraints and prototype OO: I think those will simply do great for GUI building, and for flexibility. I think you need such abstractions to be able to deal with customization and complexity of embedded structures. I am basing Fern on the Garnet GUI framework [1], which had ~80 projects and was pretty fun to use judging by what people say.

[1] http://www.cs.cmu.edu/~garnet/

[PurpleRamen]

So this is another take on the whole "text as a structure"-idea, where there are so many failed projects already? Hasn't emacs even some packages around this?