BASIC

BASIC ist eine imperative Programmiersprache, die 1964 von John George Kemeny und Thomas Eugene Kurtz am Dartmouth College entwickelt wurde.

Der Name „BASIC“ steht für „Beginner’s All-purpose Symbolic Instruction Code“, was so viel bedeutet wie „Symbolische Allzweck-Programmiersprache für Anfänger“. Die Abkürzung als Wort gesehen bedeutet außerdem „grundlegend“. Dies zeigt das Design-Ziel klar: Eine einfache, für Anfänger geeignete Programmiersprache zu erschaffen. Außer in manchen Produktnamen wird das Wort „BASIC“ grundsätzlich in Großbuchstaben geschrieben.

Allgemeines

Die Sprache wurde aufgrund von acht Entwurfsprinzipien entworfen:

Für Anfänger einfach zu erlernen
Als Allzweck-Programmiersprache einsetzbar
Erweiterbarkeit der Sprache für Experten
Interaktivität
Klare Fehlermeldungen
Rasche Antwortzeiten
Hardwareunabhängigkeit
Betriebssystemunabhängigkeit

BASIC war einst weltweit die populärste Programmiersprache, obwohl sie oft von Informatikern herabgewürdigt wird.

Viele Dialekte wurden entwickelt, und die neuesten weisen alle professionellen Elemente höherer Programmiersprachen auf. Ein Nachteil der vielen Versionen ist, dass Programme meist nicht ohne weiteres zwischen diesen Versionen ausgetauscht werden können.

Geschichte

BASIC wurde 1964 von John George Kemeny und Thomas Eugene Kurtz am Dartmouth College entwickelt, um den Elektrotechnikstudenten den Einstieg in die Programmierung mit Algol und Fortran zu erleichtern. Am 1. Mai 1964 um vier Uhr Ortszeit, New Hampshire, liefen die ersten beiden BASIC-Programme simultan auf einem GE-225-Computer von General Electric im Keller des Dartmouth College. BASIC wurde dann viele Jahre lang von immer neuen Informatikstudenten an diesem College weiterentwickelt, zudem propagierten Kemeny und Kurtz es in den frühen 1970er Jahren an mehreren Schulen der Gegend, die erstmals Computerkurse in ihr Unterrichtsprogramm aufnehmen wollten. BASIC war entsprechend dem Wunsch seiner „Väter“ für die Schulen kostenlos, im Gegensatz zu fast allen anderen damals üblichen Programmiersprachen.

Einige dieser Schüler und Studenten waren etwas später in der kurzlebigen Bastelcomputer-Szene Mitte der 1970er-Jahre aktiv, die den kommerziellen Microcomputern vorausging und machten BASIC dort bekannt. Seinen Höhepunkt erlebte BASIC mit den aus den Bastelcomputern hervorgehenden ersten Heimcomputern Ende der 1970er- und Anfang der 1980er-Jahre, die nahezu alle als Benutzeroberfläche und Programmierumgebung einen BASIC-Interpreter besaßen. Prominente Beispiele sind Sinclairs ZX-81 oder der meistverkaufte Heimcomputer aller Zeiten, der Commodore C64; aber auch die Vorläufer der Personalcomputer, wie z.B. von Philips, konnten mit CP/M-BASIC interpretierend oder kompiliert arbeiten. Die weitaus meisten dieser BASICs stammten von Microsoft; BASIC war Microsofts erstes und wichtigstes Produkt, mehrere Jahre bevor mit MS-DOS das erste Betriebssystem dieser Firma auf den Markt kam.

Praktisch alle Besitzer von Heimcomputern beherrschten zu dieser Zeit zumindest ein wenig BASIC.

Auch als Mitte der 1980er Jahre grafische Benutzeroberflächen mit dem Macintosh, Amiga und dem Atari ST Einzug hielten, wurden bei diesen weiter BASIC-Interpreter mitgeliefert, auch existierten zusätzliche käufliche Versionen von BASIC-Dialekten.

Mittels Compilern konnten einige BASIC-Dialekte direkt in deutlich schnellere Maschinenprogramme übersetzt bzw. unter Umgehung des Interpreters direkt in Aufruflisten der zugrundeliegenden Interpreter-Funktionen übersetzt werden.

Das seit 1981 verbreitete MS-DOS enthielt ebenfalls einen BASIC-Interpreter – zunächst BASICA bzw. GW-BASIC, später QBasic – welcher in Deutschland an vielen Schulen eine Rolle im Informatikunterricht spielte.

Zu dieser Zeit setzte aber ein Wandel ein, weil andere Hochsprachen wie beispielsweise C für die Heimcomputer verfügbar wurden oder die Ressourcen des jeweiligen Systems vom mitgelieferten BASIC-Interpreter nur unzulänglich unterstützt wurden und den Programmierer dazu zwang, sich mit Assembler vertraut zu machen. Nach und nach nahm außerdem der Anteil Menschen zu, die einen Computer nur bedienen, aber nicht programmieren konnten. Hauptgrund dafür, dass BASIC zwischenzeitlich fast in Vergessenheit geriet, war aber, dass nach dem Zusammenbruch der großen Heim- und Bürocomputer-Hersteller Atari und Commodore der Markt von Windows-PCs dominiert wurde. Bei diesen war kein BASIC-Interpreter inbegriffen, mit dem man Windows-Programme hätte schreiben können.

