Unlike the new ST series, there is a very limited
choice of languages available for the older 8-bit Atari computers.
Indeed, the main alternative to using the slow and unstructured
BASIC is to resort to the complexities of Assembler - an unenviable
Although considerable interest has been shown in the Forth language,
and introductory articles have appeared in most computer magazines,
it is surprising that so few programmers appear to have been
converted to it. Disk drives are essential, of course, and I would
agree that it does take some effort to become familiar with its
stack-based operation and the reverse Polish notation, but it is a
fast, powerful language, and, once bitten, most users become Forth
enthusiasts if not fanatics.
versions of Forth available for the Atari 8-bit computers in Britain
have had some weaknesses or have been rather expensive. Go-Forth is
a multi-tasking version, needing a minimum of 32k RAM, produced and
marketed in the UK by S.E.C.S. Ltd. under licence from the
quaintly-named Bignose Software. It is approved by Atari, claimed to
provide features normally only found on mini and main-frame
computers, and is on sale at a very reasonable price (£25). To see
if this represents good value, we must look at the facilities
First, I should perhaps remind you that a Forth system consists of a
dictionary of compiled 'words'. A word is similar to a sub-routine;
it carries out a particular function, and several may be combined
together and given a descriptive name to define a more complex
function. You can execute any function simply by entering its name
from the keyboard. The language is usually provided in the form of a
Forth nucleus, which is the part read into the computer on booting
up, from the disk supplied, and several 'electives', that is, sets
of definitions of words you may choose to add to the nucleus in
order to carry out specific tasks. The electives are stored on the
disk in screens or blocks which can either be read into buffers in
the computer for inspection and modification, or compiled directly
into the dictionary.
The nucleus provided in Go-Forth follows reasonably closely the
Forth-79 standard, so if you copy code obeying this standard from
another source into your system, it should compile without serious
difficulties. The differences from the 79 standard are listed in the
User Guide provided. The only one which might cause problems is the
absence of the variable STATE, which indicates whether the system
should compile or execute immediately the code presented to it.
There are ways round this, but you need to know exactly what you are
electives include not one but two editors. I found the screen
editor, which behaves rather like a text editor, particularly
effective for entering new definitions. The line editor is of the
conventional fig-Forth form, and more suited to the modification of
existing screens. The block size in Go-Forth is 512 bytes, so each
screen consists of 16 lines of 32 characters. It is more usual to
have a block size of 1024 bytes (16 lines of 64 characters), but the
smaller size fits more efficiently on the Atari text screen.
If you are accustomed to 6502 machine code, you should have few
problems with any Forth assembler, once you have adapted to the
reverse notation. In fact, because high level control words such as
IF.. ELSE.. THEN and BEGIN.. UNTIL are available, and you can break
the code into small sections, each of which can be tested and
debugged separately, assembler in Forth is actually rather easy. The
Go-Forth assembler does not, however, make use of the check digit
normally included to ensure that the control words are correctly
paired. In my opinion, this is a definite weakness; the time saved
while loading is minimal, and certain to be exceeded by that
required in checking the code and finding the mistakes.
The debugging utilities allow new Forth words to be checked by
stepping through the definition, with the contents of the stack and
any important variables shown after each step. This is a much more
useful facility than the de-compiling utility normally provided,
which merely lists the words present in the definition. It would
have saved me many hours of frustration and reams of paper in the
multi-tasking routines are perhaps the most prominent feature of
Go-Forth, and it's unusual to find these features on an 8-bit micro.
Some tasks are provided; one (TYPIST) enables you to continue using
the computer while printing out long documents or listings. Another
(TICKER) gives a digital clock on the GR.0 text screen, and
supplements other time and date routines available. Whether you find
the ability to run simultaneous tasks to be of great value depends
very much on your applications. It is particularly useful for
controlling external equipment - a sophisticated domestic control
and burglar alarm system, for example.
Other electives cover disk and I/O operations, and sound and
graphics. These on the whole correspond to the facilities available
in BASIC. No attempt has been made to provide words to cover
player-missile graphics and display list interrupts.
On the whole the package is neatly and effectively done. There are
some minor points I didn't like; for example, the disk drives are,
for no good reason, numbered 0 to 3 rather than the usual 1 to 4.
Also, no warning is given if you define a word with the same name as
one already present. This can be corrected by re-vectoring CREATE,
but I feel that a warning should be the default option. There are no
floating point routines; although the purist might claim that they
are undesirable in Forth, which predominantly uses integer and fixed
point arithmetic, I have found them very useful on occasion.
The one serious failing in Go-Forth is the documentation provided.
The reader is assumed to be 'a competent Forth programmer
experienced in the use of a standard 6502 assembly language'. A very
small fraction of the potential customers will meet these
requirements. Even if you do. the 80-page user guide is not well
written or well organised, and some sections are heavy going indeed.
It also has its fair share of errors; even the procedure on page 2
for backing up the system disk is faulty (the store word '!' has
been replaced by a degree symbol). For a beginner, a copy of
Brodie's 'Starting Forth' or of Winfield's 'The Complete Forth' is
absolutely essential. These will cover the
fundamentals, of course, and not the functions specific to Go-Forth.
To sum up, then, I would say that this is a very good version of
Forth for the Atari, with some really useful extensions, even if you
don't make much use of the multi-tasking aspects. There are a few
flaws which need correcting, and the documentation could be much
improved; if you are a newcomer to Forth, you will certainly need an
introductory text to get started. The price is very reasonable, and
represents excellent value for money.