When Atari shipped the 130XE computer
in April 1985, Optimized Systems Software (OSS) seized the opportunity to
create the first programming language designed for the expanded 128K memory
of the XE. The result is cartridge/disk BASIC XE, the fastest and
most powerful BASIC available for 8-hit Atari XL and XE computers. NOTE:
BASIC XE will not run on Atari 400 or 800 models. Users of these
earlier computers still have BASIC XL available from OSS.
Optimized Systems Software was the
first independent company to write software for Atari personal computers.
Bill Wilkinson and his programmers created the disk file management system
of DOS 1.0, 2.0 and 2.5, as well as Atari BASIC and the Atari Assembler
Editor cartridge. But they didn't stop with software just for Atari to
bundle with its computers. OSS went on to publish the best line of Atari
programming languages and tools including MAC/65, ACTION! and BASIC XL.
BASIC A+ was the first OSS enhanced
version of Atari BASIC. Unlike the Microsoft JBASIC released by Atari, BASIC
A+ was compatible with source code that ran under Atari BASIC, except for a
few minor exceptions. BASIC A + was available only on disk, but the
subsequent, improved BASIC XL came in super-cartridge form, using the
technique of bank selection to cram 16K of ROM code into 8K of address space
and save 8K for programs.
Now comes BASIC XE, one of the largest
programming languages for the 8-bit Atari computers. Its 27K of code is
divided between a 16K supercartridge and 11K of extensions that can be
loaded from disk when the cartridge is booted. If these optional extensions
are not present on the boot disk, BASIC XE still functions – but without
some of its extra features. With or without the extensions, the language
occupies 8K of address space.
BASIC XE is rich in commands and
functions, with 140 built-in keywords. I say "built-in" because
the language makes it possible for programmers to create named procedures
that accept parameters – in effect, adding statements to the language.
This enhancement completes the evolution of Atari BASIC into a tool for
modern programming. The IF:ELSE:ENDIF and WHILE:ENDWHILE constructs
(introduced in BASIC A +) allow for Pascal-like structured programming
style, and the new PROCEDURE:LOCAL:EXIT trio coupled with CALL give the
programmer modular design and recursion capabilities in an interpreted
It is now possible to create libraries
of often used PROCEDUREs quite simply. Before BASIC XE, the programmer had
to precisely define which variables contained values to be passed to a
subroutine, which variables would change during its execution, and which
variables would contain values returned from the subroutine. A chore, and
difficult to debug! Here's a sample PROCEDURE definition and execution in
30000 Rem CALCULATE F(X) WHERE F
IS A POLYNOMIAL WITH COEFFICIENTS IN P()
30010 Procedure "EVALPOLY" Using Degree, !P(),X:Local E,V
30020 For E=Degree To 0 Step -1
30040 Next E
30050 Exit V
These lines would fall near the end of
the program, usually beyond the END statement. They define a new procedure
named EvalPoly (Evaluate Polynomial) which receives three arguments: Degree,
the degree of the function; P( ), an array containing the coefficients in
ascending order; and X, the value at which to evaluate P. Note that
non-scalar parameters are preceded by an exclamation point.
LOCAL creates tbe following variables
as temporary scalars. Other variables with the same names are not affected,
and the local variables disappear when an EXIT is encountered. The EXIT
statement causes the procedure to return V (making the procedure really a
function!). EvalPoly could be called as follows:
CALL "EvalPoly" USING
4,IF(),2.5 TO Y
This statement would evaluate the
fourth degree polynomial represented in array F at the value 2.5 and store
the result in variable Y. The beauty of this parameter passing and returning
scheme is that it is totally independent of line numbers and variable names.
It is portable like Pascal procedures or C functions.
I forsee the availability of
specialized libraries to add capabilities to BASIC XE. For example, you
could collect procedures to do matrix algebra or create various graphics
objects. Since LOCAL can only create scalar floating point variables, BAS IC
XE is particularly suited to mathematical applications.
SPEED TO SPARE
This brings us to another new feature
of BASIC XE – its fast mathematics routines which replace these built into
the XL/XE Operating System, when the extensions are loaded. According to
OSS, these routines are more accurate and twice as fast as those in the
FastChip from Newell Industries, which are supposed to be 30% faster than
Atari's built-in routines.
BASIC XE also features the
semi-compiled mode of operation introduced in BASIC XL. When the FAST
command is encountered at the beginning of a RUNning program, all line
number references are converted into absolute addresses, eliminating many
time-consuming searches through the program. OSS claims that these two
enhancements make BASIC XE run two to six times faster than Atari BASIC.
To test BASIC XE's speed, I used the
off-the-shelf Atari BASIC software B/Graph, from Batteries Included. Among
B/Graph's statistical capabilities is a program to do regression analyses. I
felt this to be a good test because it uses extensive iterations and
floating point caculations – BASIC XE's strengths. Using the sample
datafile PLANET, I followed the instructions on pages 113-114 of the B/Graph
Manual and obtained the following completion times for different versions of
The first was tested under Atari DOS
2.05, the others under OSS DOS XL 2.30p. BASIC XE without the extensions
loaded performed similarly to BASIC XL, and using EXTENDed mode made no
difference in any case.
So BASIC XE does offer significant
improvements in speed when running Atari BASIC programs. Exercising its
features from start to finish in the program development process should
yield shorter, inore elegant and readable, and still faster code than
possible with any other BASIC for the Atari. And it will take less time to
write the program because BASIC XE's powerful commands take the place of
many machine-language subroutines. All this is possible on either the
1200XL, 600XL with 64K, or 800XL computers. But with the 130XE, you can do
The new EXTEND command instructs BASIC
XE to utilize the extra 64K memory available in the 130XE's secondary bank.
Your program itself is relocated into this space. Main memory is reserved
for variables, the stack, and other related items. (Page Six is always
available for user purposes.) In EXTENDED mode, depending on your Disk
Operating System, there will be approximately 63K available for program and
32K available for data.
In this way, BASIC XE lets you take
full advantage of your l30XE's memory without worrying about the nity-gritty
details of memory management. However, if you want to use your extra 64K in
another way besides a RAM-disk, BASIC XE allows you to specify an optional
bank number in the POKE, DPOKE, PEEK, DPEEK, MOVE, BGET and BPUT commands.
When referring to an address in the range $4000-$7FFF, the secondary bank's
"access window", banks 0-3 are within that bank and the default
bank 4 indicates main memory. This makes memory management convenient
compared to twiddling the PIA PortB bits.
BASIC XE's other advanced features
are, as they say, too numerous to even list here completely. They include,
among others, commands to sort arrays into ascending or descending order,
Microsoft BASIC string handling, OSS's classic file manipulation and
Player/Missile graphics commands, bit-manipulation operators, hexadecimal
numeric support, and program development aids like disk directory,
renumbering, and cross-referencing.
What should he added to BASIC XE?
Well, using the 5K remaining in my wished-for 32K cartridge, OSS could add
the REPEAT:UNTIL construct, integer variables, dynamic memory allocation,
and advanced sound control – to name just a few possibilities. And of
course, some sort of run-time library or compiler would be nice.
BASIC XE is an excellent product. It's
the language that should have been built into the 130XE. OSS is a company
that has always supplied the highest quality systems software for all Atari
computers, but they have outdone themselves with this one. One can only
wonder how they will top BASIC XE.