On Monday 5 February 2024 at 11:00:50 UTC, Jurgen Pitaske wrote:
> On Monday 5 February 2024 at 01:13:35 UTC, Marc Olschok wrote:
> > On Sat, 03 Feb 2024 08:48:14 Jurgen Pitaske wrote:
> > > [...]
> > >
> > > I learnt a lot from the people here, nothing to do with transactional..
> > > No disappointment here.
> > > The Forth bookshelf will still be available. This how it started here..
> > > I just wanted to post it here as a summary , before the posting stops on 22 Feb ...
> > Promise?
> >
> > --
> > M.O.
> Thank you very much for this useless and completely meaningless post.
>
> It demonsterates the level of intelligence of some people posting here now.
>
> Or is to the average intelligence level of the people who work at
> Fernuniversitaet in Hagen ? Then it would be ok.
> https://www.fernuni-hagen.de/MATHEMATIK/DMO/mitarbeiter/olschok.html

One of the main books on the Forth Bookshelf:
https://www.amazon.co.uk/Starting-Forth-Leo-Brodie-ebook/dp/B01MS7YDKD/ref=zg-te-pba_d_sccl_1_1/262-6131874-1834657?pd_rd_w=8HY7n&content-id=amzn1.sym.c072daa0-3920-4b4d-83e5-1f5f31c763e0&pf_rd_p=c072daa0-3920-4b4d-83e5-1f5f31c763e0&pf_rd_r=F4CT9ACM0R9X3MPW1XV5&pd_rd_wg=VVVTx&pd_rd_r=acfe5fd7-efd0-4055-b9bd-6fdd3a01eb2d&pd_rd_i=B01MS7YDKD&psc=1

Starting Forth Kindle Edition
by Leo Brodie (Author), Juergen Pintaske (Editor) Format: Kindle Edition

4.5 4.5 out of 5 stars 21 ratings
See all formats and editions

Starting FORTH by Leo Brodie
Starting Forth, the classic Forth language tutorial, is available here in its official online edition. Updates to the original Starting FORTH text include code examples that run on iForth and SwiftForth systems. Aficionados (and detractors) of the original book's illustrations will find most of them restored in this official edition by FORTH, Inc.
"…I hope this book is not so easy and enjoyable that it seems trivial. Be warned that there is heavy content here and that you can learn much about computers and compilers as well as about programming."
—Charles Moore, Forth's inventor
"A Forth to be reckoned with..."
—Leo Brodie, Author

About the book
Starting FORTH has been the classic Forth tutorial and textbook since its first release. Many experienced programmers have commented on its concise utility and completeness. Beginners will find a carefully planned introduction to the Forth programming language that will prepare them for other books like Forth Application Techniques and Forth Programmer's Handbook.
FORTH, Inc. and the book's author, Leo Brodie, thank the global community for its continued enthusiasm for this book. Many have sought a new copy, a used copy, or have asked for a reprinting. It is our pleasure to now present this online edition, with great appreciation for work done by Marcel Hendrix to generate a web version on which these pages were based.

Notes about this online edition
Changes made by FORTH, Inc. to Marcel's version were primarily related to internet coding standards and visual presentation. We also restored the book's original illustrations here, in most cases. The following notes are also relevant and important to those familiar with the original edition.

Notes by Marcel Hendrix
This transcript is not an exact reproduction. Forth code has been ANSified. All code should run on, at least iForth. Where necessary, statements that were valid in 1981 have been exchanged with statements more appropriate for 2003 (when this tribute was written)….
I have assumed a 32-bit, byte-addressing Forth with 8-bit characters. The address returned by WORD is assumed to be HERE. This allows the common trick of ALLOTing length of str CHARS after using WORD in order to compile string str to memory. Multitasking issues are ignored (e.g. no >TYPE, just TYPE).. Division is symmetric, not floored, and two's complement is assumed throughout. iForth works splendidly with it, but other Forths will work too. Chapter 7 exploits extended uses of number conversion. Most Forths are broken in this respect, but iForth and SwiftForth support these neat features.
Other Forth Books and Classes
As noted above, once you have progressed from the beginning stages and look for more-practical and detailed information, several resources are available. The Forth books Forth Application Techniques and Forth Programmer's Handbook are a good next step. In addition, Forth classes and training are available at our offices or, by arrangement, at your facility.
Thank you again for your interest in this fascinating and powerful programming language and in Starting Forth

Dr. Ting has written so much documentation for the Forth community.
Here as example one, how to start with Forth using the Arduino:

eForth as Arduino Sketch: no extra Programmer Kindle Edition

by Chen-Hanson Ting (Author), Juergen Pintaske (Editor) Format: Kindle Edition
4.6 4.6 out of 5 stars 3 ratings
See all formats and editions
eForth as an Arduino Sketch
Last year I decided to retire from electronics and microcontrollers. So I cleaned out my study and my garage, gave away all my tools and spare parts. I realized that I should not be a hardware engineer. I am only a programmer, and should just work on software.

Then, when I visited my brother in Denver last summer, I saw that my niece was working on a couple of Arduino Boards. On an Arduino board, there was a microcontroller in a DIP socket! That was very interesting. When I came back, I bought a couple of Arduino Uno Boards, and have been working on them since. I had to buy back tools and many electronic parts and ate my vow to stay away from hardware.

