BASIC: verschil tussen versies

Uit Wikipedia, de vrije encyclopedie
Interactief door geschiedenis bladeren
← Oudere bewerkingNieuwere bewerking →
Verwijderde inhoud Toegevoegde inhoud
VisueelWikitekst
PimTH (overleg | bijdragen)
133 bewerkingen
k Hergebruik bron als hergebruik gemarkeerd.
Daaf Spijker (overleg | bijdragen)
6.381 bewerkingen
k : link naar COMAL
Regel 13: Regel 13:
| dialecten = [[Liberty BASIC]], [[Turbo BASIC]], [[QuickBASIC]], [[PowerBASIC]] en vele andere
| dialecten = [[Liberty BASIC]], [[Turbo BASIC]], [[QuickBASIC]], [[PowerBASIC]] en vele andere
| beinvloed = [[Algol-60]], [[Fortran|FORTRAN II]], [[JOSS (programmeertaal)|JOSS]]
| beinvloed = [[Algol-60]], [[Fortran|FORTRAN II]], [[JOSS (programmeertaal)|JOSS]]
| invloed = [[COMAL (programmeertaal)|COMAL]], [[Visual Basic]], [[Visual Basic#Visual Basic .NET .28sinds 2002.29|Visual Basic .NET]], [[REALbasic]], [[Rexx|REXX]], [[Perl (programmeertaal)|Perl]], [[GRASS (programmeertaal)|GRASS]]
| invloed = [[COMAL]], [[Visual Basic]], [[Visual Basic#Visual Basic .NET .28sinds 2002.29|Visual Basic .NET]], [[REALbasic]], [[Rexx|REXX]], [[Perl (programmeertaal)|Perl]], [[GRASS (programmeertaal)|GRASS]]
| besturingssysteem = [[Multiplatform]]
| besturingssysteem = [[Multiplatform]]
| licentie =
| licentie =

Versie van 13 jul 2018 11:08

Voor de gelijknamige film, zie Basic (film).
BASIC
Paradigma imperatief, gestructureerd
Verschenen 1 mei 1964[1]
Ontworpen door John Kemeny en Thomas Kurtz
Typesysteem Sterk
Implementaties Apple BASIC, BBC BASIC, Microsoft BASIC, TI-BASIC en vele andere
Dialecten Liberty BASIC, Turbo BASIC, QuickBASIC, PowerBASIC en vele andere
Beïnvloed door Algol-60, FORTRAN II, JOSS
Invloed op COMAL, Visual Basic, Visual Basic .NET, REALbasic, REXX, Perl, GRASS
Besturingssysteem Multiplatform
Portaal  Portaalicoon   Informatica
Voorbeeld van BASIC.

BASIC is een imperatieve programmeertaal die oorspronkelijk was bedoeld om mensen snel te leren programmeren. De naam is een acroniem voor Beginners All-purpose Symbolic Instruction Code. BASIC vertoont gelijkenis met FORTRAN.

Er is een groot aantal verschillende implementaties van BASIC in omloop. De meeste oudere versies werkten interpreterend: het programma en zelfs losse opdrachten (zoals het evalueren van een expressie) kunnen zo onmiddellijk worden uitgevoerd. Tijdens de uitvoering kan het programma nogal eens op een fout blijven steken, de karakteristieke run-time error (bijv. Syntax error). Opvallend aan de broncode van de meeste oudere BASIC-programma's zijn de nummers vooraan elke regel.

Later kwamen meer compilers uit voor BASIC. In latere implementaties werden ook meer technieken uit het gestructureerd programmeren overgenomen, zodat de 'beginnerstaal' meer op andere hogere programmeertalen ging lijken.

Geschiedenis

Ontstaan

Alle moderne implementaties van BASIC zijn gebaseerd op de BASIC-implementatie van Mather en Waite uit 1971. Deze implementatie gaat op zijn beurt terug op een oerversie van BASIC die in 1963/1964 ontwikkeld is aan het Dartmouth College door de wiskundigen John Kemeny en Thomas Kurtz (ook bekend van hun werk aan compilers voor talen als Fortran en Algol-60 – wat verklaart waarom BASIC veel op Fortran lijkt). Zij draaiden hun eerste programma in BASIC op 1 mei 1964.[1] Zij ontwikkelden hun taal (met 14 statements) als een introductietaal voor niet-technische universiteitsstudenten met als primaire doelstellingen:

  • begrijpbaar voor niet-technici
  • de taal moest er "vriendelijk" uitzien
  • in de taal moesten snel resultaten geleverd kunnen worden ten behoeve van huiswerkopdrachten
  • toegang tot het systeem van de taal moest gratis en gemakkelijk zijn en afscheiding tussen gebruikers regelen
  • de tijd die het de gebruiker kostte moest minimaal zijn, in plaats van dat de processortijd minimaal moest zijn

Ondanks dat het eerste systeem een batchsysteem was, was de laatste eis een revolutie in het denken. Dit leidde al snel tot de herimplementatie van het systeem als een interactief systeem dat timesharing op de machine mogelijk maakte. De gebruiker bediende de machine direct in plaats van door een programma in te dienen dat door een operator ingevoerd werd en waarvan de gebruiker alleen het resultaat kreeg.

Voorbeeld

De eigenschappen van BASIC kunnen worden gedemonstreerd aan de hand van het volgende programma dat de priemgetallen tussen twee gegeven getallen afdrukt of op het scherm toont: 

 100 REM PRIEMGETALLEN
 110 INPUT "START=",A1
 120 INPUT "END=",A2
 130 FOR I= A1 TO A2
 140  GOSUB 170
 150 NEXT I
 160 END
 170 REM TEST PRIEM
 180 FOR J=2 TO SQR(I)
 190  IF I/J=INT(I/J)THEN 220
 200 NEXT J
 210 PRINT I;
 220 RETURN

Het programma wordt ingevoerd met een zogenaamde line-editor, waarbij de regels genummerd worden. De regelnummers lopen met 10 op om het invoegen van extra regels mogelijk te maken. Desgewenst kunnen alle regels hernummerd worden. BASIC maakt van deze nummering gebruik door GOTO- en GOSUB-opdrachten naar deze nummers te laten verwijzen. Er zijn dus geen afzonderlijke labels nodig. De variabelen worden niet gedefinieerd; als variabelennamen zijn alleen A t/m Z en A0 t/m Z9 beschikbaar. Arrays worden wel gedefinieerd met de DIM-opdracht als ze meer dan 10 elementen tellen. In veel implementaties is het aantal verschillende variabelen nog kleiner. In de eerste versie konden gegevens alleen in het programma worden opgenomen (met het DATA-statement) of direct worden ingevoerd (zoals hier met INPUT). In latere versies was ook input van bestanden mogelijk. Om de loop van het programma te besturen is behalve de GOTO-opdracht alleen de FOR-NEXT-lus beschikbaar. In het hier getoonde programma wordt deze meestal voortijdig verlaten door "er uit te springen". Een andere bijzonderheid van BASIC-interpretatoren is dat zij het mogelijk maken opdrachten direct uit te voeren: PRINT 2^15 zonder regelnummer geeft direct het resultaat 32768. Het nut daarvan wordt direct duidelijk als je bedenkt dat er rond 1970 nog geen spreadsheets of zakrekenmachines bestonden.

Gebruik en bezwaren

Hoewel de makers van BASIC de taal vooral als onderwijstaal bedoeld hadden nam het gebruik snel toe, vooral onder (bedrijfs)economen. Daarbij moeten we bedenken dat veel toepassingen die toen in BASIC geprogrammeerd werden nu met spreadsheets worden opgelost, zoals de berekening van de werkelijke rente van leningen met gegeven termijnbetalingen. Informatici, zoals Edsger Dijkstra ("BASIC programmers are mentally mutilated beyond hope of regeneration")[2] oefenden felle kritiek op het gebruik van BASIC uit, zowel vanwege het ontbreken van declaraties en de prominente rol van het GOTO-statement als om het gemak waarmee programma's ingevoerd, snel op de onvermijdelijk fouten getest en verbeterd konden worden. Op de meeste universiteiten moesten de studenten die aan een cursus programmeren deelnamen een dag wachten voor ze hun programma met alle foutmeldingen terugkregen en dat werd als een voordeel gezien omdat het ze zou leren om zelf fouten te zoeken en dat niet aan de computer over te laten.

Explosieve groei

BASIC vond hierna ingang bij een aantal grote bedrijven. Kemeny en Kurtz begonnen op een GE 225 met een aantal terminals voor timesharing, DEC porteerde de taal naar zijn PDP-11-machines als taal voor timesharing. Een van de vaste testgebruikers van dit systeem was Bill Gates. Na veel omzwervingen en veranderingen volgde de eerste standaardisatie van de taal door de ANSI in 1978: de Minimal BASIC Standard.

Microsoft schreef in 1975 zijn eerste BASIC-interpreter, Altair BASIC genaamd, voor de MITS Altair 8800-computer. Deze werd daarna ook verkrijgbaar voor systemen met aan de MITS Altair gerelateerde processoren, zoals de Z80 en de Intel 8080, waarop besturingssystemen als CP/M, TEKDOS en ISIS-II liepen.

Vrijwel alle homecomputers hadden een of andere variant van BASIC ingebouwd.

Commodore introduceerde in 1977 Commodore BASIC en voorzag zijn 8 bitcomputers voor thuisgebruik, waaronder de Commodore 64, hiervan.

De originele IBM PC uit 1981 werd ook geleverd met een BASIC-interpreter in de ROM, door Microsoft geschreven voor IBM, zodat de computer na aanzetten onmiddellijk kon worden geprogrammeerd. Wanneer het booten niet succesvol was liep de PC in deze Basic-mode. (Voor een uitgebreidere basic startte men BASICA van disk.)

Op computers voor thuisgebruik werd rond 1980 een variant van BASIC geleverd die door Microsoft was uitgebreid: MSX BASIC (de MSX staat hier voor Microsoft eXtended). Ook is er een populaire bibliotheek geweest die voor veel verschillende computers met een BASIC-interpreter werkte, en duidelijke uitgebreide mogelijkheden toevoegde, de zogenaamde Basicode. In de tijd dat dit populair was, werden Basicode-programma's uitgezonden over de radio, zodat ze op cassette opgenomen konden worden en vervolgens op de computer uitgevoerd.

Microsoft bracht later, voor de IBM-klonen, een versie van BASICA uit onder zijn eigen naam, genoemd GW-BASIC (1985) (Graphics Windows BASIC; heeft niets te maken met het Microsoft Windows-besturingssysteem). Deze variant van BASICA werd door Microsoft ter beschikking gesteld aan OEM's om in licentie te nemen en uit te brengen op eigen copyright/naam.

IBM bracht de door Microsoft ontwikkelde BASCOM-compiler op de markt, die ook door Microsoft zelf onder dezelfde naam werd verkocht. Microsoft verkocht van deze compiler ook een CP/M-versie.

De versies van Microsoft misten een paar functies van de IBM-versie, hoewel beide daarbuiten exact hetzelfde waren, die in latere versies alsnog terugkwamen.

BASCOM werd hernoemd naar QuickBasic, maar zelfs de compiler van de laatst uitgebrachte QuickBasic-versie vermeldde nog altijd de naam BASCOM. Gesuggereerd wordt dat Microsoft deze naamswijziging deed plaatsvinden om zich verder te distantiëren van IBM.

John Kemeny en Thomas Kurtz startten in 1983 TrueBASIC, Inc. en gingen de strijd aan met Microsoft en zijn BASCOM-compiler.

Borland bracht in 1987 Turbo BASIC van Bob Zale op de markt. Eerder programmeerde hij reeds BASIC/Z, de eerste interactieve BASIC-compiler voor CP/M en MS-DOS.

Microsoft, dat door de gebruiksvriendelijkere interface van Turbo BASIC een hoop van zijn BASIC-markt moest inleveren, sloeg een nieuwe weg in en bundelde bij zijn BASCOM-compiler de QuickBasic IDE (QuickBasic 3).

Volwassenheid

De laatste QuickBasic-versie op de markt was versie 4.5, waarna Microsoft zijn IDE en compiler omgooide om ze compatibel te maken met zijn aankomende OS/2-besturingssysteem, ontwikkeld in samenwerking met IBM. De hierop volgende versie was het Microsoft BASIC Professional Development System, waarna Microsoft zich meer ging richten op muisgestuurde interfaces, met als resultaat Visual Basic voor DOS.

Bob Zale startte in 1990 PowerBASIC en bracht Turbo Basic opnieuw op de markt onder de naam Powerbasic om weer de strijd aan te gaan met Microsoft. Powerbasic is tot op de dag van vandaag een van de meest succesvolle BASIC-compilers/interpreters verkrijgbaar voor de pc, naast Microsofts Visual Basic en het sinds 1991 bij MS-DOS/IBM-DOS 5.0 gebundelde QBasic.

Carl Gundel schreef in 1992 Liberty BASIC als reactie op het ontbreken van een Windows versie van QBASIC.

De overstap van Microsoft QuickBasic 4.5 naar "PDS" 6 (1990?) riep bij sommigen vragen op: wat was er gebeurd met versie 5? Het bij DOS 5.0 gebundelde QBASIC 1.0, als vervanger voor GWBASIC, had een op QuickBasic gelijkende interface en ondersteunde vrijwel alle commando's die QuickBasic ook ondersteunde. De QBASIC-interface was echter NIET voorzien van een compiler en mede daardoor ontbraken ook een aantal functies.

QBASIC 1.0 blijkt te zijn gegenereerd uit de broncode van QuickBasic 5, evenals de nieuwere versie QBASIC 1.1 die sinds DOS 6.0 wordt gebundeld bij de besturingssystemen van Microsoft. Een aantal geavanceerde functies zijn verwijderd om ontwikkelaars ertoe aan te zetten over te stappen op de professionele compilers (PDS) van Microsoft, wanneer zij eenmaal op dreef zijn met de QBASIC-interpreter en -gebruikersomgeving.

Vrij snel na PDS kwam Microsoft op de markt met een nieuwe ontwikkelinterface die de gebruiker moest voorbereiden op een grafische interface (Visual Basic 1.0 voor MS-DOS en Windows, 1991). Later voegde Microsoft zijn compilers samen en bundelde ze in het pakket Visual Studio 5 (1996).

Voor Visual Basic 3.0 bestonden zelfs decompilers, waarmee de binaire code, die feitelijk door een bibliotheek werd geïnterpreteerd, leesbaar terugvertaald kon worden naar de broncode.

Over de versie Visual Basic .NET (ook wel VB7 genoemd, 2002) zegt Microsoft zelf dat de taal zodanig veel veranderd is dat alle oude gebruikers hem helemaal opnieuw zullen moeten leren.

Voor de PlayStation 2 is het programma Yabasic gemaakt, waar ook een toetsenbord voor gebruikt kan worden.

Het is vooral de adoptie door Microsoft die maakt dat BASIC een taal is met veel invloed en aanhang. Inmiddels zijn de bezwaren tegen BASIC grotendeels achterhaald. De GOTO-opdracht is praktisch overbodig geworden door de IF-THEN-ELSE, WHILE-WEND en DO-LOOP opdrachten, de namen van variabelen kunnen voldoende lang zijn, declaratie van variabelen is mogelijk en kan verplicht gesteld worden en de regelnummers zijn verdwenen. Omgekeerd is het direct invoeren en testen van programma's geen voorrecht van de Basic-gebruiker meer. BASIC was eind 20e eeuw dan ook voor zeer veel programmeurs wel de eerste taal waarmee zij in aanraking kwamen.

Als voorbeeld van modern BASIC volgt hier een programma voor het berekenen van priemgetallen in VBA, de BASIC-versie die bij EXCEL geleverd wordt. Het programma kan vanaf het rekenblad aangeroepen worden en input en output geschieden van en naar het rekenblad 

 'Priemgetallen
 Option Explicit
 Sub Priem()
  Dim Start As Integer, Eind As Integer, i As Integer, t As Integer
  Start = Range("A1") 'INPUT "START=";START
  Eind = Range("A2") 'INPUT "END=";EIND
  t = 2
  For i = Start To Eind
   If Not (IsPriem(i)) Then t = t + 1: Cells(t, 1) = i 'Print i; " ";
  Next i
 End Sub
 '---------------------
 Function IsPriem(ByVal i As Integer) As Boolean
  Dim j As Integer, Deelbaar As Boolean
  Deelbaar = False
  j = 2
  While Not (Deelbaar) And j <= Sqr(i)
   If i / j = Int(i / j) Then Deelbaar = True Else j = j + 1
  Wend
  IsPriem = Not Deelbaar
 End Function

Enkele BASIC-dialecten

BASIC-dialecten op meerdere platformen

BASIC-dialecten op één platform

  • Altair BASIC (MITS Altair 8800) — Het eerste product van Microsoft.
  • AMOS BASIC — Een versie van BASIC voor de Amiga. De opvolger van STOS BASIC op de Atari ST.
  • Applesoft BASIC (Apple II)
  • AutoIt (Windows) — Een BASIC-gebaseerde programmeertaal vooral voor automatisatie binnen Windows.
  • Basic Interpreter voor Windows 10 en Windows 8.1
  • BASIC-2 (WANG 2200) — Een door WANG LABS ontwikkelde versie voor de WANG 2200-minicomputersystemen. Later ook uitgebracht als compiler voor de IBM-compatible pc-systemen.
  • BASICA (DOS) — "BASIC Advanced"
  • Business BASIC (MAI/Basic Four) — Een primitieve, geïnterpreteerde BASIC-variant in gebruik op de in de zeventiger jaren door MAI geleverde Basic Four 8-bits minicomputers. Primitief, want: met regelnummers, maar zonder enige voorziening voor subroutines of functies, 26 numerieke variabelen (a tm z), en 26 stringvariabelen (a$ t/m z$).
  • Commodore BASIC (Commodore 6502-platforms) — Versies 1.0 t/m 7.0.
  • Gambas (Linux) — Poging om het gebruiksgemak en de interface van Visual Basic te dupliceren.
  • Gnome Basic (Linux) — Bedoeld om VBA-functionaliteit te bieden in GNOME en aan vrije software in het algemeen. Veel ontwikkelaars van dit project werken nu aan Mono.
  • GW-BASIC (DOS) — Compatibel met BASICA. Onafhankelijk van de IBM-ROM-routines. Was meegeleverd met versies van MSDOS voor 5.0.
  • HBasic (Linux) — Gebaseerd op Qt.
  • Integer BASIC (Apple II)
  • Level I BASIC (Tandy TRS-80) - Een emulator is beschikbaar[3]
  • Liberty Basic (Windows)
  • MSX BASIC (MSX)
  • PBASIC — De programmeertaal voor de interne interpreter van de BASIC-Stamp Microcontroller van Parallax.
  • Philips Cassette Basic — Een variant voor de Philips P2000, tevens de standaard besturingsomgeving.
  • QBasic (DOS) — Was met versies van MS-DOS van 5.0 tot 6.22 meegeleverd.
  • QuickBASIC (DOS) — Verbeterde QBasic-variant (om nauwkeuriger te zijn, is QBasic een verminderde QuickBasic). Was de commerciële Pro-Version van QBasic met Compiler.
  • Sinclair BASIC — Een versie die op de ZX-80, ZX-81 en ZX Spectrum gebruikt werd.
  • STOS BASIC — Een versie van BASIC voor de Atari ST ontworpen om spellen te programmeren. De voorganger van AMOS BASIC op de Amiga.
  • TI-BASIC (Texas Instruments) — Basic-dialect voor diverse computers van Texas Instruments.
  • Turbo BASIC (DOS) — Een commerciële BASIC-compiler voor DOS van Borland (opvolger van BASIC/Z).
  • Visual Basic (Windows) — De object-georiënteerde BASIC-variant van Microsoft. Een dialect met Rapid Application Development voor BASIC.
  • Visual Basic .NET (Windows) — Implementatie binnen Microsoft .NET van Microsoft.

Geïntegreerde BASICs / Scripttalen gebaseerd op BASIC

Andere / onbekende / ongesorteerde BASIC-dialecten

Zie ook

Wikibooks heeft meer over dit onderwerp: Cursus programmeren in BASIC.
Overgenomen van "https://nl.wikipedia.org/w/index.php?title=BASIC&oldid=51942216"