Reviewer: Bill Bennett

Magazine: Your Computer

Date: November 1982

Another day, another planet, another micro - but the Ace is so fast that even Bill Bennett had switch into hyperdrive to review it.

THE JUPITER ACE is a radical departure from the mainstream of microcomputing, and could prove to be the start of a very important new trend. Rather than accepting the prevailing wisdom, Jupiter Cantab designed the machine around the Forth language. In a way, this makes the Ace a breakthrough - it is both the first mass-produced home computer not to use that tired old lady of micro languages, Basic, and is also one of the fastest micros ever made.

The speed element is vital; it is more or less the justification for using a hitherto arcane computer tongue. But speed is not the only advantage of Forth, or indeed of the Ace. It has that all-important feature; structure. Structured programming is definitely the "coming thing". It is preferred by both educationalists and professional programmers alike, and leads me to another fashionable computer buzz-word; portability.

Major differences

Portability is an important conception in microcomputing. Put simply it means the ability of one computer to run a program written for another, taking the hardware differences into account. Forth is highly port- able. Providing the relevant hardware details, such as screen and memory size, are taken into account, any program written in Forth should run on any Forth system.

Programming in Forth is so fundamentally different to programming in Basic that some people prefer not to call Forth software "programs" at all. It is important to discard all your current ideas about programming before you start with the language Forth.

When writing a Basic program, it seems quite normal to think of the control passing through program lines. These lines are like rails along which the control runs, complete with loops and Goto jumps. The control path is often difficult to follow even in your own, short, well-documented programs. Imagine trying to sort out someone else's epic and rather badly-documented program, which they quickly wrote in the middle of the night. This just does not happen with Forth, because each little section of code is debugged as it is written, and the control path does not really exist as a concept.

A Forth system contains a set of words, called a kernel in some implementations. On the Jupiter Ace they are referred to as ROM- words, because they are in the machine's 8K of readonly memory. These words act on whatever number is on the top of the stack, which is the area of memory that the system plays with.

The best way to think of a stack is as a pile of plates. These plates are the numbers. Plates can be added to the top of the pile at any time, but only the one on the top can be worked on. This is a much more convenient way of managing the memory than using addresses, though with Forth it is still possible to define variables and constants.

Using Forth

Each word in the ROM-word set can be thought of as a call to a machine-code subroutine. Usually any value sent into a subroutine is called a "parameter". In Forth the relevant parameters are those numbers at present on the top of the stack. For example: plus is a Forth word - written + - which adds together the two numbers at the top of the system stack, and then puts the resulting number in their place. Thus, on the Jupiter, when you input

2 ENTER the screen shows 2 OK
3 ENTER the screen shows 3 OK
+ ENTER the screen shows + OK
- ENTER the screen shows 5 OK

The command "." prints out whatever is currently on the top of the stack. For convenience I will call this "dot". We can think of the numbers 2 and 3 as parameters sent to the plus routine, and the resultant value 5 as the parameter sent to the dot routine.

As soon as a Forth word is entered it is obeyed. A number of words can be entered at a time. For example, our example could have been input as:

2 3 + . ENTER

The result 5 is printed immediately at the cursor position. It is very important to remember to put a space between all Forth words or numbers as they are entered.

Forth really comes into its own when users start to define their own words. This is very simple to do. New words are formed by combining words already defined, and in some cases using numbers which are placed on the stack. For example, to write a word that will add two numbers together and then print out the result, we shall use the name Plus:


The colon at the beginning indicates that a new word is being defined. What follows it - Plus in this case - is the name of that word, We input the + and . to tell the computer that these are the Forth words which go to make up our word, Plus, and the semi-colon at the end closes the definition.

Once a new word is defined it appears on the top of the vocabulary list. The vocabulary initially contains the 140 ROM-words, and, the top word in the list is Forth. This merely indicates that the words below it constitute the main vocabulary. The Forth word VList makes the machine print out a list of all the words in the vocabulary, including all the new ones.

It is possible to define the same word twice. If, having typed in the word Plus as I des- cribed you decided that you wanted to change it so that the screen cleared first, you would have to use the editor. Enter the following:


and up comes the previous definition of that word, laid out thus;

+ .

The word CLS - clear screen - would need to be added before the word +. This is done by moving the cursor to the position where the extra word - or words - are to be inserted and typing that word in. The cursor- control keys are the 5,6,7 and 8, used in the satne way as on the ZX-8l.

Once the word has been changed to the corrected form, typing Enter now places that word in the vocabulary. If at this stage you type VList, you would find that there are two versions of the word Plus in the list. The computer would always execute the second version, leaving the first for dead. This makes debugging software incredibly easy because any incorrectly-defined words can be tested as they are entered and continually hacked about until they reach a correct form.

Because all previous attempts at the same word are kept in the dictionary, you can return to these at any time. When the defwitive version of the word has been created, you can save memory space by deleting with Replace all the intermediate attempts.

Unlike most implementations of Forth, the Ace has a substantial level of error-checking. For example, the stack will not overflow. It is also made more powerful by the ability to redefine words without the system crashing.

