Trace: » forth03.html

[hemmerling] FORTH 3/6

Integrated Development Environments ( IDEs ) & Terminal Software with FORTH Support

The FORTH Development Process

Classical - 100% of static Code Generation on the Host ( Tethered FORTH )

  • The FORTH system boots on the target.
  • Typical in the era of software updates on the target, by buring new EPROMs ( 1975-2000 ).
  • All modern software tools for editing, code generation and source code saving can be used. But at that time, 1975-2000, typically no CVS. No continous delivery though.
  • Waterfall software development process:
    1. Create source code on the host, using a simple editor or an IDE.
    2. Generate code on the host, using an IDE, compiler, assembler.
    3. Optional testing on a hardware & software simulator, on the host.
    4. Burn EPROMs for the target, or flash the complete FlashMemory of the target.
    5. The FORTH application might be executed from FlashMemory or from RAM, this depends from the FORTH implementation.
    6. Run, test and debug the application on the target.
  • Example:
    • FORTH on an embedded board with 808x / Z80 / 6502 CPU.

Classical - 100% of static Code Generation on the Host, optional dynamic Code Generation on the Target

  • The FORTH system boots on the target.
  • Typical in the era of software updates on the target, by buring new EPROMs ( 1975-2000 ).
  • All modern software tools for editing, code generation and source code saving can be used. But at that time, 1975-2000, typically no CVS. No continous delivery though.
  • Waterfall software development process:
    1. Part I.
      1. Create source code on the host, using a simple editor or an IDE.
      2. Generate code on the host, using an IDE, compiler, assembler.
      3. Optional testing on a hardware & software simulator, on the host.
      4. Burn EPROMs for the target, or flash the complete FlashMemory of the target.
    2. Part II.
      1. The host provides an editor for creating & editing source code.
      2. The target is connected to a serial terminal of a host.
      3. The host transfers FORTH source code to the target, as if typed in by humans. The transfer stopps automatically in case of syntax errors or other faults, deteced by the FORTH system on the target.
      4. The assembler is integrated part of the FORTH system on the target.
      5. New words may be implemented immediately, but just temporarily.
    3. Part III: Run, test and debug the application on the target.
  • Example:
    • FORTH on an embedded board with 808x / Z80 / 6502 CPU.

Primitive Classical, on the Target

  • The FORTH system boots on the target.
  • The target provides an editor for creating & editing source code.
    • Either the target has a keyboard input and video output, or the target is connected to a serial terminal of a host.
  • The assembler is integrated part of the FORTH system on the target.
  • New words may be implemented immediately.
  • FORTH definitions may be edited in the dictionary on the fly, rather than using “Screens” as most Forths of that era did. I.e. there is no saving of “Screens”. By this, source code was not stored, but immediately converted to “Block Code”, which could be re-edited. Remember that there was just 1 KByte of RAM!
  • No CVS.
  • Saving of the the code ( new words, the application ) on an external serial storage medium, i.e. cassette recorder tape.
  • Example:
    • FORTH on the personal computer “Jupiter ACE” / “Jupiter Ace 4000”.
    • FORTH on the personal computer “JU+TE-FORTH-System”.

Modern & Advanced Classical, on the Target

  • An operating system system ( or the FORTH system ) boots on the target.
  • Either the target has a keyboard input and video output, or the target is connected to a serial terminal ( on a host ).
  • The target provides an editor for creating & editing source code.
  • The assembler is integrated part of the FORTH system on the target. So mostly the assembler is no independant executable application. I.e. even if there is an operating system like MSDOS, the assembler ist mostly not an executable file on the file system.
  • New words may be implemented and made permanent immediately.
  • Typically no CVS.
  • Saving of the source code and the code ( new words, the application ) on the target.
    1. By a 16 line x 64 character / line block system. It is not transparent to the user, how this block data is stored.
      1. In files on a file system. Today, most forths load just plain text files.
      2. As raw data on a storage media, e.g. sectors on a floppy disk. Implemented in FORTH systems of the 1970th and early 1980th - This is a feature from the past which made it easy to get started, e.g. on a target with floppy disks, but without affordable operating system, e.g. on CP/M hardware without expensive CP/M license.
    2. On a file system, FORTH sources as text files, FORTH binaries as binary files.
  • Examples:
    • FORTH on the CP/M, Apple II+, MSDOS platforms with disk drives, ESP32forth with on-board SPIFFS file system.
    • FORTH with block system ⇒ See “The FORTH 64×16 Screen Paradigma”.
    • FORTH with file system ⇒ See “The FORTH 64×16 Screen Paradigma”.
    • ESP32forth provides a simple editor by the serial terminal.
    • FORTH on TI-99/4A,... “TurboForth supports disk blocks for storing program code and data (or indeed, anything you wish to store) on disk”.