Arduino Uno is a lovely, small, cheap, and readily accessible microcontroller board. The operating system and the programming environment Arduino 0022 is a good match to the Arduino Uno Board. Through a single USB cable, you can upload programs from a PC to Arduino Uno, and then communicate with the Uno through the same cable using RS232 protocol. You write programs in C language as sketches in Arduino 0022, and the sketches are compiled and then uploaded to the ATmega328P microcontroller on Arduino Uno for execution. Sketches are C programs greatly simplified to the point that you just have to fill lines of code in the two following routines:

setup()

loop()

All intricacies and complications in the C language and its associated compiler and linker are taken care of by the Arduino 0022 system. No wonder Arduino is such a huge success.

FORTH is a programming language much better suited for microcontrollers than C. FORTH is really a programming language with a built-in operating system. It has an interpreter and a compiler so that you can write programs in small modules and interactively test and debug them. You can build large applications quickly and debug them thoroughly. FORTH also gives you access to all the hardware components in the microcontroller and all of the IO devices connected to the microcontroller.

So, I ported a very simple FORTH model, 328eForth, over to the ATmega328P microcontroller. It was written in AVR assembly language, and had to be assembled in the AVR Studio 4 IDE from Atmel Corp, and then uploaded to ATmega328P through a separated AVRISP mkll programming cable. Once 328eForth is uploaded to ATmega328P, it can communicate with the PC through the Arduino USB cable. BUT, 328eForth cannot be uploaded through the USB cable, because Arduino 0022 requires a bootloader pre-loaded in the ATmega328P to upload sketches, and 328eForth must use the bootloader section of flash memory in ATmega328P to store commands which writes new code into the application section of the flash memory at run-time.

For the serious FORTH programmer, a 328eForth system gives you the ultimate control over the ATmega328P microcontroller.
For the much larger Arduino user community, we need a FORTH implementation which is compatible with the Arduino 0022 system. Here is my solution: ceForth_328. It is written in C as a sketch. It can be compiled and uploaded by Arduino 0022. Once it is uploaded to the Atmega328P microcontroller, it communicates with the PC through the Arduino USB cable.
However, new FORTH commands are compiled only into the RAM memory in ATmega328P. You have only about 1.5 KB of RAM memory to store new commands, and when you turn off Arduino Uno, these new commands are lost.
In spite of these limitations, ceForth_328 is still a very useful system.
You can learn FORTH and use if to evaluate Arduino Uno for various applications. You can also use it to learn about the ATmega328P microcontroller, because it allows you to read and to write all the IO registers.
Find the sketch and soon more at https://wiki.forth-ev.de/doku.php/projects:430eforth:start#arduino_uno_und_arduino_nano

The link to this book:
https://www.amazon.co.uk/eForth-Arduino-Sketch-extra-Programmer-ebook/dp/B0881YWKRY/ref=zg-te-pba_d_sccl_1_6/262-6131874-1834657?pd_rd_w=XHcWB&content-id=amzn1.sym.c072daa0-3920-4b4d-83e5-1f5f31c763e0&pf_rd_p=c072daa0-3920-4b4d-83e5-1f5f31c763e0&pf_rd_r=TB1TB0CY9K2KX13YCX0V&pd_rd_wg=XYzHF&pd_rd_r=a23b6ce4-913e-45f5-bfbf-196be1479be3&pd_rd_i=B0881YWKRY&psc=1

And the contributions of Brad Rodriguez - Forth including a processor.
https://www.amazon.co.uk/Moving-Forth-Internals-TTL-Processor-ebook/dp/B07BTV7QVR/ref=sr_1_11?qid=1707418800&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-11

Moving Forth - Internals and TTL Processor Kindle Edition
by Brad Rodriguez (Author), Juergen Pintaske (Editor) Format: Kindle Edition
3.9 3.9 out of 5 stars 13 ratings
See all formats and editions
In 2018 we have 50 Years of Forth. When I looked for a new project for an eBook I realized that one area is not very well covered:
How do the Forth internals work?
How can you build a Minimal Processor executing Forth directly?
How do you write an Assembler in Forth?
When I looked around for some documentation, I remembered this series of articles again. They seems to fit very well together.
I contacted Brad and asked for permission to publish them as part of the Forth Bookshelf.
He liked the idea so I started formatting. I did not change any of the original material.The only part I added was an appendix, where I redid some of the pictures, so I could understand them better.
As in many cases, additional material can be found on the Forth-eV.de Wiki, and we will start with the appendix added here, and what else we might come up.
I have to thank Brad Ridriguez for the copyright to publish this documentation.
Enjoy reading and any feedback please send to epldfpga@aol.com.

From Brad: Everyone in the Forth community talks about how easy it is to port Forth to a new CPU. But like many "easy" and "obvious" tasks, not much is written on how to do it! So, when Bill Kibler suggested this topic for an article, I decided to break with the great oral tradition of Forthwrights, and document the process in black and white.
Over the course of these articles I will develop Forths for the 6809, 8051, and Z80. I'm doing the 6809 to illustrate an easy and conventional Forth model; plus, I've already published a 6809 assembler [ROD91,ROD92], and I'll be needing a 6809 Forth for future TCJ projects. I'm doing the 8051 Forth for a University project, but it also illustrates some rather different design decisions. The Z80 Forth is for all the CP/M readers of TCJ, and for some friends with TRS-80s gathering dust.

