BATTLE OF THE BASICS

Laser BASIC, £14.95 from Ocean IQ/Oasis Software, 12 Walliscote Road, Weston Super Mare, Avon BS23 1UG.

Mega BASIC, £9.95 form Sportscene Specialist Press (Your Sinclair Spectrum). 14 Rathbone Place, London W1P 1DE.

Beta BASIC, £9.95 from Betasoft, 92 Oxford Road, Moseley, Birmingham B13 9SQ.

This month's TECH TIPS looks at extensions to ZX BASIC. Ocean, Betasoft and Your Spectrum (RIP) battle it out in the contest to find the ultimate set of BASIC extensions. Laser BASIC, Beta BASIC, and Mega BASIC are the contenders - as it turns out there's no clear winner, since each utility has it's own unique advantages.

ZX BASIC, built into the Spectrum ROM, is a good language for those who want to learn about programming fairly painlessly. Most of the simplest keywords can be entered at a single key press lines are checked for syntax as they are entered and the editor is easy to use. String and graphics commands are unusually simply used. Most of the error messages are in something approaching English and you can continue after making changes to a program.

When it comes to serious use, ZX BASIC doesn't fare so well. It is very slow, especially when large programs are being run, and editing is laborious. The less common symbols and keywords are hidden in the obscure corners of the keyboard.

The best way to speed up ZX BASIC is to use a compiler - we looked at those in a previous TECH NICHE. This month's packages build on the existing language, rather than enhance what's already there. Laser BASIC, Beta BASIC and Mega BASIC add extra facilities and utilities. Facilities include on screen sprites (animated graphic symbols), extra commands, functions and control statements. Utilities make program editing and debugging easier. I'll start by comparing their presentation.

LASER BASIC - WHAT YOU GET

Laser BASIC is supplied in a plastic box, like a VHS video box but even bigger. The code was written by Oasis Software who produced the Forth-based graphics package White Lightning some time ago. The program is the flagship of Ocean's new IQ range billed as 'The secret of advanced games programming'. Look out Matthew Smith, Sandy White, and all, your secret is out! - well not quite.

For £14.95 you get two cassettes and a 90 page A5 manual printed on hideous but trendy green paper, to discourage pirates with old fashioned photocopiers. The cassettes contain the Laser BASIC program, two libraries of sprites, a sprite designer, a 'shop window' demonstration program and a game of three dimensional noughts and crosses which shows off the features of the system.

The manual is wrapped in a black card cover, with a useful 'bookmark' flap extended from the back cover. Something is needed to help you keep your place, since the presentation is not good - the manual is typeset, but only one size type is used throughout, and the layout makes the whole volume look like a ninety page technical appendix. The style is dull and verbose, but you do get a five page alphabetic command summary and two pages of contents list, including a useful 'tape map'. 21 pages are taken up with a commentary on the demonstration program, routine by routine.

BETA BASIC- WHAT YOU GET

Beta BASIC is also supplied in a video box, which holds another 90 page A5 manual and a single cassette. The cassette contains the Beta BASIC extensions and an unspectacular 'turtle graphics' demonstration.

This time the manual is printed on bright red paper - using this and Laser BASIC alternately is like taking part in a psychological experiment! Again the type is all a single size but this time it has been produced on a good quality daisywheel printer. Apparently, a modified version of Tasword II was used, but it is none the worse for all that. The layout is better than that of Laser BASIC, but still rather dull.

The style of the manual is straightforward and readable though not as good as the original Spectrum manual, mainly because of the lack of graphics. The text is divided into a summary and a reference section, with appendices to cover errors, printers, keys and special variables. There's a tow page list of contents.

Examples and observations are sprinkled through the text, and these help dilute the more technical explanations. The front cover contains a keyboard chart, showing the positions of the new commands - no overlay is provided. The back cover contains a concise syntax summary.

MEGA BASIC - WHAT YOU GET

Mega BASIC has the smallest but most readable manual of all: 30 A6 (double cassette sized) pages printed on white paper - hurrah! The single cassette contains two copies of the Mega BASIC system and a sprite designer. Unfortunately some one forgot to record the sprite designer onto either side of our tape, purchased (with £7.95 of real money!) at the ZX Microfair. We got a complete recording later.

The layout of the manual is good and the style is informal. It is very readable, much as it's parent magazine used to be before the Megawow Geewhizz Supaspeccy style took root. There's a five page list of commands, an (incomplete) table of error messages and a single, well organised contents page. Examples are far and few between - this manual is, sadly, better to look at than it it is to use.

USING LASER BASIC

Beta BASIC and Laser BASIC have a lot in common, so they are reviewed together, later in this article. Laser BASIC is the odd one out, so I'll discuss its unique features individually.

Laser BASIC offers no new editing facilities - it just modifies the syntax checker to allow a hundred or so new commands and functions, which must be typed in full (letter by letter) in capitals. The commands are all four letters long and start with a full stop. From .ADJM to .WRBV, they are almost all totally unmemorable and unpronouncable. Commands expect up to seven numeric parameters.

Functions are three letters long, similarly unpronouncable and start with a question mark. Functions can only be used in assignments - not in expressions - so you have to copy them into a normal variable with LET before you can PRINT them for example.

Most of the commands are concerned with sprite graphics. As in White Lightning you can propel sprites of almost any size, from one character to several times larger than the screen - useful for moving backdrops in games like Zaxxon or Defender. You can do all sorts of tricks if you can remember the right command - moving, scrolling, panning, recolouring, masking, rotating, animating, enlarging, shrinking, inverting and detecting collisions - in other words, you can fiddle about with patterns on the screen in almost every conceivable way.

The rest of the system is a bit of a disappointment, There are very few new commands apart form those that deal with sprites. You can renumber programs, 'trace' the current line number, read groups of keys and PEEK and POKE two-byte values. That's all. There are no new commands for editing, sound effects or 3D perspective.

You can use procedures - routines called by name rather than line number - but the names must only contain one letter, again making programs hard to understand. Values can be passed to a procedure and changes thereafter don't affect the original variables - in Technospeak: the values of the variables are local.

The Laser BASIC demonstration shows that you can produce varied and attractive flicker-free graphics with the package, but the demo is not exactly 'state of the art' - it looks like a collection of snippets from simple games of a couple of years ago.

The free game is flashy, but 3D noughts and crosses is not exactly pulse-quickening stuff. The slow speed of ZX BASIC slugs the Laser system, making it hard to keep more than one thing moving at a time. The game is played well, using an algorithm that first appeared, as far as I know, in Practical Computing in January 1981 (page 102), though the author does not acknowledge this.

