Spectrum FORTH

Big K

Fin Fahey

THE EXTENDED SPECTRUM Fin Fahey checks out a smattering of utility programs for Old Rubber Keys. System Software, as we old computer industry hacks call programming tools, is hardly destined to set the world alight. It smacks of hard work and late night sessions over a hot keyboard and seems light years away from the glamour and fun of, say, a new Melbourne House adventure release. But for people interested in stretching their minds, and their machines, some of these trusty workhorses may well turn out to have hearts of gold. But why go beyond the facilities offered by Sinclair BASIC? (One may well ask.) Quite simply, no machine, and particularly no BASIC interpreter, fills all the needs of the budding programmer, and for a lot of requirements like arcade games, just hasn't got the speed. There area fair number of - packages which just add a few useful commands to BASIC extensions r programmer's toolkits, these generally give you the sort of goodies you've always needed to develop your BASIC programs. There's no line Renumber command on the Spectrum, and for this you'll have to buy a toolkit. The same goes for many other 'system' commands. Trace, to give you a continuous listing of program lines being executed, Map, to tell you which variables have been specified, and Block Delete, so you can get rid of more than one line at a time, to name but a few. Super Toolkit, from Nectarine, has all of these plus such things as a Crunch command, to get all those useless spaces and REMs out of your program before running. It clocks up a total of 12 commands, as does Toolkit from IMS Software, which includes an Auto line-numbering routine. Slightly fewer facilities on CP Software's Spectrum Extended BASIC, only 10 commands in this case, and the only one unique to this package is Find, which will look fora specific string text in your program. CP, however also do Supercode, a machine code toolkit, incorporating a hundred off-the-shelf machine code routines. These include an impressive range of scrolling effects, high-resolution diagonal scroll, low-resolution shutter and ripple scrolls and many others. There are four sound effects generators too, but the truly impressive thing is that you can include CP's code in your own BASIC and machine code programs, an amazing bit of altruism. Each routine has full in-program documentation and a demo mode shows you what they can do. It's got to be good value. From off-the-shell machine code to creating your own. If you've decided that BASIC's too slow for your program design, then you'll probably want to write machine code. Some people seem quite happy programming this byte by byte as BASIC POKEs, but for really effective development you'll need an assembler. Assemblers allow you to put Z80 code in assembly language, a much more understandable form, even though it's a lot more obscure looking than BASIC. A good assembler will allow you to specify addresses and constants as meaningful labels which makes the code a lot easier to follow. In such a symbolic assembler, the JP instruction (equivalent of BASIC GOTO) could be rendered JP LOOP instead of giving an actual address, say JP $4000. But before actually using one of these things, you may need to learn what it's all about. To help you, there are a number of tutorial programs, and some of these actually allow you to set up and test code. Sinclair's Beyond BASIC offers a tutorial on the internal structure of the Z80 plus lessons on each assembler instruction. These are illustrated with simple moving graphics. There is an experimenter section where you can watch the effects of your own code on memory and registers. Sadly, this one doesn't cover the entire instruction set. More complete is New Generation's Machine Code Tutor. This comes on two cassettes and covers everything. Once again, you can write your own code and 'run' it on a diagrammatic simulator. Although this is rather harder work than Sinclair's, I think it gives a closer feeling to using an actual assembler. Dream Software also have a simulator. This has much nicer printed documentation than the other two, but unfortunately it describes an imaginary chip which resembles the Z80 in many respects. I think that this may be unnecessarily confusing, but as long as its borne in mind, the transition to the real chip shouldn't be too hard. So now you can get down to some real coding... Sinclair themselves market the Zeus Assembler, which allows full symbolic instructions. Lines of code are entered much as in BASIC, and editing is similar, so this should be an easy one for beginners to move to. Picturesque's Editor/Assembler, on the other hand, has a rather better editor than the Spectrum, but the key response seemed a bit slow to me. This latter program is very tolerant about the format in which you enter code. Very different from these two is Oasis Software's Spectre Macro-assembler, and I certainly wouldn't recommend this one for beginners. It's a very professional product, but using it is more like learning a new computer language than anything else. It doesn't use Z80 instructions directly; they have to be set up as procedure definitions much as in high-level languages like Forth or Pascal. This makes it very powerful, since it's just like building your own interpreter. But, as I say, not for newcomers. An indispensable tool when developing machine code is some sort of Monitor. A Monitor provides easy ways of getting at memory, moving it, changing it, searching it for particular values, that sort of thing. You can also usually get dumps of Z80 register values and step through a machine code program. The Zeus assembler has a reasonable monitor with it, but Sinclair do a more extensive version as a separate product. This also allows you to Disassemble code, which means to translate machine code back to assembly format. Useful for looking at the ROM, but maybe you'd be better off buying one of the 'Spectrum ROM disassembled' type books which also give explanatory notes. Picturesque's Editor/Assembler has no attached monitor and you have to buy theirs separately, although both programs can be loaded at the same time. Agai, there's a disassembler. Assembly language isn't the only way of getting fast code. Scope II, from ISP, is a simple language aimed at producing fast machine-code animation. The makers call it a medium-level language, as it's mid-way between BASIC and assembler. I feel it's rather closer to machine code, but it's certainly a lot easier to use. Once you've written code in SCOPE II, it is boiled down by the program to machine code routines, which can be run without Scope being present, so you develop commercial products, or give copies of your games to your friends without fear of committing piracy. This process of boiling down machine code is known as compilation, and it's possible to do it to BASIC. The only BASIC compiler we had available to look at was Softek's. This is certainly fast. From running a few simple loops, it looks roughly about 150-200 times faster than interpreted BASIC. It does have some serious drawbacks, though. For one, there a quite a few BASIC functions it can't translate, floating-point arithmetic and arrays among them. More seriously, compiled programs will not run without Softek's run-time routines being present. Unfortunately, the company is being quite prickly about this, and are claiming that if you develop your program and compile it with their program. then they've suddenly acquired a share in it, Whatever the legal position, this seems a little dubious to me, and it's certainly a discouragement to using Softek's product for commercial development. The final approach to fast code is to use Forth. This high-level language is closer to machine code than BASIC, and for most purposes runs up to ten times faster. Not spectacular maybe, but it can make a difference. The speed saving is nice, but it's not really the central point about Forth. The language takes a fundamentally different approach to BASIC, and one which provides a much sounder design discipline. It would certainly be easier to write good machine code after a grounding in it. Forth is known as a 'procedure-oriented' language. That means there's no more complaining about there not being a command in BASIC to do something. If it's not there in Forth, then you just write your own command, which is compiled into the language vocabulary. Although you can theoretically do this in BASIC by using subroutines, compiled procedures are much faster and easier to use. Forth is easier to structure too. There are at least four versions of Forth available on the Spectrum. It's hard to decide between them, but Melbourne House's Abersoft Forth is the only one recognised by the independent Forth interest Group. Sinclair also do a Forth which to my relatively untutored mind seemed much the same, both in terms of speed and usability. Both versions have minimal printed documentation, since they rely on the user going out and acquiring a Forth manual. The sad thing about Forth is that. unless you're a fan of the ill-fated Jupiter Ace, you can't market any of your programs since they won't run without someone else's product. While on the subject of languages, Logo has been stirring up interest as a teaching language, particularly for younger children. Unfortunately, the version I looked at, Snail Logo by CP Software, really merited its name. Logo is high-resolution graphics oriented, and the user commands a 'turtle', or in this case a snail, to draw shapes on the screen. The CP interpreter turned out to be written in BASIC, so every command is interpreted twice. Slow? I can't imagine anyone, adult, or child, having the patience to work through the manual, let alone use it. Something of a weirdie, but one I find particularly fascinating, is Micro -Prolog, from Sinclair. Prolog represents yet another direction in new languages, and is particularly suited for Artificial Intelligence and linguistic purposes. Its very odd to use after command oriented type languages like BASIC, or even Forth, because a program in Prolog (it stands for PROgramming in LOGic) is mostly a way of organising data, not of setting up a fl ow of commands. Now I've got the point, I want to know more about this one. Sinclair Micro-Prolog's documentation isn't bad either. Dr Ming back to the problem of generating programs, if you're an adventure game writer, you haven't really got one, The Quill, from Gilsoft, and Dream's Dungeon Builder can both be used to generate adventures of any complexity. We've reviewed them before, and they're both good value. Dungeon Builder has the edge in user-friendliness, and can be used to add graphics to adventures, while Quill has a more mechanistic approach. Both Gilsoft and Dream are perfectly happy for people to market games produced with their packages. Right on! On which cheery note I'll roll the credits and fade to black, but not before noting that this is far from being a complete survey, so if you've discovered an utterly wonderful, or unspeakably awful bit of useful/useless software in this field let us know. BASIC EXTENSIONS: SUPER TOOLKIT from NECTARINE TOOLKIT from IMS Software SPECTRUM EXTENDED BASIC from CP Software Price: £9.95 SUPERCODE from CP Software Price: £9.95 MACHINE CODE TUTORIALS: BEYOND BASIC from Sinclair Price: £9.95 THE COMPLETE MACHINE. CODE TUTOR from New Generation Software Price: £7.95 MACHINE-CODE FOR BEGINNERS from Dream Software Price. £0.00 ASSEMBLERS: ZEUS ASSEMBLER from Sinclair Price: £12.95 EDITOR/ASSEMBLER from Picturesque Price: £8.50 SPECTRE MAC-MON from Oasis Software Price: £14.95 MONITORS: MONITOR/DISASSEMBLER from Sinclair Price: £12.95 SPECTRUM MONITOR from Picturesque Price: £7.50 COMPILER from Softek Price: £9.95 LANGUAGES: SCOPE II from ISP Price: £11.95 FORTH from Sinclair Price: £14.95 ABERSOFT FORTH from Melbourne House Price. £14.95 SNAIL LOGO from CP Software Price: £9.95 MICRO-PROLOG from Sinclair Price: £24.95 ADVENTURE GENERATORS: THE QUILL from Gilsoft Price: £11.95 DUNGEON BUILDER from Dream Software Price: £9.95

