foth VS jonesforth

I hacked up a simple forth-like system in golang, by following the overview posted in this hackernews comment-chain:

https://news.ycombinator.com/item?id=13082825

The result is here:

https://github.com/skx/foth

It's not real, but it was a pretty fun experiment regardless.

Here's one of the many forks that brings it up to 64-bit:

https://github.com/matematikaadit/jombloforth

If you like forth there's an awesome series of comments here on hacker news on building a simple variant in a few simple steps:

https://news.ycombinator.com/item?id=13082825

I took that, and built a simple forth-like system, in golang following the original recipe and breaking it down into simple steps for learning-purposes:

https://github.com/skx/foth

I'll always vote up submissions referencing anything FORTH related. For me FORTH is as much fun as lisp appears to be for others. I've never really done much with it, but I always like the simplicity and the ability to reason about it.

Sure FORTH has problems of its own, but it's always nice to use. I've hacked up a couple of simple FORTH-like systems over the years, most recently this one which was inspired by a thread on this site:

https://github.com/skx/foth

A lot of people go through guides of writing a lisp, I'd love to urge people to try writing a simple FORTH interpreter instead, or even something somewhat related such as TCL.

There's even a recipe posted in a couple of comments here:

https://news.ycombinator.com/item?id=13082825

I followed that guide to implement a simple FORTH-like system in golang:

https://github.com/skx/foth

As I was following the implementation recipe I broke it down into "educational steps". Although it isn't a true FORTH it is pretty easy to understand and useful enough to embed inside other applications.

Now and again I consider doing it again, but using a real return-stack to remove the hardcoded control-flow words from the interpreter, but I never quite find the time.

I actually hacked up a simple forth-like system, after reading a brief howto here on hackernews:

https://github.com/skx/foth/

Here's the thread which has the barebones overview which inspired me:

https://news.ycombinator.com/item?id=13082825

I could have taken it further, but the implementation there is not "real" in the sense that there is no real return-stack, so you can't implement IF-statements using the lower-level primitives.

That said it is a good starting point, and I had some fun doing it. I'd guesstimate it is more of a single weekend project though, rather than longer.

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