Hacker News Reader

Comment by haolez | Hacker News Reader

I would prefer Forth. It's simple and yet manages to be close to the hardware.

Forth would be great too. I think there's value in learning a stack based language. That being said I suspect LISP is more practical.

they’re practically two sides of the same coin. I keep thinking it should be possible to build a toy language that has both a forth-like mode and a lisp-like mode, that use the same standard library

Forth is more low level, ie. there is no object memory/GC at what one would describe as implementation level. On the other hand all the Lisp Machines essentially are hardware implementations of something vaguely Forth-like with some level of hardware support for lisp-style tagged pointers.

A good way to jump over the low level implementation details is to look at Factor. Forth style but much better library and most of the low level constructs are baked in.

I can't say the documentation / tutorials that I've found are the best but it's definitely something.

There was a language for calculators called Reverse Polish Lisp. (That's all I know about it.)

If I were to design a language matching that name, I guess it'd be basically Logo written backwards. This might be interesting for a live programming environment, because in Lisp you type a whole expression and and nothing happens till you hit enter; but on e.g. an old HP RPN calculator you see the state of the data change after every keypress. You could design an "RPL" to work that way too, though after every word instead of every key.

I think you'd have to hobble Forth pretty badly to make it stand on the same level as Lisp. Lisp has too much hidden machinery- a garbage collector, environment structures, etc. You couldn't even represent forth's "/mod" without resorting to packing results into tuples. Forth is good because every piece of the compiler/interpreter is exposed, usable, and extensible. Lisp wants to keep its innards sealed off and abstracted from the hardware.

Have you ever heard of [1] https://en.wikipedia.org/wiki/POP-11 ?

HP's "RPL" language, Reverse Polish Lisp, was basically that.

the first who makes his 7yo write a scheme in Forth gets my grid laptop

This isn't at all implausible: one of you should take 'agumonkey up on this! I wrote my first Scheme interpreter at 11, and an older friend of mine taught me Forth a bit before that. I wrote my interpreter with a bootleg (and ancient) APL2 copy, though.

With parental guidance, a 7 year old could totally do this. Figuring out how to handle the stack will be the trickiest part, and there are a few examples online of this, so if you nudge them in the direction of others' work, they should be able to get it pretty quickly. They'd finish it by the time they're 8, at least.

Reply on news.ycombinator.com