Personal Computer News

Ted Ball

FLOCKS OF FORTH Forth is becoming more accessible to Spectrum-owners. Ted Ball weighs up two new packages. ARTIC FORTH NAME: Artic Forth APPLICATION: Programming language SYSTEM: 48K ZX Spectrum PRICE: £14.95 PUBLISHER: Sinclair Research FORMAT: Cassette LANGUAGE: Machine code OUTLETS: Mail order Artic Forth appears to be an impleAmentation of FIG Forth, with some minor modifications, and some extensions to handle graphics, colour, etc, on the Spectrum. The extensions largely use the same words as Spectrum Basic - PLOT, CIRCLE, INK, etc - but there are some differences, like GOVER instead of OVER because OVER is already used in Forth with a different meaning. Two words from 8080 FIG Forth. P@ and P!, equivalent to IN and OUT in Spectrum Basic, are omitted, so you will have to add your own versions in machine code if you want to use Artic Forth with I/O mapped ports. For saving your own programs on tape Artic FORTH has the standard FIG method of 'screens', a screen being a 1K block of memory arranged as 16 lines of 6-4 characters. Although this is not really suitable for the Spectrum's 22 lines of 32 characters it does allow you to type in published program listings without having to make any changes. Unfortunately, you are allowed only one screen in memory at a time, which makes it awkward to save and load programs that extend beyond this. To enter programs into a screen you have to use the editor which is on the tape immediately following the Forth code. As the editor takes up three screens you immediately get to see how awkward it can be to load programs. You have to stop the tape after each screen has been loaded, wait a few seconds for a prompt, then press ENTER and start the tape again. As there is very little space between the screens you have to be very quick in stopping the tape before the next screen comes up. The editor is fairly easy to use for entering programs into a screen, but making corrections is a lot harder. However. Artic has provided an additional 'on-screen' editor which allows you to use the arrow keys to move the cursor around and the EDIT key to copy text from the cursor position onto a new line. PERSENTATION Artic Forth is attractively packaged in a box containing two printed manuals and a cassette which has the Forth and editor on both sides. The 44-page User's Manual includes instructions for loading the tape, a brief introduction to Forth, and a glossary giving precise definitions of all the words in Artic Forth. The introduction to Forth will help you get started, but to learn the language properly you will need a textbook. The four-page Editor's Manual contains only some brief notes on using the editor, and the editor glossary. RELIABILITY Artic Forth is generally quite robust, but there are a few minor bugs, if you press BREAK while the ZX Printer is running subsequent output goes to the printer only and the command to switch output back to the screen does not work. The only way I found of getting back to normal from this situation was to type COLD or WARM. The Forth word FENCE is not implemented properly. This is meant to set a limit below which FORGET will not work, but whatever value you put into FENCE you can FORGET anything in the dictionary. There is also an oddity in the on-screen editor. If you press DELETE at the beginning of a line you get a question mark. Pressing DELETE again gives another question mark instead of deleting the first one. However, this does no damage and you can escape by pressing ENTER. VERDICT Although there is nothing important wrong with Artic Forth it is just not as good as Abersoft's version at the same price. Artic's documentation is a little better than Abersoft's, and the Artic on-screen editor is easier to use for making corrections, but Abersoft Forth has no known bugs, gives you more Forth words, and because it allows 12 screens in memory at once it is easier to load and save programs. FP50 FORTH NAME: FP50 Forth APPLICATION: Programming language SYSTEM: 48K Spectrum PRICE: £14.95 PUBLISHER: Mike Hampson, [redacted] FORMAT: Cassette LANGUAGE: Basic & M/C OUTLETS: Mail order Although FP50 is claimed to be based on Forth 79, and the Forth words included in the dictionary are closer to Forth 79 than to FIG Forth, the differences are so great that you have to forget the standard when using FP50. FP50 allows you to use integers in the range 0 to 65535 (instead of the standard -32767 to +32760) and floating point numbers in the range +/-1E38, but not the double integers of standard Forth. Many of the words in the dictionary come in pairs, one word for floating point operations and the other (preceded by %) for integer operations. For example + and %+, DO and %DO, etc. This is the opposite to standard Forth where you have + for 16-bit integer addition, D+ for 32-bit integer addition and, if you have a floating point package, F+ for floating point addition. Colon definitions for extending the dictionary and immediate commands are allowed, but there are some differences here. When you have typed in a colon definition and pressed ENTER, the name of the new word and its compilation address are printed at the top of the screen, and then the words making up the definition are printed one at a time as they are compiled. If you have included a word that is not in the dictionary you get a message 'XXXX not known. Continue definition' and you can carry on from the point you made the mistake. Unlike normal FORTH you cannot add a new word to the dictionary if there is already a word with the same name. There are two types of immediate command. The normal type consists of a string of Forth words which are executed as soon as you press ENTER, but in FP50 you have to end with a semi-colon, and before the command is executed you get a message 'compiling - please wait'. The other type of immediate command includes things like PRON and PROFF for printer on and printer off. S for save, etc. These can be used only from command mode and cannot be used in colon definitions. FP50 includes special commands for things like colour and graphics on the Spectrum, largely using the same words as Spectrum Basic. User-defined graphics are available, but with an 'immediate only' command, so you cannot easily change character definitions within a program. The only way to enter a program is to type in the colon definitions one after the other. There is no way to alter a definition after it has been entered in the dictionary except by 'forgetting' the word (and everything typed in afterwards) and starting again. To save a program you have to save the whole of FP50 with your program added to the dictionary. PERSENTATION The instructions consist of a 12-page A4 manual offset from a typed original. The manual is organised in tutorial form, taking you through the use of the FP50 program, and explaining Forth and the words in the FP50 dictionary. There is no index or glossary, and to find the definition of a particular word you have to go through the whole manual. IN USE FP50 can be quite tedious to use, with all commands and definitions being repeated by the compiler before anything is done with them. The manual includes a table giving some comparisons between the speed of Basic, FP50 floating point, and FP50 integer calculations, but although I managed to get times for the integer calculations roughly agreeing with the table, I could not agree with the times for the floating point calculations. RELIABILITY FP50 works correctly on most things, but you can get the wrong output in some cases. For example using % (integer PRINT) instead of . (floating point PRINT) will give the wrong answer. You also find that illegal calculations like 1 divided by 0, or giving the wrong input when defining user-defined graphics will drop you into Basic. The manual does, however, give warnings and tells you how to get back into FP50. Where FP50 finds errors for itself it gives helpful error messages and allows you to continue from the point where the error occurred. VERDICT The main thing wrong with FP50 is that it does not follow any standard closely enough to be useful. The advantage of standards in programming languages is to make programs portable. There is an enormous amount of useful software available in source form in FIG Forth and Forth 79, but you will find it very difficult to convert to work on FP50.

Forth is certainly multiplying on the ZX Spectrum - there's Abersoft Forth, which was reviewed in PCN issue 13, Artic Forth, and Mike Hampson's Floating Point Forth, being reviewed now, and two that we've not seen - an earlier integer-only Forth from Mike Hampson, and a version from CP Software. There are many reasons for Forth being so popular. It comes between Basic and machine code in speed, ease of use, and the control you get over the computer, and a Forth interpreter is relatively small and easy to implement, whether it is based on the assembler listings published by the Forth interest Group or written from scratch. Abersoft Forth and Artic Forth are directly comparable, both being based on the FIG standard and having almost identical extensions to allow you to use the special hardware features of the Spectrum. Mike Hampson's FP50 is quite different. It is written in Basic with some machine code subroutines, and is described as 'being based on, but not being, a Forth-79 standard'.