Microsoft besann sich allerdings auf die eigene Tradition und führte das kommerzielle Visual Basic für die schnelle Entwicklung von Windows-basierten Anwendungen ein. Der Code wurde nicht mehr zur Laufzeit interpretiert, sondern von einem Compiler während der Programmentwicklung in maschinennahen Pseudocode beziehungsweise in späteren Versionen sogar in Maschinencode (native code) übersetzt. Durch diese Maßnahme konnte die Geschwindigkeit und die Stabilität der Programmausführung deutlich gesteigert werden. Da auch die Geschwindigkeit der Computer immer mehr zunahm, wurde Visual Basic außerdem für professionelle Entwicklungen immer interessanter. Mit Einführung von objektorientierten Sprachelementen wurde der Versuch unternommen, Visual Basic mit anderen objektorientierten Programmiersprachen wie C++ gleichziehen zu lassen.

Besonders in Europa hat sich Visual Basic in der Entwicklergemeinschaft nur in begrenztem Maße behaupten können. Es bot zwar eine bessere und viel einfachere Anbindung an Windows als jede andere Programmiersprache, war aber langsamer. Erst mit der Implementierung von Visual Basic innerhalb des .NET-Frameworks ist es gelungen, die strukturellen Schwächen von BASIC zu überwinden. Gleichzeitig aber bedeutete dieser Schritt das Ende von Visual Basic als eigenständiger Programmiersprache. Innerhalb des .NET-Framework handelt es sich bei Visual Basic .NET nur noch um eine Sprach-Implementierung neben anderen, die auf einem Java-ähnlichen Kern aufsetzt. Mit Einführung der JIT-Compiler und des .NET-Frameworks als Basis für alle Microsoft Sprachen besteht zwischen der Verarbeitungsgeschwindigkeit von BASIC und anderen Programmiersprachen kein Unterschied mehr.

Das Ziel einer plattformunabhängigen Programmiersprache hat sich nie erfüllt. Im Gegensatz zum gut standardisierten C entstanden von BASIC hunderte Dialekte, die allesamt bis auf gewisse grundsätzliche Ähnlichkeiten inkompatibel zueinander waren. Die Gemeinsamkeiten beschränkten sich auf die reine Datenverarbeitung, während jeder Hersteller im Zuge der gleichzeitig verlaufenden rasanten Hardware-Entwicklung (Einführung von Disketten sowie von farbigen und grafikfähigen Monitoren) seine eigenen, auf die jeweilige Hardware abgestimmten Befehle für Ein- und Ausgabe implementierte. Allein Microsoft konnte durch die Integration von Visual Basic in nahezu alle seine Softwareprodukte einen Standard etablieren, der allerdings bis auf wenige Ausnahmen auf Microsoft-Produkte beschränkt blieb. Die starke Protegierung von BASIC durch Microsoft ist wahrscheinlich der Hauptgrund, warum BASIC bei professionellen Programmierern immer wieder auf Ablehnung stößt. Durch Einführung eines .NET-Framework Pendants für GNU/Linux (Mono-Projekt) könnte Multiplattform-BASIC Realität werden.

Durch die Umsetzung als Interpreter-Sprache waren die frühen BASIC-Dialekte außerdem deutlich langsamer als die meisten anderen, meist compilerbasierten Hochsprachen. Dies machte es besonders für zeitkritische Anwendungen unattraktiv. Mit Einführung von Visual Basic ab Version 5 erzielte Microsoft allerdings deutliche Erfolge in Bezug auf die Verarbeitungsgeschwindigkeit, die aber den zuvor verlorenen Boden nicht wieder gutmachen konnten. Immerhin zeigten Benchmarks, dass Visual Basic im Vergleich zu C++ oder Java durchaus mithalten konnte. Gegenüber Java konnten sogar in einigen Bereichen deutliche Geschwindigkeitsvorteile erzielt werden.

Beispiele

Das erste Beispiel zeigt ein Programm, das in einer frühen unstrukturierten Fassung geschrieben wurde, während das zweite Beispiel das gleiche Programm in einem moderneren Dialekt zeigt.

1. Beispiel: Unstrukturierter BASIC-Code:

10 INPUT "Geben Sie bitte Ihren Namen ein"; A$
20 PRINT "Guten Tag "; A$
30 INPUT "Wieviele Sterne möchten Sie?"; S
40 FOR I = 1 TO S
50 S$ = S$ + "*"
55 NEXT I
60 PRINT S$
70 INPUT "Möchten Sie noch mehr Sterne?"; Q$
80 IF LEN(Q$) = 0 GOTO 70
90 L$ = LEFT$(Q$, 1)
100 IF (L$ = "J") OR (L$ = "j") THEN GOTO 30
110 PRINT "Auf Wiedersehen";
120 FOR I = 1 TO 200
130 PRINT A$; " ";
140 NEXT I
150 PRINT