On Friday 9 February 2024 at 09:57:53 UTC, Jurgen Pitaske wrote:
> And the contributions of Brad Rodriguez - Forth including a processor.
> https://www.amazon.co.uk/Moving-Forth-Internals-TTL-Processor-ebook/dp/B07BTV7QVR/ref=sr_1_11?qid=1707418800&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-11
>
> Moving Forth - Internals and TTL Processor Kindle Edition
> by Brad Rodriguez (Author), Juergen Pintaske (Editor) Format: Kindle Edition
> 3.9 3.9 out of 5 stars 13 ratings
> See all formats and editions
> In 2018 we have 50 Years of Forth. When I looked for a new project for an eBook I realized that one area is not very well covered:
> How do the Forth internals work?
> How can you build a Minimal Processor executing Forth directly?
> How do you write an Assembler in Forth?
> When I looked around for some documentation, I remembered this series of articles again. They seems to fit very well together.
> I contacted Brad and asked for permission to publish them as part of the Forth Bookshelf.
> He liked the idea so I started formatting. I did not change any of the original material.The only part I added was an appendix, where I redid some of the pictures, so I could understand them better.
> As in many cases, additional material can be found on the Forth-eV.de Wiki, and we will start with the appendix added here, and what else we might come up.
> I have to thank Brad Ridriguez for the copyright to publish this documentation.
> Enjoy reading and any feedback please send to epld...@aol.com.
>
> From Brad: Everyone in the Forth community talks about how easy it is to port Forth to a new CPU. But like many "easy" and "obvious" tasks, not much is written on how to do it! So, when Bill Kibler suggested this topic for an article, I decided to break with the great oral tradition of Forthwrights, and document the process in black and white.
> Over the course of these articles I will develop Forths for the 6809, 8051, and Z80. I'm doing the 6809 to illustrate an easy and conventional Forth model; plus, I've already published a 6809 assembler [ROD91,ROD92], and I'll be needing a 6809 Forth for future TCJ projects. I'm doing the 8051 Forth for a University project, but it also illustrates some rather different design decisions. The Z80 Forth is for all the CP/M readers of TCJ, and for some friends with TRS-80s gathering dust.

And IPS - FORTH on Satellites
https://www.amazon.co.uk/IPS-Forth-like-Language-PROGRAMMING-SYSTEMS-ebook/dp/B07SGWCSKT/ref=sr_1_5?qid=1707418800&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-5

IPS - a Forth-like Language for Space: HIGH LEVEL PROGRAMMING OF SMALL SYSTEMS IN SPACE Kindle Edition
by Dr. Meinzer (Author), Juergen Pintaske (Editor) Format: Kindle Edition
4.8 4.8 out of 5 stars 9 ratings
See all formats and editions
The IPS System - 1 General design considerations IPS was primarily designed to allow the speedy writing of programs intended for the control of satellites, scientific data collection and other engineering applications. There are many programming languages claiming to be suitable for these applications. But on closer inspection most of these require either rather large systems and thus are not very practical for microcomputers or they have serious limitations, like insufficient speed or no multiprogramming. Most control oriented languages are derived from languages created for mathematical or commercial data processing. Generally, this means that the real-time part needs to be handled by the operating system, and the power of this combination is highly dependent on the capabilities of the operating system.With IPS a different approach was possible, since there is no real need to maintain compatibility with other languages and an entirely different approach could be taken. Every programming language represents an interface between machine and men. Thus, it must comply with two requirements: 1. The language should allow the translation of programs making efficient use of the underlying processor, both from a speed and memory economy point of view. This is essentially an engineering problem. 2. The language should allow the expression of problems in a way matching the human understanding and decomposition of problems; the system is to be "user-friendly". Achieving this is not an engineering problem, but a problem of psychology and aesthetics - a form of art. Let us look at the second point first. In order to be able to put the problem into perspective it would be necessary to define the "human way of understanding"; obviously an impossible task because it would have to take into account the different backgrounds of all the people intending to use the system.The second best approach would be to isolate certain general aspects of a problem area and make sure that these are matched by the language..

FIG FORTH and the 1802
https://www.amazon.co.uk/FIG-Forth-Manual-Documentation-Test-1802-ebook/dp/B01N42VLJE/ref=sr_1_25?qid=1707485671&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-25

FIG-Forth Manual: Documentation and Test in 1802 IP Kindle Edition
by C-H Ting (Author), Juergen Pintaske (Author), Steve Teal (Author) Format: Kindle Edition
2.9 2.9 out of 5 stars 6 ratings
See all formats and editions
This manual shows in detail how the FIG-Forth is designed, implemented and how it all works together. Very well explained by C-H Ting.. When we started to get it ready for publishing, we wanted to make sure it all still works.. The CDP1802 implementation in VHDL from another project came very handy and the Lattice board contains all of the hardware to replicate the function.. You can actually try it out yourself.

On Friday 9 February 2024 at 13:36:19 UTC, Jurgen Pitaske wrote:
> FIG FORTH and the 1802
> https://www.amazon.co.uk/FIG-Forth-Manual-Documentation-Test-1802-ebook/dp/B01N42VLJE/ref=sr_1_25?qid=1707485671&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-25
>
> FIG-Forth Manual: Documentation and Test in 1802 IP Kindle Edition
> by C-H Ting (Author), Juergen Pintaske (Author), Steve Teal (Author) Format: Kindle Edition
> 2.9 2.9 out of 5 stars 6 ratings
> See all formats and editions
> This manual shows in detail how the FIG-Forth is designed, implemented and how it all works together. Very well explained by C-H Ting.. When we started to get it ready for publishing, we wanted to make sure it all still works. The CDP1802 implementation in VHDL from another project came very handy and the Lattice board contains all of the hardware to replicate the function. You can actually try it out yourself.

