r/Forth

(Permalink as of this post.)

I present Nictoforth: a space-and-pedagogy-constrained art Forth. It's carefully crafted to be read top-to-bottom:

• The repo README sets the stage. Boot sector, serial IO via BIOS.
• The assembly source is packed with narrative, rationale, and cross-reference. Search for:
  • "[0]" architecture if you want to dig in.
  • "[5]" interpreter, the heart of a Forth.
  • "[7]" the lovely straightforward compiler.
  • "[8]" the extremely wacky bootstrap. It's full of character but damn dense!
• If you clone the repo you can do make terse | bat -l nasm or | less to cut away all the asides and just read the code.
• An example demo session log. See it working.

u/s1nical posted their Milliforth fork the other day so I figured why not post mine too. It was lots of fun to write and educational besides!

I was recently accused of using AI to make some of inspiration Forth, which isn’t true. The reason I was accused is that I didn’t completely edit the default README file created by gitlab when I made the repo. The README described what makes for a good README and had headers/sections pre made with instructions on what kind of things to add there. Both github and gitlab have had this sort of thing for years - I have maybe 50 or even 100 repos I made over the years. The README is a template, created by humans. They also have optional templates for issues to force people to add things like steps to reproduce and so on. I didn’t choose to use these.

I cannot stand the use of AI to make code, period. When I was working on the Console logic for Inspiration, it took several feature branches to move it along. The first being to just render individual characters on the screen, then colorized text, then cursor addressing, then (partial) ANSI escape sequence support, then ability to scroll back and view all the text printed to the console. These feature branches weren’t consecutive efforts. It took me a lot of thought to figure out the scroll back logic, and more than one aborted feature branch. So I worked on other things in the meanwhile.

The only time I used AI was a horrifying experience. I asked copilot to make a console with ANSI and scrollback support. It made it in seconds. When I looked at it, I saw someone else’s variable names. Logic that would take me days to get into before even trying to assess if it was even working code. I stopped looking at it after a few seconds. I felt like that code was lifted from someone else, without attribution. None of that code or any of its ideas has anything to do with Inspiration.

The Phred editor is something I worked on in my previous Forth implementations, and once in C++. Made from scratch, but patterned after vim. The Evade2 game is one I made 7 years ago for the company I worked for at the time. Originally in C++, I ported it in Forth to Inspiration.

Inspiration is a different animal as Forths go. It is graphics first, not console first. The concept of how C++ functions can be subroutine threaded is unique. The pthread ability is my own idea and creation. Every code word I made are either mine or from the 2012 Forth Standard.

I have no use for AI. The beauty of a desktop Forth is that my dictionary has thousands of words I already made and debugged to make new things from. And rapidly. I probably get more done in 2 days than I would with AI. It helps that I have been writing code since the early 1970s. I’ll let the features/issue board and over 800 commits to Inspiration speak for themselves.

Beyond this, I think AI slop is garbage and spam. It’s turning works of art into someone else’s trash. GitHub is becoming a landfill. Why GitHub? Because that’s where the chat bots tell people to upload their one day untested creations.

Hello fellow friends of Forth!

I wondered as I was considering to restart some work on a long and forgotten
Forth interpreter of mine, which basically was incomplete to begin with, what do
people consider the most basic primitives to bootstrap a forth system from scratch?

I can remember, that people did things with `c,`, `,`, so by bit-banging definitions into memory and then starting from there. But also implementing `CREATE`, `:` and `;` or more words to get things off the ground.

Lisp boils often down to other things like to be able to `eval` things and a couple of other 7 primitives I think with which the system then gets off the ground.

So what do you consider to be most basic stuff for bootstrapping Forth systems?

"Treat stack depth and r stack depth like bank accounts and each word in a definition like a financial transaction." After that, gemini (thinking mode) started creating words that actually worked.

A new Blog post about BoxLambda OS's File System Stack:

https://epsilon537.github.io/boxlambda/the-file-system-stack/

BoxLambda OS now supports file system access within its Forth environment. A layered stack of Forth modules provides the abstraction required for convenient, shell-level file operations.

https://preview.redd.it/73uveg9fpo0h1.png?width=940&format=png&auto=webp&s=aef81d843b95b6ff555d8828a328bce4829b8793

I've been working on a forth for RISC-V microcontrollers, and made this special TUI application for debugging. The forth is fully useable with a normal serial comms tool like minicom but this is supposed to augment it's useability with debugging features, sending and parsing the plain-text response from certain forth words in the background.

It first needs to read the startup message from the serial port, then, knowing the microcontroller is present and initialized it sends the "showWords" word which prints the memory contents of all words, which the forth_shell application parses and annotates with what certain pointers point to.

Then when a new word is added it will send "showLastWord" which will print the memory of only the last word created, which is parsed and added to the list. This is imperfect - right now it just detects when an ";" is included in the last line when enter is pressed, but for some instances like "42 const bar" in the video I need to press f5 to manually add the new word.

Eventually I will add the ability to set breakpoints (at least on words in RAM and not flash).

My first attempt at rust, which I still don't understand too well, It's a lot of libraries hacked together that allocate memory all over the place.