Modern, on a rich Target

  • Target is a desktop PC, notebook PC, server or an embedded system, running a rich operating system, e.g. Linux, Windows, MacOSX ⇒ An operating system system boots on the target.
  • All modern software tools for editing, code generation, continous delivery and source code saving ( by a CVS system like Git / GitHub ) can be used.
  • New words may be implemented and made resident, immediately.
  • The editor for creating & editing source code must not be integral part of the FORTH system, but you may use an external editor.
  • Examples:
    • ForthWin / Forth2020 - Uses Notepad++ as editor. The documentation describes how to use another external editor.
    • Gforth - Uses Emacs as editor.
    • WinForth - Has it's own editor “IDE”.

Modern, on the Host but with an embedded Target

  • The FORTH system boots on the target.
  • The source code is created on on the host, by an IDE or a rich text editor ( e.g. Visual Studio Code,... ), which has special plugins to support FORTH software development. Saving of the source code on the file system of the host.
  • All modern software tools for editing, continous integration and source code saving ( by a CVS system like Git / GitHub ) can be used, on the host.
  • Compilation process:
    1. On the target.
      • The created source code is transfered to the target, by a special terminal application on the host ( RS232 terminal emulator on the host, with special text file transfer options ).
        • On the target, there is just a “FORTH prompt” waiting for new commands. So that a host IDE must carefully - hopefully with RS232 handshake - transfer the text of a FORTH word definition as if typed by a human.... :-(. This is legacy style of software development :-(.
        • Problem #1, if there is no handshake... at all :-(.
        • Problem #2, if there is handshake, but the limited serial buffer is not large enough, or the host terminal gets a timeout if it must wait too long. So that the FORTH system needs precious time to compile a word... while the dumb host IDE tries already to push FORTH source code to the target... :-(.
      • On the target, the FORTH system compiles it to code and loads the new words into RAM. The assembler is integrated part of the FORTH system on the target.
      • The updated FORTH system may be stored as dump on the host, and / or it is stored on the permanent FlashMemory memory on the target. But at the end of the day, you have to transfer a FlashMemory memory dump back to the host ( by an RS232 terminal emulator on the host, with special binary file transfer options ).
      • By this, new words may be implemented and made permanent immediately.
      • Example: IDE “4E4th - Forth For Education” for MSP430 Launchpad.
    2. On the host.
      • Experts told me: Most C-FORTHs can be said to be crosscompiled. Some may have ways to append “compiled” forth words to that source in some data form. Either just as source or as generated code/data.
      • By this, new words may be implemented and made permanent immediately.
      • The Ardunio IDE works similarily, but there the code is totally generated on the host.

Resources

The FORTH 64x16 Screen Paradigma

FORTH with forced 64x16 Screens only

  • The 64×16 “Screen” ( also called “1 Kbyte Block” ) was the a completely normal Forth model, until the late 1980s. The FORTH “1 KByte Block” was the equivalent to the block size on permanent storage systems, e.g. the Floppy Disk.
    • A “Sector” on a standard Floppy Disk = 512 Bytes.
    • The “Cluster Size” of two standard Floppy disk sectors = 1024 bytes.
    • Classical “Screens” of legacy historical FORTH systems don't have end-of-lines ( i.e. CR/LF, CR, LF ).
  • Source code comments:
    • In times of little RAM, there was no space and so no option for source code comments.
    • In the first line of a 64×16 Screen.
    • Source code comments since about 1980, by “Shadow Screens”.
      • Most keyboards, also of the first personal computer generation since 1977, are equipped with arrow keys, either two ( Apple II+ ) or four ( IBM-PC, ATARI-ST, AMIGA, MacOS,.. ).
      • If the FORTH Screen editor displays a “Screen”, you may switch to the “Shadow Screen” by pressing the arrow key ( ”⇒” ).
      • The “Shadown Screen” is a 64×16 block just for comments, no code.
      • If the FORTH Screen editor displays a “Shadow Screen”, you may leave to the “Shadow Screen” by pressing the arrow key ( ”⇐” ).
  • How was the most simple 64×16 screen editor implemented?
    • User feedback: “figForth for the 1802microprocessor needed a low level coded EMIT for output ( It could be an external terminal or some internal program giving the EMIT output on a screen ) and KEY to fetch keyboard input. These Forth words should be available in any Forth system. I expect the Forth editor was pubished somewhere, perhaps in Forth Dimensions.

List of FORTH Systems, categorized by the Editor Modes ( Blocks, Streaming Files )

Legacy 64x16 Screen-only FORTH
  • PC/FORTH by LMI, an MSDOS FORTH. It contains an excellent editor for block screens (64 chars, 16 lines). The top line was reserved for a screen comment.
  • Volksforth, an MSDOS FORTH.
  • Z79Forth.
FORTH with Screen & processing of standard Textfiles ( "Stream Files" )
  • ESp32forth hast a built-in “1K Screen” editor, but accepts a seamless character stream ( = the contents of a standard text file ) by a terminal connection.
  • Win32forth has a special editor which can handle both “Screens” and standard text files.
  • Gforth still comes with a block editor, PolyForth-style.
    • Brief operating instructions for the block editor:
      use blocked.fb
      1 load
    • and you have a block editor similar to the PolyForth editor ( of course, the block editor is in a block file, the only one in the Gforth distribution ).
      0 l
    • will give you the help screen. The last line there says “If you don't like it, write a block editor mode for Emacs!”
  • bigForth has a GUI-based editor, which is also capable of editing blocks.
  • Notepad ++ can be configured to operate in a 64 columns mode.
No Screens anymore
  • SwiftForth.
Resources
  • In the early 1990s, the editors of most of the FORTH implementations were converted to text editors without this restriction. Newly implemented FORTH systems were designed to accept text files. The “Screens” remained as an option.
  • Expert feedback in 2021: “It would appear virtually no-one uses Forth block editors these days unless it's the only option or they are seeking a serious retro fix”.
FORTH Systems with standard Text Files, without 64x16 Screens
  • Source code comments:
    (  ... )
    \  ...
    

Excursus: Use of SQL Databases to store FORTH Screens

Maximum Length of Strings in SQL Databases
  • IBM DB2.
      • Maximum length of CHAR (in bytes or OCTETS) 255.
      • Maximum length of CHAR (in CODEUNITS32) 63.
      • Maximum length of VARCHAR (in bytes or OCTETS)2 32,672.
      • Maximum length of VARCHAR (in CODEUNITS32)2 8168.
      • Maximum length of LONG VARCHAR (in bytes)1 32,700.
      • Maximum length of CLOB (in bytes or OCTETS) 2,147,483,647.
      • Maximum length of CLOB (in CODEUNITS32) 536,870,911.
  • Microsoft SQL Server.
    • SQLShack "SQL varchar data type deep dive", 2019 - “Microsoft SQL Server 2008 (and above) can store up to 8000 characters as the maximum length of the string using varchar data type. SQL varchar usually holds 1 byte per character and 2 more bytes for the length information”.
      • LOB Type - SQL Server Data Type - Max. Size.
      • BLOB - varbinary(MAX), Image - 2,147,483,647.
      • CLOB - varchar(MAX), Text - 2,147,483,647.
      • CLOB – Unicode nvarchar(MAX), NText - 1,073,741,823.
      • XML data - xml - 2,147,483,647.
    • The Text, NText, and Image data types come from the previous versions of SQL Server.
  • MariaDB.
      • MariaDB "VARCHAR" - “A variable-length string. M represents the maximum column length in characters. The range of M is 0 to 65,532. The effective maximum length of a VARCHAR is subject to the maximum row size and the character set used. For example, utf8 characters can require up to three bytes per character, so a VARCHAR column that uses the utf8 character set can be declared to be a maximum of 21,844 characters”.
      • “VARCHAR(size) Maximum size of 255 characters” - Limit of legacy versions?
  • MySQL.
  • SQLite.
Technical Problems to store a FORTH Screen by an SQL String in SQL Databases

Resources

    • User A: “The rule, a Screen 'does not under any circumstances whatsoever allow a definition to span a block boundary' was not always true. Some old fashion Screen/Block-based FORTH systems of the 1980th have an immediate word
      -->

      that allows 'continuing compilation, i.e. LOAD-ing, to the next Screen/Block”.

      • The definition of
        -->

        implemented in these three versions, that effectively allows a colon-definition to cross a Screen/Block boundary, is as follow:

        : -->
        ?LOADING
        0 >IN !
        B/SCR BLK @ OVER MOD - BLK +!
        ; IMMEDIATE
      • Some FORTH developers use the Term “Screen/Block”. But there is not always a 1-to-1 correspondence between “Screen” and “Block”.
        • A “Block” refers to a memory area (512 bytes usually) that is the image of a disk sector or an equivalent chunk of a plain file.
        • A “Screen” refers to a set of contiguous blocks that can be interpreted via LOAD (usually B/SCR is 2).
      • In addition ?LOADING has #22 error-message usually associated with it
        : ?LOADING
        BLK @ 0= 22 ?ERROR
        ;
      • -->

        is deprecated in the 2020s. It is replaced by the standard word THRU.

      • User B: “My recollection was that
        -->

        could be used BETWEEN word definitions, but it could not be used IN THE MIDDLE of a word definition. The implication, if I understand it correctly, was that a SYSTEM, a SET of word definitions, could span a block, but NO ONE WORD DEFINITION could cross a block boundary”.

How to organize a FORTH Project ?

Prologue

  • I know that in classical FORTH times of the 1980th, with little RAM, where a project must fit into 1 Kbyte of RAM ( Jupiter Ace !), or little more, it must have been easy to keep the overview over a FORTH project. But today with a simple ARM or MSP430 CPU, you have such an amount of interfaces and hardware modules, and with now a little bit more RAM ( e.g. 64Kbytes,..) anf FlashMemory ( e.g. 256 KBytes,..) so that the applications get more complex.
  • You have definitely this structure in a modern embedded software system:
    1. A driver level of C ( in case of a C-FORTH ) or assembly language ( as FORTH words implemented in assembler ).
    2. A lowest function level in FORTH which calls the drivers.
    3. Middleware.
    4. Top of application, e.g. user interface and control of the business process, technical process and / or the device.

Hierarchical tree, BottomUp

  • You first describe some basic FORTH words, and then build higher FORTH words until you reach a control level, where the application is really-working. You create the API before you are using it.
  • This seems to me the most “obvious” style for FORTH.
  • The same style is used by agile web developers, who don´t start with a defining a database model but prefer a non-SQL database as they can later add some fields as soon as needed.

Hierarchical tree, TopDown

  • The usual style for non-embedded applications, also using mockups, rapid prototyping tools &methods: First you bild the top of application, e.g. user interface and control of the business process, technical process and / or the device, but there is still no “action”. For the lower functions, you create an API before you implement it.
  • How can this be done by FORTH, as FORTH functions are based on earlier-defined FORTH functions which give results and have parameters...?

Hierarchical tree, first Drivers then TopDown

  • The most common and simplest way to create embedded systems is to first implement a basic low-level API of functions which initializes the hardware for the 1st. software release and gives access to the needed hardware for 1st. software release, and then switch to topdown development. So that you quickly have access to the hardware ( blinking LED,..), so that the top-level application can operate with limited functions quickly.
  • If the hardware manufacturer of the embedded board provides a “board support package” ( EN.Wikipedia "Board support package" to be loaded into RAM ) or even a “BIOS” ( EN.Wikipedia "BIOS", DE.Wikipedia "BIOS", usually resident in ROM or FlashMemory ), these implements hardware initalisation routines and non-reentrant low-level drivers for the board.
  • This is called in modern terms “Minimum viable product” ( EN.Wikipedia "Minimum viable product", DE.Wikipedia "Minimum Viable Product" ).
  • With FORTH, this might work if the top application code uses kind of mockup to pass by middle-level application functions, but that for a rapid prototyping toplevel functions call lowlevel functions.

How to document the Structure of the FORTH code of a FORTH project, inside the FORTH system or even outside ?

  • Documentation of the Structure of the FORTH code of a FORTH project:
    • HolonForth - “The first Holon system had a structure of modules, groups and (Forth) words”, inspired by the hierarchical presentation of classes in Smalltalk IDEs.
    • You might use graphical tools ( UML? ), or simply sketch tools to document the hierarchical tree of your FORTH vocabulary.

FORTH, a Spaghetti Code Language ?

  • Who agrees that in “old times”, or with hobbyist project even still nowadays, FORTH programmers are known to practice this style?
  • Usually this style is accused to be practiced by BASIC or C programmer, but if you do BottomUp programming in FORTH you loose any control what you are doing, easily...

Resources

IDEs & Editors with FORTH Support

4E4th - Forth For Education

Atom

BBEdit

  • 8th is shipped with syntax file for the MacOSX-only editor BBEdit, in the ”/docs/” folder.

Emacs

Notepad ++

Notepad ++
Plugin "TextFX Characters"
Python Script by Claudia Frank
Using Regular Expressions to split after 64 characters, by tomas-chrastina
Resources
  • “Settings / Preferences / Language” - Language Menu, Available items: 'Forth'” - Syntax highlighting of words versus numbers :-), no line break after 64 characters :-(.

Vim

  • 8th is shipped with syntax file for Vim, in the ”/docs/” folder.

VisualStudio Code

The IDE & FORTH
The IDE & Debugging ( C, FORTH, ... ) on ESP8266

Resources

  • For some editors and IDEs, it is possible to limit the line length to 62 characters + CR/LF, to emulate FORTH screens. But even if the line length is limited to 64 characters -including CR/LF -, this does not provide 1K text blocks ( due to missing space characters after the last non-space character, due to the missing limit to 16 lines ).... :-(.

Terminal Technology

Terminal Software with FORTH Support

e4thcom
MyFFshell

Standard Terminal Software & USB Serial Drivers / Virtual COM Port (VCP) Drivers

Protocols to transfer Data between 2 Terminals

Resources

Literature

English Books & Magazines

Magazines

  1. “The Computer Journal. Providing Support Around The World. Small Scale Computing Since 1983. Supporting the Trailing Edge of Technology. Hands on hardware and software”, ISSN 0748-9331 - “TJC = For Having Fun With Old Computers!”.
  2. FIG UK "Forthwrite" ( 1998 - 2004 ).

Publications

  1. “Association for Computing Machinery's Special Interest Group on Forth”.
    • “Newsletter of the Association for Computing Machinery's Special Interest Group on Forth / Association for Computing Machinery / Special Interest Group on Forth. - New York, NY : ACM Press, 1989-1993” - Available at TIB :-), but not available for loaning out :-(.
    • “ACM SIGForth newsletter / Association for Computing Machinery / Special Interest Group on Forth. - New York, NY : ACM Press, 1989-1994”.
  • “FORML”.
    • “FORML article reference : a listing of Forth articles from FORML conference proceedings, the euroFORML and euroForths from 1980 thru 1993 / Forth Modification Laboratory” ⇒ Can be loaned out, at TIB - “RO 2050(Ind, 1980-93)” - :-).
    • Several other papers are available at TIB :-), but not available for loaning out :-(.
  1. “Institute for Applied Forth Research”.
    • Several papers are available at TIB :-), but not available for loaning out :-(.

Books

    • The book refers to the fig-FORTH standard.
    • Editions:
      • 1984, TIB “Haus2, FJ 5885” :-).
      • 1989, revisioned and expanded edition, TIB “Haus2, FJ 5885/1989” :-).
    • Z-Library "Anita Anderson, Martin Tracy: Mastering FORTH", 1989 - “Revised and Expanded” ( 2nd. edition ).
    • “In this book, we will introduce you to each of the commands required by the FORTH-83 Standard”.
    • Named FORTH-83 implementations:
      1. UR/FORTH 1.0 by Laboratory Microsystems, Inc.
      2. PolyFORTH ISD-4 1.0 by Forth, Inc.
      3. F83 2.1.0, a popular public-domain dialect by Henry Laxen and Michael Perry. We will refer to this as L&P F83.
      4. MacFORTH Plus 3.53 by Creative Solutions, Inc.
      5. MasterFORTH 1.2.4 by Micromotion Products, Inc.
      6. ZEN 1.0, a simple subset of MasterFORTH.
  1. Leo Brodie
  2. Book Owen N. Bishop: "Exploring FORTH", 1984. TIB “Haus2, FH 2487” :-).
    • “There are two main versions FORTH. One of these, FORTH-79, is defined by a standard set out by the FORTH Standards Team. The other main FORTH is that prepared by the FORTH Interest Group in the United States of America. It is called fig-FORTH. These two versions have a lot in common. As far as possible, this book uses words which occur in both versions”.
  3. Book Paul M. Chirlian: "Beginning Forth", 1983 ( not available in TIB :-(, but available in TIB in German language :-) ).
  4. Document “HartForth - A 79-standard Forth compiler” by A. M. Graham, 1983.
    • The book refers to the FORTH-79 standard.
          • “Hartforth: Forth compiler by Andrew M. Graham (*) - Model I/III” - The readme.txt of the archive “forth5-1.zip” contains corrections for the user manual “forth.pdf”
             >>>>> Documentation Update <<<<<
            ==============================================================
            09/15/88 - Please make the following correction in the manual:
            page: 26 -- R should be R@
                  28 -- (blank)     @
                        C           C@
                  29 -- <           <#
                        (blank)     #
                        S           #S
                        >           #>
                  35 -- IN          #IN
                        D IN        D#IN
                  36 -- 2           2@
                  37 -- "           "@
                  41 -- F           F@
            -----
            Please make the following correction in the manual:
                 page 36: Screen Editor
                      control I (not control P) for "Put line..."
                      control K (not control E) for "Empty the entire..."
            Note: CONTROL is obtained by simultaneous depression of the
            SHIFT and DOWN-ARROW keys.
            ==============================================================
            
          • “Documentation: Text / PDF / Word 97 / Scripsit”.
  5. Richard De Grandis-Harrison.
      • “This version of FORTH is based on the public domain publications provided through the courtesy of the FORTH Interest Group” ( = fig-FORTH ).
      • “Published by: Acornsoft Limited. ATOM FORTH on cassette and System FORTH on disc are available from Acornsoft”.
      • The book refers to the FORTH-79 standard.
      • “Appendix A”
        1. *”The FORTH-79 Standard”.
        2. “1 System requirements” ( Acornsoft FORTH are in brackets ).
          1. 2000 ( 5000 ) min ! bytes of memory for application dictionary.
          2. Data stack of 64 ( 72 ) bytes.
          3. Return stack of 48 ( 234 ) bytes.
          4. Mass storage capacity of 32 ( 90 or more ) blocks,numbered consecutively from zero.
          5. One ASCII input/output device acting as an operator's terminal ( keyboard + VDU ).
        3. “2 Required word set” ( about 145 words ).
          1. 73 nucleus words:
            ! * */ */MOD + +! +loop - /MOD 0< 0= 0> 1+ 1- 2+ 2- < = > >R ?DUP Q ABS AND BEGIN C! C@ colon CMOVE constant create D+ D< DEPTH DNEGATE do does> DROP DUP else EXECUTE EXIT FILL I if J LEAVE literal loop MAX MIN MOD MOVE NEGATE NOT OR OVER PICK R> R@ repeat ROLL ROT semicolon SWAP then U* U/ until variable while XOR
          2. 35 interpreter words:
            £, £> KS ' ( -TRAILING 79-STANDARD <K >IN ? ABORT BASE BLK CONTEXT CONVERT COUNT CR CURRENT DECIMAL EMIT EXPECT FIND FORTH HERE HOLD KEY PAD QUERY QUIT SIGN SPACE SPACES TYPE U. WORD
          3. 29 compiler Words:
            +LOOP , ." : ; ALLOT BEGIN COMPILE CONSTANT CREATE DEFINITIONS DO DOES> ELSE FORGET IF IMMEDIATE LITERAL LOOP REPEAT STATE THEN UNTIL VARIABLE VOCABULARY  WHILE [ [COMPILE] ]
          4. 8 device words:
            BLOCK BUFFER EMPTY-BUFFERS LIST LOAD SAVE-BUFFERS SCR UPDATE
  6. “Dr. Dobb's Toolbook of FORTH”.
    1. Book Dr. Dobb's Toolbook of FORTH Paperback – 1 Jan. 1987, Marlin Ouverson "Dr. Dobb's Toolbook of Forth" ( = Volume I ) - “This collection of programs and tutorials on the Forth programming language has been drawn from Forth articles in 'Dr Dobb's Journal', revised and expanded where necessary and combined with new Forth material. Aspects of the language covered include the Forth philosophy, programs, mathematics and implementations. A computer disk containing source code, formatted in MS/PC-DOS, is available”. TIB “Haus2, FJ 9397(1)” :-).
    2. Book Dr. Dobb's Toolbook of FORTH Paperback – 1 Nov. 1987, 1987 ( = Volume II ) - “Picks up where the first volume of 'Dr Dobb's Toolbook of Forth' leaves off, and offers information on the most recently developed tools that can help Forth programmers improve their skills. Also available is a disk formatted in MS/PC-DOS which contains the screens from the book as ASCII files. The articles and material in this book are drawn from 'Forth Dimensions', 'Journal of Forth' and 'FORML'”. TIB “Haus2, FJ 9397(2)” :-).
  7. Book Glyn Emery: "The students' FORTH", 1985. TIB “Haus2, FH 9299” :-)
    • “This textbook provides information on using and implementing FORTH and is aimed at readers with some experience of programming in another language such as Basic. FORTH-83, the new implementation, is used throughout the book. The differences between this and the widely-used FORTH-79 are discussed, and in addition the author refers to MMSFORTH and the multi-user version POLYFORTH”.
  8. Book Ron Geere: "Forth: The Next Step", 1986. TIB “Haus2, FJ 7359” :-).
    • “There are, however, variants in the language and some word definitions can be in the native code of teh machine in use and probably will not transfer directly to a different processor type. These Forth dialects are usually not too different but where a difference is known to exist, this has been noted in the text. Additionally most differences are between FigForth and the '79-standard and are listed in Chapter 1. At the time of writing these two standards, although superseded, are still dominant in number. Variants considered are FigForth, '79-standard and '83-standard. Commercial variants such as MMS-Forth and PolyForth are not covered in this book because tehir comprehensive vensor support renders it unnecessary. Where CODE definitions are used, 6502 code is used with high-level Forth equivalents also included where applicable”.
    • “It shows how WHYP (a version of Forth written specifically for this book) can be used to program the new 68HC12 microcontroller in an efficient and interactive way. It includes an abundance of worked examples and complete C++ code for the WHYP host that runs on the PC”.
      • “To practice Forth on a PC you can use 'The Forth Course', a set of 11 lessons that use F-PC, a public domain, DOS-based Forth for the PC”.
        • “WHYP, which is pronounced whip and stands for Words to Help You Program”.
        • “WHYP is a subroutine threaded Forth which means that WHYP words are just the names of 68HC12(11) subroutines... The names of all WHYP words (subroutines) are stored in a dictionary that is maintained in the PC. We want to be able to “talk” to the target system by typing a WHYP word on the PC and having the corresponding WHYP subroutine execute on the target system. We do this by sending the address of the subroutine over the serial line to the target system... WHYP is run from a DOS prompt by typing WHYP12 (or WHYP11) at which point it looks like normal Forth. Each time a colon definition written, either by typing it on the keyboard or loading it from a file, the 68HC12 subroutine corresponding to the new word is downloaded to the target board at which point it is available to use”.
      • ResearchGate "WHYP - A C++ Based Version of ouForth for the Motorola 68HC11". Abstract - “The C++ program communicates with a 192-byte kernel that resides in the target system. WHYP contains four kinds of Forth words: primitive Forth words written in the native assembly language of the target; high-level, common Forth words written as colon definitions; high-level Forth words that are specific to the operation of the target microcontroller; and compiler-type Forth words that are written as C++ functions in the PC program. All header and dictionary information is maintained in the C++ program in the PC and only executable, subroutine-threaded code is resident in the target system. An example of WHYP that contains 107 primitive and over 170 high-level Forth words stored in less than half of the 12-Kbyte EPROM of a 68HC711E9 running in the single-chip mode on Motorola's EVBU board is presented”.
  9. Glen B Haydon.
    1. The free online book Glen B. Haydon "The FORTH Guide".
    2. Series of books “MVP-FORTH Series”, 1st. edition.
      • “MVP-FORTH Series / 2, MVP-FORTH Source Listings : 8080, CP/M. IBM-PC. APPLE II”, 1984, by Glen B Haydon. TIB “Haus2, FJ 2595(2)” :-).
      • “MVP-FORTH Series / 4, MVP-FORTH Expert System Toolkit : Knowledge-based inference program”, 1984 by J. Park. TIB “Haus2, FJ 2595(4)” :-).
      • “MVP-FORTH Series / 5, Data Security and file management system on MVP-FORTH”, 1983, by P. Moreton. TIB “Haus2, FJ 2595(5)” :-).
      • “MVP-FORTH Series / 6, MVP-FORTH Expert-2 [two] Tutorial”, 1984, by M. Derick and L. Derick. TIB “Haus2, FJ 2595(6)” :-).
      • “MVP-FORTH Series / 7, FORTH Guide : An exploration of the intricacies of MVP-FORTH”, 1985, by Glen B Haydon. TIB “Haus 2, FJ 2595(7)” :-).
      • “MVP-FORTH Series / 8, Professional Applications Development System (PADS) for IBM/PC/XT/AT”, 1985, by Thomas E. Wempe. TIB “Haus2, FJ 2595(8)” :-).
      • “MVP-FORTH Series / 9, Word Processor and calculator development system”, 1985, by Thomas E. Wempe. TIB “Haus2, FJ 2595(9)”.
      • “MVP-FORTH Series / 10, Word processor and calculator development system source” by Thomas E. Wempe. TIB “Haus2, FJ 2595(10)” :-).
    3. Series of books “MVP-FORTH Series”, 2nd. edition.
      1. Book “MVP-FORTH Series, Teil: 1: All about FORTH : an annotated glossary of common FORTH ideograms”, 3.print, by Glen B Haydon. TIB “Haus2, FJ 2595(1),2” :-).
      2. Book “MVP-FORTH Series, Teil: 2: FORTH floating Point”, 2. ed., completely rev, by P.J. (Paul) Koopman. TIB “Haus2, FJ 2595(3),2” :-).
  10. Shareware document “Real Time Forth” by Tim Hendtlass - Associate Professor Scientific Instrumentation Group Physics Department, Swinburne University of Technology -, 1993.
  11. The free online book concept “Building Forth” by “Immortalin”, uncompleted.
  12. Book David Johns: "A beginner's guide to Forth", 1984 ( not available in TIB :-( ).
  13. Paul A.C. Kail.
  14. Book Kenneth B. Knecht: "Introduction to FORTH", 1982 ( not available in TIB :-(, but available in TIB in German language :-) ).
  15. J. V. Noble.
    1. Book “A beginner's guide to Forth” by J. V. Noble.
  16. The free PDF book Stephen Pelc "Programming Forth" ( PDF ) about FORTH programming with MPE Forth.
    • ( Page 112 ) I/O ports. Memory mapped I/O is handled using the normal Forth memory operators. In some cases, peripherals are reset by reading a register and discarding the result:
      <address> @ drop
    • Extremely aggressive compilers, e.g. the MPE 68xxx and 386 VFX compilers, can optimise such phrases away. In these cases, synonyms such as P@ in place of @ (‘P’ for Port) will be available that cannot be optimised away. Where code such as device drivers is intended to be portable across different hardware, use of port access words makes portability much easier when code is moved to a CPU with a separate I/O space, e.g. Rabbit or 386. The standard port access words are:
      PC@ PW@ PL@ P@ PC! PW! PL! P!
    • The C/W/L denote 8/16/32 bit access and P@ and P! denote a native cell. For memory mapped systems you can always alias these words to an existing word using compiler macros.
    • All Forth cross compilers we have come across (at least for embedded work) provide a facility to name a number. This permits the names of numbers to be held in the compiler without using any space in the target except when used, in which case they will treated just like the number they represent. They are equivalent to conventional ssembly language equates and are defined like CONSTANTs.
      <value> EQU <name>
      
  17. Juergen Pintaske ( his books are not available in TIB :-( ).
    1. E-book Leo Brodie, Juergen G. Pintaske "Starting Forth" - “Updates to the original Starting FORTH text include code examples that run on iForth and SwiftForth systems”.
    2. Book Tim Hendtlass, Juergen Pintaske "Real Time Forth", 2019 - “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”.
    3. “Programming A Problem Oriented Language: Forth - how the internals work”.
    4. Book Stephen Pelc, Juergen G. Pintaske "Programming Forth: Version July 2016", 2018 - “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”.
  18. Elizabeth D. Rather ( her books are not available in TIB :-( ).
  19. Elizabeth D. Rather & Marlin Ouverson ( their books are not available in TIB :-( ).
  20. Book W. P. Salman, O. Tisserand, B. Toulout: "Forth, 1984. TIB “Haus2, FH 4570” :-).
    • 1982. TIB “Haus2, FF 7734” :-).
    • 1983, 2nd. printing. TIB “Haus2, FH 2840” :-).
  21. Book James Terry: "Library of Forth routines and utilities", 1986. TIB “Haus2, FO 931” :-).
  22. Book Alan Winfield: "The Complete FORTH", 1983. TIB “Haus2, FH 3659” :-).
  23. Jack Woehr.

