Classic Computer Magazine Archive ANTIC VOL. 6, NO. 1 / MAY 1987



The first cartridge-based ST BASIC

Reviewed by David Plotkin

Fast ST BASIC from Computer Concepts is the first BASIC to be available in cartridge form. It is, without a doubt, the most full-featured version of BASIC that I have ever seen, including BASICs on mainframe computers. It comes complete with an excellent editor and lots of GEM support, all in a package which takes up virtually no memory. It does still suffer from some awkward spots and downright bugs, which will be difficult to fix since it is cartridge-based.


There are more keywords (commands) in Fast ST BASIC than is possible for me to cover. Fast ST BASIC offers:

  • Full math support, with both single- and double-precision numbers and functions. Double precision does sacrifice some speed, but accuracy is amazing.
  • Full file access, both random and sequential for bytes and records. Full device. access and redirection of input and output.
  • Advanced structured programming, with FUNCTIONs and PROCEDUREs supporting LOCAL variables and passed parameters.
  • Full decision and looping commands, including FOR/NEXT, WHILE/WEND, IF/THEN/ELSE, REPEAT/UNTIL, CASE and GOSUB/GOTO.
  • Access to system variables, such as drive numbers, free disk space, file attributes, keyboard rate, and time and date (including format conversions).
  • Access to machine language subroutines by use of USR, CALL and LAUNCH to execute both GEM and non-GEM subroutines and applications.
  • Direct access to all VDI graphics calls for circles, rectangles, points, lines, text, fills, markers, polygons, setting the palette, text color, graphics colors, setting of the text or graphics rectangles, and user-defined lines and patterns. All of these graphics commands are called by dedicated keywords, as opposed to ST BASIC's use of numbered calls.
  • Information about screen height, width and resolution. The locations in memory of the current screen for viewing and the current screen for drawing are available. These do not have to be the same, and the ability to use and modify these values makes for easy page flipping animation.
  • Ability to reserve safe memory that will not be overwritten by the program or other data.
  • Full access to directories and paths, including making and deleting subdirectories (folders). Also handy is a command to load the current directory into a string, so it can be manipulated and printed out.
Fast ST BASIC has the capability to hold 10 programs in memory at the same time. It loads the programs into sections called segments. These segments can have programs loaded into them, run, or cleared out under program control, making dynamic chaining and merging of programs quite flexible.

Bit block transfer (blitting) is fully supported. Both use of GEM's MFDB Blitting and built-in commands which are simpler (but just a little slower) are possible. BASIC's built-in commands are easy to use and provide excellent animation potential. It also has full mouse support, including whether the mouse is visible, used by GEM, the coordinates of the pointer, and the button state. Cursor and screen control are also available under program control.

Commands in Fast ST BASIC support most of the GEM AES functions: Alert boxes, full window support including creation, display, redraw and removal of windows, file selector boxes, menu creation and display, horizontal and vertical sliders, rubber boxes, and full event management. It also features full error trapping and HELP keytrapping.

There are even some keywords I have never seen anywhere else. The EVAL function evaluates a BASIC string to produce a numeric or string result, making it a snap to design a simple spreadsheet, since any math functions entered in a cell can be evaluated by BASIC. Also handy is the EXEC command, which lets you execute a string containing a valid BASIC statement.

Fast ST BASIC even supports in-line assembly code, because it includes its own assembler. 68000 mnemonics can be inserted right into your BASIC code, and the interpreter will assemble it into machine code at runtime. The Address and Data registers of the microprocessor are directly accessible from BASIC by use of pseudo variables with the same name, i.e. "PRINT A0" will print out the contents of Address register zero!

Also included is a full range of debugging tools, including TRACE and TRACKING. You can even slow down program execution so you can watch what is happening. TRACE single-steps through the program or can stop when a key sequence is pressed, allowing you to see where you are. TRACKING is more valuable, letting you define what variables you would like to see values for in a separate window You can then set up the program to print the values after every statement, only when a special key is pressed, or only when a value changes.

A wide range of variable types is available. These include bytes, words and four-byte integers, as well as single- and double-precision real numbers. You can also use binary and hex notation, although this last feature is not documented in the manual.

You can access variables through the @ operator, which returns the memory address at which a variable is stored. This is useful for passing a pointer to a table in memory as required by certain GEM functions.

Finally, line numbers are entirely optional, and labels can be used instead.


Fast ST BASIC is accompanied by a 400-page manual, a quick reference card, and a disk of sample programs. The manual is arranged into two main sections. The first contains all the keywords except the GEM AES, and the other contains the GEM AES keywords. Other sections contain brief introductions on variable handling, the in-line assembler, the editor, and an excellent index.

The two sections containing keywords are arranged in strict alphabetical order. In the case of the main keywords, this can be mildly confusing because certain keywords appear before their concept has been explained. For example, ENDWHILE occurs long before WHILE, but the concept of the WHILE loop is not explained until you reach the WHILE command. In the case of the GEM AES keywords, alphabetical order makes very little sense. A better way would have been to arrange the AES keywords by category (windows, events, etc.) and then by the order you would actually use them. The Personal Pascal manual is arranged this way, and it works.

