News, Reviews and Letters Index > Review from Popular Computing Weekly 1982

Jupiter Ace makes
Forth bid for
Boris Allan presents the first review of the new Jupiter Ace and explains its use of the language

The Jupiter Ace is a microcomputer from two leading designers I of the Sinclair Spectrum (Richard Altwasser and Steve Vickers). The Ace is based on the Z80A microprocessor, with 8K bytes of ROM and 3K bytes of RAM; has a Spectrum-style keyboard   (though  it  is    promised to  be more  positive);
has a proper memory-mapped screen (unlike the Spectrum), with a 32 x 24 display on an ordinary television; and has sound and cassette facilities similar to those of the Spectrum, but no colour. It costs £89.95.
   If the Ace sounds like a Spectrum under a different cover, it is not: the Ace is set apart from the Spectrum, and all other small microcomputers, by the use of the programming language Forth alone.
   To emphasise, you cannot, program the Ace in Basic, you have to use this rather different language Forth. Though it is an uncommon language, many people have recently become interested in Forth, and versions have appeared inter alia for the Atom, ZX81, MZ80K, BBC computer, and there is Forth available on the latest version of the Osborne 1.
   For Forth to appear on the Osborne (a business machine) implies that this is a language which is beginning to make commercial sense.
   When confronted with a machine with higher resolution graphics, and a claim from its designers that "Ace is ideal for games", the question is "why Forth and not Basic? Is Forth an easy language for beginners?"
   In a way some people are afraid of Forth — a fear of the unknown? — as it seems unnatural to type in
          2 5 +
when you really mean
          2 + 5
   If I ask you to add 2 and 5, you answer 7; if I ask you to take 2 and
5 and add them together, you will still answer 7. When you add two numbers you are doing something to those two numbers to produce a result (another number).    In Forth it is clear you are doing something to numbers, to produce another number.
   Forth says here are two numbers, add them together; 2 and 5 are the numbers, and + means 'add them together'
          2 5 +
   Its not all that strange really.

   What is Forth? In essence Forth is a computer language which is truly interactive (almost as if it were a Basic in instant mode all the time), and it is a language which is truly extensible.
   In Basic it is possible to add new functions and procedures, but very difficult to add new commands unless one uses machine code routines.
   Forth is a very efficient language, much speedier than most Basics. The 8K of ROM in the Ace corresponds to a far greater amount of ROM for any Basic, and the 3K of Ram is worth more than 3K of Ram if used by a Basic program.
   The version of Forth used by the Ace is based, loosely. on two standards, FIG-Forth (Forth Interest Group) and Forth-79, but with important modifications. All the modifications seem to be improvements. I will examine some of them in more detail after I have looked at more general features, common to most Forths.
   Forth is most notable for the way in which it uses basic functions (or procedures) to produce more powerful functions, so that, finally, the whole program (or 'application') is just one all-embracing function (or 'word').
   Forth also uses a stack, and the user can control what happens on the stack. Think of the stack as a pile of numbers, on which you can put more numbers or take numbers off, but at one end only.
   Suppose I want to multiply two numbers together. In Forth I say "here are two numbers, multiply them together"
          2 5 *.

and this line means take the numbers 2 and 5, multiply them together, and finally print out the result (which is what the "." means).
   Forth copes with this line by starting at the left, and moving right. The first item encountered is "2" and this is recognised as a number. The number 2 is 'stacked' for later use. The second item is "5". This is a number and is stacked on top of the 2, for later use. When the program meets the word "*" it knows that this means multiply. It multiplies the two numbers on the top of the stack (ie 2 and 5), so removes them and places the answer on top. When the word "." is met it is understood to mean print the value of the number on top of the stack and remove the number.
   The word "." is not very self-explanatory, but in Forth if you do not like the name of a function/word you can change it, eg:

          : PRINT . CR ;
and now the word "Print" means do "." and then carriage return ("CR") The sum now looks like
          2 5 -PRINT
and it is possible to continue.
   It would be nice to find the square of the number 7, and it could be done by

          7 7 * PRINT
or, possibly

          7 DUP " PRINT

Interior layout of a pre-production model of the Jupiter Ace.

