third VS jonesforth

My first programming languages were x86 assembly and Forth. My Dad was into Forth, and I learned programming from him. I wrote several x86 Forth systems for DOS as a teenager, culminating in a somewhat-polished ANS compatible one I called "Third": https://github.com/benhoyt/third -- it's kind of amazing being able to have a fully bootstrapped Forth compiler (including an assembler) in a couple thousand lines of code.

Just the other day I transcribed an old article I had co-written for the Forth Dimensions magazine. I still like the ideas in Forth, but the stack manipulation quickly gets tedious and is very hard to read. Just look at the code examples in https://benhoyt.com/writings/forth-lookup-tables/ -- especially Search-Table. Yikes! Yes, naming things is hard, but apparently not naming them is even harder.

I just finished transcribing this from the scanned PDF, and thought it might be interesting to others. It certainly took me back! I was really into Forth as a teenager, and wrote several of my own Forth compilers [1]. It's a unique and interesting language, though most Forthers spend too much time writing their own compilers and being language zealots instead of getting things done. It's hard to believe anyone could think the Search-Table code in "Figure Five" is sane. There's more stack-effect tracking than code!

[1] For example, "Third", a 16-bit self-hosting Forth compiler for DOS: https://github.com/benhoyt/third

My dad, who was a minister by day and Forth hacker by night, got me into programming when I was a teenager, and Forth and x86 assembly were my first languages. I wrote a small self-hosting Forth compiler for 8086 DOS (https://github.com/benhoyt/third), a tiny 32-bit Forth operating system for the 386 (I guess you'd call it "bare metal" today). Incidentally, my brother used my Third compiler at his work for a few years to write test scripts for embedded systems.

I still love the simplicity of Forth, and the fact that you can get a full Forth system going in a few KB on a new microcontroller. I learned the basics of assemblers, bootstrapped compilers (though not parsers, because Forth doesn't need a "real" parser), recursion, how to implement control structures, various kinds of bytecode (called "threaded code" in the Forth world), linked lists, hash tables, and so on. I also dislike 3rd party dependencies to this day (Forth has a pretty extreme not-invented here culture).

I was really intrigued by Factor when it came out (https://factorcode.org/), as a modern incarnation of Forth, but I never really used it. By that point I had a "real" programming job and was doing absurd things like writing CGI scripts in C, until I discovered Python in the early 2000's. I stuck with Python for many years and really liked it, though more recently I've moved to Go.

I learned a lot by playing with Forth as a teenager, and I'm really grateful for the language. It was an amazing way to start programming.

Cool. Here are some other resources that I've encountered along the way of learning Forth:

- JonesForth: https://github.com/nornagon/jonesforth/blob/master/jonesfort...

This is legit a text that goes the an x86 Forth implementation. Actually, it's just an implementation with really extensive comments. That said, including whitespace and comments, it's just 2000 lines and the pedagogy is excellent. Highly recommended for anyone who would rather see behind the curtain before picking up a larger text.

- SmithForth: https://dacvs.neocities.org/SF/

So, Smith decided to hand-write a Forth directly in x86-64 opcodes (well, the corresponding ascii hex bytes). It's incredibly slim and enlightening how you can bootstrap a language in just a couple hundred bytes or so.

This project actually inspired me to really learn the x86-64 architecture, so I ended up hand-decompiling the SmithForth binary instead of going through his commented implementation. Hand-decompilation is an absolutely fascinating exercise. You learn all about ELF structure, opcode encodings, and actually start to see the gaps where microarchitectural details shine through. Highly recommended for any hacker that really wants to grok low level details.

- Mecrisp: https://mecrisp.sourceforge.net/

An amazingly fast Forth implementation for MSP430, ARM, RISC-V, MIPS, and some FPGAs. This gave me one really nice understanding of Forth as

    A REPL into your hardware!

I've git-cloned JonesFORTH (https://github.com/nornagon/jonesforth/blob/master/jonesforth.S) and achieved to compile it (i.e. run make w/o an error. When I start the executable, it presents me with an empty line, and when I say BYE, it says PARSE ERROR: bye.

Is there any particular language you're looking for? I've found some languages hideous until I understood them and could appreciate their respective graces. Off the top of my head the I can think of a couple.

The first is Jones Forth (https://github.com/nornagon/jonesforth), start with jonesforth.S and move into jonesforth.f. I really enjoyed following along with it and trying my hand at making my own stack based language.

The other is Xv6, a teaching operating system from MIT (https://pdos.csail.mit.edu/6.828/2021/xv6.html), not all the code or implementations are top notch but it shows you non-optimized versions (just because they're simple and more readable) of different concepts used in OS design.

If you're interested in the embedded world, there is a really neat project I've been following that feels a more structured and safe (as in fault-tolerant) while still staying pretty simple (both conceptually and in the code itself): Hubris and Humility (https://hubris.oxide.computer/).

Very low hardware requirements, so basic industrial control at the level where you'd otherwise use an Arduino or so but on scavenged hardware. Forth is ridiculously simple to get an implementation running.

https://github.com/nornagon/jonesforth/blob/master/jonesfort...

Is a nice starting point. It's obviously not as compact as say 'Brainfuck' but it is far more versatile.

OP mentioned jonesforth, but linked to a nasm port of it. Which is probably good it’s just that the documentation in the comments with ascii art doesn’t look right on my screen. So here’s a more common repo: https://github.com/nornagon/jonesforth

Rip the asm macros for the basic FORTH words out of this and then embed them in a C binary, statically linked with your favourite libs for whatever task. Although I haven't tried this yet, I'm planning on doing it with ncurses for my own Roguelike. From there, if you can convert the function calls and your parameters down to raw numbers, you can send instructions to ncurses or whatever other API you like, directly from a FORTH stack.

or the mirror of this site in github: https://github.com/nornagon/jonesforth