6 ms·
I'm amazed that it worked so well, it did confuse me that each repl didn't know the previously defined functions, is that just me? Forth is almost the postfix
by mikewarot 6y ago
I'm amazed that it worked so well, it did confuse me that each repl didn't know the previously defined functions, is that just me?
Forth is almost the postfix inverse of lisp. Instead of arity errors, you have stack over and underflow. And it only has one list, instead of lists of lists.
Oh, and it's not garbage collected
Oh, it it's not homoiconic
{edit]I guess it's really not the same thing at all
Amazing how a day's exposure to Racket shifted my opinion
- mumblemumble 6y ago> Oh, it it's not homoiconic Is it as homoiconic as it needs to be? It's been a while since I've played with it in any real way, but, as I recall, Forth represents both data and code in exactly the same way: Blobs of data with no associated type information, that you're allowed to fiddle in any way you want, with no guard rails. So it seems like there's no reason you couldn't write some words for manipulating code every bit as easily as you could write some words for manipulating any other data. Lisp gives you a lot more out of the box, of course. But Lisp gives you a lot more of everything out of the box.
- astrobe_ 6y agoIt depends on the implementation. With Indirect Threaded Code (ITC), "functions" are represented more or less as a list of other functions or primitives to call. But there are also classic bytecode-based Forth implementations, subroutine threaded code implementation (which is a simple form of native code generation), etc. In my experience, Forth's "immediate" words, which let you execute code at compile time, combined with the availability of some (or most) of the compiler's part, let you do quite a lot of things. In other words, you don't manipulate code, you directly generate code. For instance, if your implementation does not have 1+ (silly example), you can make a word "1+" that compiles "1 +" inline (or increment the top of stack if you interpret stuff from the REPL). To answer your question, I use a dialect of Forth that has, I think, less capabilities than standard Forth in this area and rarely felt the need to implement them. At the risk of showing I am a blub programmer, I think homoiconicity is overrated - for the user (for language implementers maybe it's another story).
- mikewarot 6y agoLisp can take a chunk of lisp code and operate on it directly... forth can't do the same. The big difference with forth is the inability to do things other than variables (fixed allocations) and use the stack. The handling of lists and garbage collected larger things on the heap are a huge advantage for the Lisper.
- RodgerTheGreat 6y agoForth doesn't need an abstraction for operating on threaded code; forth programmers routinely write their own words for control structures with an awareness of the internal structure of dictionary entries. You're operating on code-as-data, it's just an entirely different mechanism for doing so. It's entirely possible to work with dynamically allocated memory in a Forth that runs on top of some other operating system, like GForth. When you're on metal, you can build whatever kind of allocator you want. The primitives "create"/"allot" are just that- primitives. Here's a trivial example of building a cons-pair heap in Forth: https://gist.github.com/JohnEarnest/4522067 https://gist.github.com/JohnEarnest/4522067
- isaacimagine 6y agoLet Over Lambda has a section about leveraging Common Lisp's macro system to make a Forth in a really clever way, IIRC.
- RodgerTheGreat 6y agoThe comparison to Lisp always seems to pop up for some reason, but at the end of the day Forth draws very little, if any, inspiration from Lisp, and has very different functionality and evolutionary history. They are both "small" languages in some sense, but it is rare to see anyone claim that Brainfuck is a Lisp, or that they are somehow twins separated at birth if you turn your head to the right angle and squint. It is better to simply learn about Forth instead of attempting to hammer it into the mold of another language one has heard of before.
- mikewarot 6y ago> It is better to simply learn about Forth instead of attempting to hammer it into the mold of another language one has heard of before. I knew Forth, I'm learning Racket (Lisp)... and I'd previously watched Uncle Bob Martin's talks about the quest for the ultimate programming language (Which at the time, he thought was Clojure)... it was then that I realized there is a continuum from Prefix (Lisp, etc) through infix (C, Pascal, Fortran, etc) to Postfix (Forth, Postscript, Cannon Cat, etc) Stoical is a Forth that handles lists, dictionaries, etc... it was implemented on the DEC PDP-11, and formed the basis of the RED editor. It was then ported to Linux by the author who later wrote DAW. I tried to revive it, but I don't really know C that well, and it made a LOT of assumptions about word size that I don't know how to get around in a 64 bit environment. I strongly suspect you could write Lisp in Stoical and vise-versa.