Page 13
where the word "Dup" means take the number on top of the stack (in this case 7) and put another copy on top of it (Duplicate). It would be nice to do this by just saying
          7 SQUARED
and one can by
           : SQUARED DUP * PRINT;

which is a 'colon' of the word "Squared", which definition uses a word "PRINT" defined earlier. And so the process can continue.
   In normal Forths editing words and applications can be tedious (for reasons too tedious to explain) and the designers of the Ace had come to the same conclusion. In normal Forths it is possible to keep a copy of a definition on what is termed   a    'screen',    but    once
many ideas in Steve Vickers version of Forth (eg Redefine or Fast or Edit) which are worth incorporating in other versions.
   I have found that Forth on micro computers is not (generally speaking) user friendly — on most systems it is only too easy to find oneself in a situation where the only thing one can do is switch off and reload the Forth system. The Ace system is user-friendly, and difficult to crash.
   The question of how user-friendly is the Ace is important because, being aimed, as it is, at the cheap end of the market and competing with cheaper black and white computers, and slightly more expensive colour computers, and as it uses what   is   a novel language,
   For a beginner, I do not think that Forth is intrinsically any more difficult to lean than Basic, if it is approached in the righ manner; but even if it is not more difficult is it any better? Altwasser and Vickers are I believe, sincere in their belief that Forth it intrinsically a better language, and in on sense I agree. Forth is better because as we have seen it is possible (once the groundwork has been done) to perform complicated operations with a minimum of programming. Some of the queries come with "once the groundwork has been done".

   The word "Squared" used another word "Print" and another word might use their both, but "Squared" could not use "Print" until we had defined "Print"; though with Ace Forth it is possible to give a dummy definition to "Print" (eg : PRINT ;) and then later use "Redefine" to give a proper definition. A possible problem with this approach (for novice and not so novice) is the "design at the keyboard" syndrome. That is, it is easy to get tied up in the minutiae and lose sight of the overall structure. This is also a problem with most other languages, whether they be called structured or not.

   I have a feeling that the Ace might well find a market as a cheap way of learning Forth (schools, colleges, and businessmen?)  for some,  and for

Steve Vickers puts the Jupiter Ace's keyboard through its paces.
the definition has been compiled the internal workings cannot be changed. With the Ace there is no need to keep a separate copy of the listing of the definition — in fact one does not, in any case — and one can edit, list, and "Redefine" words (replace an earlier version of a word by the latest definition, and redefine any other definitions that are necessary).
   Forth's do not normally have floating point operations as part of the standard set of words, but the Ace has five special floating point words for use on six significant digits (1 E64 to 1 E-64). Ace Forth also has inbuilt array using features.
   In many respects the Ace has many of the good features of the Spectrum, very good cassette saving, loading, and verifying, good line editing, good user defined graphics capabilities. As a way of using Forth, it is excellent. Apart from these resemblances, the Ace is a very different machine because it is in black and white (though a colour facility is being considered), and it can use the ZX81 16K Ram pack (plus many of the other ZX81 add-ons). An easy machine to use.
   Though the machine I used was not the final production version I have no doubts about the eventual production machine. I am sure that as a Forth machine it will be excellent. I think that given my use of Forth on the Ace there are
the Ace has to be user-friendly to succeed. Once one has the dictionary of words — tailored to one's own interest — to create sophisticated applications should not be as difficult as creating large programs in Basic. One word can stand for a program or a standard (often complex) facility.
   Though it is possible to merge dictionaries and applications, often this will not 1)1 necessary. As Forth itself is in ROM, if the system does crash — Steve Vickers and had great difficulty in performing this feat   —   if   it does crash,   Forth   is   not   lost.
others a cheap way of obtaining a machine with the speed of Forth (not far slower than poorly written machine code) for control applications. For those who would like to use the Ace for control applications, the way in which the Ace talks to the world is obviously important. The Ace talks via the television, and a rear port — the one I saw connected to the Ram pack. Richard Altwasser told me that they planned to provide means of coupling up to all the main interfaces one would need for use in control applications.

Richard Altwasser "providing the Ace with interfaces for use in control applications".