However, should you require yet more speed than normally available, there is a Fast command. This does away with the error checking, so it is wise to use it only when a program is totally debugged. It takes the computer's speed up to about 90 percent of a machinecoded program, but it does disable the break key.

At an end-user price of £89.95, the Jupiter Ace is an excellent way of learning an important new computer language. It will have a special appeal to those who feel that they have now grown out of their ZX-81s, especially as far as Basic programming is concerned. It will also be a Godsend to those who want the speed and economy of machine code but cannot grasp its principles.

Fast machine

The Jupiter Ace comes in a white plastic case, not all that dissimilar in style to the now- defunct ZX-80's horrible box. It is undoubtably the machine's worst feature, and the cost-cutting that has been done here could turn out to be that ha'porth of tar that spoilt the ship.

The printing on the case is in a matt-black, broken only by a series of red lines. These red lines are obviously the microcomputer world's equivalent of the "go-faster" stripes that teenage car owners sport to make their old Ford Cortinas look a little sleeker.

The truth of the matter is that the Jupiter is very fast. The manufacturer claims that it is the fastest microcomputer in this quadrant of the galaxy. This has a lot to do with the rapidity of the Forth language, but some of the credit has to go to the Z-80A processor which nips along at a rate of knots - 3.25MHz to be precise.

Speed implies heat, but there is not much danger of the Jupiter overheating, or at least a sight less danger than some machines, because inside that flimsy plastic case is plenty of breathing room and what is more, the case is better ventilated than that of the ZX range.of computers.

Internal design

Sinclair cognoscenti will smile when they peer inside the case and see the heatsink. I often wonder why they are such odd shapes - could it be they were designed by Picasso? Comparisons with the Sinclair machines will inevitably keep cropping up, because the designers of the Ace were, until recently, in the employ of Sinclair Research and so take some of the credit and blame for the ZX Spectrum.

Apart from the gross departure of choosing the Forth language, the design is fairly standard. Sinclair owners will find much inside the Ace's case that is familiar to them.

The keyboard closely resembles that on the ZX-81, both in the number of keys and their layout. But rather than having those horrid little squares that you have to struggle to push down as you program, the Ace uses a rubbery "moving-key" design. Personally I find it is a little like shaking a dead man's hand. The keys do at least have the advantage of being readable - that is, there are none of the Spectrum's red words which you can only track down using special spectacles.

Another small mercy that we can thank Jupiter for - or Zeus if you are Greek - is that there is no single-keyword entry to contend with. However, the designers probably did not abandon it for any good reason, but merely because the infinity of word names available to Forth makes it impracticable.

There are also some significant advances. For example, there are both upper and lower- case letters. It is also possible for the user to define his own character set - in fact by doing so, some reasonably high~resolution graphics are possible. In this way the graphics of the Ace remind me of a non-colour Spectrum. In normal mode there are 32 character positions across the display and 24 down.

In the Plot mode, there is a resolution of 64 by 48 points - not exactly high resolution. If you are prepared to play about with the character definition then this increases to a respectable 192 by 256.

The operation of the word Plot is like the other Forth words. The top three numbers on the stack are the parameters which are passed to a machine-code routine. At the top of the stack is a number which describes how the point is to be drawn, and the next two give its screen location.

Probably the biggest advantage of the Ace's picture quality over the ZX-81's is that the Ace has a rock-steady black screen on which any printing appears in white: the ZX-8l does the reverse which is not a natural way for a computer to behave.

The two machines certainly have a good deal in common, apart from the designer. The review machine did not have a power supply. That was no problem because I used the Sinclair Research one, which worked perfectly.

The user port on the rear of the Ace, closely resembles that on the Sinclair machines. It is not difficult to justify this as there are not really many ways of presenting the Z-80 lines at the edge of a board. Any device that connects to the rear of a Sinclair computer will snugly fit on the back of the Ace. All that is needed is a special cable that unshuffles the lines.

It will probably take a few months at least for a budding Forth programmer to need more than the 3K of user RAM that comes as standard with the Ace, but should you ever require more, the Sinclair 16K RAM pack will fit the bill.

Forth was originally designed as a control language, and the Jupiter Ace makes a fine control computer. In fact, this may become its eventual role. There are two words, In and Out for controlling the data lines. Put the Ace together with any of the available add-on hardware designed for the Sinclair, and you have a powerful control system.

The way forward

Other features available on the Ace include a speaker, which can operate right across the audio range. But, like the Spectum's, it is very quiet. It is controlled by the ROM-word Beep, and can be manipulated very easily by the language. Again, Forth is ideal for this kind of programming, and musical sequences are among the easiest things to write on the Ace. There is also a quartz timer, which doubles as the system clock. This can be accessed from Forth and has a number of possible applications. The timer sorts a number in four bytes, from 15403 to 15406. These can be extracted by use of the fetch word, written as @. I expect the most common use for such a facility will be in the timing of responses and in the generation of random numbers. Here is a very crude random-number generator:

RAND 15403 @.;

Perhaps the way forward for the Ace is best indicated by the other port at the back of the machine. It takes the video lines out from the main card. Eventually it will be used for a colour video generator.