Movitz and Cells could rule the world if...

[Anti Vigilante]

I have become disgustipated by the way computers work. I'm not going to
get into details. I just want to mention what the next revolution or
rather renaissance ought to be courtesy of Color Forth, Movitz Lisp
machines, and a new memory architecture.

The first step that I think is necessary has already been put forth by
um... FORTH!; particularly Color Forth. Read, define, and compile are
separated. The domination of executable code over the majority of RAM is
over.

The computer is truly yours under Color Forth because source code is
king and the executable is the beast of burden. But it's a postfix stack
machine which needs all sorts of utility functions which obscure the
structure of a program.

The second step solves these issues with the switch to prefix notation
and the introduction of lists. Lisp lists could provide a front end for
the madness Forthers have to endure tweaking the stack. Forth is truly a
kind of assembly language for an imaginary generic unlimited CPU.

But lisp lives inside a monolithic environment which loads an image and
other smaller images. How do we make Lisp the system? Movitz! Boot and
go! The control offered by Color Forth with the beauty of lists rather
than Forth's Klein bottles.

The final step is compiling a shell of a function rather than the final
code. Rather than compiling to bytecode or bare metal machine what one
compiles is configurable shells. These shells are run by loading
arguments or functions or objects and then applying the shells to them
with the possibility of applying shell over shell.

This would involve allocating RAM for the source code and for executable
code as well a kind of holding space where both can exist. When the
system compiles an application it is not limited to the original
structure of the program. If two programs are nearly equivalent they
should compile to nearly the same shell code. Perhaps the holding space
could simply be patches to nearly similar code. These could be preloaded
as code execution approaches the relevant lines.

The final result is to bring about the marriage of these two giants. I
want source code to be dominant while having Lisp be the language at the
bottom. And heck if we need some kind of Forth at the hardware interface
it's a welcome solution. I would suggest REBOL, but it's not semantics
and syntax I want to focus on. I want to have control of my system to
the maximum extent possible.