TING and his EP32
https://www.amazon.co.uk/EP32-RISC-Processor-Description-Implementation-ebook/dp/B071D3XMPS/ref=sr_1_28?qid=1707485671&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-28

EP32 RISC Processor IP: Description and Implementation into FPGA Kindle Edition
by Dr. Chen-Hanson Ting (Author), Steve Teal (Editor), Juergen Pintaske (Editor) Format: Kindle Edition
4.2 4.2 out of 5 stars 4 ratings
See all formats and editions
A 32 Bit RISC Processor in VHDL. VHDL Code Package ordered separately includes Simulator.
It seems to be impossible, but you can design your own 32 processor system. Here with the help of the free to download Lattice Diamond Software just needed to program the FPGA.
The image ( available soon ) includes the synthesized VHDL and the eForth and is programmed into the FPGA, start your favorite Terminal program and reset the Brevia board - writing code can start. More details to be found at https://wiki.forth-ev.de/doku.php/projects:ep32:start
No additional hardware needed to get started, communication and Power Supply via the same USB cable.

From the book:
The eP32 microprocessor is a Minimal Instruction Set Computer (MISC), vis-à-vis Complicated Instruction Set Computer (CISC) and Reduced Instruction Set Computer (RISC). MISC was originally developed by Mr. Chuck Moore, and implemented in his MuP21 chip. It happened that Chuck also invented the FORTH programming language. For many years, Chuck sought to put FORTH into silicon, because he thought FORTH was not only a programming language, but also an excellent computer architecture.

In the early 1990s, a group of engineers from the MOSIS multiple design chip service program came to Silicon Valley and started Orbit Semiconductor Corp, offering foundry services to the general public. Their service was based on a 1.2 micron CMOS processes on 5 inch wafer, with two metal layers. The smallest design they accepted was on a 2.4mmx2.4mm silicon die. Chuck figured that he could design a 20 bit CPU in that small area. It was named MuP21, because it was a multiprocessor chip, with a 20 bit CPU core, a DRAM memory coprocessor, and a video coprocessor, and all registers and stacks in the CPU core were 21 bits wide, with an extra bit to preserve the carry bit..

Because of very limited silicon area, the MuP21 had a very small set of instructions, but they were sufficient to support a complete FORTH operating system and very demanding applications with real time NTSC video output. The chip was produced and verified, but productions in plastic packages were not successful because of poor yield.

When FPGA chips became available, I tried to implement FORTH chips based on MuP21 instruction set. The first experiments were on an XS40 Kit from Xess Corp. It had a Xilinx VC4005XL FPGA on board with a 32 kB SRAM chip and an 8051 microcontroller. The purpose of this kit was to demonstrate how easy it was to use an FPGA to replace all glue logic between RAM and 8051, and to build a complete working microprocessor system. I managed to squeeze a 16-bit microprocessor, P16, into the VC4000XL chip and eliminated the 8051.

Over the years, Xilinx added more logic gates and RAM blocks to their FPGAs, and I was able to put a 32-bit microprocessor, P32, into a VCX1000E chip (which had 16 kB of RAM) to host a FORTH system. This design was also ported to FPGA chips from Altera and Actel. P32 gradually evolved into eP32 with an eForth operating system. eForth is a very simple FORTH operating system designed specifically for embedded systems. However, FPGA chips were expensive, development boards were expensive, and development software tools were especially expensive. I talked about eP32 implementations, but very few people in the audience had these development tools to explore FPGA designs.

It was therefore very exciting to learn about the LatticeXP2 Brevia Development Kit, which was on sale for $49. Development software was free to download. The Kit has a LatticeXP2-5E-6TN144C FPGA chip, which has enough logic cells to implement eP32, and enough RAM memory to host the eForth system. Its RAM memory is mirrored in flash memory on chip, and you do not need external memory chips for programs and data. It is truly a single chip solution for microprocessor system design.

Going back to the beginning of Forth:
https://www.amazon.co.uk/Footsteps-Empty-Valley-issue-3-ebook/dp/B06X6JGM5L/ref=sr_1_30?qid=1707485671&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-30

Footsteps In An Empty Valley issue 3 Kindle Edition
by Chen-Hanson Ting (Author), Juergen Pintaske (Editor) Format: Kindle Edition
5.0 5.0 out of 5 stars 2 ratings
See all formats and editions
Chuck Moore is the inventor of the High Level computer Language Forth. In this eBook you find the background, how and why it was designed as is. People talk about C friendly instruction set - but Chuck went one level further and implemented complete functionality in silicon long before others looked at such configurations. And there is the Forth code from then, designed by Chuck and typed in by Ting. A lot has changed from the first edition of Footsteps. It has been heavily updated in 2016/2017 to add the latest information and add cleaned up pictures. We are working as well on the Novix IP to have this processor core revived adapted and running on an FPGA Board - the same as we did for the FIG-Forth Manual, where we implemented a basic RCA CDP1802 - more than 30 years later. See it at https://goo.gl/RIjHLU And it does run the code published and described in the eBook. There is more and how to implement it at https://wiki.forth-ev.de/doku.php/projects:fig-forth-1802-fpga:start and I added there as well a screen print I did running the system at my desk. Enjoy reading this book. It is part of our Forth Bookshelf at https://www.amazon.co.uk/Juergen-Pintaske/e/B00N8HVEZM