2. Beispiel: Strukturierter BASIC-Code:

INPUT "Geben Sie bitte Ihren Namen ein"; UserName$
PRINT "Guten Tag "; UserName$
DO	
  INPUT "Wie viele Sterne möchten Sie? "; NumStars
  Stars$ = ""
  Stars$ = REPEAT$("*", NumStars)	'<-ANSI BASIC
  'Stars$ = STRING$(NumStars, "*")	'<-MS BASIC
  PRINT Stars$
  DO
    INPUT "Möchten Sie noch mehr Sterne(J/N)?"; Answer$
  LOOP UNTIL Answer$ <> ""
LOOP WHILE UCASE$(LEFT$(Answer$, 1)) = "J"
PRINT "Auf Wiedersehen ";
FOR A = 1 TO 200
  PRINT UserName$; " ";
NEXT A
PRINT

Kritik an BASIC (klassische unstrukturierte Dialekte)

Man kann auch strukturiert programmieren:

100 N = 2
110 REM WHILE
120   FLAG = 1
130   FOR I = 2 TO SQR(N)
140     IF NOT I = N THEN 160
150       GOTO 210 : REM CONTINUE
160     REM ENDIF
170     IF NOT N MOD I = 0 THEN 200
180       FLAG = 0
190       GOTO 220 : REM BREAK
200     REM ENDIF
210   NEXT I
220   REM ENDFOR
230   IF FLAG = 0 THEN 250
240     PRINT "PRIM:";N
250   REM ENDIF
260   N = N + 1
270 GOTO 110

Die „REM ENDIF“-etc.-Kommentarzeilen sind vor allem notwendig, damit neuer Code eindeutig vor oder nach der Blockgrenze eingeführt wird. Dieser Stil ist umständlich, aber nicht unmöglich. Unmöglich ist es aber in BASIC, den Daten Struktur zu verleihen!

Kritikpunkte:

Zeilennummern sind umständlicher als Labels
Keine indirekte Addressierung möglich(!)
Ausschliesslich globale Variablen

Zu 1.: Hier ist BASIC sogar beschwerlicher zu programmieren als Assembler(!)

Zu 2.: Während in anderen Sprachen, die „keine Zeiger haben“ (wie z.B. Java), z.B. verkette Listen selbstverständlich möglich sind, ist das bei BASIC nicht der Fall. Auch hier ist BASIC sogar beschwerlicher zu programmieren als Assembler, oder es ist gar unmöglich, gewisse Probleme in BASIC zu realisieren (wenn man davon absieht, mit unglaublichem Aufwand auf die Turingmächtigkeit der Sprache zu pochen).

Zu 3.: Nicht zuletzt wegen der Unmöglichkeit, innerhalb einer Funktion Variablen zu deklarieren, erzwingt BASIC unübersichtliche Programmierung.

Die „GOTO“-Anweisung ist nur die Spitze des Eisberges. Die übliche Kritik an (klassischem) BASIC fokussiert strukturierten Code und lässt die weit schwerwiegenderen Mängel, die es nicht nur dem Anfänger unmöglich machen, sinnvolle Datenstrukturen zu entwickeln, unerwähnt. Schöne Datenstrukturen sind aber Grundlage eines jeden wartbaren/fehlerfreien/schnellen Programmes.

(Einige) BASIC-Implementationen

BASIC ist heute auf nahezu allen Computer-Plattformen in verschiedenen BASIC-Dialekten erhältlich. Für eine Liste der BASIC-Dialekte, siehe den Artikel Basicdialekte.

Dokumente, die BASIC definieren

Die meisten real existierenden Interpreter und Compiler halten sich leider nicht an diese Standards.

ANSI Standard for Minimal BASIC (ANSI X3.60-1978 “FOR MINIMAL BASIC”)
ISO Standard for Minimal BASIC (ISO/IEC 6373:1984 “DATA PROCESSING—PROGRAMMING LANGUAGES—MINIMAL BASIC”)
ANSI Standard for Full BASIC (ANSI X3.113-1987 “PROGRAMMING LANGUAGES FULL BASIC”)
ISO Standard for Full BASIC (ISO/IEC 10279:1991 “INFORMATION TECHNOLOGY—PROGRAMMING LANGUAGES—FULL BASIC”)
ANSI Addendum Defining Modules (X3.113 INTERPRETATIONS-1992 “BASIC TECHNICAL INFORMATION BULLETIN # 1 INTERPRETATIONS OF ANSI 03.113-1987”)
ISO Addendum Defining Modules (ISO/IEC 10279:1991/ Amd 1:1994 “MODULES AND SINGLE CHARACTER INPUT ENHANCEMENT”)

Literatur

Dr. Hans-Joachim Sacht, BASIC-Dialekte, ISBN 3-581-66524-7