Each keyword includes a description and an example program fragment. A list of related keywords and GEM usage is also given. In general, the explanations are adequate, especially since more difficult concepts such as PROCEDUREs are given more lengthy treatment. The explanations for the GEM AES keywords are still too sketchy, and you'll find it necessary to study carefully the example programs. This problem is compounded by the poor ordering of the commands. "Object trees," necessary for dialog boxes, are ignored, leaving a large hole in the program's AES capabilities. Still, the treatment of AES is far superior to any other BASIC.

The overall order of the manual is a little strange. Important concepts such as file handling are left until the end of the manual, while complex subjects such as variable indirection are right in the front. There also doesn't seem to be any general information on strings and arrays, so beginners won't find any help in understanding these.

Computer Concepts' Fast ST BASIC is,
without a doubt, the most full-
featured BASIC I have ever seen.
It comes complete with
an excellent editor and lots of GEM
support, all in a package which
takes up virtually no memory.


Fast ST BASIC comes with a very good, flexible editor. It is menu-driven and features icons for easy control. Printing out the program is as simple as dragging the program icon on top of the printer icon. Saving and loading from disk is just as simple, or you can pull down a menu. A clipboard is also supported, and you can even print it out.

Under normal circumstances, there are two windows open on the desktop- the edit window and the output window. This allows you to view your program and its output on the screen at the same time. I like this arrangement. You can also call up an "immediate" window for executing immediate commands such as printing out the value of variables. Features of the editor include many functions found in word processors. Movement of the cursor can be by character, line, word, and page. You can swap letters and switch case, go to the top or bottom of the program, cut and paste, and search and replace. To aid in structuring, there is an auto-indent feature, so that each new line will be flush with the line above. You can easily merge two files, and prevent the SAVE function from overwriting existing files.

Strangely, there is no syntax checking during data entry, so that debugging must take place when you run the program.


Would that this were the perfect program! Unfortunately, it does have some frustrating bugs. Certain keywords, notably LPRINT (print to the printer) and STRINGS (fill a string with a character) simply don't work. BASIC doesn't recognize them as commands, and attempts to treat them as variables, generating all sorts of strange error messages. It is possible to work around them, but, as in the case of all bugs, these will cost you time and some hair.

BASIC's PEEK and POKE commands only allow you to look at single bytes. When you want to look at more than one byte at a time (for example, when you want the four-byte value at address $0462-the system timer) BASIC has what are called "indirection operators." These supposedly allow you to get the one, two or four bytes at any memory location.

What they actually do, more often than not, is crash your ST, requiring you to reset. This is because the indirection operators neglect to issue the command to put the microprocessor in supervisor mode, which is necessary to look at any memory location outside of a narrow range. In fact, quite a few of the sample programs crash the ST. The icon editor is an example. Another way to crash the ST is from the editor. Sometimes when you load a program, the listing is in the edit window in large letters. Just attempting to scroll through this listing may cause a crash. Finally, some programs will refuse to run, giving the error message "dodgy variable" (I am not making this up!). This error message (can you guess) is not documented in the manual.

Then there are the annoying problems. The GEM support provided does not allow for using dialog boxes. There are no commands to build a dialog box in the program and no way to load an external resource file. There are also no commands to return the state of an object in the dialog box, and no way to read the contents of editable fields. There is also no sound support except for direct data entry to the sound registers, but no information on what values or registers to use is provided. Fast ST BASIC is much more syntax sensitive than any other BASIC I have ever used. Keywords must be capitalized or they will be treated as variables (this is not documented). Something normally as harmless as an extra space after PRINT# can reward you with an error message. This is doubly confusing because the manual itself inserts the extra space after PRINTER#, OPENUP# and other keywords in the section on file handling. As a result, the examples in that section will not run.

Printing out a program is
as simple as dragging the program
icon on top of the printer icon.
Saving and loading from disk is
just as simple, or you can
pull down a menu.


I like this language. It is not really for inexperienced users, due to the problems mentioned above, but it is extremely powerful. I also am puzzled as to how technical support will be provided. The company is based in England, and there is no phone number and no local distributor to turn to. It is not realistic to market a product for as much money as this one and not provide support.

Further, the utility of the language is limited by the fact that there is no runtime package, so someone else must own a copy of this BASIC to run an application you have written. Computer magazines will only print applications written in widely distributed languages or ones that are stand-alone (don't require the user to own a copy of the language). This one doesn't qualify. If, however, you want an excellent, full-featured BASIC and don't mind experimenting on your own, or have a hankering to play around with GEM in an interpreted language, then this language could work out well for you.

Computer Concepts
Gaddesden Place, Hemel Hempstead
Hertfordshire, England HP26EX
Cartridge $139.95