This is a special one. I formatted in a way, so it is just 1 page. OK alarge one A2 size, hanging on my wall now
https://www.amazon.co.uk/eForth-Overview-C-H-Ting/dp/1726852369/ref=sr_1_10?qid=1707486205&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-10

eForth Overview: C.H. Ting Paperback – 19 Oct. 2018
by C.H. Ting (Author), Juergen Pintaske (Editor)
4.5 4.5 out of 5 stars 12 ratings
See all formats and editions
Before diving directly into eForth, I would like to discuss the general principles of Forth language. The language consists of a collection of words, which reside in the memory of a computer and can be executed by entering their names on the computer keyboard. A list of words can be compiled, given a new name and made a new word. In fact, most words in Forth are defined as lists of existing words. A small set of primitive words are defined in machine code of the native CPU. All other words are built from this primitive words and eventually refer to them when executed.

On Friday 9 February 2024 at 13:46:14 UTC, Jurgen Pitaske wrote:
> This is a special one. I formatted in a way, so it is just 1 page. OK alarge one A2 size, hanging on my wall now
> https://www.amazon.co.uk/eForth-Overview-C-H-Ting/dp/1726852369/ref=sr_1_10?qid=1707486205&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-10
>
> eForth Overview: C.H. Ting Paperback – 19 Oct. 2018
> by C.H. Ting (Author), Juergen Pintaske (Editor)
> 4.5 4.5 out of 5 stars 12 ratings
> See all formats and editions
> Before diving directly into eForth, I would like to discuss the general principles of Forth language. The language consists of a collection of words, which reside in the memory of a computer and can be executed by entering their names on the computer keyboard. A list of words can be compiled, given a new name and made a new word. In fact, most words in Forth are defined as lists of existing words. A small set of primitive words are defined in machine code of the native CPU. All other words are built from this primitive words and eventually refer to them when executed.

Regarding eForth Overview - and here you find the link to download it as one page - or on normal print pages that you can put together with sticky tape
https://wiki.forth-ev.de/doku.php/en:projects:430eforth:start

eForth on the Arduino - if you know how to program tha 328 and overwrite the Bootloader ...
https://www.amazon.co.uk/Arduino-eForth-Chen-Hanson-Ting/dp/1726868478/ref=sr_1_6?qid=1707486205&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-6

Arduino and eForth Paperback – 8 Nov. 2018
by Chen-Hanson Ting (Author), Juergen Pintaske (Editor)
4.4 4.4 out of 5 stars 7 ratings
See all formats and editions
All these years, I have been looking for microcontroller platforms on which I can teach people how to program in the FORTH language. I designed a training course I called Firmware Engineering Workshop. I could train an open minded engineer to program in FORTH in about a week, with a reasonable capable platform, i.e., a microcontroller evaluation board with a FORTH operating system loaded. Good platforms are expansive, and low-cost platforms are inadequate. What I did was to grab any microcontroller board at hand and used it. It did not work well because what I taught could not be easily replicated by people at home. People got frustrated when they could not reproduce results I demonstrated. Then, I found the Arduino Uno Board. The microcontroller evaluation board I need must have a microcontroller with reasonable capabilities. An 8-bit microcontroller with a fast clock is adequate. 16-bit of 32-bit microcontrollers are of course much better. The board must have at least 8 KB of ROM memory and 1 KB of RAM memory. It must also have a USART port to communicate with a terminal emulator on a host PC. Any other I/O devices will be icings on the cake. The more the better. Arduino Uno has all of the components I listed above. It is also inexpensive, costing only $29. It uses ATmega328P, a very interesting microcontroller which has 32 KB of flash memory, enough to host a FORTH operating system, 2 KB of RAM and many I/O devices to build substantial applications. Arduino Uno also has a USB port which connects to a PC and an USART device in ATmega328P. This serial interface is necessary for a FORTH system so that you can run and program ATmega328P interactively from a terminal emulator on the PC – as the complete Forth is on the chip. Arduino Uno is a lovely machine. You connect it through a USB cable to your PC, and you can program it to do many interesting things. Its microcontroller ATmega328P, running at 16 MHz, is very capable of running many interesting applications. The template of a sketch, which is the software in Arduino 0022, captures the essence of firmware programming in casting user applications in two statements: setup() and loop(). It eliminates all the syntactic statements required by a normal C program and exposes to you only the core of an application. However, Arduino software insulates you from the intricate nature of ATmega328P microcontroller, its instruction set, and its I/O devices. Instead, you are given a library of useful routines which are used to build applications. The insulation initially helps you to program the microcontroller in a C-like high level programming language. However, being an 8 bit microcontroller, ATmega328P in C language will run out of gas when application demands performance. At this point, you will have to get down to the bare metal to push ATmega328P to its limit. Then, you have to learn its instruction set and all its I/O devices, and perhaps program it in assembly language. The best alternative approach is to program ATmega328P in the FORTH language. FORTH exposes ATmega328P to you. You can interactively examine its RAM memory, its flash memory, and all the I/O devices surrounding the CPU. You can incrementally add small pieces of code, and test them exhaustively. An interactive programming and debugging environment greatly accelerates program development, and ensures the quality of the program. Since 1990, I have been promoting a simple FORTH language model called eForth. This model consists of a kernel of 30 primitive FORTH commands which have to be implemented in machine instructions of a host microcontroller, and 190 compound FORTH commands constructed from the primitive commands and other compound commands. By isolating machine dependent commands from machine independent commands, the eForth model can be easily ported to many different microcontrollers. This model is ported to ATmega328P, and the result is the 328eForth system.