Books #2

    • TIB “T 09 B 3287” :-).
    • “Masterminds of Programming includes individual interviews with: Charles H. Moore: FORTH” ( Chapter 4, pages 59-77 ).

Not a Book

German Books & Magazines

Magazines

Books

  1. Rainer Aumiller, Denise Luda.
  2. Leo Brodie
    1. Book Leo Brodie: "Programmieren in FORTH", 1984. TIB “Haus2, FH 3618”, “85-3491”, “Haus2, FH 3618”, “Haus2, FH 3618 a”, “Haus2, FJ 2593” :-).
    2. Book Leo Brodie: "In FORTH denken", 1986. TIB “89-4389” + “Haus2, AH 8792” :-).
  3. Book “Der Einstieg in FORTH” by Paul M. Chirlian, 1985.
  4. Ekkehard Floegel ( = Ekkehard Flögel ). His books were published by the legendary “Ingenieur W. Hofacker GmbH” publishing house.
  5. Book Thom Hogan, Gisela Nissen-Baudewig: "FORTH - ganz einfach" ( = Thom Hogan, Karl-Heinz Büchner: “FORTH - ganz einfach” ), 1985.
    • TIB “Haus2, FH 9322” :-).
    • TIB “Campusweiter Zugriff (Universität Hannover)” :-).
  6. Master / Diploma thesis 'Paul Kleinrubatscher: “Compilerbau mit Forth”', 1995.
  7. Book “Einführung in FORTH” by by Kenneth B. Knecht and Gayle C. Prokasky-Fraas, 1985. TIB “Haus2, FH 435” :-).
  8. Book C. Kevin McCabe: "Programmieren mit FORTH". TIB “RN 8185(37)” :-).
  9. Book Cölestin Lorenz "FORTH-Schnellkurs", 1989. 60 pages(!), published by the legendary “Ingenieur W. Hofacker GmbH” publishing house.
    • “Deutsche Digitale Bibliothek” ⇒ “Der Zugriff auf Teile des Objekts ist unbeschränkt möglich”.
    • TIB “Haus2, FN 9323” :-).
  10. Book Albert Nijhof: "Die Programmiersprache Forth", 2004. TIB “Haus2, T 04 B 6341” :-).
  11. Book Gert-Ulrich Vack: "Programmieren mit FORTH", 1990. TIB “Haus 2, FO 7315” :-).
    • 1987, 3rd. edition. TIB “Haus2, FF 7790,3” :-).
    • 1985, 2nd. edition. TIB “Haus2, FF 7790,2” :-).
    • 1984. TIB “Haus2, FF 7790”, “Haus2, FF 7790 a”, “Haus2, FF 7790 b” :-).

