BASIC

A BASIC (Beginner's All-purpose Symbolic Instruction Code) általános célú programozási nyelvet 1964-ben készítette Kemény János és Thomas Kurtz a Dartmouth College-ben, oktatási céllal.

A nyelv alapjait a Fortran programozási nyelv alapján tervezték meg. A nyelv interpretált nyelv, azaz a programot futás közben fordítja a gép saját nyelvére.

Elterjedésében nagyban közrejátszottak az 1980-as években elterjedt számítógépek, melyeknél gyakran a számítógéppel egybeépítve adták a BASIC értelmezőt. Ezekben a különböző számítógépeken futó BASIC programok szinte mindig inkompatibilisek voltak egymással: az egyik géptípusra írt programot más számítógéptípusokon nem lehetett futtatni.

Nagy lökést jelentett a nyelv elterjedésében a DOS operációs rendszer elterjedése, melynek újabb verzióiba beépítették a Qbasic nevű BASIC változatot. A Qbasic szoros rokonságban állt a Microsoft QuickBasic fejlesztőeszközével, de nem tudott futtatható fájlt készíteni.

Az 1990-es évek elejére sokan leírták a Basicet, mivel a Basic alapú mikroszámítógépek kora lejárt, PC-n a C/C++ és a Pascal nyelvek vívtak ki vezető szerepet. A Microsoft 1991-ben kiadta a Visual Basicet, ami a legnagyobb megújítása lett a nyelvnek: a QuickBasic strukturált Basic nyelvjárása eseményvezéreltté vált, megjelentek benne objektumorientált vonások, így hatékony és egyszerűen használható Windows fejlesztőeszközzé vált. Tovább segítette a nyelv terjedését két variánsa: Visual Basic for Applications (VBA) a Microsoft Office programcsomag makrónyelvévé, a Visual Basic Script a Windows operációs rendszer scriptnyelvévé vált.

A Visual Basic 2002-ben jelentős átalakításon esett át: megjelent a Visual Basic .NET, ami teljesen objektumorientálttá tette a nyelvet, a .NET keretrendszerhez igazodva. A Visual Basic .NET-ben gyakorlatilag csak a kulcsszavak emlékeztetnek a klasszikus Basicre, a változások olyan mélyrehatóak voltak, hogy még a klasszikus Visual Basickel sem kompatibilis visszafele. Emiatt több kritika érte és éri, sokak szerint csak nevében Basic, a legközelebbi rokonságban a C# nyelvvel van.

Noha a Microsoft-féle irányvonal a legelterjedtebb a nyelv fejlesztésében, a Basicnek rengeteg nyelvjárása és értelmezőprogramja van. Könnyű tanulhatósága miatt sokan kezdik a programozást vele. Több speciális célú Basic-változat létezik, például mikrovezérlők programozására vagy játékfejlesztésre.

Jellemzők

Adattárolás, változók 
A BASIC nyelvjárások nagy részében nem kell a változókat deklarálni. Az új változókat ebben az esetben a parancsértelmező futásidőben hozza létre a nevük első előfordulásakor. Ez hibalehetőséget jelent annyiban, hogy az elgépelt nevű változók is létrejönnek így. Az idők folyamán azonban több megoldás is létrejött:

Az első változatban, a Dartmouth Basic-ben egy, illetve kétjegyű változóneveket használhattunk, az első jegy betű (A-Z), az (opcionális) második számjegy (0-9), így a BASIC összesen 11x26=286 változót tudott kezelni (A-Z, A0-A9,…, Z0-Z9).

Az értékadás a LET kulcsszóval történt (például LET x=26), ami több későbbi változatban is benne maradt, bár idővel fölöslegessé válva kikopott.

A változók A Dartmouth Basicben mind lebegőpontos számok voltak, később megjelentek más típusok is. Ezeket általában a változónév végén álló karakterek jelzik:
 % - egész szám (például a%=5)
 ! vagy nincs – (egyszeres pontosságú) lebegőpontos szám (például a=5.1)
 # – kétszeres pontosságú lebegőpontos szám (például a#=5.5)
 $ – szöveges változó (string) (például a$="Cica")
Megjegyzendő, hogy a stringeket kezelő függvények neve is $-re végződik általában.

Egyes verziók lehetővé tették a változók típusának előzetes deklarációját, a DEFINT, DEFSTR, … utasításokkal:
DEFINT A-Z: REM minden változó legyen egész
DEFSTR S: REM az S-sel kezdődő változók stringek

Idővel ez a jelölésmód korszerűtlenné vált, rontotta a nyelv használhatóságát. Újabb értelmezőkben - mint a Quick Basic vagy a Visual Basic - elterjedt az a megoldás, hogy a tömbök deklarására használt DIM parancsot lehet használni. Példa (Visual Basic):

Dim x As Long
Dim y As String
x=123456
y="Cica"

A "klasszikus" Visual Basic bár nem tette kötelezővé a változók deklarálását, az Option Explicit fordítási direktíva bekapcsolásával kötelezhette magát erre a felhasználó. A Visual Basic .NET a CLI-kompaibilitás miatt nem támogatja a deklarálatlan változókat.

Ez eredeti változatban az egyetlen használható típus-konstrukció a tömb, a tömböket a DIM utasítással lehet deklarálni ('dimenzionálni'), egyes változatok a dimenzionálatlan tömböket automatikusan tízelemű tömbként dimenzionálták, pl:

DIM x(22): REM szabályos dimenzionálás
LET y(3)=3: REM implicit dimenzionálás: DIM y(10), nem minden verzióban

A tömbindexek általában eggyel kezdődtek, egyes megvalósításokban viszont nullától (ekkor a tömb a megadottnál eggyel több elemet tartalmazott), vagy az 'OPTION BASE {0|1}' utasítással volt beállítható a kezdőindex.

Sorszámozás 
A korai BASIC változatokban kötelező volt a sorok számozása. Minden programsor elején egy sorszám állt. Ennek több oka volt:

 Az ugrásoknál (GOTO, GOSUB) sorszámra hivatkozva lehetett csak megadni, hova ugorjon a vezérlés, a nyelv kezdeti változatai nem ismerték a címkéket.
 A kezdetleges fejlesztőkörnyezeteknél a sorszámról döntötte el az értelmező, melyik programsort írta be a felhasználó. Ha például a 30-as sor után írta be a 20-ast, akkor az sorrendben a 30-as elé került futtatáskor.
 A hibaüzeneteket is a sorszámot kiírva adták meg az interpreterek.

A sorszámozás hátránya a nehézkes bővíthetőség volt: ha a sorokat 10-esével számoztuk, akkor a 20-as és 30-as sor közé csak 9 sort szúrhattunk be. Emiatt a nyelvből lassan eltűntek a sorszámok, bár sokáig lehetett használni őket a visszafelé kompatibilitás megőrzése miatt. Microsoft vonalon az 1998-ban megjelent Visual Basic 6 volt az utolsó nyelv, ami még támogatta a használatukat. A feltétel nélküli ugrásokhoz a nyelv címkéket használ, amik sor elején álló, kettőspontra végződő azonosítónevek. A címkéket nem kell deklarálni.

Példa sorszámos ugrásra:
10 PRINT "Ez a szöveg ismétlődni fog!"
20 GOTO 10
Példa a címke használatára

eleje:
PRINT "Ez a szöveg ismétlődni fog!"
GOTO eleje

Hello World 
 Az interpretált BASIC parancsként tudja futtatni a "PRINT" (írd ki) utasítást:
PRINT "Hello World!"
Megj.: A PRINT sok nyelvjárásban rövidíthető kérdőjellel:
? "Hello World!"

 Programba illesztve (klasszikus változat, sorszámok használatával):
10 PRINT "Hello World!"
20 END
Megjegyzés: Az "END" (vége) utasítás opcionális, a programfutás az utolsó sornál mindenképp véget ér.

Futtatása:
RUN

Példaprogramok

Nyelvi változatok 
Zárójelben a program futtatókörnyezete található.

 Altair BASIC (MITS Altair, S-100; Microsoft első terméke)
 Amiga BASIC (Commodore Amiga)
 AMOS BASIC (Commodore Amiga)
 Apple Business BASIC (Apple ///)
 Applesoft BASIC (Apple II)
 ASIC programozási nyelv (MS-DOS)
 Atari 2600 Basic Programming (Atari 2600 video játék konzol)
 Atari BASIC (aka Sheperdson BASIC) (Atari 8 bites család)
 Atari Microsoft BASIC II (Atari 8 bites család)
 B32 Business Basic (Data General Eclipse MV, UNIX, MS-DOS)
 BASCOM (MCS Electronics) (Atmel AVR 8 bites mikrovezérlő családhoz) (Intel 8051-es 8 bites mikrovezérlő családhoz)
 BASIC09 (OS-9 és OS-9 68K, a Motorola 6809 és 68K processzoron, külön külön)
 Microsoft BASICA interpreter (Advanced BASIC, IBM PC korai változatán ROM-ba égetve) (Lemezzel ellátott gépeken a PC-DOS része)
 BASIC A Plus+ (Atari 8-bit család)
 BASIC-E programnyelv (aka 'submarine BASIC') (CP/M)
 Basic Plus (Digital Equipment Corporation gyártmány a RSTS/E OS, PDP-11 processzoron)
 BASIC XE programnyelv (Atari 130XE)
 BBC BASIC (Acorn/BBC Micro, RISC OS, Tiki 100, Cambridge Z88, CP/M, MS-DOS)
 Blitz BASIC & Blitz3D & BlitzMAX & BlitzPLUS (Win32, Commodore Amiga)
 Business Basic
 Bxbasm (Win32, open source, native compile)
 Bywater BASIC (aka bwBASIC) (MS-DOS, POSIX)
 Caché Basic (Caché Database egyik parancsleíró nyelve a kettőből)
 CBASIC programnyelv (BASIC-E leszármazottja) (CP/M, MS-DOS)
 Chipmunk Basic programnyelv (Apple Macintosh, CLI port Win32 részére, GNU/Linux; szabad szoftver)
 Color BASIC programnyelv (Tandy Radio Shack TRS-80 Color Computer, aka CoCo)
 Commodore BASIC (Commodore 8 bites család)
 DarkBASIC & DarkBASIC Professional
 Dartmouth BASIC (lásd még: True BASIC)
 Data General Business Basic (Data General Nova és későbbi DG miniszámítógépek)
 Ethos Game Basic (MS Windows)
 Extended Color BASIC (TRS-80 Color Computer)
 FutureBASIC (Apple Macintosh)
 Gambas (GNU/Linux) (Visual Basic-hez hasonló)
 geoBASIC (GEOS Commodore 64 számítógépen)
 GeoBASIC (Leica) (Leica TPS 1000/1100 vizsgálati állomásokon)
 Gnome Basic (GNU/Linux) (Visual Basic klón)
 GFA BASIC (Commodore Amiga, Atari ST)
 Microsoft GW-BASIC interpreter (MS-DOS) (BASICA compatibilis, IBM ROM routinoktól független)
 Hbasic (GNU/Linux) (Visual Basic-hez hasonló)
 HotPaw Basic programnyel (aka yBasic, nee cbasPad Pro) (PalmOS)
 IBasic (MS Windows)
 Integer BASIC (Apple II)
 IS-BASIC (Enterprise Computers: Enterprise 64, Enterprise 128)
 Liberty BASIC programnyelv (MS Windows)
 Locomotive BASIC (Amstrad CPC)
 LotusScript (Lotus Notes)
 MAI Basic Four Business Basic (többféle miniszámítógép)
 Mallard BASIC programnyelv (Amstrad PCW, CP/M on ZX Spectrum +3)
 MapBasic (MS Windows, MapInfo Professional)
 Microsoft BASIC (Microsoft BASIC variációk) (különféle mikroszámítógépeken)
 Microsoft MBASIC programnyelv (CP/M operációs rendszer alatt)
 MSX BASIC (MSX)
 Northstar BASIC (Processor Technology, Northstar, később átdolgozva x86 platformra Bazic '86 néven)
 NSBasic (Windows CE rendszer alatt)
 Phoenix Object Basic programnyelv (GNU/Linux)
 PowerBASIC (Turbo BASIC leszármazottja) (MSDOS, Win32)
 PureBasic (Win32, GNU/Linux és Commodore Amiga)
 QBASIC programnyelv (MS-DOS)
 Microsoft QuickBASIC fordító (MS-DOS)
 RapidQ (keresztplatform, szabad szoftver)
 REALbasic (Apple Macintosh, Win32, Linux)
 Revelation BASIC programnyelv (MS-DOS)
 SAM Basic programnyelv (SAM Coupé)
 ScriptBasic (Win32 and GNU/Linux)
 Sharp BASIC (Sharp zsebszámítógép)
 Sinclair BASIC (ZX80, ZX81/TS1000, ZX Spectrum)
 Sinclair Spectrum Beta BASIC (ZX Spectrum)
 SmallBASIC (GNU/Linux, MS-DOS, Win32, PalmOS; GPL)
 SmartBASIC (Coleco Adam)
 ST BASIC (Atari ST)
 StarOffice Basic (aka StarBasic) (OpenOffice, StarOffice)
 STOS BASIC (Atari ST)
 SuperBasic (Sinclair QL)
 THEOS Multi-User Basic
 TI BASIC programnyelv (Texas Instruments programozható kalkulátorok)
 TI BASIC (TI 99/4A) (Texas Instruments TI 99/4A)
 TI Extended BASIC programnyelv (ditto)
 Tiny BASIC (korai S-100 gépek)
 TRS-80 Level I BASIC programnyelv (TRS-80) (TinyBASIC alapú)
 TRS-80 Level II BASIC programnyelv (TRS-80)
 True BASIC (MS-DOS, MS Windows, Apple Macintosh)
 Turbo BASIC (BASIC/Z utód)
 VBScript (MS ASP, MS Windows with WSH)
 Visual Basic (MS Windows)
 Visual Basic .NET (MS Windows)
 Visual Basic for Applications (VBA) (MS Office beépített nyelv MS Windows és Apple Macintosh alapú gépeken)
 Watcom Basic
 WordBasic (MS Office verziók elődje)
 wxBasic (BASIC interpreter wxWidget részére)
 XBasic (Win32, GNU/Linux) (GPL)
 Yabasic interpreter (Win32, GNU/Linux, Playstation 2) (GPL)

Rokon programozási nyelvek 
 COMAL programozási nyelv (többféle mikroszámítógépre)
 OPL programozási nyelv (Open Programming Language: Nyitott programozási nyelv, korábban: Organiser Programming Language - hordozható eszközökhöz, mint pl. Psion Organisers, Psion PDA-k)

Szabványok 
 ANSI Minimal BASIC szabvány (ANSI X3.60-1978 "FOR MINIMAL BASIC")
 ISO Minimal BASIC szabvány (ISO/IEC 6373:1984 "DATA PROCESSING – PROGRAMMING LANGUAGES – MINIMAL BASIC")
 ANSI teljes BASIC szabvány (ANSI X3.113-1987 "PROGRAMMING LANGUAGES FULL BASIC")
 ISO teljes BASIC szabvány (ISO/IEC 10279:1991 "INFORMATION TECHNOLOGY – PROGRAMMING LANGUAGES – FULL BASIC")
 ANSI modul definíciós kiegészítés (X3.113 INTERPRETATIONS-1992 "BASIC TECHNICAL INFORMATION BULLETIN # 1 INTERPRETATIONS OF ANSI 03.113-1987")
 ISO modul definíciós kiegészítés (ISO/IEC 10279:1991/ Amd 1:1994 "MODULES AND SINGLE CHARACTER INPUT ENHANCEMENT")

További információk 
 
 Tom Kurtz and John Kemeny (fotó), computerhistory.org

 
Programozási nyelvek