GFA BASIC

GFA BASIC is a dialect of the BASIC programming language, by Frank Ostrowski. The first version was finished in 1986. In the mid and late 80's, it became very popular for the Atari ST homecomputer range (since the ST BASIC shipped with them was more primitive). Later, ports for the Commodore Amiga, DOS and Windows were marketed. Although theoretically still available today, it has been superseded by several other programming languages.

File:Gfa basic screenshot.png

Screenshot of a GFA BASIC program running at medium resolution under the WinSTOn emulator

GFA BASIC (as of version 2.0, the most popular one) was, by the standards of its time, a very modern programming language. It did without line numbers, one line was equivalent to one command, and the IDE, to greatly simplify maintenance of long listings, even allowed for code folding. It had a reasonable range of structured programming commands (procedures with local variables and parameter passing by value or reference, loop constructs, etc.). Modularization was only rudimentary, making GFA BASIC 2.0 best suited for small and medium-sized projects.

GFA BASIC 3.0 included a number of improvements over 2.0 (including support for user-defined structures and other agglomerated data types), the final released version being 3.6.

The GFA BASIC interpreter was compact and reasonably fast, and was shipped with a runtime that could be distributed freely with your own programs. When a compiler was made available, execution speed could be increased by another factor of roughly 2. GFA BASIC allowed extreme optimisations for execution speed, supporting some direct assembler-level calls, and even the ability to embed sections of assembler code directly within the BASIC source code. GFA BASIC integrated neatly into GEM and TOS, the Atari ST's operating system, providing menus, dialog boxes, and mouse control (see WIMP interface).

Although the source code was usually stored in a tokenized version to save room on disk, pieces of code could also be saved in ASCII form, and as such made it possible to set up reusable libraries. The tokenized source files were a benefit in other ways too—for instance, GFA BASIC allowed users to include binary data in their BASIC code via an "INLINE" statement, and could even be integrated with the GFA Assembler to allow users to develop machine code programs inside INLINE statements in order to accelerate particular areas of a program. It also meant that the BASIC interpreter (and later the compiler) didn't need to tokenise a program when it was loaded, which would have been a significant load-time overhead for some of the larger GFA BASIC programs that were written.

File:Gfa basic editor.png

Screenshot of the GFA BASIC editor under the WinSTOn emulator

Operating Systems

Atari

The Atari ST had an enthusiastic user-base in Germany, GFA's home market, where the ST was regarded as "the poor man's Apple Mac". The strength of this local market helped to encourage a number of German companies to develop sophisticated technically-oriented tools and applications for the ST (such as Calamus_(DTP), an advanced desktop publishing system almost unknown outside of Germany).

Many Atari ST users were introduced to GFA BASIC through magazine articles and tutorials in popular Atari magazines such as ST Format, and free copies were sometimes given away on these magazines' cover discs.

DOS

GFA BASIC for DOS allowed users to write programs that would run under DOS with crude Windows-like GUI interface support. This was useful for writing utilities for low-level disc operations, without the user being restricted to a command-line interface. Porting a GFA program to DOS usually required changing colour values to match the DOS system pallette.

Windows

GFA BASIC for Windows included a thorough implementation of the Windows API calls. Although the product had a number of technical advantages over some of the more popular products (the combination of an "easy" language with robust architecture and fast, compiled, reliable code), it didn't achieve great success in the Windows market. Software professionals who wanted high-performance code tended to stay with the more "technical" languages, and to regard BASICs as inferior. For professionals who didn't have a problem with BASIC, a number of well-established software tool vendors such as Microsoft and Borland were actively promoting new "visual" programming systems such as Visual Basic. These allowed users to create windows and dialog boxes populated by standard components (text, buttons, frame outlines) with the help of a drag-and-drop interface and object orientated editing.

One of the advantages of GFA BASIC for Windows was that the compiler (sold separately) could create stand-alone .exe files, and also included a relatively easy option for creating Dynamic Link Library (.DLL) files for Windows. This allowed a user to write and test routines within GFA Basic, export them as functions to a Windows .DLL file, and then access those pre-compiled functions from within other tools or programs, such as Visual Basic 3.0 (which was unable to produce compiled code itself). This feature allowed GFA BASIC to be used as a "number-crunching" add-on product for Visual Basic, for writing high-speed routines for applications such as database sorting or media signal processing that would have been impractical under the then-current version of VB.

GFA BASIC did not have the company recognition or product recognition factors of companies such as Microsoft and Borland in the US market, and as a simple text-based code creation system, it lacked the exciting new "visual" user interfaces of its better-known competitors. Although GFAfW was developed further to include support for Visual Basic's components, their use under GFA was more technical than under VB. Without a large marketing budget, or a clear reason why journalists should write about it, GFA BASIC for Windows remained a comparatively obscure product.

Trivia

The name is derived from the company ("GFA Systemtechnik GmbH"), which distributed the software. GFA is an acronym for "Gesellschaft für Automatisierung" i.e. "Company for Automatization".

In a time before scanners and online help, some editions of the GFA manual came printed black on red paper, to avoid successful photocopying and bootlegging.

GFA Basic was widely used to quickly create editors by game developers. For example, Éric Chahi wrote a game editor in GFA basic to create his game Another World, including scene design and game scripting; only the game engine (polygon rendering and music) was done in assembler. This editor was used to make all ports of the game, including console ones and the collector edition for Windows released in 2006.

External links

• Official web site (off line since 2002). Archive.
• GFA-Basic Community
• GFA-BASIC 32 for Windows — Free Community version
• Atari GFA Basic 3 (LST format) to Java 1.0 converter
• The UnOfficial Home of GFA-Basic (Atari ST)
• GokMasE´s GFA Page — links / source / manuals - Another site with resources and links for GFA Basic on the Atari ST
• RUN! Software — comprehensive IDE, application builder, runonly interpreter, library with new features and bugfixes (site German, docs English)
• X11-Basic — Interpreter with full X graphic capability and syntax similar to the Atari ST implementation of GfA Basic.
• http://tigen.ti-fr.com/gfabasic/index.php — GFA Basic on TI89! (French)
• http://www.people.freenet.de/p.hinz.kunz/index_e.html Code and downloads (GFA-Basic for Windows 32-Bit)
• http://www.vistoso.de/jh/programmer.html Code and Downloads for Windows 16-bit and 32-bit (German)