4 ms·

This seems relevant to my open ended curiosity around the question 'what is the irreducible form of compute?' I've been thinking of solving it with Forth, as w

This seems relevant to my open ended curiosity around the question 'what is the irreducible form of compute?' I've been thinking of solving it with Forth, as well, coincidentally. I basically want to build a bootstrappable Forth as a meta-transpiler over a Forth VM that initially starts out in the earliest stage as the most minimum possible representation and add from there. In my research things that led to this being possible but I haven't sussed out: 1. Mov based architecture 2. Transport Triggered Architecture 3. Some two push-down automata based on some operation that assumes stack operations for left and right to manage params/addresses.

alexisread 3y ago
I'd have a look at Freeforth (Anonymous function eval at the shell, threaded subroutines with no swap, MSP433 cross compiler) https://github.com/dan4thewin/FreeForth2/blob/master/ff.asm https://github.com/dan4thewin/FreeForth2/blob/master/ff.asm Sectorforth (Minimal - 7 operators, everything else is in the prelude including IF) https://github.com/cesarblum/sectorforth/blob/master/sectorforth.asm https://github.com/cesarblum/sectorforth/blob/master/sectorf... And Retroforth (Multi platform VM, quotations) https://github.com/crcx/retroforth/tree/master/vm https://github.com/crcx/retroforth/tree/master/vm For larger coding, you may need a GC, Retro has a list class, and Freeforth operates a compacting dictionary which you may be able to modify
sph 3y ago
> 'what is the irreducible form of compute?' That is a very interesting question, which I'm trying to explore from another angle: what is the irreducible form of computing? As in, how minimal can a modern (operating) system be, to be able to boot and develop it completely at runtime? Modern development is like preparing a blueprint of a sculpture, magically applying it on real marble, and when something is not ideal, back to the blueprint. I don't know what the future operating system and post-UNIX paradigm looks like, but I want to explore that design space with a chisel and hammer on live silicon rock. A bare metal REPL to a fully reprogrammable environment/language. I don't have an answer to my or your query, but reducing the hypercomplex world of computing down to its axioms is a very fascinating topic.
- alexisread 3y ago
  This is what the the COLA papers talk about as you're aware, a REPL where you can modify, recompile and use the environment dynamically. Smalltalk is also similar in this regard, with a nicer UX. One of the reasons why this style has not taken off (image-based) is that its very easy to lose track of changes while developing - there's no formal iteration boundary. This guy https://github.com/attila-lendvai/maru https://github.com/attila-lendvai/maru Has been experimenting with git branches for this. https://github.com/crcx/retroforth/blob/master/doc/RETRO-Book.md#metacompilation-and-assembly https://github.com/crcx/retroforth/blob/master/doc/RETRO-Boo... talks about this issue, and the Retroforth author's attempt to define more clean boundaries.
  - sph 3y ago
    The hypothesis I want to test is that image/live development has a much higher ceiling of productivity than what we're used to, we just haven't tried hard enough. The failure of Smalltalk are known and easily found, my issue with it is that we've abandoned research on this "fancy and new" aspect from the 80s because of its failures and returned to the mainframe style of the 60s, which is still the model today. It is incredible how many advanced ideas are starting to pop in our languages today, that were active areas of research in the 50+ years ago. Some papers from that era still read like science fiction today. So there is this unknown field of research that can only be explored with the most malleable of environments, where you can switch between Self-like prototyping and Smalltalk-like rigid class model at runtime. Or turn it into an imperative language, why not. That is the beauty of COLA as a research ground to me. That said, thanks for the reading list and food for thought :)

alexisread 3y ago

I'd have a look at Freeforth (Anonymous function eval at the shell, threaded subroutines with no swap, MSP433 cross compiler) https://github.com/dan4thewin/FreeForth2/blob/master/ff.asm https://github.com/dan4thewin/FreeForth2/blob/master/ff.asm Sectorforth (Minimal - 7 operators, everything else is in the prelude including IF) https://github.com/cesarblum/sectorforth/blob/master/sectorforth.asm https://github.com/cesarblum/sectorforth/blob/master/sectorf... And Retroforth (Multi platform VM, quotations) https://github.com/crcx/retroforth/tree/master/vm https://github.com/crcx/retroforth/tree/master/vm For larger coding, you may need a GC, Retro has a list class, and Freeforth operates a compacting dictionary which you may be able to modify

sph 3y ago

> 'what is the irreducible form of compute?' That is a very interesting question, which I'm trying to explore from another angle: what is the irreducible form of computing? As in, how minimal can a modern (operating) system be, to be able to boot and develop it completely at runtime? Modern development is like preparing a blueprint of a sculpture, magically applying it on real marble, and when something is not ideal, back to the blueprint. I don't know what the future operating system and post-UNIX paradigm looks like, but I want to explore that design space with a chisel and hammer on live silicon rock. A bare metal REPL to a fully reprogrammable environment/language. I don't have an answer to my or your query, but reducing the hypercomplex world of computing down to its axioms is a very fascinating topic.

alexisread 3y ago
This is what the the COLA papers talk about as you're aware, a REPL where you can modify, recompile and use the environment dynamically. Smalltalk is also similar in this regard, with a nicer UX. One of the reasons why this style has not taken off (image-based) is that its very easy to lose track of changes while developing - there's no formal iteration boundary. This guy https://github.com/attila-lendvai/maru https://github.com/attila-lendvai/maru Has been experimenting with git branches for this. https://github.com/crcx/retroforth/blob/master/doc/RETRO-Book.md#metacompilation-and-assembly https://github.com/crcx/retroforth/blob/master/doc/RETRO-Boo... talks about this issue, and the Retroforth author's attempt to define more clean boundaries.
- sph 3y ago
  The hypothesis I want to test is that image/live development has a much higher ceiling of productivity than what we're used to, we just haven't tried hard enough. The failure of Smalltalk are known and easily found, my issue with it is that we've abandoned research on this "fancy and new" aspect from the 80s because of its failures and returned to the mainframe style of the 60s, which is still the model today. It is incredible how many advanced ideas are starting to pop in our languages today, that were active areas of research in the 50+ years ago. Some papers from that era still read like science fiction today. So there is this unknown field of research that can only be explored with the most malleable of environments, where you can switch between Self-like prototyping and Smalltalk-like rigid class model at runtime. Or turn it into an imperative language, why not. That is the beauty of COLA as a research ground to me. That said, thanks for the reading list and food for thought :)