The Jupiter ACE

The Jupiter ACE was an 8-bit microcomputer released in 1982 by Jupiter Cantab and was named for a pioneering British computer of the 1950s - The Pilot ACE. It was developed by Stephen Vickers and Richard Altwasser. The company name of “Cantab” was derived from the word Cantabrigian, which means of Cambridge University, where the two designers both studied.

Vickers and Altwasser had previous significant experience in home micros from their work developing machines for Sinclair. Indeed, some similarity can be observed between the ACE and the original Sinclair Spectrum. The release price point of £89.95 was also very competitive at this end of the market.

The ACE was intended as a low cost machine for programmers and its most distinctive feature, as compared with other contemporary computers, was the choice of Forth as the primary programming language, which was bundled with the machine on ROM. In the early 1980s most home computers would offer the BASIC language and use of Forth was a bold departure from this convention.

From a software engineer's perspective, Forth made a great deal of sense. Whilst compiled versions of the BASIC language can now be easily found, the most common implementations of BASIC that shipped with machines at the time, such as Microsoft BASIC, were interpreted. This was a pragmatic response to the usually very low amount of memory available on early home computers.

Interpreters run a program directly from the source code, which means that there is no necessity to simultaneously hold a compiled version in memory when developing software. The consequence of this approach is slow execution because the source code must be repeatedly parsed on every execution and is usually not of a form that directly maps to machine code, requiring a degree of on-the-fly translation.

The Forth language is a halfway house, being semi-compiled and semi-interpreted. Somewhat after the style of Java, a compiler generates an intermediate form of the software called “threaded code” which is analogous to the concept of, although not the same as, bytecode. Note that threads in this context has nothing to do with the modern concept of execution threads.

In Forth, the threaded code was designed to be exceptionally compact, making it ideal for low memory systems, but it is also very fast for an interpreter to execute, requiring very little parsing. Using the Forth language, it is possible to achieve near to compiled speed and a Forth program might run at ten times or more the speed of a BASIC program. This was a considerable advantage given the comparatively slow performance of home computers at the time.

Despite being semi-compiled, Forth is an interactive language where it has a command prompt (like the modern Python prompt) and programs can be incrementally developed. Similarly to BASIC, commands may be immediately executed when typed, which encourages experimentation and learning. The language design also makes developing a Forth system comparatively easy. It was perceived by the designers of the ACE that this would reduce time to market.

Forth had a lot going for it. The language had received some positive press attention in the early 80s and was an excellent complement to the modest hardware. However, the home computer market had already coalesced around BASIC as a quasi-standard by this time. BASIC was increasingly widely taught in education and hundreds of BASIC books were already available. Forth was always going to face challenges due to the lack of customer familiarity and the limited available support. This was particularly so in the pre-web era where the computer user had to rely on the learning resources available in their local library and newsagent, neither of which would have been well stocked with Forth materials.

The Jupiter ACE was a very cheap machine that incrementally improved on the Sinclair ZX81, but may have been cost cut a little too far at a time when the British public were becoming more comfortable with computers and were starting to open their wallets, seeking higher specifications. The monochrome graphics and relatively lackluster hardware didn’t open up gaming as an alternative avenue for sales when Forth programming failed to capture the imagination. It could have been a very viable ZX81 competitor had it not been that the successor, the colour ZX Spectrum, shipped a few months prior to the ACE and the public could now see what else was possible in a budget machine. Ultimately the ACE only sold in the region of 5000 units and Jupiter Cantab ceased trading by the close of 1983.

Specifications

The Jupiter ACE was based around a 3.25Mhz Z80, which was also used in many other machines of the era, including the Sinclair computers. The machine shipped with just 3KB of RAM, of which 2KB was reserved for video use. Unlike in the ZX81, the video memory in the ACE was separated from the main memory resulting in less contention between the CPU and video circuitry. This resulted in better performance than the ZX81 as the CPU could more easily run in parallel with the video display.

While supplying only 1KB of available user memory in the base machine was not terribly helpful, the company may have taken inspiration from the Sinclair ZX81 marketing approach, where a low initial price point took the risk out of the purchase. If the user subsequently determined the machine was of interest, they could buy additional memory later with available upgrade modules providing an additional 48K.

Video was monochrome and character based with a 32x24 grid of 8x8 pixel characters. Each of the characters was user-definable, which was a slight step up from the ZX81, with 1KB of the video memory reserved for holding the character definitions. This meant that graphics could be produced more easily, although somewhat less conveniently than with the bitmapped display modes that were now routinely appearing on competing machines.

Video output was delivered via the common option of an analogue UHF interface for a domestic television. The video signals were broken out and externally accessible at the rear with the unusual choice of an edge connector for this purpose, presumably because it was the cheapest option.

The external video connector carries analogue composite video, but also interestingly delivers access to the video RAM signals, which was not a common feature. No commercial product is known to have used this connector and the purpose was not officially documented but it is speculated that it may have been intended for aftermarket upgrades to the video capabilities in recognition of the relative weakness of the machine in this area. Perhaps this would have worked somewhat like the way a new video card may be added to a modern PC.

A circuit diagram making use of the connector with an associated article by John Wike subsequently appeared in the April 1984 edition of ETI magazine that provided exactly this. It describes construction of a video card delivering a colour upgrade with capabilities very similar to the ZX Spectrum, with two colours from a palette of eight possible for each character cell.

Storage was provisioned by cassette tape at 1500 baud and a simple beeper was available for sound. An edge connector was available at the rear with access to the system bus signals for expansion. Typically this would have been used for additional memory, with at least one such adapter being available.

Forth versus BASIC

Despite the many technical advantages of Forth, the more common BASIC could be more intuitive and suited to education. The following examples show Forth as compared with equivalent BASIC syntax.

This example prints "hello world" on the screen:

." HELLO, WORLD!" CR

Which is equivalent to this in BASIC:

10 PRINT "HELLO, WORLD!"

Creating a function to loop through the numbers 1 to 10 is achieved like this (printing each number):

: COUNTDEMO 11 1 DO I . LOOP ;
COUNTDEMO

• "COUNTDEMO" is effectively a user defined function or "word" in Forth parlance. The colon begins a new word and the semi-colon ends it. Typing "COUNTDEMO" on the next line runs the function.
• The syntax of a for loop in Forth is: limit index DO ... LOOP, where index means the initial value of the loop and limit is one greater than where the loop will stop.
• Printing the current loop iteration is achieved with I . where "I" pushes the current iteration of the loop onto the top of the stack. The dot pops the stack and prints whatever is finds there.

The equivalent in the relatively sophisticated BBC BASIC is:

10 PROCcountdemo
20 END

100 DEF PROCcountdemo
110 FOR I = 1 TO 10
120   PRINT I
130 NEXT
140 ENDPROC

Many other BASICs did not have very elegant structured programming capabilities and something like this might be used:

10 GOSUB 100
20 END
100 FOR I = 1 TO 10
110 PRINT I
120 NEXT I
130 RETURN

This example calculates (2 + 3) * 4 and stores it in the variable RESULT. It then prints the variable contents:

VARIABLE RESULT
2 3 + 4 *
RESULT !
RESULT @ .

• "VARIABLE RESULT" generates an address for a new variable
• Forth works only in reverse polish notation and 2 3 + 4 * is equivalent to (2 + 3) * 4. The result is pushed onto the stack.
• RESULT ! stores the top of the stack to RESULT.
• RESULT @ fetches the value from result and pushes it to the stack
• The dot prints the top of the stack

BASIC is able to use regular infix notation and the calculation is a lot clearer:

10 LET RESULT = (2 + 3) * 4
20 PRINT RESULT