Obsah
1. Historie vzniku programovacího jazyka BASIC
2. Programovací jazyk BASIC na mainframech a minipočítačích
3. Programovací jazyk BASIC na osmibitových mikropočítačích
4. Základy programovacího jazyka BASIC
7. Řídicí příkazy – podmínky a programové smyčky
8. Obsah následující části seriálu
1. Historie vzniku programovacího jazyka BASIC
V dnešní části seriálu o architekturách počítačů, jejich operačních systémů i programovém vybavení se začneme zabývat stručným popisem programovacích jazyků používaných nejenom u československých osmibitových domácích mikropočítačů, ale i u mikropočítačů zahraničních. Naše vyprávění samozřejmě musí začít u (v této oblasti informatiky nejrozšířenějšího) vyššího programovacího jazyka, jehož více či méně kvalitní dialekty existovaly prakticky pro všechny typy domácích (ale i profesionálních) osmibitových počítačů. Jedná se samozřejmě o jazyk BASIC (Beginner's All-purpose Symbolic Instruction Code), jehož syntaxe a především sémantika pozitivně, ale i negativně ovlivnily celou jednu generaci programátorů (včetně autora tohoto článku). Ovšem tento programovací jazyk je z historického hlediska zajímavý i proto, že se v souvislosti s jeho vývojem poprvé objevují jména Bill Gates a Paul Allen spolu s jejich společností původně nazývanou Micro-Soft.
Obrázek 1: V ČSSR vyšlo poměrně velké množství učebnic programovacího jazyka BASIC. Na tomto obrázku je zobrazená fotografie obálky jedné z nejstarších českých knih o tomto jazyce, která vyšla již v roce 1979. Popisuje dialekt BASICu dostupný na minipočítačích SMEP (Systém Malých Elektronických Počítačů).
V následujících odstavcích si popíšeme historii vzniku a následného rozšíření tohoto programovacího jazyka, od jeho počátků v roce 1964 až po současnost, v níž se název BASIC používá pro zcela odlišnou třídu programovacích jazyků, které již mají s původním BASICem společný už pouze název a jména některých základních příkazů.
Obrázek 2: Přední stránka manuálu k historicky první verzi jazyka BASIC.
Programovací jazyk BASIC byl vyvinut v roce 1964 J. G. Kemenym a T. E. Kurtzem na universitě v Dartmouthu. Kemeny a Kurtz tento jazyk navrhli s ohledem na to, aby umožnili rychlé osvojení ovládání počítačů i jejich programování pracovníkům a studentům, kteří nejsou (a ani nechtějí být) specialisty na programování, ale potřebují problémy řešené v jejich praxi vhodným způsobem algoritmizovat a následně vhodným způsobem zapsat tak, aby počítač mohl zapsané algoritmy skutečně provést. Důraz na co největší jednoduchost jazyka se projevil například omezením počtu proměnných na 26, automatickou deklarací a inicializací proměnných (což je u větších programů velmi záludná vlastnost), existencí (původně) pouze jednoho datového typu atd.
Obrázek 3: Manuál k první verzi FORTRANu určeného pro mainframy IBM 704.
Syntaxe původního programovacího jazyka BASIC byla částečně založena na FORTRANU II a ALGOLU 60. Není se ostatně čemu divit – oba autoři jazyka BASIC totiž předpokládali, že někteří studenti po zvládnutí BASICu postupně přejdou na FORTRAN, který byl ve druhé polovině šedesátých let minulého století stále považován za lingua francu programátorů. Původní BASIC byl orientován především na programování matematicky zaměřených úloh – podporoval „přirozený“ zápis aritmetických výrazů včetně korektního vyhodnocování priorit operátorů a dokonce i práci s maticemi (některé pozdější interprety tohoto jazyka práci s maticemi nepodporovaly). Vzhledem k tomu, že délka jmen proměnných byla omezena na jeden znak anglické abecedy (tj. na 26 písmen) a jazyk nepodporoval tvorbu uživatelských funkcí ani procedur, byl zápis složitějších programů poměrně problematický. Navíc jazyk zpočátku nepodporoval ani práci s řetězci; tato velmi důležitá funkcionalita byla přidána až o rok později, tj. v roce 1965. Zajímavé bylo, že první dvě verze BASICu byly implementovány jako překladač, nikoli interpret, a navíc byl překlad BASICových programů rychlejší než překlad obdobných programů napsaných ve FORTRANu a ALGOLu.
Obrázek 4: Jedna z populárních dobových učebnic ALGOLU 68 (což je, jak ostatně název napovídá, norma jazyka ALGOL, která je o čtyři roky mladší než první verze jazyka BASIC).
2. Programovací jazyk BASIC na mainframech a minipočítačích
Původní implementace programovacího jazyka BASIC vznikla na počítači GE-265. Jedná se o jeden z počítačů poměrně populární řady GE-200, jehož řadič a aritmeticko-logická jednotka byla sestavena z diskrétních elektronických součástek, konkrétně z přibližně deseti tisíc tranzistorů a dvaceti tisíc diod. Operační paměť byla vytvořena z cca 186 tisíc feritových jader. Vzhledem k poměrně vysoké ceně tohoto počítače není divu, že se Kemeny a Kurtz snažili vytvořit takový programovací jazyk s podpůrným systémem, který by umožnil co nejlépe využít jeho strojový čas (neboli dostupnou výpočetní kapacitu, která ostatně nebyla nijak velká). Mimochodem: podpora pro souběžnou interaktivní(!) práci s počítačem byla vlastnost, která byla v pozdějších letech, především s nástupem osmibitových mikropočítačů, ztracena, aby se o cca dvě desítky let později znovu objevila na osobních počítačích, kde ji firmy prezentovaly jako revoluční novinku :-).
Obrázek 4: Čtyři bity feritové paměti (zvětšeno).
Již v předchozí kapitole jsme si řekli, že první verze programovacího jazyka BASIC neumožňovala práci s řetězci i to, že se tato funkcionalita objevila až ve druhé verzi vytvořené v roce 1965. Vzhledem k tomu, že J. Kemeny a T. Kurtz jazyk šířili bez licenčních omezení (chovali se podobně jako mnoho jejich universitních kolegů), došlo k poměrně rychlému rozšíření tohoto programovacího jazyka, přesněji řečeno jeho druhé verze, na mnoho typů minipočítačů i mainframů. BASIC byl používán například na počítačích DEC PDP, strojích firmy HP, mainframech firmy IBM či počítačích řady SMEP, což byly počítače vyráběné v zemích RVHP (včetně Československa) odvozené od populárního PDP-11. U počítačů SMEP byl jazyk BASIC součástí většiny operačních systémů, které pro tyto stroje vznikly. Jedná se například o LOS (operační systém orientovaný na používání děrné pásky), DOS RV a DOS RVR (optimalizovaný na práci s disky) či FOBOS (podpora souběžné práce více uživatelů). Kromě základní verze BASICu byl pro počítače SMEP dostupný i BASIC plus, který navíc podporoval například hromadné zpracování dat.
Obrázek 5: Řídicí panel počítače PDP-11–70.
3. Programovací jazyk BASIC na osmibitových mikropočítačích
Zatímco na mainframech a minipočítačích byl BASIC pouze jedním z mnoha dostupných programovacích jazyků, byla situace v oblasti osmibitových mikropočítačů v mnoha ohledech odlišná – zde se totiž jazyk BASIC stal všeobecně uznávaným a hojně používaným vyšším programovacím jazykem, který byl u mnoha osmibitových mikropočítačů přítomen přímo v paměti ROM, takže ho nebylo nutné zdlouhavě nahrávat z kazety či diskety. Toto téměř výsadní postavení BASICu má několik důvodů. Jedním z těchto důvodů byla omezená velikost pamětí ROM i RAM u prvních typů mikropočítačů, takže snahou výrobců bylo používat takový programovací jazyk, který by paměť využíval co nejefektivnějším způsobem. Pro tuto oblast se nabízel právě BASIC, přesněji řečeno jeho interpret (překladače BASICu většinou vyžadují větší množství paměti), který byl doplněn interaktivním textovým editorem, v němž se program současně zapisoval, spouštěl i ladil. Tento editor byl buď řádkový nebo celoobrazovkový.
Obrázek 6: Program zapsaný v AppleSoft BASICu spuštěný na počítači Apple II.
Jednodušší verze BASICu si vystačily již se čtyřmi kilobajty paměti ROM, v níž byl uložen jak interpret, tak i poměrně jednoduchý textový editor umožňující interaktivní práci s interpretrem, a s pouhým jedním kilobajtem operační paměti, jejíž část byla navíc použita jako obrazová paměť (viz další díl tohoto seriálu). Mezi osmibitovými domácími počítači byly nejrozšířenější verze jazyka BASIC uložené v paměti ROM o kapacitě 8 až 16 kB. Díky použití takto velké kapacity ROM mohly tyto interpretry obsahovat větší množství příkazů (například pro práci s grafikou či zvuky), podporovaly výpočty s čísly uloženými ve formátu plovoucí řádové čárky atd. Jedním z důvodů poměrně malých nároků na kapacitu operační paměti bylo to, že interpretry BASICu každý programový řádek zadaný uživatelem ihned zpracovaly – klíčová slova se převedla na takzvané tokeny (většinou jednobajtové), jména proměnných na jednobajtové indexy do tabulky proměnných atd.
Obrázek 7: Úvodní obrazovka interpretru jazyka BASIC na počítači Commodore C64.
Zdrojový kód programu zadaný uživatelem se tak ve skutečnosti ihned po jeho převodu na tokeny (tj. po provedení takzvané „tokenizace“) vymazal, protože ho interpret mohl kdykoli později, například při požadavku na jeho výpis či tisk, zrekonstruovat, a to dokonce v upravené podobě – zkratky příkazů se nahradily jejich plným zněním, odstranily se přebytečné mezery, program se seřadil podle čísel řádků atd. V pozdější době začaly být pro osmibitové mikropočítače nabízeny takzvané „diskové BASICy“, což byly interpretry či překladače jazyka BASIC uložené většinou na disketách nebo zásuvných modulech (na rozdíl od původních interpretrů uložených v ROM). Součástí těchto jazyků byly mnohdy i poměrně rozsáhlé knihovny, které mohli programátoři při vývoji využít. „Diskové BASICy“ navíc mnohdy obsahovaly takové programové konstrukce, které umožňovaly plnohodnotné strukturované programování; jednalo se například o plný (víceřádkový) příkaz typu IF-THEN-ELSE, různé typy programových smyček, možnost definice vlastních funkcí atd.
Obrázek 8: Jednoduchý program zapsaný v celoobrazovkovém editoru programovacího jazyka Atari BASIC.
4. Základy programovacího jazyka BASIC
V následujícím textu si stručně popíšeme strukturu BASICových programů, přičemž se zaměříme především na „klasické“ dialekty tohoto programovacího jazyka, tj. na dialekty, které vyžadovaly číslování řádků, podporovaly pouze jeden typ programové smyčky (konkrétně počítanou smyčku typu for) a naopak nepodporovaly tvorbu uživatelských funkcí, procedur ani vlastních datových typů. Tyto dialekty BASICu se používaly především v dobách kralování osmibitových domácích počítačů a i některé interpretry dostupné na výkonnějších strojích (například GW-Basic) měly podobnou strukturu. Vraťme se však k popisu toho, jakým způsobem se programovalo v „klasickém“ BASICu. Celý program zapisovaný interaktivně v textovém editoru byl rozdělen do programových řádků, přičemž každý programový řádek začínal svým číslem. Minimální číslo řádku bylo obvykle rovno jedné, maximální číslo pak 9999 popř. 32767, v závislosti na interním způsobu ukládání numerických hodnot (BCD kód vs. binární reprezentace).
Obrázek 9: Jeden z prvních zveřejněných algoritmů zapsaných v programovacím jazyce BASIC. Jedná se o ukázkový program uvedený v manuálu původního BASICu, který byl vydán již v roce 1964 (viz též druhý obrázek s úvodním listem tohoto manuálu). Povšimněte si jedné zajímavosti – autoři v celém manuálu používají pro znak O (velké písmeno ó) znak 0, a pro číslici 0 naopak znak O, což je poněkud zvláštní a vymyká se to konvencím zavedeným u jiných systémů i programovacích jazyků.
Čísla řádků si programátor mohl zvolit podle své vůle, přičemž platilo, že interpret jazyka si řádky při překladu (přesněji řečeno při tokenizaci) automaticky uspořádal do rostoucí posloupnosti. Pokud programátor zapsal pouze číslo řádku bez uvedení příkazu, byl tento programový řádek z programu vymazán. Jak si řekneme v dalším textu, měla čísla řádků velký význam především při zápisu programových skoků (příkaz GOTO) popř. skoků do podprogramů (příkaz GOSUB). Za číslem řádku následoval nějaký příkaz reprezentovaný svým názvem, který mnemotechnicky vyjadřoval činnost příkazu (PRINT – tisk dat, INPUT – vstup dat, LET – přiřazení, DRAW – kreslení). Za jménem příkazu mohly následovat jeho operandy, popř. aritmetický či logický výraz, jenž mohl obsahovat i volání některé zabudované funkce (SIN, LOG, PEEK, RND/RAND, CHR$, VAL apod.).
Obrázek 10: Jedna z původních verzí hry Ultima, která byla naprogramována v jazyku AppleSoft BASIC pro počítače Apple II. Pozdější verze této hry již byly programovány v assembleru.
Z předchozího textu mj. vyplývá, že BASIC poměrně striktně rozlišoval mezi příkazy a funkcemi. Na programovém řádku se většinou mohlo nacházet i více příkazů, které od sebe byly odděleny dvojtečkou. Interpretry programovacího jazyka BASIC navíc podporovaly, ostatně jako naprostá většina ostatních programovacích jazyků, zápis poznámky, která byla reprezentována speciálním příkazem REM, za nímž mohl následovat libovolný text, který byl interpretrem při tokenizaci pouze uložen do operační paměti bez jeho dalšího zpracování. Pokud programátor zapsal nějaký příkaz bez uvedení čísla řádku, byl tento příkaz ihned proveden. Tímto způsobem se vlastně (bez nutnosti znalosti klávesových zkratek či použití menu) celý interpret jazyka ovládal. Například pro vymazání stávajícího programu sloužil příkaz NEW, pro spuštění programu příkaz RUN, pro jeho výpis příkaz LIST atd. Ovšem i mnoho dalších příkazů mohlo být spuštěno mimo vlastní program, takže interpret BASICu mohl například sloužit jako výkonná kalkulačka, což je ostatně patrné i při pohledu na následující obrázek.
Obrázek 11: Příkazy spouštěné (interpretované) ihned po jejich potvrzení klávesou Enter či Return (screenshot z emulátoru Atari 800 se spuštěným Atari BASICem).
5. Numerické hodnoty a práce s řetězci
Již v úvodních kapitolách jsme si řekli, že první verze programovacího jazyka BASIC podporovala pouze číselný datový typ a teprve ve verzi druhé byla přidána podpora pro práci s řetězci. Většina interpretrů BASICu pro osmibitové počítače však již dokázala pracovat jak s numerickými hodnotami, tak i s řetězci. Některé první interpretry BASICu, omezené především malou kapacitou paměti ROM, podporovaly pouze práci s celočíselnými údaji. Příkladem může být například interpret dodávaný k počítači Apple 1 (jednalo se o známý Integer BASIC Steva Wozniaka) či k neméně slavnému počítači ZX80 (Sinclair Basic Johna Granta). Ovšem prakticky všechny další verze interpretrů BASICu dokázaly pracovat s reálnými čísly (resp. s jejich aproximací) a to v mnoha případech do takové míry, že celočíselný datový typ vůbec nepodporovaly – to znamená, že jak celá čísla, tak i logické hodnoty (0–false, 1–true) byly ukládány jako reálná čísla, což je sice poněkud neefektivní jak z hlediska obsazení paměti, tak i kvůli pomalejším výpočtům, na druhou stranu se však syntaxe jazyka velmi zjednodušila, protože bylo nutné rozlišovat pouze dva typy dat – (reálné) číslo a řetězec.
Obrázek 12: Příkaz spouštěný (interpretovaný) ihned po jeho potvrzení (screenshot byl proveden z emulátoru ZX Spectra, v horní části obrazovky je výsledek předchozího příkazu).
Numerické hodnoty bylo možné příkazem LET (který se někdy nemusel zapisovat) ukládat do proměnných jejichž názvy byly v nejjednodušších interpretrech omezeny na znaky velké anglické abecedy (tj. maximálně bylo možné využít 26 proměnných). V interpretrech vyspělejších se rozlišovaly první dva, čtyři nebo i více znaků z názvu proměnné. Zajímavé a pro jazyk BASIC velmi typické bylo to, že proměnné nebylo zapotřebí deklarovat ani inicializovat – číselná proměnná se jednoduše vytvořila a inicializovala (na nulovou hodnotu) v místě svého prvního použití. Na první pohled přednost se však mohla vymstít v případě, že se programátor v nějakém místě programu přepsal a uvedl název jiné proměnné. Dále bylo možné více numerických hodnot uložit do pole, přičemž většina interpretrů umožňovala práci s jednorozměrnými či dvourozměrnými poli. Pro vytvoření pole sloužil příkaz DIM za nímž následoval počet prvků jednorozměrného pole (vektoru) popř. rozměry pole dvourozměrného (matice). Při práci s poli se prvky indexovaly (opět ve velkém množství interpretrů, ale zdaleka ne ve všech) od jedničky, přičemž se indexy zapisovaly do kulatých závorek, podobně jako při volání funkcí:
Obrázek 13: Práce s numerickými proměnnými a poli v BASICU. Povšimněte si, že na řádku 50 se do proměnné A vloží hodnota 0 a současně se vytvoří numerické proměnné B a C inicializované na nulu. Dále se na řádku 70 vytvoří desetiprvkové pole, na řádku 80 se nastaví hodnota prvního prvku tohoto pole na 42 a na řádku 100 se vypíše hodnota zdánlivě neinicializovaného prvku číslo 2 (který je ve skutečnosti nastaven na nulu).
6. Práce s řetězci
Textové řetězce se ukládaly do proměnných, v jejichž názvu se na konci uváděl znak dolaru. To znamená, že například proměnná A mohla obsahovat reálné číslo, zatímco proměnná A$ obsahovala řetězec. Většina „klasických“ BASICů nepodporovala datový typ „znak“, namísto toho se používaly jednoznakové řetězce. Základ práce s řetězci byl ve všech interpretrech podobný – řetězce (resp. proměnné, do nichž se řetězce ukládaly) se deklarovaly příkazem DIM, řetězce bylo možné (lexikograficky) porovnávat běžnými relačními operátory, načítat řetězce ze vstupu příkazem INPUT a tisknout řetězce příkazem PRINT. Další operace s řetězci se už v jednotlivých interpretrech lišily – zatímco BASICy prodávané firmou Microsoft používaly funkce LEFT$, RIGHT$ a MID$ pro přístup k částem řetězce, jiné interpretry používaly jednodušší a efektivnější způsob – uvedením indexu začátku a konce řetězce v závorkách (někdy s klíčovým slovem TO), přičemž počáteční nebo koncový index nemusel být zapsán (ostatně podobně je to řešeno například v jazyce Python).
Obrázek 14: Základy práce s řetězci v Atari BASICu: deklarace řetězce, přiřazení hodnoty (řetězcového literálu) do řetězce, vytvoření podřetězce (první až pátý znak, popř. sedmý znak až konec řetězce) a nastavení jednoho znaku v řetězci.
7. Řídicí příkazy – podmínky a programové smyčky
Jedním z typických rysů původního jazyka BASIC, který však byl využíván i v interpretrech určených pro osmibitové domácí i šestnáctibitové osobní počítače, byl způsob řízení běhu programu a implementace některých programových smyček pomocí (nechvalně) známého příkazu GOTO popř. ON GOTO. Tyto příkazy bylo možné v prvé řadě použít při zápisu podmíněných bloků kódu – za příkaz/podmínku IF-THEN se mohly zapsat různé příkazy mj. i příkaz GOTO s číslem řádku, na který měl být proveden skok v případě, že podmínka byla splněna (příkazy provedené při splnění podmínky totiž musely být zapsány na jediném programovém řádku, což ostatně uvidíme i v demonstračním příkladu). Druhým úkolem těchto příkazů byla tvorba programových smyček i výskoků ze smyček v případě splnění nějaké podmínky (obdoba céčkových příkazů break a continue). Příkaz ON GOTO navíc umožňoval vytvoření programové konstrukce, kterou v jiných programovacích jazycích známe pod názvem switch-case (C, C++, Java, JavaScript) popř. case-of (Pascal, Delphi).
Obrázek 15: Demonstrační příklad zapsaný v Atari BASICu. Povšimněte si, že není zapotřebí používat příkaz LET ani příkaz GOTO v případě, že následuje ihned za klíčovým slovem THEN.
Nejprve si ukažme, jakým způsobem by bylo možné v „klasickém“ BASICu implementovat jednoduchý program, který po svém spuštění čeká na zadání dvou celých kladných čísel a posléze vypočítá jejich největší společný dělitel (NSD, anglicky GCD – Greatest Common Divisor). Pro jednoduchost nejsou v programu implementovány žádné kontroly, zda uživatel skutečně zadal dvojici kladných čísel a současně je použita varianta Euklidova algoritmu, která nevyžaduje provádění operací podílu a zbytku po dělení – vystačí si pouze s celočíselnými operacemi rozdílu (vzhledem k tomu, že BASIC nepodporuje rekurzi, nebylo navíc možné použít rekurzivní tvar Euklidova algoritmu). V BASICu by tento algoritmus mohl být zapsán formou vnořených programových smyček implementovaných s využitím podmínek (příkazu IF-THEN) a skoků na určený řádek programu (příkaz GOTO n). Následující program byl odladěn pro Atari BASIC, ale v prakticky nezměněné podobě ho lze zapsat i v jiném interpretru „klasického“ BASICu (většinou postačuje pouze dopsat příkaz LET před přiřazení A=A-B a B=B-A na řádcích 30 a 40, popř. na řádku 50 uvést za THEN příkaz GOTO):
10 INPUT A 20 INPUT B 30 IF A>B THEN A=A-B:GOTO 30 40 IF A<B THEN B=B-A:GOTO 40 50 IF A<>B THEN 30 60 PRINT A,B
Pro zajímavost: v Céčku by se obdobný program mohl zapsat pomocí vnořených smyček, z nichž je lépe patrná struktura implementovaného algoritmu. Na druhou stranu je céčkový program delší kvůli nutnosti deklarace proměnných, definice funkce main atd.:
#include <stdio.h>
int main(int argc, char **argv)
{
int a, b;
scanf("%d", &a);
scanf("%d", &b);
while (a != b)
{
while (a>b)
a-=b;
while (b>a)
b-=a;
}
printf("%d\t%d\n", a, b);
return 0;
}
Obrázek 16: Demonstrační příklad zapsaný v Sinclair BASICu. Jednotlivé příkazy nebyly vypisovány znak po znaku, ale použily se klávesové zkratky (které si uživatelé nemuseli pamatovat, neboť je měli natištěné přímo na klávesnici).
Kromě smyček vytvářených pomocí kombinace příkazů IF-THEN-GOTO (viz předchozí příklad s trojicí takových smyček) obsahoval původní BASIC pouze podporu pro jeden typ programové smyčky – jednalo se o počítanou smyčku typu FOR, v níž bylo možné specifikovat jak počáteční a koncovou hodnotu řídicí proměnné smyčky, tak i krok, o který se proměnná zvýšila popř. snížila při každém průchodu smyčkou (na rozdíl od Pascalu se nepoužívaly celočíselné proměnné, ale proměnné obsahující reálná čísla). Vzhledem k tomu, že vstupní bod této smyčky (přesněji řečeno číslo programového řádku + pořadí příkazu FOR na tomto řádku) byl ukládán na interní zásobník, bylo možné tyto smyčky vzájemně vnořovat. Následuje velmi jednoduchý příklad použití této smyčky při výpočtu sumy všech čísel od 1 do 100. Povšimněte si především toho, že smyčka je ukončena příkazem NEXT i, kde i je jméno řídicí proměnné.
100 REM This is probably the canonical BASIC example 110 REM Program. Note that REM statements are ignored. 120 PRINT "This is a test program." 130 PRINT "Summing the values between 1 and 100" 140 LET total = 0 150 FOR i = 1 TO 100 160 LET total = total + i 170 NEXT i 180 PRINT "The total of all digits between 1 and 100 is " total 190 END
Obrázek 17: Výsledek výpočtu provedeného demonstračním příkladem na počítači ZX Spectrum (resp. na jeho emulátoru).
Příklad počítané smyčky, v níž je zadaný i krok, o nějž se řídicí proměnná sníží po každém průchodu smyčkou:
100 FOR i = 90 TO 0 STEP -0.1 110 PRINT i, SIN(i) 120 NEXT i
8. Obsah následující části seriálu
V následující části seriálu o architekturách počítačů, jejich operačních systémech i základním programovém vybavení budeme pokračovat v popisu postupného (a nutno říci, že poněkud chaotického) vývoje programovacího jazyka BASIC. Nejprve si řekneme, jaké dialekty tohoto programovacího jazyka byly použity na osmibitových domácích počítačích, a to jak počítačích tuzemských (například na IQ-151, PMD-85, Didaktiku Alfa, počítači Ondra a dalších), tak i na zahraničních strojích, především na počítačích Apple 1, Apple II, Atari, Commodore či ZX80, ZX81 a ZX Spectrum. Posléze si popíšeme některé dialekty BASICu dostupné na osobních počítačích Atari ST, Amiga a samozřejmě i na osobních počítačích firmy IBM (IBM PC, PC XT, PC AT…) i jejich klonech. Nakonec se zmíníme i o zajímavém použití BASICu v zařízení nazvaném příhodně Basic Stamp, což je kombinace mikrořadiče s interpretrem BASICu a paměťového čipu, kterou lze použít například při konstrukci amatérských elektronických zařízení bez nutnosti používat assembler pro programování mikrořadiče.
Obrázek 18: Známá hra Gorily, která byla naprogramována v QBasicu. Tato hra se stala v dobách kralování MS-DOSu velmi populární, především proto, že byla nainstalovaná (možná by bylo lepší říci předinstalovaná) prakticky na jakémkoli počítači s tímto operačním systémem.
Kromě mnoha dalších interpretrů a překladačů programovacího jazyka BASIC se příště budeme podrobněji zabývat především dnes již historickými vývojovými prostředími používanými na osobních počítačích IBM, mezi něž patří zejména QBasic (jedná se o interpret a současně i vývojové prostředí dodávané spolu s MS-DOSem 5.0, 6.0, Windows 95 a, i když poněkud skrytě, i k operačnímu systému Windows 98), dále pak QuickBasic (interpret i překladač s poněkud většími možnostmi než nabízel QBasic), Borland Turbo Basic (u nás kupodivu poněkud neznámý překladač, i když další vývojová prostředí firmy Borland u nás byla velmi populární) a taktéž některými moderními verzemi tohoto jazyka, především FreeBASICem vyvíjeným pod licencí GPL (jedná se o překladač bez vývojového prostředí) a v neposlední řadě taktéž zajímavým vývojovým prostředím Gambas, které lze mj. použít i pro vývoj aplikací využívajících knihovnu Qt, grafickou knihovnu OpenGL atd.
Obrázek 19: Ve FreeBASICu šířeném pod licencí GPL vzniklo několik zajímavých programů, například tato RPG hra nazvaná The Griffon Legend. Zdrojové kódy této hry jsou dostupné, takže je možné poměrně jednoduše prozkoumat, do jaké míry se programovací jazyk BASIC po více než 45 letech vývoje přiblížil moderním programovacím jazykům.
9. Odkazy na Internetu
- Rosetta Code – Main Page
http://rosettacode.org/wiki/Main_Page - Rosetta Code – Category Basic
http://rosettacode.org/wiki/Category:BASIC - Dartmouth College Computation Center: 1964 – The original Dartmouth BASIC manual
http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf - The Original BASIC
http://www.truebasic.com/ - BASIC – Beginners All-purpose Symbolic Instruction Code
http://hopl.murdoch.edu.au/showlanguage.prx?exp=176 - FreeBASIC home page
http://www.freebasic.net/ - FreeBASIC Wiki
http://www.freebasic.net/wiki/wikka.php?wakka=FBWiki - FreeBASIC Manual
http://www.freebasic.net/wiki/wikka.php?wakka=DocToc - FreeBASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/FreeBASIC - The Griffon Legend
http://syn9.thingie.net/?table=griffonlegend - QBasicJedi
http://www.freewebs.com/qbasicjedi/ - QBasic/QuickBasic Downloads
http://www.freewebs.com/qbasicjedi/qbdownloads.html - QuickBASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/QuickBASIC - QBasic.com
http://www.qbasic.com/ - QBasic (Wikipedia)
http://cs.wikipedia.org/wiki/QBasic - Dialling with QBASIC
http://www.mysundial.ca/tsp/qbasic.html - Visual Basic .NET (česky)
http://www.vbnet.cz/ - BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/BASIC - BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/BASIC - Turbo BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Turbo_BASIC - Sinclair BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Sinclair_BASIC - More BASIC Computer Games
http://www.atariarchives.org/morebasicgames/ - How to build an interpreter in Java, Part 1: The BASICs
http://www.javaworld.com/jw-05–1997/jw-05-indepth.html - Apple I
http://applemuseum.bott.org/sections/computers/a1.html - The Apple 1 history
http://apple2history.org/history/ah02.html - The Apple 2 history
http://apple2history.org/history/ah03.html - Applesoft Lite: Applesoft BASIC for the Replica-1
http://cowgod.org/replica1/applesoft/ - Speccy.cz
http://www.speccy.cz/ - Planet Sinclair
http://www.nvg.ntnu.no/sinclair/ - World of Spectrum
http://www.worldofspectrum.org/ - History of the BASIC family of languages
http://dotnetmasters.com/historyofbasic.htm - A brief history of the development of BASIC
http://www.phys.uu.nl/~bergmann/history.html - A GE-225 is found
http://ed-thelen.org/comp-hist/GE225.html - GE-200 series
http://en.wikipedia.org/wiki/GE-200_series - Gambas Almost Means BASIC
http://gambas.sourceforge.net/en/main.html - Gambas
http://en.wikipedia.org/wiki/Gambas - MBASIC
http://en.wikipedia.org/wiki/MBASIC - BASIC Stamp
http://www.antratek.com/Parallax_Stamps.html - Sinclair BASIC
http://en.wikipedia.org/wiki/Sinclair_BASIC - Sinclair ZX81 BASIC Programming
http://www.worldofspectrum.org/ZX81BasicProgramming/ - Introduction to BASIC
http://en.wikibooks.org/wiki/Introduction_to_BASIC - Apple II Programmer's Reference
http://www.landsnail.com/a2ref2.htm
ČLÁNKY DO MAILU