The goal is to create a software system that escapes the rigid boundaries of conventional software tools and programming languages by empowering the end-user to create their own experience through direct-manipulation. Everything within the system (including all parts of the system itself) will be composed of "objects" that can be created & modified through a visual interface, and thus everything about the system can be modified while you are using it. (Discuss on forum, or see Motivation further down)
How is this possible?
The "things" in a computer exist only as representations -- in other words, it's all just structured information. Traditionally, everything is stored as raw data without any explicit structure, and each software tool must convert it into a structure that can be viewed or manipulated in some meaningful way. If instead, everything was stored in an explicit structural form to begin with, then you could directly modify everything however you want, rather than only doing what each software tool allows. This structure will consist of "objects" that can be modifed in place and combined to form any ad-hoc structure of information. And since "code" is nothing more than structured information for "what to do" (code is data), this means creating & modifying whatever "things" and behaviors you want.
What will it look like?
All that matters here is that there is any interface to begin with, because the end-user can then manipulate it into whatever they want. This calls for a minimal interface just good enough to allow one to see and manipulate the structure of everything. And by making it a visual interface (GUI), the user's ability to modify it also means that they can create whatever graphical representation or tool that is most ideal for each scenario. For example, editing the size & position of a ball by clicking and dragging a ball, rather than by editing numeric data about a ball (see Brett Victor's "Dynamic Visualizations" and "Learnable Programming").
Implications for Programming
(TO-DO: INSERT EXPLAINATION OF HOW THIS ESCAPES ANY SPECIFIC PROGRAMMING LANGUAGE)
Every operation that can be performed on an object (and thus on any part of the system), is itself stored as an object within the system. Thus, everything that happens within the system -- whether it be from user-interaction or from running code -- is accomplished by triggering one or more of these operations. This dissolves the boundary between "programming" (API) and user-interaction (UI), because the end-user can now do anything that code can do, and vice versa.
(Alan Kay's "Computer revolution hasn't happened yet"; Kay, Engelbart, Alexander all tried to expand human aspects; Brett Victor; programming is generally awful, and a better interface is needed to see enough to do it right. Also, every other software tool other than programming has a better interface than text. Something non-perscriptive, but open-ended and exploratory)
IMPLEMENTATION PLAN / HOW IT WORKS:
Create an interactive UI (visual interface) as the sole means for interacting (as an end-user) with the system. For now, this just provides a generic way to inspect and edit AST objects in a visual interactive fashion. (This requires some "native" code for graphics and user interaction, but all of it is coded into the AST). This voids the need for a REPL, since AST objects to be created, modified, and executed directly in a visual manner.
"Bootstrap" the interpreter by re-coding it as an AST object-graph (like everything else). The intpreter can now be edited entirely in AST form, and then compiled to replace the existing "native" interpreter. (The AST interpreter could also just run on top of the "native" one to test it amid modifications). Now the Entire system is modifiable in AST form.
By creating compilers for other platforms, the entire system can transfer itself to any other environment or machine. And since everything is written in the high-level language of the system, everything from the old system "comes with". In this way, the system becomes capable of transferring itself from platform to platform (and back again) ... Kind of like Ultron :)
HOW TO TEST / USE IT:
- Open a blank tab in your web-browser (enter "about:blank" into the address bar).
- Open the developer console (press F12).
- Copy the contents of Objects.js and paste it into the developer console, and then hit "enter" or click the "run" button.
- Observe the results in the console and on the blank page.
- You can try entering single commands by typing "Test(null, [...])" (where "..." is the code to run) into the console. (After step 3, you should already see some examples that have run in the console).