foth VS Vacietis

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.

Yes. Not because of the developer, but because of how extremely flexible and dynamic the Lisp-family languages are. The power and joy of Lisp is in how it's almost a meta-language, so every project can become its own EDSL. The most famous (infamous?) example of this is Vacietis[2], which is a Common Lisp library that allows C code to be imported directly(!!).

[0] IIRC the Yesod framework's Warp does well on benchmarks, and when you look at code like https://github.com/yesodweb/wai/blob/master/warp/Network/Wai... you can see the lengths they had to go through to work around the choice of implementation language.

[1] Go has a garbage collector, but exposes the stack/heap distinction more directly than Haskell, so it's easier to write allocation-free code in hot paths.

[2] https://github.com/vsedach/Vacietis

racket and common lisp both offer reader interfaces which allow parsing non-s-expression languages. see https://github.com/vsedach/Vacietis , a c compiler implemented in common lisp which uses the common lisp reader.

Very funny. One might be interested in e.g. Vacietis which does manage to compile enough of C correctly to a higher level language (in this case, Common Lisp) to be interesting.

https://github.com/vsedach/Vacietis - C in CL

C

How about C?

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

https://github.com/vsedach/Vacietis

================

Vacietis is a C compiler for Common Lisp systems.

Vacietis works by loading C code into a Common Lisp runtime as though