Books 2

Standards

Kitt Peak

figForth ( fig-FORTH ), 1978

Forth79

FORTH-83

ANS94

Forth 2012

Literature Lists & Literature Repositories

Resources

  • TIB - Search for “forth”:
      1. TIB "Ihre Aktion. Sachbegriff: FORTH. Quelle:Au=DB" ⇔ “\8661 forth and (\8661 forth or s9)” ⇒ 23 hits, all are FORTH books :-). The service did not know how to come to that result.
      2. ”[TIT] Titel ( Stichwort )” ⇒ 6034 hits for “forth”.
      3. ”[TPR] Titel ( Phrase )” ⇒ 50 hits for “forth”.
      4. “Sonderstandort” + “L \ mat 799” - Everything which is in the readers' room of 1st. floor ( so no books from archive, Haus2 archive ) ⇒ 37 hits, no FORTH books :-(. FORTH books have “Sachgebiete” signatures “mat 799 Forth” or “mat 799 FOR”.
      5. “forth” + “unscharfe Suche [x]” = Too many hits.
    • TIB, New Catalogue, with up to 64 extra databases.
      • ”[x] Nur im Bibliothekskatalog der TIB suchen”.
      • “TIB-Lesesaalbestand” - ”[x] Technik/Naturwissenschaften” ⇒ 16 hits for “forth”, No FORTH books :-(.

Videos

Video Channels

Resources

FAQs, Help, and Tutorials

Simple Projects for FORTH Starters

Resources

Forums, Newsgroups

Appropriate OpenDirectory Directory Pages

 
en/forth03.html.txt · Last modified: 2021/09/25 12:05 (external edit) · []
Recent changes RSS feed Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki