What are the all-time great projectional / structure editors? I'm particularly interested in: • tight focus on a specific language • really good autocomplete / hinting (ie: type-aware, don't show me unhelpful stuff at all) • pulling far away from the feel/experience of raw text typing, pushing toward "press a button, out comes exactly the program you wanted"

Emacs with paredit for Lisp satisfies the first two points. And it's actually in use by lots of people.

The "all-time" makes me think of Visual Basic. It was theoretically superseded by C# (WinForms, then WPF) but along that way it lost something essential.

Editing on the various Lisp machines was quite good, but not very “modern”

Hmm, the 3rd requirement makes me think of but doesn't directly fit with the wording of the question. IMO, Lisp is the LCD for projectional editing. If you can ask an app to generate some Lisp (Scheme) code, then you're most of the way there - you just need to transmogrify the Lisp code into some other syntactic form (see OhmJS, t2t, etc. :-).

(3) Scratch (and clones - i love Snap! the language, but EX is same) deserves a mention for being demonstrably easy for beginners (incl. beginners taught by beginners :) and good with touch. I'd say the editing experience is low-floor, mid-ceiling at best? There are not many power-user editing moves... (1) Things like costumes have a tight focus e.g. direct lo-fi painting. OTOH tasks like "create 10 sprites" and "cut&paste between sprites" are hard, and feel more like "ad-hoc GUI" than a unified editor, imho a weakness_._ E.g. I dont think you can move a costume to another sprite, only delete and re-create? (2) Builtin library of images & sounds + default values in many places (instead of prompting) all help unlock creativity 👍 (2) Some hinting via dropdowns, shapes (boolean = hexagonal etc.,), not very strong. But the language is designed to be very forgiving, closer to Lisp / Perl not Rust / ML. IMHO part of its success was inverting (1): designing the language to fit the editor, not the other way around! • stdlib sized to discoverably fit in reasonable ~10 palettes. • Forgiving (few errors, at worst error balloon but keeps running) to encourage click-to-execute experimentation. Can even execute inside the palette! • Persistent image: contually running, no state-losing "restart". Green flag convention to code your own initialization. This semantics (A) relives beginners of need to understand process lifetime 💡 (B) blurs the line between programatic actions and editing. E.g. I can directly drag a sprite to where I want it to be, or I can execute a "set opacity 50%" block - and both are on equal footing. => Many properties have no other GUI, the blocks palette doubles as an editing menu! • Block names freely mixing parameters amid text. [compare:Smalltalk or:ObjC names] • Snap! custom blocks have macro-like powers do mimic any block shape, incl. control structures. Also some affordances to add help tooltip and param type hints & defaults. This is great didactic tool for a teacher to add lesson-specific scaffolding. • Concurrent execution semantics match greatly with free-floating code chains with separate on- event trigger "hats" 🥰 . Plus, per-sprite implicit "self" takes advantage of intuitive "visual OOP" to make accessible some concurrent programming that would be genuinely mentally hard in textual languages. This is IMHO scratch's deepest achievement.

Intentsoft but that is lost to the sands of time. Jetbrains MPS which I believe included a pretty good Java structure editor https://en.wikipedia.org/wiki/BlueJ and it’s successor Greenfoot mixed method-level text editing with large-scale structure editing

I shared this originally over on my introduction thread and didn't really get any response or reactions so I thought I'd share it over her too. Basically I came here to this Slack group aftr being heavily inspired by the work of Bret Victor, most especially his Learnable Programming and Media for Thinnking the Unthinkable thought pieces as well and the Humane Representation of Thought. I had been thinking that a Projectional Editor that allows non-programmers to manipulate Abstract Syntax Trees would be integral to realizing Bret Victor's vision for Learnable Programming as well as climbing Up AND Down the Ladder of Abstraction. I recently watched a video interview featuring the developers of the Graphite grpahics editor and the integrated Graphene node graph editor. The Graphene nodes represent Rust functions and the graphs between the nodes represent the dataflows and algorithms that are executed at runtime by the integrated Rust compiler. I realized that the Graphite Editor is essentially already a proectional editor and the developers expressed the goal for it functionality to extend well beyond just 2d graphics. https://graphite.rs/features/#roadmap

When you say "the graphite editor is essentially already a projectional editor", can you say a bit more about what that means? Can you link to anything explaining / showing this editor?

That's up to you mate. If you can't be bothered to watch a video that you can skim through, I don't have much faith you have the patience to engage with it as a projectional editor. So I'd prefer not to waste my own time laying it out for you lol.

I think I misunderstood your first comment. You were describing the vector graphics editor, right? I got confused about graphene vs graphite — this is the first I'm hearing of these projects, and have no frame of reference, so you'll have to forgive me not keeping the names / relationships straight. So I'd thought what you were describing was some sort of visual node editor, that this was the thing that was "essentially already a projectional editor", which piqued my curiosity. I inferred from other parts of your comment that this hypothetical node editor was used to build the vector art tool shown on the website you linked, but I couldn't find any additional detail about anything beneath that art tool. I did skim the video and saw nothing to this effect. I searched the web, read through a few pages, and still found nothing about this. So faced with the potential next step of watching a very long video about a project I know nothing about and am unsure of the relevance of, I asked for clarification. If my comment came across negatively, I'm sorry! I just pecked it out in a hurry while making my daughter lunch (I only have a few fleeting moments to spend looking at the wealth of links shared in this community, sadly). I'm a bit bummed by your reply, but I can imagine how you might have felt, and I understand.

FWIW i've listened to that episode of Developer Voices, it's a good interview discussing how Graphite devs frame it as a language for graphic operations + visual editor. It's a podcast, the youtube version is just talking heads, they don't show the software which is ironically insufficient for this subject :)

I suppose you've already encountered https://github.com/yairchu/awesome-structure-editors, but that's just a big list, so it doesn't answer which is the "all-time greatest". Perhaps check out Lamdu (https://www.lamdu.org/) for some interesting UX ideas in this space (though it seems to still be in the prototype phase).

Haven't! Thanks! Figures there'd be one of those.