BASIC Bonanza
Powerhouse languages for 8-bit Ataris
It's a great time to be a BASIC programmer on the Atari 8-bit computer. With three new BASICs on the market, there are now six to choose from. If you can afford it, it's worth buying them all. Each offers distinct advantages, and the cost for all six is still less than what you'd pay for a single copy of Microsoft BASIC for the IBM PC.
But for those who can buy just one or two, the decision
is tough. To help you, we'll take a good look at each one. The three most
important features to look for in a BASIC programming language are: compatibility,
run-time packages and compilers.
KEY FEATURES
Compatibility This is the internal similarity between languages. "Upwardly
compatible with Atari BASIC" means the language can run Atari BASIC programs
without any modifications.
Runtime Packages: You can't run an Atari BASIC program without either a BASIC cartridge or built-in BASIC. A runtime package will make your program run without the language. This lets other people use your programs even if they don't own the language.
Compilers: Before a program is executed, it must be translated into codes that the computer can understand. Most versions of BASIC do this each time the program is RUN. A line is translated and then executed, the next line is translated and executed, and so forth. However, a compiler translates the whole program and saves the translated version. This speeds up the. execution by 10-20 times and usually produces a program that runs without the language and does not need a runtime package.
ATARI BASIC
One of the best reasons to buy Atari BASIC (Atari Corp., $15)
is the huge collection of public domain and commercial utilities and enhancements
available for it. Revision C BASIC is built into the Atari XE computers
and is available in cartridge form for earlier models. If you are still
using Revision A (the 400-800 cartridge) or Revision B (built into the
XL computers), you should upgrade immediately. No runtime package is available,
but none is needed since every Atari owner already has Atari BASIC. Several
compilers are available, including Turbo BASIC XL.
MICROSOFT BASIC II
This is an implementation of the BASIC that is standard on almost all
other personal computers. So consider Microsoft BASIC II (Atari
Corp. $29.95) if you need to translate programs to the Atari from Apple
II or IBM PC versions.
This BASIC is powerful, but some special Atari features aren't directly supported. For example, you must PEEK to read joysticks. Error-checking is at runtime only. If you make a typing mistake, you won't find out about it until you RUN the program.
There is no runtime package or compiler. Your programs will only be useful to others who own Microsoft BASIC II. The few advantages (mostly in string handling) are generally outweighed by the losses in compatibility, memory space and ease of use.
BASIC XL
Until the flurry of new versions, BASIC XL (OSS, $59) was the
BASIC of choice for serious programmers. Upwardly compatible with Atari
BASIC and four to five times faster, BASIC XL is a joy to use.
The Optimized Systems Software supercartridge packs 16K of language into 8K of memory space. When used with DOS XL from OSS, even more memory is free. BASIC XL has advanced string handling, graphics, I/O and program control commands. A runtime package is available in the Programmer's Toolkit along with many useful routines and examples. There is no compiler.
BASIC XE
BASIC XE (OSS, $79) has all the features of BASIC XL plus additional
functions and high-speed math routines to replace the Atari's notoriously
slow floating point package. On a l30XE, it allows the extended memory
area to be used for data storage, freeing the main memory for very large
programs.
BASIC XE requires an XL or XE with at least 64K of memory. There is no runtime package, but the BASIC XL runtime can be used for programs limited to BASIC XL functions. The BASIC XL Programmers Toolkit is compatible, but there is no compiler.
ADVAN BASIC
With Advan BASIC (Advan Language Design, $39.95) it's not only
possible to write a high-speed arcade game, it's easy. Create effortless
Player/Missile graphics, background music and vertical blank interrupts.
This BASIC supports the Atari's special capabilities better than any other
language. But, just as the Atari is not just a game machine, Advan BASIC
is not just a game language. This is a powerful, complete implementation
with advanced program control, I/O and string handling.
Advan BASIC has a compiler, so it runs 10-15 times faster than Atari BASIC. But the compiled programs require an optional runtime package in order to "stand alone." Utility packages and a new high-speed optimizing compiler (see adjoining review) are also available. Advan BASIC is not compatible with Atari BASIC and uses its own Atari-compatible DOS.
TURBO BASIC XL
Turbo BASIC XL has features that put it somewhere between Atari
BASIC and BASIC XL. A public domain language by Frank Ostrowski of West
Germany, Turbo BASIC XL is free. You can get a copy from your local users
group or download it from a bulletin board. On CompuServe, Turbo BASIC
is available with a large library of utilities and help files - just go
to SIG * Atari 8-bit Data Library 3 and type BRO/KEY TURBO.
Turbo BASIC is compatible with Atari BASIC, but it runs three to four times faster when interpreted and has advanced program control and I/O commands. Using the Turbo BASIC compiler makes programs run 15-20 times faster than Atari BASIC-and it will compile Atari BASIC programs too!
No runtime package is necessary, because Turbo BASIC can
be given away free along with your program. Turbo BASIC will only work
on XL and XE computers with at least 64K. Ostrowski is also the author
of GFA BASIC for the Atari ST, which is being distributed in the U.S. by
MichTron. GFA BASIC is reviewed in this issue's ST pages.
FIGURE 1
BASIC FEATURES COMPARISON CHART
| Atari BASIC | Microsoft Basic II | BASIC XL | BASIC XE | Advan BASIC | Turbo BASIC XL | |
| Minimum System | ALL | ALL/48K | ALL | XL/XE/64K | ALL/48K | XL/XE/64K |
| Upward compatible with Atari BASIC | N/A | NO | YES | YES | NO | YES |
| Runtime package | N/A* | NO | YES | YES* | YES | N/A* |
| Compiler | YES | NO | NO | NO | YES | YES |
| Editing/Debuging | ||||||
| DELETE Lines | NO | YES | YES | YES | YES | YES |
| Auto Line numbering | NO | YES | YES | YES | NO | NO |
| Renumber | NO | YES | YES | YES | NO | YES |
| Trace | NO | YES | YES | YES | NO | YES |
| Program Control | ||||||
| IF/THEN/ELSE | NO | YES | YES | YES | YES | YES |
| WHILE/WEND | NO | NO | YES | YES | YES | YES |
| REPEAT/UNTIL | NO | NO | NO | NO | YES | YES |
| CASE | NO | NO | NO | NO | YES | NO |
| PAUSE/WAIT | NO | YES | NO | NO | YES | YES |
| Named subroutines/procedures/commands | NO | YES | YES | YES | YES | YES |
| I/O | ||||||
| Directory | NO | NO | YES | YES | YES | YES |
| DELETE "D:FILENAME | NO | YES | YES | YES | YES | YES |
| LOCK/UNLOCK | NO | YES | YES | YES | YES | YES |
| Binary LOAD/SAVE | NO | NO | YES | YES | YES | YES |
| INPUT with prompt | NO | YES | YES | YES | YES | YES |
| PRINT USING | NO | YES | YES | YES | EXCELLENT | NO |
| Strings | ||||||
| Max String Length | Memory | Bytes: 120 | Memory | Memory | Bytes: 256 | Memory |
| Auto dimensioning | NO | YES | YES | YES | YES | NO |
| String arrays | NO | YES | YES | YES | YES | NO |
| String matrices | NO | NO | NO | NO | YES | NO |
| Find substring | NO | YES | YES | YES | YES | EXCELLENT |
| LEFT$/MID$/RIGHT$ | NO | YES | YES | YES | YES | NO |
| Memory functions | ||||||
| Double PEEK/POKE | NO | NO | YES | YES | YES | YES |
| Block MOVE | NO | YES | YES | YES | NO | YES |
| Set block to a value | NO | NO | NO | NO | NO | YES |
| 130XE Expanded memory | NO | NO | NO | YES* | NO | NO |
| Graphics/Sound | ||||||
| Extented graphics | NO | NO | NO | NO | GOOD | EXCELLENT |
| Player/Missile graphics | NO | NO | GOOD | GOOD | EXCELLENT | NO |
| Vert. blank int. | NO | NO | NO | NO | YES | NO |
| Extended sound | NO | GOOD | NO | NO | EXCELLENT | GOOD |
| Numbers | ||||||
| High speed math | NO | NO | NO | YES | NO | NO |
| Integer math | NO | YES | NO | NO | YES | NO |
| Hexadecimal numbers | NO | YES | YES | YES | YES | YES |
| Binary numbers | NO | NO | NO | NO | YES | NO |
| Boolean operations | NO | AND/OR/XOR/NOT | AND/OR/XOR | AND/OR | AND/OR/XOR | AND/OR/XOR |
| Price | $15 | $29.95 | $59 | $79 | $39.95 | FREE |
* -See text
RECOMMENDATIONS
If you're just starting out, get Atari BASIC Rev. C and Turbo BASIC
XL. Beyond that, the choice depends upon what you're going to do with the
language.
If you frequently modify existing programs for your own use, OSS BASIC XL and XE are very good choices. If you like animation, music, and complicated screen designs, Advan BASIC is the best bet. Need very large programs that manipulate a lot of data? A 130XE with BASIC XE is the only way to go. Whatever you choose, you can't go far wrong. All of these excellent languages are among the best BASICs available for today for any microcomputer.
MANUFACTURERS
ATARI BASIC
MICROSOFT BASIC II
Atari Corp.
1196 Borregas Avenue
Sunnyvale, CA 94088
(408) 745-2000
CIRCLE 185 ON READER SERVICE CARD
BASIC XL
BASIC XE
Optimized Systems Software (055)
1221B Kentwood Avenue
San Jose, CA 95129
(408) 446-3099
CIRCLE 186 ON READER SERVICE CARD
ADVAN
Advan Language Designs
P.O. Box 159
Baldwin, KS 66006
(913) 594-3420
CIRCLE 187 ON READER SERVICE CARD
IF YOU'D ENJOY SEEING MORE ARTICLES LIKE THIS ONE. CIRCLE 188 ON THE READER SERVICE CARD.
ADVAN OPTIMIZER
Advan Language Systems
P.O. Box 159
Baldwin, KS 66006
(913) 594-3420
$24.95, 48K disk
CIRCLE 175 ON READER SERVICE CARD
Reviewed by Charles Cheriy
Advan BASIC was already pretty fast. Now it's the fastest BASIC in Atari history. In our Sieve Benchmark, the Advan Optimizing Compiler is about four times faster than the MMG Compiler, six times faster than regular Advan, 20 times faster than compiled Turbo-BASIC XL and 120 times faster than uncompiled Atari BASIC. In fact, it's more than half the speed of ACTION!- that's getting real close to pure assembly language.
The Optimizing Compiler also has high-speed floating-point math routines to replace the admittedly slow ones in the Atari computer. Using these routines, a math-intensive program could run faster in Advan BASIC than any other language-even assembly language.
The compiler can optimize designated sections of a program for speed. It can optimize the rest for size. By choosing your sections carefully, you can create code which is fast and compact.
The Optimizing Compiler works only with Advan BASIC- it
can't be used with Atari BASIC. It does not compile automatically like
the standard Advan compiler and requires an extra step. The object code
produced by the compiler still requires the Advan language or runtime package
to execute.