6502.org

Tali Forth 2 has just formally reached Version 1.0 (https://github.com/scotws/TaliForth2). Yay!

To recap, Tali is a bare-metal, Subroutine Threaded (STC), mostly ANS Forth that was created explicitly for the 65c02. It now has the basic features, including blocks and wordsets, assembler and disassembler, and is pretty stable thanks to its test suite. Not only is the code happily over-commented, but the documentation now includes a manual with more than 120 pages in the PDF version, with tutorials for wordsets, blocks, and a (limited) 6502 clone of the ed line-based editor. The aim is to make a Forth that is easy to understand and adopt for other projects, one reason why it's released in the public domain. It will run out of the box with the py65 simulator (https://github.com/mnaberez/py65), making it easy to experiment with.

This has been almost six years to the day in the making, so a lot of thanks are in order to everybody who has given feedback, raised issues, and provided encouragement. Most very special thanks go to Sam Colwell, who not only did an enormous amount of work, but also added lots of really clever stuff that improved the quality immensely, not the least the test suite in its current form. The py65 simulator and Ophis assembler (https://michaelcmartin.github.io/Ophis/) are both rock-stable, and I can only recommend both.

And of course thanks to everybody here at 6502.org, without whom I would have never even tried Forth.

The one big thing that is still missing from Tali is multitasking. Since it is neither covered in a standardized way by ANS Forth nor by Gforth, this is going to require creating a new wordset. One minor (cough) problem will be that we've run out of space -- the idea was to keep Tali in 24 Kb ROM so that users can use it side-by-side with another system, and further 2 Kb of that are reserved for the user to define their own high-level Forth words. Based on feedback, that 24 Kb limit might fall.

Any and all feedback, suggestions, and comments are of course very welcome. And thanks again, this has been a really fun project.

How difficult would it be to take a page out of the C64 book and have Tali Forth ROM as well as this other system occupy the same memory but use a byte in your I/O block to configure which one is mapped into memory?
[Edit: Poor choice of words on my part, I know, but block in this instance has nothing to do with Forth blocks.
Maybe I/O section? ]

I honestly don't know, for the first step, we've been trying to keep it simple, which is why multitasking wasn't added from the beginning. I'm also not sure if this is something that py65 supports, which is the current tool for me for most of the work. I know the Steckschwein people have "bankable ROM" (https://steckschwein.de/home/) but haven't taken a look at the details yet ...

Congratulations on reaching V1.0!

I didn't realize py65 had mass storage. How is this manifested?

The mass storage for py65 and platforms without nonvolatile storage is done using a ramdrive built into Tali. Running the command will allot four 1K blocks and will install the vectors (XTs) for block-read and block-write to routines that access the ramdrive. This facility is used to test all of the block words in the py65mon simulator.

For systems that actually have non-volatile storage, the user simply installs the vectors to their own routines for reading/writing a block to/from storage. On my single board computer, I have an I2C bus implemented through a VIA with an I2C EEPROM. Tali has a user-words.fs file where you can put such things and they will be stored in the ROM and compiled on bootup.

Sort of a meta-question - is there any way to change the subject line of this thread? The "ALPHA" in the headline is outdated, it would be nice if this could just be "Tali Forth for the 65c02" or something to that effect ... sorry if I'm missing something obvious ...

I'm not certain, but perhaps you could just navigate to your head post and edit the subject line to see what global effect it has, if any?

If that doesn't have the desired result, I'm sure that no one would complain if you started a new thread with your desired title, as long as you referred back to this one as applicable.

Ah, that worked. Thanks!

Honestly, the programmer in me hates summer, I seem to be spending all my time outdoors, in the fresh air, with green things and my family, getting exercise. To make matters worse, my NAS motherboard died, and I had the genius idea of switching the new system to a Ubuntu Server basis with ZFS and Docker, because how hard can that be, right? That's sucked up indoor time. At least those pools don't involve actual cool, refreshing water.

Anyway, finally managed an update to Tali Forth. Carsten Strotmann has contributed platform files for Apple machines, thank you very much! And the Steckschwein people sent me a patch (as in diff) to make BYE customizable, and that will be next.

Probably when it rains. You'd think that would be a thing in Germany, but noooo, has to be sunny all the time. Next thing you know, there will be speed limits on the Autobahn.

Also, Carsten is the maintainer of https://theultimatebenchmark.org/ which is a Forth based benchmark that started off a couple of years ago as some silly 6502 vs Z80-argument (sheesh) at the Vintage Computer Festival Europe in Munich and has become a regular event since then.

Carsten has some results using TaliForth2, and "the Steckschwein people", too:
https://theultimatebenchmark.org/#sec-7

(I kinda like "the Steckschwein people", makes me think "crab people", and hear their chant https://www.youtube.com/watch?v=e20DtUJDxDg)
I'm all for it!

Just in case somebody missed it in the other thread: There is a discussion started at https://github.com/scotws/TaliForth2/issues/232 for the lower-level details of how to continue with Tali Forth 2 from here. It's probably going to be a bit too detailed for here, where we should probably stick to more high-level things. For instance, Tali needs a different assembler that can handle conditional assembly, and a more modular system so people can pick and choose what extra parts they want. Suggestions and comments welcome!

(Might be worth looking at BeebAsm too. It's not specific to Acorn machines, AFAIK. It's an assembler with a programming language, not unlike BBC Basic with the embedded assembler, which allows not only for conditional assembly but also for programmatic code generation, I think.)