I haven't been looking at FOC stuff for a while, so asking this if anyone can give some advice: What are the best implementations of interactive UI usage of OOP interfaces? for example I'd envision seeing an object as a box containing a list of methods (and other objects it contains, also as boxes), and being able to click on a method, and having it expand to give me places to drag and drop other objects in, and then turning into another box representing the object it returns. (Specifically I'm interested in making such an interactive UI for an advanced low-level OS interface I've created, mostly as a way to teach the interface)

Pharo and Glamorous Toolkit are pretty good. I'm also fond of the approach you see in game engines like Unity.

That's also an accurate description of my project: https://github.com/d-cook/Interact I also intend for this system to expose its own code through its own UI (including the code for the UI, etc.). This way the whole thing is 100% moldable at any level. The description is out of date (but not far off). I've also used the "Issues" as a dump of all the different approaches I might take with it. I've not had time to work on it in ages, but still plan on finishing it someday.

@Dan Cook that's an interesting project, have you thought of the analogy to application macros, e.g. in vim or emacs? interestingly, in Emacs, you can record a macro by performing actions, and then store it as Elisp code which calls the functions those actions invoked

i will never get tired of posting the self language video in this slack. no one can stop me

@Spencer Baugh - Not specifically, but what I am seeing is that many many things in software are all just variations of recording and replaying actions: Functions, code commits (GIT), SVG, lisp macros (they're just functions of code), app macros, UI forms, audio/video files, build pipelines, automated tests, ... In theory we could replace all of it with plain old function composition. The same could be said of data (aka "homoiconicity"). Even the idea of a "programming language" / compiler is just a function from code to code, and that boundary need not be so hard or all that separate from the thing being built from it (aka "infrastructure as code", i.e. another examine of reifying what something is and how it's made as code aka actions)