And a different approach, Georg Heinrichs started to write his Forth from scratch
https://www.amazon.co.uk/ATTINY-Forth-Project-Combined-English/dp/172662692X/ref=sr_1_27?qid=1707502437&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-27

ATTINY Forth Project: Combined English and German Version Paperback – 7 Oct. 2018
by Georg Heinrichs (Author), Juergen Pintaske (Editor)
See all formats and editions
2018 is the time to celebrate 50 Years of Forth. This year in September is as well EuroForth 2018 – where the Forth specialists meet, this time at the river of Forth in Scotland. The inventor of Forth, Chuck Moore, has been invited to attend, and he promised he will be there. And he was there.I started the Forth Bookshelf 5 years ago. It has now – including this book – grown to 20 books altogether. First published as eBook for cost reasons and no delivery cost. But many people want to hold the print book in their hands, so this year I started converting, and 6 books are available now as print book now as well – with more to come over the next couple of months.I stumbled by chance over this project of Georg Heinrichs, when I was looking for a Forth for the small Microchip Attiny 2313.. There really is a small Forth implementation with the whole Forth on the chip – but not tried it yetThe 2313 has it’s limitations: with just 2k of Flash.But on the positive there is a 20 pin DIL-package. So very breadboard friendly. Easy PCB to make if needed.There are smaller packages, if you can deal with it. But there was another reason for me as well:There is one other book on the Forth Bookshelf - the Sparrow; where there is no Forth implementation yet, as it uses the Attiny13, which is even smaller with its 8 pin DIL package – and 1k FLASH.BUT SPARROW can be programmed over the internet – no PC, no special software, no programmer required, just your mobile phone/PC, and this chip could be probably used as a target for this MikroForth as well. Still to be tested.Back to this MikroForth project here now:I contacted Georg and started with a first translation, as his German version would be a bit difficult to digest for a worldwide audience. He agreed to the translation. We started a Wiki page on the German Forth group website, and there is much of this available now for download and print at https://wiki.forth-ev.de/doku.php/attiny . More to be added as there is time.I do like the approach that Georg took and he kindly agreed that I can convert his information into an eBook – and later then as well as print book as part of Forth Bookshelf at https://www.amazon.co.uk/Juergen-Pintaske/e/B00N8HVEZMAnybody with a 2313 chip, a resistor and a capacitor – plus a USBtoTTL converter can get going as the software runs on the PC and generates a hex file for programming .Georg offers as well chips with a Bootloader programmed in already: You can find his website at http://www.g-heinrichs.de/wordpress/A complete kit of parts including the PCB – as shown on the cover page.And as well a pre-programmed chip 2313 with a bootloader already programmed in.There is as well a blog in German at http://www.forum.g-heinrichs.de/viewforum.php?f=12But the project can be built using a solderless breadboard as well.Or some other options I tried out and documented here in addition.One of the points important to me ist to have a system in a box including batteries, so you can run an application without problems – and in an enclosure which is probably available worldwide – I often use a TicTac Box as we needed a low-cost enclosure for the MicroBox project..I tried tis out to ensure it all works. But just take it as example and find your own way.Enjoy the eBook – a print version is planned and will be available some time in 2018/19, depending on interest.I took the decision to make this documentation available as a combined version in English for the non-German world, but to keep as well Georgs original in German – rather than publishing two separate items.I am planning to have this eBook available on amazon around EuroForth (12th of September ) so there might have to be a preliminary version.We hope you enjoy this eBook – and please leave a bit of feedback at amazon, so other readers can use your feedback as guidance. I am often asked why Forth – there is Python, C, and many other languages. But I like Forth

And another one of Tig's works:
https://www.amazon.co.uk/eForth-Zen-32-bit-86eForth-Visual-ebook/dp/B06VXR1TX3/ref=sr_1_7?qid=1707554149&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-7

eForth and Zen - 3rd Edition 2017: with 32-bit 86eForth v5.2 for Visual Studio 2015 Kindle Edition
by Dr. Chen-Hanson Ting (Author), Juergen Pintaske (Editor) Format: Kindle Edition
4.6 4.6 out of 5 stars 11 ratings
See all formats and editions
eForth has a long history, but here in this eBook you see it updated, and the 2017 edition 3 includes ports that are recent, and all of the sources are available to order, check and use - directly from Ting. It is important to have this whole range of eForth variants available, as this eForth range of implementations includes as well so called Soft Cores, which are microprocessors, targeted at Programmable devices called FPGAs. Here, a standard version supplied separately can be used in projects and in addition to the processor core the complete eForth language to drive this chip is supplied. In addition, the Core can be modified, and the modifications can be controlled by extensions of the supplied eForth software - complete flexibility to adapt SW and HW to the design.

You are spamming.

On Sat, 10 Feb 2024 09:19:47 +0000
minforth@gmx.net (minforth) wrote:

> You are spamming.

Maybe 'his' books aren't selling well.

--
Bah, and indeed Humbug.