The Laser Sprite Generator is written in BASIC. The program is a bit slow and long winded to use, but good results can be obtained if the sprite libraries supplied are anything to go by (I can't draw). The display is rather lurid and it is a shame that you can't edit sprites with a Kempston joystick.

CAN A MEGA BEAT A BETA?

Beta BASIC is the oldest utility reviewed here, although the latest version - 3.0 - was only published this summer. In many ways it seems to have been produced in direct response to Mega BASIC, which rather shook up the world of Spectrum BASIC extensions when it was launched a year ago. Already Mega BASIC has outpaced Beta BASIC on the version number front - I looked at version 4.0.

Beta BASIC looks just like ZX BASIC when you first load it - even the copyright message looks like the Sinclair one which we have all come to know and love or hate... depending on what we were doing before it appeared.

The Mega BASIC start up screen is much more impressive. The program name, version and author appear on the top of the screen. The ink is yellow on black. The bottom line contains an indication of the mode (the cursor is now a solid block) and whether or not CAPS LOCK is enabled.

TYPING PRACTICE

Both systems let you dispense with the Spectrum's keyword entry scheme, which is great if you've got a proper keyboard - I used a Fuller FDS. In Mega BASIC you have to type all the commands letter by letter although they can be abbreviated to their first few letters followed by a full-stop.

Beta BASIC lets you select normal keyword entry (the extra keywords are accessed from graphics mode) or letter-by-letter typing, or an ingenious mixture of both which I used most of the time. In the mixed mode, keywords at the start of a statement can be typed as normal, or type letter by letter if preceded by a space - a natural action for a touch typist, The mixed mode is convenient since it means that common commands - LET, PRINT, GO TO and so on - can be typed with one press, and the rest can be typed out with no need to look down and search for the required keyword.

Both BASICs provide user defined keys - so a group of characters can be produced when the appropriate 'key' is pressed. In Beta BASIC you must press symbol shift and space, then a letter or digit. Mega BASIC expects you to select extended mode then type a shifted digit.

Both BASICs improve the performance of the line editor. They allow you to edit lines by number - you don't have to LIST them first. They also let you move quickly through a line with the up and down keys as well as left and right, and provide a short-cut to the start or end of a line.

In Beta BASIC you have to press Enter before changing the current line, whereas you change it by typing the AND and OR symbols in Mega BASIC. Mega BASIC also gives you a second 'copy' cursor - like the BBC Micro - which can be moved independently with a rather strange group of keys; characters can be copied from the position of this cursor to the other with a shifted keypress. Beta BASIC won't do this, but it does let you join and split lines at will.

Beta BASIC tokenises lines rather slowly, but you soon get used to the slight pause after you hit Enter. It lets you put premature line-feeds into a listing (so that lines don't just run from one margin to another) but this can cause confusion when editing as the 'extra' text is not always cleared from the display.

I think that BBC Micro enthusiasts will probably prefer the Mega BASIC editor, but I preferred the Beta BASIC one be cause of the facility to join lines and the neat listings - Beta BASIC indents loops and tests for you automatically if asked to do so - this time Beta BASIC collects a BBC Micro feature. One big snag with Mega BASIC is the fact that that you can't always re-edit an incorrect line- sometimes you just get a 'Bad Line' message and have to type the lot again. Ugh!

The Mega BASIC keywords are not easily mastered since they almost all end with underscores - Symbol Shift Zero, if you've never needed one before - for no obvious reason. This is taking QL emulation too far. Mega BASIC is also needlessly fussy about the space character in instructions such as OPEN # and GO TO.

BLOCK STRUCTURE

Both BASICs provide some facilities for writing block structured, modular programs, but Mega BASIC features are not very substantial. You can define procedures (which must have names starting with an AT sign) but these can't be typed as commands and local variables aren't allowed. Simple REPEAT UNTIL loops are the only new control structure.

Beta BASIC provides a range of facilities that would satisfy even an ALGOL 86 programmer (ALGOL 86 is a language so comprehensive that no one has implemented it fully yet, and they've been trying for 18 years!). It's a computer scientist's dream: you get named procedures, local or reference parameters with default values if they're not supplied you can pass lists of parameters for sequential processing. There's multi line IF THEN ELSE, a general purpose looping construct which allows exit from any point, and these structures can be nested arbitrarily.

Beta BASIC even speeds up a few ZX BASIC commands. Some aspects of ZX BASIC slow up alarmingly as program size increases, Beta BASIC avoids this, so that FOR loops, GO TOs, GO SUBs and RETURNS can be increased in speed by a factor of up to twenty times in long programs. This effect is, of course, largely swamped by the execution time for other statements, but it is still a nice feature.

You get long and short (single statement) forms of ON GO TO and ON GO SUB, which brings me to the only missing feature I could think of: Beta BASIC has no SELECT or CASE statement.

UNIQUE FEATURES - BETA BASIC

It would take a whole CRASH Christmas Special to list all the unique features of Beta BASIC, but they include commands to sort and shuffle rows from string and numeric arrays. There are new integer functions and operators such as MOD and bitwise OR. and there are some fast but low precision trigonometric functions. It is a shame that the new function are typed in as DEFined FNs since this reduces the number of user defined functions you can use.

Clever print-formatting is allowed for neat tables of figures. There's an optional clock display, with an alarm, and a command which passes characters to the command line as though they were typed in - the ultimate in self-writing software. The contents of memory can be treated like an enormous string array, allowing all sorts of neat tricks.

The Beta BASIC toolkit lets you list lines, groups of lines, variables, key definitions and procedures. You can search out and replace information in a program, renumber, save and delete groups of lines. You can delete groups in Mega BASIC but the rest of these tricks are beyond it.

Beta BASIC graphics commands include a FILL, function which colours bounded areas of the screen for you. Filling is fairly fast and you even get a count of the number of points filled. Graphics can be shifted and scaled within a window and you can use absolute co-ordinates rather than offsets, when drawing lines on the screen.

What Mega BASIC excels at is multi-tasking. The Spectrum's interrupt facility is used all over the place. You can produce intricate non-stop sound effects while a program runs, or make two programs run at once - or all three at the same time! The software multi-tasks rather crudely, executing lines from two parts of a program alternately.

Mega BASIC has simple, four-character-size animated sprite graphics. The eight sprites can move, changing shape automatically, while the program controlling them does something else. It amazes me that Laser BASIC did not include this feature - in fact it DOES appear in the Amstrad and Commodore versions of Laser BASIC.

The Mega BASIC Sprite Designer was a bit of a disappointment since it wasn't recorded on my cassette. We got a replacement at the next Microfair, and found it to be a competent but unimaginatively-written program - not as good as the Horizons cassette, for instance. It is written in Mega BASIC, which makes it rather sluggish but decent results can be obtained with a bit of effort.

Machine code support is noticably absent from Beta BASIC, presumably because it is considered unnecessary. Mega BASIC gives you a small but useful 'front panel' to control machine code and an extended CALL statement which allows parameters to be passed to machine code but not returned.

User defined graphics can be designed in a single Mega BASIC statement; as far as I know this is a neat trick from the Memotech repertoire. Strings can be printed down, rather than across the page and large characters can be printed in fuzzy, 'stippled' colours. Screen output can be redirected to machine code or a printer; in fact it's very easy to do this in ZX BASIC if you know the right command.

The main Mega BASIC system includes a tape header reader which prints the details of tape files. There's also a rather dangerous cassette file copier that destroys your current program and crashes the machine if the file concerned is more than 20K long!

Mega BASIC is generally frustrating to use if you make a mistake. The commands don't check their parameters properly, so silly mistakes can cause weird results or even crash the machine. The manual pleads lack of memory but my verdict is lack of effort and poor software design.

SHARED FEATURES

Both systems let you divert execution to a subroutine when each end of line is reached by in the main program. This can be very useful when debugging. They both have a facility to trap errors and disable break-ins from the keyboard but Mega BASIC can't trap Interface 1 errors or - more mysteriously - the error codes it generates itself! Both offer two-byte PEEK and POKE instructions, and can provide automatic line numbers.

Both BASICs are associated with magazines. The glossy monthly Your Sinclair is owned by the publishers of Mega BASIC and has contained several articles based around the system in Your Spectrum days. The Beta BASIC magazine is less pretty but more substantial. It consists of fourteen typed pages crammed with neat routines and tips for Beta BASIC users. A six issue subscription costs £5.50.

Windows have definitely arrived - Beta BASIC and Mega BASIC allow you to restrict display output to a limited area of the screen and dial up a range of character sizes, including a Tasword-style 64 characters per line. Areas of the screen can be scrolled smoothly in all directions, or saved for later re-display in various sizes. The attribute grid can be blasted in various ways, for special effects. Printing can be offset from the grid so you can position text with pixel accuracy.

Only Mega BASIC lets you select between three possible typefaces - Spectrum, BBC and Amstrad character shapes. Of course you can redefine the characters in Beta BASIC or normal, boring ZX BASIC with just a few POKEs, but this superficial Mega BASIC advantage haunts the machine. A system running Mega BASIC just doesn't seem like a Spectrum when you use it. Beta BASIC is more subtle, and doesn't immediately appear to have changed the nature of the machine. Some people will choose Mega BASIC on the basis of this feature alone - it all depends how much you like the Sinclair style.

Both systems take up a lot of memory - about 20K - which is inconvenient for business users. It's a shame the publishers don't let you choose a subset of the commands, as you used to be able to do on the venerable ZXED toolkit from Dk'tronics.

WINDING UP

Mega BASIC and Beta BASIC are both recommended to those who want to inject new life, and perhaps a little excitement, into their ZX BASIC programming. Both systems are very powerfull and usable, though the publishers of Mega BASIC really ought to tidy up its error-handling.

I preferred Beta BASIC, mainly because of its elegance and comprehensive support for software engineering: the Spectrum was designed, oddly enough, as a programmer's machine rather than a games one (hence no joystick port, poor sound, friendly BASIC, microdrives, limited colour etc). Beta BASIC takes the Spectrum a long way onward as a programmer's machine. Others may be drawn by the multi-tasking, the machine code support and graphical gloss of Mega BASIC.

If you want to push pixels around the screen then Laser BASIC is great, but the code needed is hard to read and hard to debug. At present you can't use Laser BASIC in commercial games without infringing Ocean's copyright, but a run time system, misleadingly called the Laser BASIC Compiler should be available for £9.95 by the time you read this. I don't expect that there will be many takers.

(Simon N Goodwin owns the copyright to this review. Please visit http://simon.mooli.org.uk to find original articles and updates, much new material and his contact details.)

IF YOU KNOWS OF A BETA BASIC, GO TO IT

At last it's worth programming the Spectrum 128 in BASIC - Betasoft has produced a new version of its peerless Beta BASIC system for new models of the Spectrum. The faults that make the 128 a pain to program have been cured, and there we extra commands to bring all the hardware under BASIC control.

The 128 appeared almost four years after the launch of the original 48K Spectrum, but has only two extra BASIC commands. PLAY gives control over the Midi synthesizer ports and the three-channel sound chip - as long as we don't mind BASIC stopping while sounds are generated. SPECTRUM tells the system to revert to 48K mode, disconnecting the sound chip, serial port and 80K of memory.

Apart from these new commands, the standard 128 offers a simple RENUMBER option and facilities to store files on a 74K RAM disk. A screen editor lets you edit and enter programs character by character, without looking up obscure SHIFTed combinations to satisfy the 48K keyword-entry scheme, where some keys print whole words.

The 128's editor is good in theory, but annoying in practice. The cursor doesn't warn you whether you're about to type graphics, capitals or small letters - though in the 48K version it does, which is helpful. And there's a delay after the first key is pressed in an editing session, and no key-buffer, so the first part of your command may be lost unless you type v-e-r-y- s-l-o-w-l-y.

There's another delay whenever you enter a line, as the system converts it back into keywords so the 1982-vintage interpreter can make sense of it. That conversion sometimes goes wrong, reordering the values you entered, as recently explained in this column.

So Sinclair's 128 BASIC lets the machine down, but Betasoft has the answer.

FAST AND NEW

Beta BASIC adds more than 100 new commands and functions to ZX BASIC and speeds up or improves many of the standard features. And Beta BASIC 4.0 (not Gamma BASIC!) is the first to take advantage of the Spectrum 128 hardware.

The package comes in an inch-thick black plastic box. Inside you find a 90-page A5 manual for Beta BASIC 3.0 (reviewed in CRASH way back in February 1986 - Issue 25), a 30-page booklet covering the new features of Beta BASIC 4.0, and a single cassette with Beta BASIC 3.0 and 4.0. Tape-loading time is about three minutes.

Beta BASIC is compatible with virtually all disk systems and printer interfaces, and it fixes the bug which stopped you sending control codes to a serial printer from the 128. It's sensible to write for advice if you've got obscure bits and pieces hanging off your system, though.

On a 48K machine, Beta BASIC 3.0 occupies 18K of program memory, which is a bit restrictive. Version 4.0 uses 25K on the 128, but you can easily use the RAM disk for program sections or arrays of up to 64K (which you can't with Sinclair 128 BASIC), so the net result is usually an increase in RAM available for programs.

HARDWARE CONTROL

Beta BASIC 4.0 looks just like 48K BASIC when you load it, but the appearance is deceptive. You've got all the 128's hardware to play with.

A new BEEP command controls three-channel sound which plays continuously and doesn't stop your program running at the same time (hurrah!). Hundreds of sounds can be queued, and there are commands to empty the queues and check their contents.

You can control all the features of the sound chip, and the manual lists plenty of examples - trains, planes, boings, zzaps and crashes (of course). Music is trickier, as you must use internal note values (as listed in CRASH issue 32) rather than note names or semitone numbers. The manual contains helpful examples, and PLAY works normally.

Beta BASIC 4.0 lets you store arrays on the RAM disk, rather than in the normal BASIC area. This gives you access to 73K of extra variable space. 1K of the standard 74K RAM disk is always used by Beta BASIC: a further 2K may be used for sound queues, and 10K during graphic FILLing. New commands let you read the RAM-disk catalogue and file details from within a program.

Arrays on RAM disk can be sorted or searched very quickly with single statements. There's an irritating rule that references to RAM-disk arrays must be at the start of a calculation, though. The arrays use the format of DATA files, and you can copy them directly to disk or microdrive. Programs on RAM disk can be listed directly - there's no need to LOAD them first.

Routines can be merged or deleted automatically as a program runs - there's even an error-trapping function to tell you the name of a routine that's needed but isn't there. And it's possible to run programs of over 90k if you organise them carefully.

TYPING PRACTICE

In Beta BASIC you can select 48K-style keyword entry, with extra keywords accessed from graphics mode; 128K letter-by-letter typing; or an ingenious mixture of both. In this last mode, keywords at the start of a statement can be typed with one key, or letter by letter if you start with a space - an easy habit to pick up if you're used to entering text.

Common commands - LET, PRINT,GOTOandsoon-canbe typed with one keypress, and the others can be typed in full so there's no need to look up the required keyword.

User-defined keys are allowed. You can program any group of characters to pop up when you press SYMBOL SHIFT and SPACE followed by a letter or digit of your choice.

Like the 48K Spectrum, Beta BASIC edits lines one by one at the bottom of the screen, but editing is much easier than on the 48K. You can join and split lines at will, and edit lines by numbers with no need to LIST them first.

The UP and DOWN keys move quickly through a long line, and you can jump directly to either end of a line. Beta BASIC stores lines faster than 128 BASIC, though there's still a slight pause after you type ENTER.

If you like, Beta BASIC will automatically indent your listings to show the 'scope' of loops and tests. You can put premature line feeds into a listing, to arrange statements tidily.

The Beta BAIC toolkit lets you list procedures, groups of lines, variables and key definitions. There's an automatic line-number generator, convenient for entering listings. You can automatically search out and replace information in a program. And any group of lines can be renumbered, moved, saved or deleted in one step.

BLOCK STRUCTURE

If you're into structured programming, Beta BASIC will suit you down to the ground. It has named procedures with local or reference parameters, and you can set defaults for missing values. Recursion works fine, and there's no problem passing arrays, or lists of items to be processed one by one.

Besides the normal IF and FOR statements there's a multiline IF THEN ELSE and a qeneral-purpose DO..LOOP with conditional EXITs allowed from any point. You can combine or 'nest' these structures as you like. There are also single and multistatement versions of ON GO TO and ON GO SUB, but alas no SELECT or CASE statements.

Beta BASIC even speeds up a few ZX BASIC commands. Some aspects of ZX BASIC slow down alarmingly as program size increases, but Beta BASIC avoids this, so FOR loops, GO TOs, GO SUBs and RETURNs can be up to 20 times faster in long programs.

Most statements work at the same slothful rate as normal, but the array-handling tricks can give an impressive speedup. Often they let you replace a loop with a single machine-code command. Sadly, there's little prospect of a Beta BASIC complier.

Array-handling is comprehensive, to say the least. New keywords quickly sort and search string and numeric arrays. You can shuffle whole rows in one mighty move, and the current 64K of memory can be treated like an enormous string array, which you can slice and set at will.

FUNCTIONS AND ESOTERICA

Beta BASIC 4.0 includes 30 new BASIC functions which translate values from one form to another in lots of useful ways. Machine-code support is lacking, apart from two-byte PEEK and POKE and number-base conversion functions. New integer operations include MOD and bitwise AND.

You can convert numbers into three-byte, four-byte and five-byte strings, which can be convenient for sorting and packing data into records. Extra trigonometric functions trade accuracy for speed.

Print-formatting allows neat tables of figures. Variable values can be edited on screen - as with INPUT, but with a default value entered for you. An ingenious command passes characters to the command line as though they were typed in, so a program can edit itself!

There's an alarm clock, with options for a continuous display and a jump to a certain line when the alarm goes off, but the clock loses time during disk and cassette operations. You can divert execution to a subroutine when each end-of-line is reached in the main program, which can be useful when debugging. Errors and BREAK can be trapped.

QUICK ON THE DRAW

Beta BASIC graphics commands include a FILL function which colours bounded areas of the screen. Version 4.0 uses 10K of RAM disk space as a work area, making filling spectacularly fast - almost any shape can be filled in in under a second. A function lets you check the number of points painted, and you can fill shapes with any pattern of 16 by 16 dots - great for wallpaper-designers.

Version 4.0 includes superfast line-drawing commands. DRAW is about two-and-a-half times quicker than normal; CIRCLE works over the screen border, and is more accurate and 12 times faster than normal. All the drawing commands, with the annoying exception of FILL, will work on the whole screen - not on just the top 22 lines. But Beta BASIC lets you confine display output to a window or a limited area of the screen.

Character shapes are based on the normal 8x8 character set, or a 4x8 alternative, but you can choose any character size. You can have one character filling the screen, or 24 lines of 64 characters. Text can be positioned with pixel accuracy. You can shift and scale graphics within a window, and use absolute coordinates, rather than offsets, when drawing lines on the screen.

Other commands let you independently manipulate the colour-attribute grid. Areas of the screen can be smoothly scrolled in all directions, or saved for later redisplay in various sizes. These commands are fast enough for static pictures and graphic design work, but they'd be rather clumsy for animation. There are no masked sprite commands for games programmers.

THE VERDICT

Beta BASIC shows the Spectrum off very well. It's elegant, reliable, friendly and much more powerful than BASIC add-ons for say, Commodore or Amstrad machines. Like all BASIC interpreters it's a bit slow for shoot-'em-up games, but it's ideal for most other programming projects.

Beta BASIC 4.0 on the 128 is exceptionally powerful, with extra commands, faster graphics and full access to the machine's extra RAM and sound chip if you intend spending a few hours programming the 128 in BASIC. Beta BASIC 4.0 is the best utility you could buy. It's not cheap, but you get a heck of a lot for your money.

Beta BASIC 4.0 costs £15.95 (upgrade from 3.0: £8.95) from Betasoft, 92 Oxford Road, Mosely, Birmingham B13 9SQ.

(Simon N Goodwin owns the copyright to this review. Please visit http://simon.mooli.org.uk to find original articles and updates, much new material and his contact details.)

SOFT BUT STRONG

Power to the programmer from software tools

MASSIVE BETABASIC 4

If you're frustrated by the limitations of Spectrum BASIC and you'd prefer a larger, more structured set of commands, Betasoft's BetaBASIC is probably the answer. It's a massive package, so this is just a brief summary.

BetaBASIC is a £16 extension of ZX BASIC rather than a new interpreter. It adds more than 100 new commands to Sinclair BASIC, and speeds up some of the old ones - such as GOTO, GOSUB and FOR loops. It runs on any Spectrum apart from the +3, though there should be a special version for that machine later this year.

But BetaBASIC is BIG! It consists of 18K of code on a 48K Spectrum, leaving you with about 22K for your program. The extra commands for the Spectrum 128K take up another 7K, leaving you only 15K. The compensation is that often one BetaBASIC command can do what would otherwise have taken dozens of lines. (You can also store up to 70K of array variables and routines in the 128's Instant-access RAM disk.)

VERSATILE EDITOR

The BetaBASIC editor is a fast, improved version of the 48K Spectrum editor, rather than the slow, clumsy screen editor that normally runs in 128 BASIC. You can type commands in full, use an extended version of Sinclair's keyword-entry scheme, or mix the two - entering the commands you can remember as single-keypress keywords, and typing the others in full. User-defined keys are also allowed.

You can renumber, move, delete or copy any section of a program. There are search and replace facilities, and you can join and split lines easily.

Procedures and functions are allowed, with no restrictions on parameter-passing or local variables other than available memory. Block IF THEN ELSE and DO LOOPs are allowed, but there's no SELECT or CASE statement other than the old-fashioned and error-prone ON GOTO and ON GOSUB.

Array commands let you sort, search and shuffle entire arrays or slices very quickly. There are 30 new functions to convert, combine and format numbers or strings.

BetaBASIC's graphics commands are faster and more flexible than ZX BASICS. Besides using faster versions of the standard commands you can define windows and FILL any shape; graphics operations are particularly fast in the 128K program. Flexible scrolling and new character sizes are supported.

A souped-up BEEP command for 128-users lets you use the full potential of the AY-3-8912 sound chip. Sounds are queued, so your program carries on running while a tune or sequence of sound effects is played. This is a vast improvement on Sinclair's weedy PLAY command, though it's a bit harder to use. And PLAY, like all the other Sinclair commands, is still available if you want it.

Since Tech Niche last reported on BetaBASIC, the software has been improved to trap errors generated by the Disciple and Plus D disk systems as well as BREAK and other standard reports.

Software-designer Andy Wright says he's been encouraged by 'lots of post' about the +3, and intends to get down to work on a new version soon. He plans to implement serial data files on the +3 disk, and ideally random-access files as well, but he can't think of much else that isn't already done by BetaBASIC 4.

Betasoft has moved: its new address is 24 Wyche Avenue, Kings Heath, Birmingham B14 6LQ.

A BETTER BASIC

Memory: 48K
Price: £11.00

Beta Basic, from Betasoft, has already established itself as the standard extended Basic for the Spectrum. The launch of version 1.8 confirms that view with routines added to support interface and microdrives.

The new language adds 30 new commands and 20 functions to Sinclair Basic and makes use of the structuring commands which are available for machines such as the BBC Micro and the Commodore SX-64.

The language is so much better than the Sinclair Basic. As well as the structure commands such as DEF PROC which creates procedures similar to those on the QL there are also programming aid utilities, graphics commands, easier access to the memory of the Spectrum and a real time clock which even has an alarm.

The utilities include an AUTOline number command, a command which TRACEs the number of a line as it is executed in a program RUN and a horizontal screen SCROLL which behaves in a similar fashion to that on the ZX-81. There is also a ROLL utility which will scroll the screen vertically in any direction.

The 20 new functions include a PEEK which looks at 16-bit words, decimal to binary and decimal to hexadecimal converters, a SCREEN$ command which recognises both ordinary and user defined graphics and a function to convert a number into a different format such as that of decimal currency.

It is a great pity that Sinclair Research has not brought out a version of Beta Basic on its new Spectrum+ either on board the machine or as a microdrive cartridge or ROM. Betasoft turns Sinclair Basic from a good version of the language to a fantastic one.

JOHN WASE REVIEWS THE UPGRADED BETA BASIC VERSION 4.0.

Betasoft
£15.95

To say the least, it's a headache to write a review of this program, because, like Tasword, it has a long and noble line of predecessors; nevertheless, some readers clearly don't use it, or haven't even come across it. So I'll start with a short account of Beta Basic 3.0 for the 48K Spectrum for the 128 or +2 in 48K mode) and then discuss some of the extra 128K program features.

Effectively, what Beta Basic does is to enhance Spectrum BASIC by adding many new commands and functions. There are so many I cannot give very much detail but merely select from some seventy extra commands, most multiple, and twenty-six extra functions which appear as still further keywords. The essential Sinclair format remains the same, although much has been added. For instance when the computer stops after executing a command, type in the figure nought, and up comes the keyword EDIT on the input line (no keyword or line number starts with zero). Add the line number, ENTER, and there it is, waiting on the bottom lines to be edited. Saves all this listing to a line, breaking, and so on. In addition, the cursor is improved, the editing cursor moves up and down as it ought to. CSIZE changes the size of the lettering on-screen, you can arrange either to type in keywords. Individual letters, or even a mixture of modes, and JOIN and SPLIT program lines... But I digress. The most important bits for any BASIC programmer are things like the enhanced loops (DO... LOOP; DO WHILE condition; DO UNTIL condition; EXIT IF). Structured programming is also enhanced with commands like iF... THEN... ELSE, ON (to select a line number or a statement from a list) and LIST FORMAT which provides automatically indented listings to emphasise structure. But undoubtedly the most elegant and useful facility is the very full implementation of procedures, (allowing really well structured programs) and including the keywords PROC DEF PROC END PROG with LOCAL, REF parameter, DEFAULT variable value and iTEM function. Global and LOCAL variables can be used, and parameters can be passed by reference; even arrays, so that you need hold only one copy in memory.

There is also an assortment of graphics commands (CSIZE; GET a screen area, POKE it into memory, ALTER various attributes; DRAW TO; FILL, ROLL and SCROLL any parts of the screen, and WINDOW). Beta Basic's improved SAVE, LOAD, MERGE and VERIFY all permit use of parts of programs (SAVE a library of procedures) and allow simplified syntax for microdrives or discs (LOAD 1; "program", or use DEFAULT).

You can SAVE. MOVE, or COPY part of an array to another array, or ALTER its size without data loss. DELETE deletes part of an array and SORT gives very fast alphabetic or numeric sorting. INARRAY and INSTRING functions search arrays and strings whilst LENGTH gives an array's dimensions and location to check if it will fit in memory.

Finally a comprehensive set of toolkit commands includes block move, copy or delete, a comprehensive RENUMber command and ALTER, a search and change command. Those of you who don't know Beta Basic and who actually write BASIC programs (useful if you want to understand what the program's about when you look at it next month) will be wondering "What's the catch?" The answer is all this lot takes quite a chunk of memory in the 48K Spectrum, although it still leaves about 22K of memory for your BASIC program. (How many BASIC programs are longer than this?). The crunch comes when you want to handle large amounts of data, particularly large arrays. Which is where I came in: with Beta Basic 4.0.

BETA 4.0

The last but one Beta Basic Newsletter (contact Betasoft for details of this service) was rather jaundiced about the 128 or +2's very restricted memory paging, but has now relented, mainly because the data handling restrictions I just mentioned, and the ability to handle large arrays are among the features of the new program which I tested.

The presentation, a pleasant surprise, is still 48K-type with an input line at the bottom. The full-screen editor of the 128K mode is a bind, because it has to redraw the whole screen for each command and invariably loses the first few letters of the next command typed in as there is no input buffer. Beta Basic 4.0, like previous versions, allows keywords to be typed in, in full, so with its improved editing facilities, its display is probably better.

ARRAYS

Let's start with the serious stuff; arrays. Although the display looks 48K, the new keywords are distinctly 128Kish. So DIM! fred!, (1000, 60) creates a 60K RAM disc file. You can then sort it using SORT!. (e.g. SORT! fred$0). LET! enables you to assign a number or a string to a specific element in the array (e.g. LET! fred$ (20) = "hello") and PRINT INARRAY ("fred$", "test") found "test" in fred$ in about 0.66 sec/1000 strings if all length (60) was searched, and about 0.26 sec/1000 strings if position in the strings was given. LIST! AND LLIST! list arrays to screen or printer (e.g. LIST! "fred$"). LIST! being the most important feature of these new array-handling facilities as it provides the ability to LIST! to any peripheral with direct access to streams/ channels.

In effect, this means you can set up files in RAM which are essentially random access, manipulate them incredibly rapidly whilst still in RAM and dump them out again to storage. Even microdrive owners can have random access facilities now, and at a speed many a PC owner would envy. The final extra RAM disc command is INPUT! to LOAD a file back from a device to RAM disc (eg. OPEN#5;"m";1;"filename": INPUT #5;!"fred$") which LOADs fred$ back to the RAM disc array. The complete collection of RAM disc commands is SAVE!, LOAD!, MERGE! and ERASE! (same as in Spectrum 128 BASIC): CAT! (now gives free disc space; normal, 78K); INPUT! and LIST! to move stuff to and from bulk storage. DIM! to set up a RAM disc array. INARRAY to sort RAM or RAM disc array and SORT! to sort a RAM disc file.

BEEP!

In addition, there are some fun bits. A fast CIRCLE (about twelve times faster than Sinclair's) and DRAW (about 2.5 times faster: it will also draw on the bottom two lines of the screen which the new PLOT can also use); a new FORMAT to allow a ZX printer to work correctly in 128K mode; FILL USING gives fast patterned, even stippled fills. I filled a quick circle with a nice redbrick pattern. Whilst Beta Basic of course supports the new PLAY command which is great for music, but which stops the computer every time it sounds. It also has a totally new, super-fun command; an interrupt-driven BEEP! which can have up to six specifiers.

There isn't room here to describe them in detail, but all the facilities of the sound chip are at your disposal. The big advantage over PLAY is that BEEP! is interrupt-driven: Beta Soft provided me with a few lines of Beta Basic illustrating several features rather nicely; a rapid circle, rapid filled and bounced up and down between two lines at ever-increasing velocity, raising the pitch of the "boing" at each bounce. With PLAY, the poor old computer and ball would have stopped at each surface to make the noise; with BEEP! the ball carried on bouncing.

All in all, this is a super program. It provides an unbelievable number of facilities, and comes as a package containing the 48K Beta Basic 3.0 and the 128K Beta Basic 4.0 recorded together.

The complexity of these programs is indicated by the size of the instruction manuals; 88 closely printed A5 pages for the basic 48K version 3.0, and a supplementary manual containing a further 30 or so pages for issue 4.0, all tightly packed with information and carefully laid out with illustrative programs.

The whole comes packed in a stylish wallet from Beta Soft, 92 Oxford Road, Moseley, Birmingham, B13 9SQ. Write to them for details of disc versions and upgrades for existing owners.

Beta Basic 3.0 was superb, one of the classic programs for the 48K Spectrum. Beta Basic 128 is even better; it's solid gold. Get it!

USER-DEFINED POSSIBILITIES

John Gilbert says: Why not stop playing games and do something useful instead?

The definition of a utility in computer parlance has widened in the past year. In the early days of the industry it meant a program which aided the machine code programmer to accomplish a task. Now it can have five meanings.

The first category takes in the graphics and sound toolkits. Those expand the Basic command set, adding instructions which create shapes, fill them in, and save pictures to tape or microdrive. The sound generators sometimes included within those packages can make music or even create a voice for your computer.

Machine code utilities include assemblers, disassemblers and monitors, all of which are designed to help you write your own machine code routines. If you are not up to that sort of exercise you may like to acquire a new operating system or high level language such as Pascal, Forth or C.

General utilities which will teach you the highway code, help you with car maintenance or show you how to diet efficiently are also available.

Graphics packages have the most visible effect on a Spectrum or QL, and they have proved popular this year even with people who would not normally program a computer. Light Magic, from New Generation, started the interest in all things graphical during 1985. It carried on where Melbourne Draw, from Melbourne House, and Paintbox, from Print 'n' Plotter, left off.

The program is totally menu driven and can be operated either under keyboard or joystick control. There are five modes of display. The first is pen mode in which, you can draw on the screen using an electronic nib.

Circle and Fill mode will allow you to produce circles and arcs which can then be filled in with colour. Brush mode is similar to Pen mode but you can use 10 types of brush.

The block mode operates in parts, or blocks, of the screen. It allows you to rotate and mirror blocks on pictures, saving time if you need to draw an object which is symmetrical.

Finally, the Text mode enables you to write on the screen. User-defined graphics can also be produced as a UDG generator is included in the package.

If Light Magic does not impress you then The Artist, from Softechnics surely will. It is one of the most powerful packages on the market.

The Artist can be used to take one section of a picture and reproduce it on another part of the screen, where it can be enlarged or reduced. The package will also allow you to produce UDGs and a animator utility is included within the program. Not satisfied with that the author has also included a simple routine which will take a screen display and reduce the number of RAM bytes required to store it.

Art Studio, from OCP outperforms The Artist in almost every way. It has superior speed to the Softechnics package and the pull down menus are easy to use. It can be used with disc, tape or microdrive and contains a printer driver which handles most Spectrum compatible printers. It should be of use to professional artists and designers as well as to the home user.

A similar package came onto the market for the QL. GraphiQL marked the entry of quality software house Talent onto the QL scene. Not only can the package produce every conceivable type of line, circle, are and angle, but it can also be used to define textures, using form and colour. Those can then be used with Fill routines.

The program allows you to enlarge shapes on the screen. That facility enables you to ensure that Fill texture does not leak out of a shape which has a hole in its border.

QL Art, from Eidersoft, has the same sort of facilities as GraphiQL but does not have the same professional edge to it. Unlike the Talent package it is fully menu driven. One of the faults with GraphiQL is that you must rely on the instruction manual or special help option for information about user commands.

Illustrator, from Gilsoft, is the long awaited adventure graphics designer for the Spectrum. It is no ordinary package as it produces graphic screens which can be put into adventures designed by Gilsoft's adventure design program The Quill. Although the routine can only produce static screen pictures it brightens up the adventures written by its sister program and gives adventure programmers more scope for invention.

White Lightning, from Ocean, is one of the most exciting advances in graphics design packages for the Spectrum that I have seen in the last year. Its aim is to allow you to produce high standard arcade game graphics and, in order to do that, you must use its special Forth-type language. The package combines a sprite generator with a screen layout designer. It is great fun to use and its limitations are only in the mind of the beholder.

A similar package has been produced for the QL, although Super Sprite Generator, from Digital Integration, will produce and animate only sprites and not full screen game backdrops.

The program adds extensions to SuperBasic and is run in two parts. The first is the generator and the second the animation routine. It is an excellent package which has been used by professional programmers to produce arcade games. Night Nurse from Shadow Games is one example of its use.

Only one good example of a sound toolkit came onto the market last year. Varitalk produces speech through the Spectrum Beep unit. Its performance can be enhanced using a loudspeaker or by putting the sound through a tape recorded output channel.

A large number of phonetic sounds are included in the package. Those can be accessed by using a code made up of the first letter of the type of sound required and the number of that sound from a list which has been provided on the cassette inlay. There are no parameters within the program to allow you to set emotion or inflection into the speech. You cannot even get the package to ask a question properly.

Machine code utilities may only appeal to assembly language programmers but that audience has grown larger during the past year, especially within the ranks of those who own a QL.

No less than four QL assemblers arrived on the market during 1985. The most powerful was from Metacomco. The QL Assembler Development Kit comprises a full screen editor, together with a three-pass compiler.

The editor can input ASCII code files and so can be used with code Basic programs and even word processor files. Once your assembly code listing has been entered you must save it to microdrive, or disc, and then load it into the assembler program. The package takes approximately two minutes - and three code overlays - to convert the code file into a machine code format.

Also included with the assembler is a library of QDOS calls. Those can be named within you programs. A linker was put into the second version of the assembler package at which time Metacomco dropped the price.

Computer One was also quick to produce an assembler for the QL. The difference between it and the Metacomco program is that it can be loaded into the machine complete with the source editor. You can, therefore, write your assembly program and then convert it to machine code without having to load any overlays from microdrive.

The Sinclair Research assembler is similar to that from Metacomco, but it is not as powerful. Incidentally, the full screen editor in the package was written for Metacomco. GST, the company which wrote the Sinclair assembler, just does not seem to have the knack of producing editors.

Adder Publishing was not as quick to produce an assembler package as Metacomco and Computer One but it did release one after the launch of its classic QL Advanced User Guide.

The program was similar in structure to the other products on the market but adheres closely to the notation in the User Guide Book.

It was some time before anyone realised that what the QL market was missing was a debugging tool such as a monitor or disassembler. That was soon put right, however, as four companies put monitors onto the market almost simultaneously.

The first program came from Digita1 Integration. QL Super Monitor is an economical package, put out in a cassette format box. It performs its task well and allows to view and alter code in a hexadecimal format.

Computer One was again quick on the scene with a monitor which followed, and was compatible with, its assembler package.

Not to be outdone Hi-Soft also decided that it should bring out a token QL product and opted for Andrew Pennel's QL MON. Unlike the Computer One program it is not automatically invoked when the machine is powered-up. Pennel's monitor is a QDOS job and can be called simply by typing a new SuperBasic command, MON. As it is easy to break out of the package back into SuperBasic the monitor can reside in RAM, be called at any time, and not disrupt any of the other tasks being performed by the QL.

The same technique is used in Tony Tebby's QL Monitor which is produced by Sinclair Research. The package has all the usual debugging facilities, a one line disassembler, and routines which displays the values of the registers or a block of memory in hexadecimal.

Another good feature of the package is that you can set it to run on any channel or in any window. That means that you could set up several versions of the program within the machine, each of which work on different sections of code.

You may prefer, however, not to get tangled up in the web of machine code. That does not mean, however, that you have to stick to SuperBasic, or to buying packages off the shelf. You can still experiment with QDOS and machine code by buying one of the toolkits or SuperBasic extension packages which have just become available.

The most famous toolkit, of course, was written by Tony Tebby and can be obtained for the QL from Sinclair Research. It provides a whole spectrum of new SuperBasic commands and run-alone programs which show the power of the QL multi-tasking operating system.

The main body of QL Toolkit comprises SuperBasic extensions which control jobs, allocate or clear memory, and display the status of the system.

A series of separate programs, some in SuperBasic, some machine code, are also included in the package. They provide a user-defined graphics generator, an exceptionally fast back-up utility, and a multi-tasked digital clock which can be run while the package is in operation.

One task which the toolkit will not do is to check microdrives for errors or repair files which have become corrupt. Those sort of occurrences may be well known to you. They are unfortunate but fairly regular and if you do not have a back-up copy of a file you will usually be in trouble.

The Cartridge Doctor, from Talent, does away with many of the problems posed by the microdrives. It checks every sector on a cartridge to see it any errors have occurred and informs you if files have been corrupted.

Once you know about an error you can set up the Cartridge Doctor to deal with it. The most usual way is to read the file in and display it in ASCII format. A cursor is then provided by the program and you can rewrite any parts of the file which have been damaged. You can even repair the headers of files if necessary.

Machine code is a low level language because you cannot understand it but the computer finds it easy to understand. A high level language, such as Basic, is easy to understand from your point of view - as a user - but needs some translation before the computer can understand it. There are several types of high level language for both the Spectrum and QL.

Although Sinclair Basic, for the Spectrum, is highly respected it does have some faults and one software house, Betasoft has brought out a new version of structured Basic. Many of the additions provided by Beta Basic can also be found on machines such as the BBC Microcomputer, Amstrad and QL. They include WHEN and WHILE loops, a real time clock, new graphics commands and instructions to make Interface 1 and microdrives easier to use.

The Betasoft version of Basic is one of the best on the market for any machine. It has undergone several transformations during its relatively short three-year life span.

Pascal is another popular language and can often be found in schools. Indeed it is on the curriculum of some O and A level examination boards.

The first company onto the market with a full version of the language was Hi-Soft. Although it does not have an ISO standard of certification, which most full versions of the language have, it does run many times faster than Sinclair Basic and includes Logo turtle graphics.

The big Pascal launch of the year, however, was for the QL, from Metacomco. The QL Pascal Development Kit did receive ISO standard certification - an award which is to Pascal what a BSA certificate is to car safety seats.

The Metacomco package provides a full version of the language with extensions for QL graphics and sound. The source code is taken from a full screen editor and compiled into true 68000 code.

It was the first QL product to receive a Sinclair User Classic and, indeed, it was the first utility to receive that award for software excellence.

Computer One brought out a version of Pascal which while not up to the standard of the compiler from Metacomco comes a very close second. The first version of the package compiles the source into P-code which, although faster than SuperBasic, requires the Pascal operating system to be in memory. Computer One later amended the program so that code could either be translated into P-code or compiled to form a job which would run without the operating system being present.

The compiler is more user friendly than the Metacomco package - all sections of the screen editor and compiler can be accessed through a menu based program - but the QL Pascal Development Kit wins hands down in the features race.

Metacomco and Computer One both brought out versions of the popular artificial intelligence list processing language LISP. The Computer One program is less expensive than the one from Metacomco. Both versions can deal with the QL graphics commands and both are interpreted.

The medium level language C also proved popular with QL software houses during 1985. The first company to bring out a version was GST, which is famous for the 68K/OS alternative QL operating system. Unfortunately the product is a version of public domain RATC, a scaled down version of the original with additions to allow the use of QL graphics and QDOS traps. It is, of course, a compiler but the source must first be typed into a screen editor, run through a compiler which produces assembly language source, and put through an assembler to produce 68008 code. It is an unnecessarily complex operation and the code could be compiled in one go if GST had produced a machine code compiler.

GST also ranks among the companies which brought out QL operating systems in 1985. Its 68K/OS was originally intended to be the QL operating system. The package consists of as ROM board, slotted into the expansion slot at the side of the QL, and several microdrive cartridges.

As operating systems are usually judged on the amount of software available for them 68K/OS is a dismal failure. So far GST has only produced an assembler and word processor for its baby. One wonders what would have happened if Sir Clive had decided to use the GST operating system.

The C/PM-68K operating system from disc drive manufacturer Quest Automation did little better than the GST product. A few business packages are available for it but, despite the fact that it uses discs or microdrives, few software houses have taken up the challenge to produce anything of note for it.

A large variety of DIY utilities came onto the market in 1985. They teach everything from garden design to touch typing and computer athletics.

Sinclair Research wins our first Most Useless Utility Award for 1985 with QL Gardener. While it is obvious to see the benefits of a plant dictionary and garden design package for those who like gardening, and own a QL, with the dearth of QL software the company must be green behind the ears to bring out such a product. Where are all the fantastic business and educational programs which will show off the true power of the 16-bit - or is it 32-bit - machine?

Our second MUU of 1985 award goes to Car Cure, a program which aims to diagnose the problems which you may encounter with your car. All you have to do is type in the symptoms of your vehicle's illness and the program will come up with an answer to your problems - maybe. Most of the time it just recommends that you contact a qualified mechanic immediately.

Another car-orientated program which is marginally more useful than Car Cure is Highway Code. Through a series of multi-choice questions it will teach you about the signs and situations which you may encounter on the road. The graphics are simple, but effective, and the program has been checked by a qualified driving instructor.

If you want to stay fit then Microfitness from VO2 is for you. It will take you through a series of carefully graded exercises culminating in - I hope for your sake - physical fitness. When it was reviewed early in 1985 our own Clare Edgeley found out how unfit she was!

Finally, touch typing programs for beginners came from QL software houses during the past year. Two were produced, one from Computer One and the other four months later, from Sinclair Research. Touch 'n' Go from Sinclair Research provides more in the way of graded exercises and a more complex results table.

The utility market is the area in which the QL has done best. There are many languages available for it and a host of machine code utilities which allow the use of the power of the 68008 processor and QDOS.

It is a pity that the same cannot be said of the Spectrum. Very few utilities were produced for the machine and most software houses have moved to other machines. That is unfortunate as the Spectrum still has a lot of power within it which lies untapped because people like you cannot get at it.

An alternative Basic language for the Spectrum which offers more than the standard ZX Basic.

As well as providing all the Sinclair commands, it also has a number of commands available from BBC Basic. BBC Basic commands include extensions to FOR...NEXT loops, and new control structures such as WHILE...WEND and IF...THEN...ELSE.

Beta Basic provides utilities such as decimal, hexadecimal and binary number base conversions, extensions to graphics and sound, and a Trace facility which tracks down errors in programs.

The language, which is available on cassette or microdrive, is successful because it is continually changing and getting better.