Author here! This was a super fun project that consumed over a month of evenings and weekends. In the past couple of days I finished the examples, and I'm glad to finally put it out there.
I don't quite remember how I fell into the Forth rabbit hole, but I think I first heard about Collapse OS. Then I read yosefk's "My history with Forth & stack machines" [0], which is actually very critical of Forth. But when I saw if/then/else being defined in Forth itself, I was hooked.
I've always been fascinated by the idea of having a minimal kernel of primitives from which "everything" can be built. Before Forth, I had only seen that in the form of Lisp's "Maxwell equations of software", which is cool, but always left me a little disappointed because it is too abstract to build something that you can actually interact with - you can't break out of its esoteric nature. The same applies to brainf*ck and other extremely small environments.
With Forth, however, you can start from almost nothing, and start adding things like ifs, loops, strings, etc., things that look more like your day-to-day programming. I find that there's a lot of beauty in that.
Anyways, I hope the examples in the repository do not look too awful to experienced Forth programmers :D
... a non-exhaustive list of projects that create super-minimal interpreters, compilers, or maybe operating systems with very few dependencies or prerequisites.
> a non-exhaustive list of projects that create super-minimal interpreters
One of the items on that page is described as "25k lines of asm". That's the problem with 'tiny'. It means different things to different people. This FORTH thing however appears to be an exception. You know you're playing the game at a different level when your entire app can be statically linked with all its dependencies and still be small enough to fit inside the master boot record of a floppy disk (i.e. less than 512 bytes). I just wish I could figure out how to use the thing.
I'd really like to revive https://github.com/nathell/lithium sometime. It can't bootstrap itself yet, but "no dependencies, runnable on bare metal" was a goal from the start.
I tried to do something “interesting” with my own little lisp based on the “Maxwell’s Equations of Software” paper. I don’t know if I succeeded exactly (and like most such projects I left it in a somewhat unfinished state), but I did achieve the same “now we’ve defined comments!” kind of mystical experience as the author of the linked article.
It's a very different kind of simplicity and self-hosting. Vau uses rich features of a managed programming language in order to achieve lispiness.
The true beauty of something like SectorForth is its mechanical empathy. It relies only on the machine code of the system, and while it has quirks and shortcomings to fit in 512 bytes, it has everything you would need to bootstrap into a fully-productive Forth.
Of course, if Oscar Toledo feels inclined to step in and furnish a 512 byte extensible Lisp that runs on an 8080, I won't be upset.
Yep. I was definitely cheating, and it’s more like “syntactical self hosting”. I’ve wanted to try my hand at a Forth like this but so far I haven’t started anything.
I also recently hacked up a simple FORTH-like system, but mine just emulates the effects making IF/ELSE/THEN and DO/LOOP be built-in primitives.
In short I let you define words, and work in a FORTH-like manner, but without the real extensibility of an actual FORTH system. That will be something I tackle next:
This is awesome! I've had a similar history very recently and am trying to write a forth with a type system (I think I've found a way to do it with nearly zero overhead) for Civboot.org I have a few notes about it on the github page, and I've just made it through the jobesforth tutorial. Learning asm ain't easy!
Leaving out numeric literals is an interesting choice to simplify your Forth kernel. Not many languages have sufficiently flexible naming rules to permit something like ": 3 1 2 + ;"
Stylistically, one of the main suggestions I took to heart early in my career with Forth was to outright ignore "rot" and "-rot"; they make the stack tricky to follow. I see that helloworld.f defines "rot", but it's only used in one place.
Related advice would be to annotate every stack effect with a comment, no exceptions.
Back when I was into Forth, I had this wild notion of adding a stack checker, defining two additional comment words which would be aware of the stack effect of all core words, and require a stack effect to be defined for every new piece of vocabulary.
Never did anything with it, don't write Forth anymore, doubt I will again. I still think it's a good idea though, so I like to put it out there.
It's not any more or less intuitive to me than nip and over.
Where there's three or more items to be manipulated there's always at least ambiguity which way rot is supposed to rotate according to codebase author. With more than three items it's easy to see what can be done but no unambiguous and meaningful names. The only consistent stack word names that work 4 items deep are 2dup and 2drop.
Best[1] I could do was a non-networked forth that easily fit in a jumbo frame. Maybe one day I'll think of a trick to fit it in a normal MTU, but it's more likely that networking will widen in the meantime.
[1] I chose the constraint that CODE words were fine, but the kernel had to already contain the dictionary implementation: no "magic numbers" known to both the forth and kernel source. The motivation for that constraint was the "three instruction forth" which I would call a "monitor program" instead.
I don't quite remember how I fell into the Forth rabbit hole, but I think I first heard about Collapse OS. Then I read yosefk's "My history with Forth & stack machines" [0], which is actually very critical of Forth. But when I saw if/then/else being defined in Forth itself, I was hooked.
I've always been fascinated by the idea of having a minimal kernel of primitives from which "everything" can be built. Before Forth, I had only seen that in the form of Lisp's "Maxwell equations of software", which is cool, but always left me a little disappointed because it is too abstract to build something that you can actually interact with - you can't break out of its esoteric nature. The same applies to brainf*ck and other extremely small environments.
With Forth, however, you can start from almost nothing, and start adding things like ifs, loops, strings, etc., things that look more like your day-to-day programming. I find that there's a lot of beauty in that.
Anyways, I hope the examples in the repository do not look too awful to experienced Forth programmers :D
[0] https://yosefk.com/blog/my-history-with-forth-stack-machines...