On Saturday 10 February 2024 at 09:20:54 UTC, minforth wrote:
> You are spamming.

Well, there are different points of view in this world.
I cannot see posts about Forth, so the Forthers have gone elsewhere anyway.
As posting here will stop in less than 2 weeks, I thought a list of books about Forth might be a good idea.
And there are only one or 2 left ...

On Saturday 10 February 2024 at 09:23:30 UTC, Kerr-Mudd, John wrote:
> On Sat, 10 Feb 2024 09:19:47 +0000
> minf...@gmx.net (minforth) wrote:
>
> > You are spamming.
>
> Maybe 'his' books aren't selling well.
>
> --
> Bah, and indeed Humbug.

I agree with you - HUMBUG.
Hopefully this is the last post I see from you.
Really looking forward to this.

On 10/02/2024 8:29 pm, Jurgen Pitaske wrote:
> On Saturday 10 February 2024 at 09:23:30 UTC, Kerr-Mudd, John wrote:
>> On Sat, 10 Feb 2024 09:19:47 +0000
>> minf...@gmx.net (minforth) wrote:
>>
>>> You are spamming.
>>
>> Maybe 'his' books aren't selling well.
>>
>> --
>> Bah, and indeed Humbug.
>
>
> I agree with you - HUMBUG.

Not selling or not the author? If the former then you can relinquish
your copyright to the books and donate them to forth.org. Only then
will you and authors be on the same page.

On Saturday 10 February 2024 at 11:17:48 UTC, dxf wrote:
> On 10/02/2024 8:29 pm, Jurgen Pitaske wrote:
> > On Saturday 10 February 2024 at 09:23:30 UTC, Kerr-Mudd, John wrote:
> >> On Sat, 10 Feb 2024 09:19:47 +0000
> >> minf...@gmx.net (minforth) wrote:
> >>
> >>> You are spamming.
> >>
> >> Maybe 'his' books aren't selling well.
> >>
> >> --
> >> Bah, and indeed Humbug.
> >
> >
> > I agree with you - HUMBUG.
> Not selling or not the author? If the former then you can relinquish
> your copyright to the books and donate them to forth.org. Only then
> will you and authors be on the same page.

I was not aware that you are mentally handicapped.
And your reading capabilities have deteriorated as well.
It is quite clearly stated who is the author and who is the publisher.
But is shows quite clearly that you are not interested.
Just want to post your silly shit.

On Saturday 10 February 2024 at 12:52:10 UTC, Jurgen Pitaske wrote:
> On Saturday 10 February 2024 at 11:17:48 UTC, dxf wrote:
> > On 10/02/2024 8:29 pm, Jurgen Pitaske wrote:
> > > On Saturday 10 February 2024 at 09:23:30 UTC, Kerr-Mudd, John wrote:
> > >> On Sat, 10 Feb 2024 09:19:47 +0000
> > >> minf...@gmx.net (minforth) wrote:
> > >>
> > >>> You are spamming.
> > >>
> > >> Maybe 'his' books aren't selling well.
> > >>
> > >> --
> > >> Bah, and indeed Humbug.
> > >
> > >
> > > I agree with you - HUMBUG.
> > Not selling or not the author? If the former then you can relinquish
> > your copyright to the books and donate them to forth.org. Only then
> > will you and authors be on the same page.
> I was not aware that you are mentally handicapped.
> And your reading capabilities have deteriorated as well.
> It is quite clearly stated who is the author and who is the publisher.
> But is shows quite clearly that you are not interested.
> Just want to post your silly shit.

Nearly 1600 people looked at this post.
About 5 of them posted bullshit.
Quite a good result.

On Saturday 10 February 2024 at 12:58:45 UTC, Jurgen Pitaske wrote:
> On Saturday 10 February 2024 at 12:52:10 UTC, Jurgen Pitaske wrote:
> > On Saturday 10 February 2024 at 11:17:48 UTC, dxf wrote:
> > > On 10/02/2024 8:29 pm, Jurgen Pitaske wrote:
> > > > On Saturday 10 February 2024 at 09:23:30 UTC, Kerr-Mudd, John wrote:
> > > >> On Sat, 10 Feb 2024 09:19:47 +0000
> > > >> minf...@gmx.net (minforth) wrote:
> > > >>
> > > >>> You are spamming.
> > > >>
> > > >> Maybe 'his' books aren't selling well.
> > > >>
> > > >> --
> > > >> Bah, and indeed Humbug.
> > > >
> > > >
> > > > I agree with you - HUMBUG.
> > > Not selling or not the author? If the former then you can relinquish
> > > your copyright to the books and donate them to forth.org. Only then
> > > will you and authors be on the same page.
> > I was not aware that you are mentally handicapped.
> > And your reading capabilities have deteriorated as well.
> > It is quite clearly stated who is the author and who is the publisher.
> > But is shows quite clearly that you are not interested.
> > Just want to post your silly shit.
> Nearly 1600 people looked at this post.
> About 5 of them posted bullshit.
> Quite a good result.

Sorry, I do have to mention as well,
that there were a few positive exchanges actually - Forth related.

Just for completeness the last book on the list I think.
Unfortunately, MPE changed its mind and wanted to set conditions that I could not agree with.
So, after a few years of availability, it had to be unpublished on amazon, but I still own a few.
https://www.amazon.co.uk/Programming-Forth-Version-July-2016/dp/1717967663/ref=sr_1_36?qid=1707573940&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-36

