<lispmacs[work]>
I just got set up with VICE and have been playing with 64Forth on Commodore64
<f-a>
how was it
<lispmacs[work]>
so far a good experience, except I'm having some confusion about figuring out where some special C64 keys map to on my real keyboard
<lispmacs[work]>
to go into insert mode in the block editor, you have to press something like Shift-Insert on the C64 which doesn't seem to map to the same keys on my real keyboard
<lispmacs[work]>
but, I figured out anyway how to save normal definitions to a disk image, and load them
<lispmacs[work]>
compiled definitions
<lispmacs[work]>
I might have made more progress but got a bit distracted playing M.U.L.E. for C64
<remexre>
siraben: ooh, nice; adding it to my list
<remexre>
been reading thru http://www.itu.dk/people/sestoft/pebook/ for the last couple of days; doesn't seem easy to apply it to Forth, but cool stuff nonetheless
<lispmacs[work]>
how would you do partial evaluation in Forth? you would need some kind of special operator, wouldn't you, to hold the applied values?
<f-a>
siraben would probably agree that the way to go is to write an Haskell compiler in Forth
<f-a>
*agree with me
<siraben>
f-a: to implement partial evaluation?
<f-a>
and to use Haskell :P
<f-a>
I am not sure I can link Forth to PE
<f-a>
evaluate what?
<f-a>
stuff on the stack?
<siraben>
Forth doesn't really have a notion of closure, is that required for PE?
<f-a>
you can for sure short circuit and and friends
<siraben>
remexre: nice, for a second I thought that cover was AoP haha
<remexre>
oh huh; yeah, I'm checking it out in the context of the calculating-compilers stuff
<remexre>
I'm thinking if I wanna do a JIT, I could do the same sorta "partial evaluation as a consequence of polymorphic inline caching" that graalvm does
<remexre>
but my advisor's like "you should actually read any of the partial evaluation literature lol it's probably not /that/ bad to do it statically"
<siraben>
f-a: I was actually strongly contemplating translating ben lynn's lazy λ-calculus VM into Forth
<remexre>
esp because the calculated exec function is structurally recursive
<siraben>
f-a: the closest I got to that was an SKI machine running on EVM
<KipIngram>
Stack juggling has more or less vanished from my code.
<KipIngram>
The stack frames dealth with it.
<KipIngram>
The purists hate it, but I've decided that being able to treat the top few elements of the stack as a small array, and having a variety of words that operate on them, is the way to go.
<KipIngram>
Not just fetch and store, but also +! and other such.
<KipIngram>
I'm looking at the operations my 41 CV allowed. It provided a rich library of commands to operate on all four elements of the stack.
<KipIngram>
THEY. HELP.
<KipIngram>
I'm actually naming my top four elements x, y, z, t like in that calculator. That's the top elements of the actual stack, whereas the stack frame is a more fixed thing. So it's really two separate mechanisms.
<KipIngram>
I'm sold on both things - any future Forth I do will have them.
<siraben>
KipIngram: that's well and good, but that routine had to be as efficient as possible and factoring would have added too much overhead
<siraben>
this is because I'm faking subroutine calls as well, the EVM doesn't actually have it
<KipIngram>
Fair enough.
<siraben>
bbl, sleep
<KipIngram>
Well, I do factor a lot these days, but the frame and the stack access words aren't really "factoring related."
<KipIngram>
They're just more primitives, particularly the HP-stolen ones.
<KipIngram>
In fact, some of them would boost efficiency - things like store and recall arithmetic. HP would have called RCL* Z for example - for me that would be z@*
<KipIngram>
We already had SWAP - I added x<>z and x<>t. Store and recall arithmetic for all four basic operations. Increment and decrement, by 1, 2, 4, and 8.
<KipIngram>
For all four elements, that is.
<KipIngram>
On the other hand, the stack frame only provide words to give you the address of the frame elements (the first few - 0 through 4). Then you use that like any other address.
<KipIngram>
I would say that the overhead of opening a stack frame, and closing it when you're done, would be similar to the overhead of calling and returning from a factored word, so that's a fair comparison.
<KipIngram>
The HP words are just "there," though - no cost to use them, and they combine operations that would otherwise have to be done separately.
<KipIngram>
Their "cost" is just a fatter dictionary.
tech_exorcist has quit [Ping timeout: 268 seconds]
tech_exorcist has joined #forth
pbaille has quit [Remote host closed the connection]
tech_exorcist has quit [Remote host closed the connection]
tech_exorcist has joined #forth
gravicappa has quit [Ping timeout: 268 seconds]
pbaille has joined #forth
actuallybatman has joined #forth
lispmacs[work] has quit [Remote host closed the connection]
mtsd has quit [Remote host closed the connection]
mtsd has joined #forth
neuro_sys has joined #forth
mtsd has quit [Ping timeout: 265 seconds]
f-a has quit [Quit: leaving]
f-a has joined #forth
f-a has quit [Read error: Connection reset by peer]
f-a has joined #forth
pbaille has quit [Remote host closed the connection]
pbaille has joined #forth
neuro_sys has quit [Read error: Connection reset by peer]
lispmacs[work] has joined #forth
dave0 has joined #forth
<dave0>
maw
f-a has quit [Quit: leaving]
tech_exorcist has quit [Ping timeout: 268 seconds]
<lispmacs[work]>
wam
<KipIngram>
:-)
pbaille has quit [Remote host closed the connection]
pbaille has joined #forth
pbaille has quit [Ping timeout: 265 seconds]
dave0 has quit [Quit: dave's not here]
pbaille has joined #forth
<cmtptr>
somebody please find me a new job
<lispmacs[work]>
we've got an opening for night parts clerk. I think it pays a dollar or two above minimum wage