Programming Forth: Version July 2016 Paperback – 2 Aug. 2018
by Stephen Pelc (Author), Juergen Pintaske (Editor)
4.6 4.6 out of 5 stars 12 ratings
See all formats and editions
Programming Forth introduces you to modern Forth systems. In 1994 the ANS Forth standard was released and unleashed a wave of creativity among Forth compiler writers. Because the ANS standard, unlike the previous informal Forth-83 standard, avoids specifying implementation details, implementers took full advantage. The result has been what I choose to call modern Forths, which are available from a range of sources both commercial and open-source.

Checking the list, showed that this little gem had not been included yet. A little one, but by Chuck
https://www.amazon.co.uk/Forth-Background-information-beginnings-Computer-ebook/dp/B00JZI64U8/ref=sr_1_14?qid=1707582843&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-14

Forth - The Early Years: Background information about the beginnings of this Computer Language Kindle Edition
by Charles H Moore (Author), Juergen Pintaske (Editor) Format: Kindle Edition
4.2 4.2 out of 5 stars 22 ratings
See all formats and editions
Forth is a very special computer language - as is the inventor Charles H Moore. This eBook describes the early years of Forth, a simple natural computer language as Charles describes it, and how it developed over the years. It documents the different locations where the inventor Charles H Moore worked and optimized Forth.
MIT 1958, Stanford 1961, Freelance 1965, Mohasco 1968, NRAO 1971.
Within programming community there is a very strong feeling about this language - for it and against it, often quite emotional.
Charles' moral from the eBook:
I know Forth is the strongest language so far.
I'm disturbed that people who should don't appreciate how it embodies their own description of the ideal programming language.
Forth has lead to an architecture that promises a wonderful integration of software and silicon.
One way it has been described: You need longer to learn it to work with it efficiently - but from then on you will program faster. The same even seems to apply if the programmes steps back to her/his language of choice.

And another one as well
https://www.amazon.co.uk/Real-Time-Forth-Tim-Hendtlass-ebook/dp/B06Y6FYPN1/ref=sr_1_18?qid=1707583246&refinements=p_27%3AJuergen+Pintaske&s=books&sr=1-18

Real Time Forth Kindle Edition
by Tim Hendtlass (Author), Juergen Pintaske (Editor) Format: Kindle Edition
5.0 5.0 out of 5 stars 7 ratings
See all formats and editions
Tim Hendtlass, the author of Real Time Forth, obtained a PhD in Ionospheric Physics in 1974 working at Massey University, New Zealand, and then worked at RMIT and Swinburne University of Technology, both in Melbourne, Australia where he currently resides.
Discovered Forth in 1979 and used it as his primary programming language until the mid-1980’s. His first AI applications were written in Forth and he earned notoriety by teaching introductory digital electronics by taking his students through the design of a stack oriented processor with Forth as its native language.
This design operated successfully when realised using an FPGA and was demonstrated to the students at the end of the subject. Still uses Forth today as the problem definition language in his population based optimisation work.. His current Forth engine (written in Pascal) has a data stack that can concurrently hold integers, floats, strings, arrays and matrices.
The book Real Time Forth was written in 1993, and contains a vast amount of Forth code to go through and understand; and this gem has now been saved and made available as part of the Forth Bookshelf at https://www.amazon.co.uk/Juergen-Pintaske/e/B00N8HVEZM .
The book is based on F-PC, a DOS based Forth, which was very much in use at the time. Additional information from the Preamble: This book has been written to provide information about using a computer with the real world so the two may work cooperatively together. In many situations in which a computer is used, the main constraint is getting the job done, usually as quickly as possible. The exact time each part of the task takes is not of great significance and the job proceeds with timing to suit, and dictated by, the computer.
Interfacing the computer with the outside world requires things to be done at precisely the times the outside world demands. Often many things (tasks) must be done, if not together, in an interleaved way so that one task is not kept waiting to start until all other tasks have fully finished. Data will need to be taken as and when available, output will need to be passed on at the times and in the form the outside world needs it. This is why there is 'Real Time' in the title. Why Forth?
This book is intended for use as a teaching text, either in a formal situation or for self study. The only way to learn is to first read and then to do. This requires that a language suitable for the task be chosen. Forth is used as the language for interfacing for a number of good reasons. It is fast, especially when run on hardware designed for the language, but fast enough even when run on general purpose equipment.
It is interactive, providing an environment in which immediate testing as you go clarifies the task in hand and helps catch errors early so they can be painlessly corrected. It is a rich, structured language that provides facilities useful for interfacing that are missing in many other languages.

Just as a quick summary:
Which Forth books of this list here are people interested in?
See the top 100 in Compiler Design
https://www.amazon.com/best-sellers-books-Amazon/zgbs/books/3970/ref=zg_bs_pg_2_books?_encoding=UTF8&pg=2

On Sunday 11 February 2024 at 11:14:31 UTC, Jurgen Pitaske wrote:
> Just as a quick summary:
> Which Forth books of this list here are people interested in?
> See the top 100 in Compiler Design
> https://www.amazon.com/best-sellers-books-Amazon/zgbs/books/3970/ref=zg_bs_pg_2_books?_encoding=UTF8&pg=2

And the link to this post to save somewhere,
as there is so much rubbish now on CLF:
https://groups.google.com/g/comp.lang.forth/c/lkwh5gcqf8M
May the Forth be with you ...