Hlavní navigace

Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari

6. 4. 2021
Doba čtení: 46 minut

Sdílet

 Autor: Frank Ostrowski
Dnes se seznámíme s vybranými jazyky používanými na domácích osmibitech Atari. V žádném případě se nejedná pouze o interpret BASICu, který nás asi napadne nejdříve, protože pro „atárka“ vznikly i velmi specifické jazyky.

Obsah

1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari

2. Assemblery, interpretry a překladače

3. Atari Assembler Editor

4. MAC/65

5. Atari BASIC

6. Vybrané vlastnosti Atari BASICu

7. Slavný Turbo-BASIC XL

8. Strukturované programování v Turbo-BASICu

9. Pomůcky při vývoji a ladění programů v Turbo-BASICu

10. Atari LOGO

11. Unikátní vlastnosti Atari Loga

12. Interlisp/65 (INTER-LISP/65)

13. Specifika Interlispu/65

14. Programovací jazyk Action!

15. Datové typy v jazyku Action!

16. Programové konstrukce v jazyku Action!

17. FIG-Forth

18. Co zbývá?

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari

V dnešním článku se seznámíme s vybranými programovacími jazyky používanými na domácích osmibitových mikropočítačích Atari. S některými dále zmíněnými jazyky jsme se sice již na stránkách Roota setkali dříve, ovšem většinou pouze ve stručnosti a v odlišném kontextu. Popíšeme si jak některé assemblery (resp. přesněji řečeno jazyky symbolických adres – JSA – popř. jazyky symbolických instrukcí – JSI), tak i vybrané interpretované jazyky, mezi které patří například Atari BASIC, Turbo-BASIC XL, Atari LOGO či Interlisp/65. Nezapomeneme ovšem ani na překladače (mezi něž ve světě osmibitových Atari patří zejména jazyk Action!) a dokonce ani na ty programovací jazyky, které leží na pomezí mezi čistými interpretry na straně jedné a čistými překladači na straně druhé – jedná se především o programovací jazyk Forth, konkrétně o jeho variantu pojmenovanou FIG-Forth zmíněnou v sedmnácté kapitole. Příště se zmíníme o mnohem mladším jazyku, jenž se jmenuje FastBASIC. Tento jazyk se v několika zásadních ohledech od klasických BASICů odlišuje a využívá se dnes v některých programátorských soutěžích.

Obrázek 1: Tuto obrazovku zná každý Atarista. Jedná se o výchozí režim osmibitových mikropočítačů Atari ve chvíli, kdy není přítomna cartridge, nebyl spuštěn Self Test, není zapnut režim nahrávání z kazetového magnetofonu ani není připojena disketová jednotka. V tomto režimu může uživatel zadávat příkazy Atari BASICu, s nímž se ve stručnosti seznámíme v rámci páté kapitoly. Na rozdíl od implementací BASICu pro některé jiné mikropočítače je v případě Atari BASICu k dispozici celoobrazovkový textový editor s průběžnou kontrolou chyb.

Poznámka: tento článek je zkrácenou verzí rozsáhlejšího článku, který vyjde v magazínu (přesněji řečeno diskmagu) FLOP určeného (nejenom) pro skalní Ataristy. Všechny předchozí díly FLOPu je možné spustit v prakticky libovolném emulátoru osmibitových Atari, například v multiplatformním emulátoru atari800.

Obrázek 2: Uvítací obrazovka jedné z variant Interlispu pro osmibitové domácí mikropočítače Atari. O tomto jazyku se zmíníme ve dvanácté kapitole.

2. Assemblery, interpretry a překladače

Na osmibitových mikropočítačích (a nyní se zaměříme především na domácí mikropočítače) měli ti uživatelé, kteří se chtěli zabývat programováním, na výběr z relativně velkého množství různých vývojových nástrojů a pomůcek. Některé mikropočítače byly vybaveny pouze velmi jednoduchým operačním systémem zajišťujícím základní vstupně/výstupní operace (čtení klávesnice, zápis znaku na obrazovku, rutiny pro čtení a zápis dat na magnetofon). Poměrně často byl tento minimalistický operační systém doplněn o takzvaný monitor což byl (a někde doposud je) program umožňující manipulaci s daty v operační paměti, tj. zápis dat do paměti, čtení (zobrazení) vybraného bloku, přesun bloku, vyplnění určité oblasti konstantou, čtení a zápis dat na externí paměťové médium (typicky na magnetofon) a některé pokročilejší monitory byly vybaveny i takzvaným disassemblerem umožňujícím transformaci sekvence bajtů na symbolické instrukce. Mimochodem – při výpisu obsahu operační paměti se v monitorech většinou používal stejný formát, jaký najdeme u mnoha moderních programátorských hexa editorů.

Obrázek 3: Celoobrazovkové uživatelské rozhraní monitoru pro mikropočítače Apple II.

Poznámka: pro zajímavost – původní monitor použitý v počítači PMD 85.1 byl uložen ve čtyřech kilobajtech paměti EPROM a obsahoval následující příkazy: SUB, JUMP, MEM, DUMP, BASIC, MGLD, MGSV, MGEND a JOB.

Obrázek 4: Monitor pro slavné osmibitové počítače Commodore C64.

Monitory, zejména ty vybavené disassemblerem (zpětným assemblerem) bylo možné použít i pro tvorbu programů na úrovni strojového kódu. Program se většinou nejprve zapsal na papír ve formě assembleru, dále se provedl ruční překlad jednotlivých instrukcí do sekvence decimálních nebo hexadecimálních číslic a následně se tato sekvence zapsala do monitoru do určité předem vybrané oblasti operační paměti. V případě, že monitor podporoval zápis bloku paměti na externí paměťové médium (kazetový magnetofon, disketu), jednalo se o dosti primitivní, ovšem stále ještě použitelné (a v některých případech i používané) vývojové prostředí. Programování na úrovni strojového kódu je samozřejmě velmi pracné, zejména ve chvíli, kdy je nutné existující program modifikovat a tím pádem měnit cílové adresy skoků, adresy globálních proměnných atd. Mnohem civilizovanější způsob představovalo použití takzvaných assemblerů, což byly nástroje schopné překládat programy zapsané v jazyku symbolických adres/instrukcí do strojového kódu – ostatně přesně pro podobné činnosti jsou počítače zkonstruovány.

Obrázek 5: Jedním z poměrně velkého množství assemblerů vyvinutých pro osmibitové mikropočítače Atari je SynAssembler vytvořený a prodávaný společností Synapse Software. Tato společnost, s níž jsme se již na stránkách Roota seznámili, se nezaměřovala pouze na vývoj počítačových her. Kromě nich totiž vydávala i programy určené jak pro běžné koncové uživatele (FileManager 800, DiskManager, SynFile+, SynCalc, SynChron, SynComm, SynStock, SynTrend, …) tak právě vývojové nástroje; mezi nimi i SynAssembler.

Na osmibitových domácích mikropočítačích se používaly dva typy assemblerů. Prvním typem byly assemblery interaktivní, které uživateli nabízely poměrně komfortní vývojové prostředí, v němž bylo možné zapisovat jednotlivé instrukce, spouštět programy, krokovat je, vypisovat obsahy registrů mikroprocesoru atd. Výhodou takto pojatého řešení byla nezávislost těchto assemblerů na rychlém externím paměťovém médiu. S těmito assemblery určenými pro počítače Atari se ve stručnosti seznámíme i v dnešním článku, protože jak Atari Assembler Editor, tak i MAC/65 náleží do této kategorie. Druhý typ assemblerů je používán dodnes – jedná se vlastně o běžné překladače, kterým se na vstupu předloží zdrojový kód (uložený na kazetě či disketě) a po překladu se výsledný nativní kód taktéž uloží na paměťové médium (odkud ho lze spustit). Tyto assemblery byly mnohdy vybaveny více či méně dokonalým systémem maker (odtud název macroassembler). Příkladem takového assembleru pro Atari jsou všechny moderní crossassemblery.

Obrázek 6: Disassembler (zpětný assembler) určený pro mikropočítače Atari (úvodní nastavení).

Mezi nejpoužívanější jazyky populární v dobách osmibitových domácích mikropočítačů patřily zejména výše zmíněné assemblery a taktéž více či méně dokonalé interpretry BASICu. To ovšem neznamená, že by nabídka programovacích jazyků byla takto omezená. Ve skutečnosti bylo na osmibitové mikropočítače portováno velké množství překladačů vyšších programovacích jazyků, zejména jazyků podporujících procedurální paradigma, tj. skládání programů z procedur (subrutin), v nichž se používají strukturované konstrukce pro tvorbu rozeskoků a programových smyček.

Obrázek 7: Disassembler určený pro mikropočítače Atari (výpis disassemblovaného kódu).

Z těchto jazyků byl populární především Pascal, a to díky tomu, že tento jazyk byl navržen takovým způsobem, aby byl překlad programů proveden jednoprůchodově a tudíž velmi rychle v porovnání s víceprůchodovými překladači. Ovšem existovaly i další jazyky, například i populární céčko. Zde je nutné zmínit především známý překladač Aztec C portovaný na velké množství různých typů mikropočítačů, zapomenout nesmíme ani na Deep Blue C pro počítače Atari (zde se autoři museli vyrovnat s faktem, že znaková sada neobsahovala složené závorky, tento jazyk měl ovšem i mnoho dalších omezení). A taktéž se jednalo o jazyky, které vznikly pouze pro jedinou platformu a jinam se nerozšířily. Ve světě osmibitových Atari je takovým jazykem Action!.

3. Atari Assembler Editor

Jedním z nejstarších vývojových nástrojů pro osmibitové mikropočítače Atari je Atari Assembler Editor, jehož vznik se datuje do let 1979 až 1980. Tento nástroj byl používán i pro vývoj samotného operačního systému počítačů Atari. Jak však tento nástroj vůbec vznikl, když ještě vlastně počítače Atari nebyly dokončené? První (zjednodušené) verze byly ručně děrovány na děrnou pásku, která byla použita pro naprogramování čipu EPROM. Ten byl vložen do prototypu Atari a následně otestován. Jednalo se tak o jednu z forem bootstrapingu, kterým jsme ze zabývali v článku Můžeme věřit překladačům? Projekty řešící schéma „důvěřivé důvěry“. Výsledná podoba Atari Assembler Editoru byla dodávána na standardní cartridge o kapacitě osmi kilobajtů (ovšem ve skutečnosti se do značné míry využívaly subrutiny z operačního systému a používané i Atari Basicem).

Obrázek 8: Úvodní obrazovka Atari Assembler Editoru je pojata přísně minimalisticky. Pouze se na ní oznamuje aktuálně vybraný režim, zde konkrétně režim editace.

Atari Assembler Editor se skládal ze tří částí: editoru, assembleru a debuggeru (což však byl ve skutečnosti pouze monitor). Všechny tři části byly dostupné z cartridge a bylo možné se mezi nimi přepínat. Zdrojový kód zapisovaný v editoru byl překládán dvouprůchodovým překladačem a mohl být v operační paměti uložen souběžně se zdrojovým kódem, což ovšem znamenalo omezení maximálního objemu zdrojového kódu. Zajímavé a typické pro interaktivní assemblery je, že řádky zdrojového kódu byly číslovány, podobně jako v BASICu. K dispozici však byly i poměrně pokročilé operace pro vyhledání návěští atd.

Obrázek 9: Přepnutí do režimu debuggeru a výpis obsahu prvních několika bajtů s interpretrem jazyka Basic.

Debugger (spíše monitor) umožňoval zobrazení obsahu operační paměti, zobrazení obsahu registrů mikroprocesoru, modifikaci paměti, zobrazení disassemblované části paměti, krokování programu atd. – ovšem ne tak kvalitně, jako tomu bylo u dále popsaného assembleru MAC/65.

Obrázek 10: Disassembling neboli zobrazení symbolických instrukcí získaných z obsahu strojového kódu.

4. MAC/65

Další programátorský nástroj, s nímž se dnes alespoň ve stručnosti seznámíme, se jmenuje MAC/65. Jedná se o assembler a současně i o debugger, jehož ovládání je odvozeno od výše zmíněného Atari Assembler Editoru; ve skutečnosti je však MAC/65 prakticky po všech stránkách lepší (až na poněkud vyšší cenu). Za vývojem MAC/65 stála společnost Optimized Systems Software (OSS), s níž se setkáme ještě jednou v souvislosti s programovacím jazykem Action! (ovšem OSS vytvořila i překladače jazyků C a Pascalu). MAC/65 byl dodáván na specializované cartridgi s kapacitou 16kB, což je dvojnásobná kapacita, než jakou počítače Atari podporují (konektor měl pouze třináct adresních pinů). Z tohoto důvodu bylo oněch 16kB rozděleno do dvojice paměťových bank, z nichž každá měla kapacitu osmi kilobajtů a mezi kterými se provádělo automatické přepínání (taková cartridge se někdy nazývala „supercartridge“ a existovalo jich více typů, které se lišily způsobem přepínání paměťových bank).

Obrázek 11: Úvodní obrazovka MAC/65 verze 1.02.

Předností assembleru MAC/65 byl mnohem rychlejší překlad v porovnání s Atari Assembler Editorem. Taktéž byla k dispozici lepší forma debuggeru dostupná pod příkazem DDT. Některé základní vlastnosti MAC/65 si ukážeme na sérii screenshotů, v němž vytvoříme velmi jednoduchou programovou smyčku.

Obrázek 12: V režimu EDIT se zapisují jednotlivé deklarace i instrukce procesoru MOS 6502. Řádky s deklaracemi a instrukcemi jsou číslovány, takže přidání, resp. smazání řádku je snadné. Taktéž je možné si vyžádat automatické číslování (což například Atari BASIC neumí). K dispozici jsou i složitější příkazy – obecně je možné říci, že programátorský editor v MAC/65 je propracovanější, než v případě BASICů.

Obrázek 13: Po žádosti o překlad se zobrazí (pokud to ovšem není zakázáno příslušnou deklarací) zapsaný program i s ukázkou strojového kódu. V prvním sloupci jsou adresy, v dalším sloupci pak vlastní strojový kód (operační kódy instrukcí).

Obrázek 14: Příkazem DDT se spustí debugger a současně i monitor. Můžeme zde vidět, že se zobrazuje jak obsah paměti (s instrukcemi strojového kódu), tak i registry mikroprocesoru, obsah příznakového registru a nastavené breakpointy.

Obrázek 15: Do vstupního pole ENTER COMMAND se zapisují příkazy debuggeru.

Obrázek 16: Po opuštění debuggeru příkazem Q je možné pokračovat ve vývoji, například si nechat vypsat uživatelem zapsaný kód příkazem PRINT, zde bez čísel řádků.

5. Atari BASIC

Popis vývojových nástrojů a programovacích jazyků pro osmibitové mikropočítače Atari by samozřejmě nebyl úplný, pokud by nebyl zmíněn vyšší programovací jazyk, 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 17: Programovací jazyk Atari BASIC obsahoval příkazy, pomocí nichž bylo možné nastavovat různé grafické režimy, vykreslovat body (pixely) či úsečky, popř. měnit barvovou paletu. Na tomto obrázku je zobrazen grafický režim číslo 15, v němž se zobrazuje čtyřbarevná bitmapa o rozlišení 160×160 pixelů, pod níž jsou umístěny čtyři textové řádky, které může interpret jazyka BASIC využít stejným způsobem, jako standardní textový režim (číslo 0) – tedy pro svůj interaktivní editor.

Osmibitové mikropočítače Atari byly dodávány s 24 kB paměti ROM, přičemž 16 kB obsadil samotný operační systém počítače (včetně ovladačů základních periferních zařízení) a zbylých 8 kB bylo vyhrazeno pro interpret programovacího jazyka BASIC. Inženýři ze společnosti Atari původně plánovali využít, podobně jako například firma Apple pro její modely Apple ][, programovací jazyk BASIC dodaný firmou Micro-Soft, ovšem tento interpret se nevešel do zbylých 8 kB paměti ROM (někteří lidé poněkud zlomyslně poznamenávají, že Micro-Soft měl již tehdy problém s hardwarovou náročností svých aplikací, což se projevilo právě při portaci interpretru BASICu na procesor MOS 6502, při jehož programování je nutná poměrně podrobná znalost jeho adresových režimů).

Obrázek 18: Ukázka použití grafického režimu číslo 8, v němž se pracovalo s monochromatickou bitmapou o rozlišení 320×160 pixelů a obligátním čtyřřádkovým textovým polem.

Vzhledem k tomu, že rozšíření kapacity paměti ROM by bylo problematické a samozřejmě i poměrně drahé (každý ušetřený dolar se v tomto případě násobil počtem prodaných počítačů) se nakonec firma Atari rozhodla, že bude financovat vývoj vlastního interpretru programovacího jazyka BASIC, přičemž na nový jazyk měla dva základní požadavky – interpret se musí vejít do 8 kB ROM a jazyk by měl obsahovat příkazy, které by alespoň částečně dokázaly využít grafické a zvukové schopnosti počítačů Atari, což je důležité jak z praktického, tak i obchodního hlediska. Atari BASIC, jak se nově vzniklý programovací jazyk jmenoval, se skutečně podařilo uložit do pouhých osmi kilobajtů paměti ROM. Jednalo se sice o relativně pomalý interpret, ovšem jeho vlastnosti byly poměrně zajímavé. Tento dialekt BASICu totiž obsahoval celou řadu rutin umožňujících práci s rozličnými grafickými režimy čipů ANTIC a GTIA; například se jednalo o příkazy COLOR, SETCOLOR, PLOT, DRAWTO, POSITION či LOCATE.

Obrázek 19: Jednoduchý program pro výpočet největšího společného dělitele (NSD, GCD) celých čísel z řady 2..10. V tomto programu jsou mj. využity i některé formátovací možnosti příkazu PRINT, například přechod na další tabulační zarážku (formátovací znak čárka) či zákaz přechodu na další řádek (formátovací znak středník).

Dále Atari BASIC obsahoval příkaz SOUND pro základní ovládání zvukového čipu POKEY (POKEY byl při práci v Atari BASICu nastaven do režimu čtyřkanálového zvukového generátoru, kde byl každému kanálu přiřazen jeden osmibitový čítač). Tento programovací jazyk dále umožňoval práci se skalárními proměnnými, jednorozměrnými poli (vektory) i dvourozměrnými poli (maticemi), v nichž mohla být uložena čísla s pohyblivou řádovou čárkou. Každé číslo bylo reprezentováno šesticí bajtů, jejich rozsah i přesnost tedy ležely zhruba v polovině mezi typy single a double známými z dnešních programovacích jazyků a matematických koprocesorů. Taktéž bylo možné pracovat s jednorozměrnými řetězci (pole řetězců však nebyla přímo v jazyku podporována, většinou se nahrazovala jediným řetězcem a vektorem indexů nebo oddělovacími znaky).

Obrázek 20: Hra naprogramovaná v Atari BASICu s využitím strojových subrutin (Dungeons of Xotha).

Jednou z nevýhod Atari BASICu byla jeho pomalá interpretace a taktéž to, že dokázal pracovat pouze s šestibajtovými reálnými čísly, nikoli například s dvoubajtovými čísly celými, jak tomu bylo v některých jiných dialektech BASICu. Právě kvůli pomalým rutinám pro práci s reálnými čísly (resp. přesněji řečeno s čísly s plovoucí řádovou čárkou) a pomalém vyhledávání cílů skoků se jednalo o jeden z pomalejších interpretrů, zejména při porovnání s konkurenčními platformami.

Obrázek 21: Další screenshot ze hry Dungeons of Xotha.

6. Vybrané vlastnosti Atari BASICu

V Atari BASICu, přesněji řečeno v subrutinách uložených v ROM, které se staraly o výpočty nad reálnými čísly, se používal formát odlišný od prakticky všech formátů používaných na jiných platformách. Stále se sice jednalo o hodnoty s plovoucí řádovou čárkou, ovšem báze nebyla rovna dvěma (většina strojů) ani šestnácti (IBM/360), ale stu! Navíc nebyla mantisa uložená binárně, ale používal se kód BCD, což konkrétně znamená, že v pěti bajtech bylo uloženo přesně deset číslic (procesor 6502 dokázal s BCD pracovat nativně). To na jednu stranu není úplně špatné řešení, protože ho najdeme například na mnoha kalkulačkách. Zjednodušují se převody řetězců na čísla a naopak, na druhou stranu jsou však veškeré výpočty značně pomalejší a přesnost ani rozsah hodnot není tak vysoký, jako při použití binárního kódu. I z tohoto důvodu další dialekty BASICu zaváděly práci s celými čísly.

Příklad výpočtu založeného na práci s reálnými čísly počítačů Atari ukazuje, že i proměnné používané v programových smyčkách FOR-NEXT byly reprezentovány jako reálné číslo:

1 REM VYPOCET KONSTANTY PI
2 REM UPRAVA PRO ATARI BASIC
3 REM
10 N=1
20 FOR I=1 TO 10
25 GOSUB 1000:REM VYPOCET PI
30 PRINT I,N,PI
35 N=N*2
40 NEXT I
999 END
1000 REM
1001 REM SUBRUTINA PRO VYPOCET PI
1002 REM
1010 PI=4
1020 FOR J=3 TO N+2 STEP 2
1030 PI=PI*(J-1)/J*(J+1)/J
1040 NEXT J
1050 RETURN

Zajímavým způsobem je v Atari BASICu realizováno uložení řetězců, což je vedle jednorozměrných a dvourozměrných polí jediná datová struktura (na rozdíl od jediného primitivního typu – čísel s plovoucí řádovou tečkou). V tomto dialektu BASICu je totiž nutné velikost řetězce předem určit příkazem DIM, který současně i provede alokaci bloku v operační paměti pro řetězec. Ve skutečnosti jsou však v operační paměti uloženy dvě struktury, které řetězec plně popisují – jedná se především o sekvenci znaků v kódování ATASCII (odvozeno od ASCII doplněním spodních 32 znaků a změnou několika běžných znaků) a taktéž o strukturu o délce osmi bajtů, která obsahuje typ proměnné (první bajt), index jména proměnné s řetězcem (druhý bajt), adresu začátku řetězce (přesněji řečeno offset), alokovanou délku řetězce (maximálně 32767 znaků) a aktuální délku řetězce (opět maximálně 32767 znaků). To znamená, že i když je například provedena alokace pro řetězec o délce 1000 znaků, může v něm být reálně uloženo jen deset znaků.

Obrázek 22: Po inicializaci interpretru Atari Basicu je k dispozici 37902 volných bajtů. Po alokaci řetězce o délce deseti znaků přijdeme celkem o 20 bajtů – dva bajty zabere název proměnné, osm bajtů struktura popsaná v předchozím odstavci (typ+index proměnné, adresa řetězce, jeho maximální délka a aktuální délka) a zbylých 10 bajtů je vyhrazeno pro vlastní řetězec.

Veškeré operace s řetězci jsou zcela bezpečné, protože nikdy nedojde k překročení jeho délky (přepisu jiné paměti); při spojování řetězců dojde k ukončení na předem stanoveném limitu. Mimochodem: poměrně častým trikem bylo uložení strojových instrukcí do řetězce, zjištění adresy řetězce funkcí ADR a „spuštění řetězce“ další funkcí USR, které se předala adresa řetězce (resp. jeho prvního znaku).

Obrázek 23: Pokud alokujeme další řetězec o maximální kapacitě 100 znaků, přijdeme o 110 bajtů. Opět platí, že „chybějících“ deset bajtů bylo použito pro jméno proměnné, její typ, adresu+délku+maximální délku řetězce.

Vzhledem k tomu, že Atari BASIC neumožňuje ukládat řetězce do polí, bylo možné operátor indexování () „přetížit“ takovým způsobem, že je možné přistupovat jak k jednotlivým znakům řetězce, tak i k podřetězci (jedná se tedy o operaci, kterou dnes nazýváme termínem slicing). Tento operátor je možné použít i na levé straně přiřazovacího příkazu pro změnu vybrané části řetězce, což je velmi užitečný přístup k řetězcům:

10 DIM S$(15),T$(15),Q$(15)      vypíše se
20 S$="ATASIC":PRINT S$          ATASIC
30 Q$=S$(3,5):PRINT Q$           ASI
40 T$="RI_BA":PRINT T$           RI_BA
50 S$(7,13)="T$:PRINT S$         ATASICRI_BA
60 S$=S$(1,6):PRINT S$           ATASIC
70 T$(6,9)=S$(4,6):PRINT T$      RI_BASIC
80 S$(4)=T$:PRINT S$             ATARI_BASIC
90 Q$=S$(1):PRINT Q$             ATARI_BASIC
100 Q$=S$(1,1):PRINT Q$          A

Obrázek 24: Z výpisu adres řetězců je zřejmé, že jsou v paměti uloženy těsně za sebou (první řetězec má délku 10 znaků) a že se nepočítá s žádným ukončovacím znakem.

Obrázek 25: Do řetězce A$ o kapacitě deseti znaků můžeme uložit kratší text a zjistit jeho délku. Při snaze o uložení delšího textu nedojde k žádné chybě a už vůbec ne k přepisu cizí paměti – řetězec se pouze na příslušném místě odřízne.

Obrázek 26: Pokus o alokaci řetězce, který se již nevejde do volné operační paměti samozřejmě skončí s chybou a proměnná nebude vytvořena.

Podívejme se nyní na způsob uložení programového kódu v operační paměti. Ihned po zápisu každého řádku se provádí takzvaná tokenizace, která nahradí jednotlivé konstrukce jazyka osmibitovými kódy. Příkladem může být tokenizace tohoto programového řádku:

10 LET X=1 : PRINT X

V operační paměti tento kód není uložen (pouze v bufferu textového editoru, odtud je však ihned poté přemazán). Namísto toho se uloží sekvence bajtů s následujícím významem:

číslo programového řádku (10)
Sekvence bajtů Stručný popis
A0 00
13 délka celého tokenizovaného řádku (19 bajtů)
0F offset konce prvního příkazu
06 token příkazu LET
80 index proměnné X
2D token operátoru =
0E následuje numerická konstanta
40 01 00 00 00 00 takto vypadá zakódovaná hodnota 1 (na začátku je exponent)
14 konec (prvního) příkazu
13 offset konce druhého příkazu
20 token příkazu PRINT
80 index proměnné X
16 značka EOL pro konec řádku

Před začátkem tokenizovaného kódu se ještě ukládá několik tabulek, především tabulka s proměnnými, tabulka s vektory (adresami) několika dalších paměťových struktur atd. Například následující zdrojový kód:

10 PRINT "X=";
20 INPUT X
30 PRINT "Y=";
40 INPUT Y
50 IF X=Y THEN PRINT "GCD: ";X:END
60 IF X>Y THEN X=X-Y:GOTO 50
70 IF X<Y THEN Y=Y-X:GOTO 50

Se převede do tokenizované a spustitelné (resp. interpretovatelné) podoby takto:

00000000: 00 00 00 01 02 01 03 01 13 01 85 01 96 01 d8 d9  ................
00000010: 00 00 00 40 08 00 00 00 00 00 01 40 08 00 00 00  ...@.......@....
00000020: 00 0a 00 0b 0b 20 0f 02 58 3d 15 16 14 00 07 07  ..... ..X=......
00000030: 02 80 16 1e 00 0b 0b 20 0f 02 59 3d 15 16 28 00  ....... ..Y=..(.
00000040: 07 07 02 81 16 32 00 18 09 07 80 22 81 1b 15 20  .....2....."...
00000050: 0f 05 47 43 44 3a 20 15 80 14 18 15 16 3c 00 1b  ..GCD: ......<..
00000060: 09 07 80 21 81 1b 11 36 80 2d 80 26 81 14 1b 0a  ...!...6.-.&....
00000070: 0e 40 50 00 00 00 00 16 46 00 1b 09 07 80 20 81  .@P.....F..... .
00000080: 1b 11 36 81 2d 81 26 80 14 1b 0a 0e 40 50 00 00  ..6.-.&.....@P..
00000090: 00 00 16 00 80 11 11 19 0f 09 48 3a 47 43 44 2e  ..........H:GCD.
000000a0: 42 49 4e 16                                      BIN.

Velikost souboru s čitelným zdrojovým programem v BASICu je rovna 146 bajtům, zatímco soubor s tokenizovanou formou má v tomto případě délku 164 bajtů.

Poznámka: v některých případech je však tokenizovaná podoba kratší. Ovšem předností tokenizace není v první řadě úspora operační paměti, ale spíše urychlení interpretace a taktéž urychlení nahrávání programů z kazety nebo diskety (ostatně i z tohoto důvodu se při načítání zdrojových kódů příkazem ENTER používají delší odmlky mezi bloky, než při nahrávání tokenizovaného kódu příkazem CLOAD).

Obrázek 27: Jednou z her naprogramovaných v Atari BASICu je simulátor jaderné elektrárny SCRAM. Viz též Historie vývoje počítačových her: simulace a strategické hry naprogramované Chrisem Crawfordem

7. Slavný Turbo-BASIC XL

Rychlost interpretru programovacího jazyka Atari BASIC záhy přestala mnoha programátorům a samozřejmě i uživatelům dostačovat. Někteří z vývojářů se namísto BASICu naučili využívat assembler mikroprocesoru MOS 6502, ovšem jiní by uvítali „pouze“ rychlejší variantu BASICu, ideálně ještě doplněnou o některé chybějící příkazy. Kromě poměrně neúspěšného Microsoft BASICu se záhy rozšířil překladač BASICu do strojového kódu (který byl ovšem v praxi použitelný především pro překlad již odladěných programů, nikoli pro samotný vývoj) a především Turbo BASIC, jehož autorem je známý Frank Ostrowski (tento programátor později vytvořil GFA BASIC pro osobní počítače Atari ST). Turbo BASIC téměř splňoval všechny sny BASICových programátorů – byl rychlejší než původní Atari BASIC, byl s Atari BASICem plně kompatibilní, díky programovému „odklápění“ ROM nabízel vývojářům prakticky stejné nebo i větší množství volné operační paměti (což působilo téměř magicky) a navíc Turbo BASIC obsahoval poměrně velké množství nových příkazů, ať již určených pro strukturované programování (nové typy programových smyček), tak i příkazy zjednodušující programátorovu každodenní činnost.

Poznámka: dostupný byl taktéž překladač Turbo BASICu, o němž se zmíníme příště.

Obrázek 28: Úvodní obrazovka Turbo-BASICu XL.

Poznámka: ve skutečnosti pro počítače Atari vznikla celá řada dalších dialektů BASICu, například BASIC A+ (od stejných autorů, jako původní Atari BASIC), BASIC XL (velmi úspěšný), BASIC XE (málo rozšířený), Advanced BASIC, Microsoft BASIC a moderní dialekty Altirra BASIC a Fast BASIC.

Obrázek 29: Program pro vykreslení Mandelbrotovy množiny naprogramovaný v Atari BASICu, ovšem beze změn použitelný i v Turbo BASICu.

Novými „grafickými“ příkazy byly například CIRCLE či TEXT (vykreslení textu do bitmapy), k příkazu SOUND přibyl příkaz DSOUND (práce se šestnáctibitovými čítači čipu POKEY namísto čítačů osmibitových), dvojice příkazů POKE a PEEK pracujících s hodnotami uloženými v jedné (osmibitové) paměťové buňce byla doplněna o šestnáctibitové varianty DPOKE a DPEEK, což programátorům ušetřilo opakované použití výrazů typu PEEK(88)+256*PEEK(89) atd. Originální Turbo BASIC byl různým způsobem upravován a rozšiřován. Mezi tuzemské úpravy patří především zabudování ovladače Turba 2000, takže se práce s kazetovým magnetofonem v mnohém vylepšila (LOAD „T:POKUS.BAS“ namísto primitivního CLOAD atd.) a taktéž zabudování ovladače tiskárny BT-100 – kromě nové funkce příkazů LLIST, LPRINT atd. bylo dokonce možné vyvolat hardcopy obrazovky, tj. tisk aktuálního obsahu obrazovky a to i tehdy, pokud byl použit nějaký nestandardní grafický režim.

Obrázek 30: Výsledek běhu programu, jehož listing je zobrazený na patnáctém obrázku. Doba výpočtu Mandelbrotovy množiny dosahuje několika hodin v případě použití Atari BASICu a cca jednu hodinu při použití Turbo BASICu.

Turbo BASIC převzal z Atari BASICu i mnohé nedokonalosti. Jedna z nich se týká automatického rozpoznávání příkazů – klasické BASICy totiž vždy musely za číslem řádku používat příkaz, což například znamenalo, že přiřazení muselo začínat slovem LET. Atari BASIC již explicitní LET nevyžaduje (přidává si totiž vlastní LET s odlišným tokenem), ovšem v případě, že jméno proměnné začíná stejně jako příkaz, nebude tento koncept pracovat korektně.

Podívejme se na následující příklad, kde se snažíme přiřadit hodnoty do dvou proměnných nazvaných ED a PRINTED:

1 REM JMENO PROMENNE ZACINAJICI NA PRINT
2 REM UPRAVA PRO ATARI BASIC
3 REM
10 ED=42
20 PRINTED=0
30 PRINTED=42

Atari BASIC ovšem tento program pochopí jinak – jako snahu o výpis, zda je hodnota proměnné ED rovna nule či 42:

1 REM JMENO PROMENNE ZACINAJICI NA PRINT
2 REM UPRAVA PRO ATARI BASIC
3 REM
10 ED=42
20 PRINT ED=0
30 PRINT ED=42

V Turbo BASICu je problém ještě větší, protože tento jazyk obsahuje více klíčových slov. Další příklad je tedy zcela korektní v Atari BASICu, ovšem nikoli v Turbo BASICu, protože DO je v tomto jazyce klíčové slovo:

1 REM JMENO PROMENNE ZACINAJICI NA DO
2 REM UPRAVA PRO TURBO BASIC
3 REM
10 DONE=1
20 DONE=0
Poznámka: jedná se o jednu z mála nekompatibilit mezi oběma popisovanými programovacími jazyky.

8. Strukturované programování v Turbo-BASICu

Turbo-BASIC obsahuje některé konstrukce, které se přibližují klasickému strukturovanému programování. Konkrétně to znamená to, že jsou podporovány procedury (pojmenované podprogramy), strukturovaná konstrukce IF-ELSE-ENDIF a programové smyčky FOR-NEXT, DO-LOOP, WHILE-WEND a REPEAT-UNTIL. Interpret Turbo BASICu dokáže tyto konstrukce automaticky vypsat s odsazením, které v tokenizovaném kódu nezabírá žádné místo (tudíž zde neexistují nekonečné diskuse o tom, jak má odsazení vypadat, o kolik znaků se odsazuje a zda používat TAB nebo mezery). Použití těchto konstrukcí si ukážeme na několika demonstračních příkladech.

Výpočet faktoriálu v Atari BASICu, v němž se podprogramy realizují pomocí GOSUB a RETURN:

1 REM VYPOCET FAKTORIALU
2 REM UPRAVA PRO ATARI BASIC
3 REM
10 FOR N=0 TO 20
11 GOSUB 100
12 PRINT N,FACT
13 NEXT N
99 END
100 REM VYPOCET FAKTORIALU
101 FACT=1
102 FOR I=N TO 1 STEP -1
103 FACT=FACT*I
104 NEXT I
105 RETURN

Přepis do Turbo BASICu využívajícího pojmenované procedury – klíčová slova PROC a ENDPROC:

1 REM VYPOCET FAKTORIALU
2 REM UPRAVA PRO TURBO-BASIC XL
3 REM
4 ------------------------------
10 FOR N=0 TO 20
11   EXEC FACTORIAL
12   PRINT N,FACT
13 NEXT N
99 END
100 ------------------------------
101 REM VYPOCET FAKTORIALU
102 PROC FACTORIAL
103   FACT=1
104   FOR I=N TO 1 STEP -1
105     FACT=FACT*I
106   NEXT I
107 ENDPROC

Výpočet největšího společného dělitele s několika příkazy GOTO:

1 REM VYPOCET NEJVETSIHO SPOLECNEHO DELITELE
2 REM REALIZACE V ATARI BASICU
3 REM
10 PRINT "X=";
20 INPUT X
30 PRINT "Y=";
40 INPUT Y
50 IF X=Y THEN PRINT "GCD: ";X:END
60 IF X>Y THEN X=X-Y:GOTO 50
70 IF X<Y THEN Y=Y-X:GOTO 50

Realizace s využitím WHILE-WEND a strukturovaných podmínek:

1 REM VYPOCET NEJVETSIHO SPOLECNEHO DELITELE
2 REM IMPLEMENTACE PRO TURBO-BASIC XL
3 REM
4 ------------------------------
10 PRINT "X=";
20 INPUT X
30 PRINT "Y=";
40 INPUT Y
50 WHILE X<>Y
60   IF X>Y
61     X=X-Y
63   ENDIF
70   IF X<Y
71     Y=Y-X
73   ENDIF
80 WEND
90 PRINT "GCD: ";X
91 END

Využití programové smyčky typu REPEAT-UNTIL s podmínkou na konci:

1 REM TEST PRESNOSTI VYPOCTU FP
2 REM REALIZACE PRO TURBO-BASIC XL
3 REM
4 ------------------------------
10 H1=0
11 H2=0
12 N=1
20 REPEAT
21   H1=H2
22   H2=H1+1/N
23   PRINT N;" ";H1;" ";H2
24   N=N+1
30 UNTIL H1=H2

Využití programové smyčky typu REPEAT-UNTIL s podmínkou na konci i klasické smyčky FOR-NEXT:

1 REM CIRCLE MOIRE
2 REM UPRAVA PRO ATARI BASIC
3 REM GRAFICKY REZIM 9
4 ------------------------------
10 GRAPHICS 9
20 FOR Y=0 TO 191
30   FOR X=0 TO 79
40     C=INT(X*X/10+Y*Y/40)
50     COLOR C MOD 16
60     PLOT X,Y
70   NEXT X
80 NEXT Y
998 REM CEKANI NA STISK TLACITKA JOYSTICKU
999 REPEAT :UNTIL STRIG(0)=0
1000 END

9. Pomůcky při vývoji a ladění programů v Turbo-BASICu

Při ladění programů v Turbo-BASICu lze využít několik užitečných příkazů. Především se jedná o příkaz TRACE, jenž po spuštění programu začne vypisovat čísla řádků, které se právě spouští. Dále musíme zmínit příkaz DUMP určený pro výpis všech proměnných, samozřejmě včetně jejich hodnoty. Výpis lze provést i na vybrané zařízení, například na tiskárnu, disketovou jednotku, RAMdisk atd. S čísly řádků tak typickými právě pro klasické BASICy souvisí i příkazy pro jejich manipulaci. Jedná se o příkaz DEL pro smazání vybraných řádků, resp. rozsahu hodnot a dále o příkaz RENUM pro přečíslování určitého bloku. Pro získání informace o poslední chybě (tu lze odchytit pomocí TRAP) slouží pseudoproměnné ERR (číslo chyby) a ERL (číslo programového řádku). A konečně – při vzniku chyby se nevypíše pouze její číslo (kód), ale i krátký popisek chyby.

10. Atari LOGO

Většina programovacích jazyků byla vytvořena buď pro potřeby praktického programování nebo pro výuku programování. Programovací jazyk Logo, o němž se v dnešním článku taktéž v krátkosti zmíníme, je v tomto smyslu poněkud odlišný jazyk, protože programování zde není cílem ale pouze nástrojem, který má pomoci při vzdělávání. Logo stojí na základech daných takzvanou konstruktivní vzdělávací filozofií a je navrženo k podpoře konstruktivního učení. Konstruktivismus vysvětluje znalosti a dovednosti, jak jsou vytvořeny žáky v jejich vlastních myslích, prostřednictvím vzájemné interakce s jinými lidmi a okolím. Tato zajímavá teorie je spojena především se švýcarským psychologem Jeanem Piagetem, který strávil mnoho času studováním a zdokumentováním učení malých dětí. S Piagetem v Ženevě spolupracoval i Seymour Papert, který později stál u vzniku Loga jakožto poněkud svébytného programovacího jazyka.

logo0101

Obrázek 31: Pohled na klasické Logo – grafická plocha a příkazový řádek.

První testovací implementace programovacího jazyka Logo se jmenovala „ghost“ a byla vytvořena na slavné MIT společně s firmou BBN (Bolt, Beranek and Newman Inc.) v programovacím jazyce LISP na počítači PDP-1. U zárodku této prvotní implementace, která vznikla už v roce 1967, stál i Seymour Papert, který však jazyk neprogramoval (programátoři, kteří Logo implementovali, se jmenovali Daniel Bobrow a Wallace Feurzeig), ale pracoval jako odborný konzultant. Tato implementace Loga se po nezbytných úpravách postupně rozšířila i mimo MIT, například na univerzitu v Edinburgu. Jméno Logo se objevuje až později s implementací od Wallace Feurzeiga (opět) a Paula Wexelblata, ve které se poprvé objevuje známá želva (turtle), a to dokonce v mechanické podobě a ovládaná radiem (tento robotek se jmenoval Irving).

logo0102

Obrázek 32: Mechanická želva vytvořená z LEGA a ovládaná programem napsaným v Logu.

Větší rozšíření Loga nastalo až s nástupem osmibitových domácích počítačů. V Evropě jsou známé především značky Sinclair, Atari a Commodore, ale v USA, kde se Logo začalo těšit prakticky masové oblibě, se ještě před těmito značkami rozšířily především osmibitové domácí počítače Apple II (zejména model Apple IIe), které obsahovaly mikroprocesor MOS 6502 (později MOS 6502C) taktovaný na 1MHz. U Apple II bylo možné v grafickém režimu s vysokým rozlišením zobrazovat bitmapy o rozměrech 280×192 pixelů ve čtyřech, popř. v šesti barvách. Takové grafické schopnosti již dostačují k práci želví grafiky, na které je Logo částečně postaveno. Ve stejně době bylo Logo také portováno na počítače Texas Instruments TI 99/4.

logo0106

Obrázek 33: Schématický květ nakreslený pomocí Loga.

Pravděpodobně nejúspěšnější implementace Loga pro počítače Apple II pochází od firmy LCSI (Logo Computer Systems, Inc.), která v roce 1980 vytvořila Apple Logo. Tato implementace se stala základem i pro verze určené pro novou generaci domácích počítačů – Atari Logo, Commodore Logo (jedna verze Commodore Loga byla postavena nad Terrapin Logem), atd. O tom, jak bylo Apple Logo úspěšné, svědčí i to, že některé moderní komerční implementace Loga ve svých manuálech uvádí převodní tabulku mezi příkazy Apple Loga a jeho moderním protějškem. V kontextu dnešního článku se pochopitelně zaměříme především na Atari Logo, jehož některé unikátní vlastnosti jsou popsány v navazující kapitole.

logo0110

Obrázek 34: Vzor vytvořený v Logu za pomoci želví grafiky.

11. Unikátní vlastnosti Atari Loga

„Atari Logo is one of the most intelligently-conceived and well-executed pieces of software ever published by ATARI."“

Atari LOGO bylo vyvinuto na základě LCSI Loga, ovšem došlo k několika úpravám, které umožnily do větší míry využít některá specifika osmibitových mikropočítačů Atari. Především byly přidány příkazy pro přehrávání melodií. Konkrétně se jedná o příkaz TOOT, jenž dokáže přehrát notu o zvolené frekvenci, hlasitosti a délce trvání – to je podstatný rozdíl oproti příkazu SOUND v BASICech. Přidány byly taktéž příkazy pro čtení hodnot paddle (tedy analogových ovladačů).

Obrázek 35: Úvodní obrazovka Atari LOGA.

Největší změny se týkají samotné želvy. Kromě jedné želvy (standardní Logo) je totiž možné použít až čtyři želvy (každou s jinou barvou), které lze ovládat buď samostatně nebo je možné stejné příkazy nechat vykonat více želvami. Samotné želvy jsou realizovány sprity, což tvůrcům Atari LOGA umožnilo i další triky – například existují příkazy pro změnu tvaru želvy, příkazy pro zjištění, zda se želva dotkla nějakého nakresleného obrazce (popř. jakou barvu tento obrazec měl) a zjistit lze i kolize dvou želv. Samotný svět, v nichž se želvy pohybují, může být nekonečný, nebo se jeho protilehlé okraje mohou dotýkat tak, jak je to implementováno například ve hře Asteroids.

Obrázek 36: Zobrazení kreslicí plochy a želvy příkazem HOME.

Implicitní zobrazení grafické plochy, po které se želvy pohybují, je realizováno grafickým režimem 7, tj. lze kreslit třemi barvami a používá se rozlišení 160×192 pixelů.

Obrázek 37: Kreslení s použitím dvojice želv.

Obrázek 38: Kreslení pomocí čtyř želv.

Obrázek 39: Všechny čtyři želvy vykonávají stejné příkazy.

12. Interlisp/65 (INTER-LISP/65)

Pro domácí osmibitové mikropočítače Atari vznikl i interpret programovacího jazyka LISP nazvaný Interlisp/65, ovšem označovaný taktéž jako INTER-LISP/65. Jedná se o variantu na (kdysi) slavný jazyk Interlisp, s nímž jsme se již ostatně na stránkách Rootu nedávno setkali v článku Interlisp aneb oživujeme dinosaura. Další odstavce tedy budou uvedeny pouze pro připomenutí.

Obrázek 40: Interpret Interlispu/65.

Jeden z populárních dialektů programovacího jazyka Lisp se jmenoval MacLisp. Ten byl používán ve slavných AI Lab na MITu od konce šedesátých let minulého století až do začátku osmdesátých let, byl po dlouhou dobu považován za neoficiální standard Lispu, tedy za jakousi „referenční implementaci“ (což je dnes zcela běžné – ostatně mnoho moderních programovacích jazyků staví právě na referenční implementaci a nikoli na rigidní specifikaci). MacLisp byl rozšířen na poměrně mnoho platforem, například na PDP-6 a PDP-10, Honeywell 6180, běžel na Multicsu (ten ukázal slepou uličku, kterou se NEvydal pozdější UNIX) atd. Samotný MacLisp se pochopitelně postupně vyvíjel a zajímavé je, že byl použit pro vývoj a implementaci dalších variant programovacích jazyků, mezi jinými i jazyka Scheme. Dále není bez zajímavosti, že první varianta Emacsu založená na Lispu, používala právě MacLisp pro systém Multics (v IT je prostě vše propojeno).

Obrázek 41: Ukázka komunikace s interpretrem Interlispu/65.

Interlisp, jakožto ideový pokračovatel MacLispu, znamenal v době svého vzniku poměrně zásadní změnu v tom, jak byl jazyk a celé jeho interaktivní prostředí navržen. Původní Lispy totiž do značné míry vypadaly tak, jako například dnešní GNU Guile – všechny formy musely být zapsány jako s-výrazy, přičemž se netolerovaly žádné chyby, závorky musely být balancovány atd. Interlisp byl dosti odlišný. Zejména byly rozšířeny možnosti nástrojů dodávaných společně s tímto jazykem – přidán byl například v té době přelomový korektor překlepů, přidány byly balíčky pro práci se soubory, balíček CLISP umožňující zápis algebraických výrazů, programátorský editor pro strukturovaný kód atd. Za většinou nových myšlenek implementovaných v Interlispu stál Warren Teitelman, který napsal svoji disertaci na téma symbiózy mezi člověkem a počítačem. A povšimněte si, že všechny novinky implementované v Interlispu a zmíněné výše se soustředí právě na rozhraní mezi počítačem a uživatelem (resp. programátorem) a nikoli například na nové jazykové konstrukce.

Obrázek 42: Ukázka použití funkce POKE v Interlispu/65.

Příkladem může být korektor překlepů realizovaný balíčkem pojmenovaným DWIM neboli „Do What I Mean“. Pokud se ve formě zapsané uživatelem nacházel neznámý symbol, mohl být balíček DWIM automaticky vyvolán, aby našel správný symbol ze seznamu již definovaných symbolů a nabídl uživateli opravu, korigoval chybu automaticky nebo vypsal chybové hlášení, jak je to dodnes běžné.

Obrázek 43: Pokud se nebudou používat grafické režimy, zůstane Interlispu/65 více operační paměti pro uložení programu a jeho dat.

13. Specifika Interlispu/65

Interlisp/65 byl vydán společností DataSoft v kooperaci s nám již známou firmou Special Software Systems již v roce 1981, což znamená, že vznikl jeden z prvních „alternativních“ jazyků, které vůbec pro osmibitové mikropočítače Atari byly vydány. V mnoha ohledech se jedná o zcela standadní interpret programovacího jazyka LISP, ovšem s tím, že je v některých případech vyžadováno explicitní zavolání správce paměti, a to konkrétně funkcí MEM. Interlisp/65 byl upraven tak, aby do značné míry umožňoval využití grafických a dalších možností počítačů Atari, takže vznikly funkce, které mají obdobu v příkazech BASICu. Jednalo se o funkce pro operaci s pamětí POKE, PEEK a XIO, čtení joysticků (STICK, STRIG), práce se zvukem (SOUND) a práce s grafikou GR, COL, SETCOL, PLOT, DRAW a XIO. Taktéž bylo možné použít I/O operace operačního systému OPEN, CLOSE, PR#, IN# atd. Navíc bylo podporováno ladění funkcemi BREAK a BACKTRACE. Při aritmetických výpočtech se používaly rutiny operačního systému – stejně pomalé, jako v případě Atari BASICu.

Obrázek 44: Manipulace s takzvanými tečka-dvojicemi a se seznamy.

V následující tabulce jsou vypsány všechny funkce, které bylo možné v interpretru Intelispu/65 použít:

AND APPEND APPLY ASSOC
ATOM BACKTRACE BREAK CAR
CDR CLOSE COL COND
CONS DEFINE DEFINEQ DIR
DRAW EQ EVAL EXP
GET GO GR IN#
INT LAMBDA LAST LENGTH
LIST LOAD LOG MACRO
MEM MEMBER NEW NIL
NLAMBDA NOTE NSUBR OBLIST
OPEN OR PACK PAGE
PEEK PLOT POINT POKE
PR# PRIN1 PRIN2 PRINT
PROG PROGN QUOTE READ
READA READC RESET RETURN
RPLACA RPLACD SAVE SET
SETCOL SETQ SOUND STICK
STRIG SUB SUBR T
TAB TERPRI UNPACK XIO
Poznámka: povšimněte si zajímavého „mixu“ funkcí známých z Atari BASICu (POKE, PEEK, DRAW) i z klasických LISPů (NIL, T, LAMBDA, PRIN1).

Obrázek 45: Základní (standardní) funkce pro práci se seznamy.

14. Programovací jazyk Action!

Velmi zajímavým vyšším programovacím jazykem, který byl optimalizován pro použití na osmibitových mikropočítačích, byl jazyk nazvaný Action!. Tento jazyk byl určen pro osmibitové mikropočítače Atari a od ostatních (obecnějších) jazyků se odlišoval zejména tím, že jeho možnosti odrážely schopnosti těchto mikropočítačů (datové typy omezeny na bajt, 16bitový integer se znaménkem a bez znaménka atd.). Syntaxe jazyka Action! je odvozena od Algolu (resp. od Algolské větve jazyků, kam spadá i Pascal), což se týká zejména způsobu zápisu programových smyček a podmínek (IF-FI, DO-OD). Action! podporoval strukturované programování, uživatelé mohli vytvářet lokální proměnné, ovšem ne na zásobníku, jehož velikost i možnosti adresování byly na MOS 6502 omezeny. Zajímavě bylo vyřešeno rozhraní jazyka Action!, protože uživatelé měli k dispozici plnohodnotný textový editor, jednoprůchodový (a tedy rychlý) překladač a monitor, v němž bylo možné provádět i ladění vyvíjené aplikace. Zdrojový text mohl být neustále uložen v operační paměti současně s přeloženou (nativní) aplikací, což bylo umožněno tím, že samotný Action! byl umístěn na přídavném paměťovém modulu (cartridge).

Obrázek 46: Zdrojový kód části programu napsaného v jazyce Action!

V následující tabulce jsou vypsána všechna klíčová slova jazyky Action!:

AND FI OR UNTIL
ARRAY FOR POINTER WHILE
BYTE FUNC PROC XOR
CARD IF RETURN  
CHAR INCLUDE RSH  
DEFINE INT SET  
DO LSH STEP  
ELSE MOD THEN  
ELSEIF MODULE TO  
EXIT OD TYPE  
Poznámka: povšimněte si, že se tvůrci tohoto jazyka pravděpodobně skutečně nechali inspirovat Algolem 68, protože v obou těchto jazycích nalezneme stejné „příkazové závorky“, konkrétně dvojici IF-FI, DO-OD atd.

Obrázek 47: Minimalisticky pojaté prostředí jazyka Action.

15. Datové typy v jazyku Action!

Programovací jazyk Action! podporuje tři základní (primitivní) datové typy pojmenované BYTE, INT a CARD. BYTE představuje osmibitovou hodnotu typu bajt (bez znaménka), INT je šestnáctibitová hodnota se znaménkem a CARD je taktéž šestnáctibitová hodnota, ovšem bez znaménka. Příklad deklarace a popř. i inicializace proměnných těchto typů:

BYTE x,y,z
INT num=[0]    <- inicializace
BYTE x=$8000   <- ulozeni na adresu
Poznámka: převody mezi různými typy jsou prováděny automaticky podle klíče BYTE → INT → CARD.

Obrázek 48: DOS dodávaný společně s jazykem Action!

Kromě toho lze používat i šestnáctibitové ukazatele, podobně, jako je tomu v jazyku C:

BYTE POINTER ptr
CARD POINTER ptr2

Podporována jsou i pole, přičemž inicializaci prvků polí (libovolného typu) lze provést přes řetězcový literál:

BYTE ARRAY pole
INT ARRAY x(10)
BYTE ARRAY str = "This is a string constant"

Aby toho nebylo málo, je možné deklarovat i vlastní struktury (záznamy), opět podobně jako v jazyku C:

TYPE r=[BYTE b1, b2
        INT i1]
Poznámka: je až s podivem, že i tento „malý“ jazyk má větší vyjadřovací schopnosti, než mnohé konkurenční vyšší programovací jazyky.

Obrázek 49: Jednoduchý program s procedurou INIT, která odpovídá céčkovskému main.

16. Programové konstrukce v jazyku Action!

Programovací jazyk Action! podporuje strukturované programování a má v tomto ohledu zhruba stejné vyjadřovací schopnosti, jako již zmíněný jazyk C či Pascal. Ostatně podívejme se na několik ukázek dostupných programových konstrukcí (včetně odsazení, které je taktéž podporováno).

Implementace podmínky:

IF podmínka THEN
    příkazy
    příkazy
    příkazy
FI

Plné rozvětvení:

IF podmínka THEN
    příkazy
    příkazy
    příkazy
ELSE
    příkazy
    příkazy
    příkazy
FI

Vícenásobné rozvětvení podle většího množství podmínek:

IF podmínka THEN
    příkazy
    příkazy
    příkazy
ELSEIF podmínka THEN
    příkazy
    příkazy
    příkazy
ELSE
    příkazy
    příkazy
    příkazy
FI

Obrázek 50: Přepnutí do příkazového režimu.

Nekonečná smyčka:

DO
    příkazy
    příkazy
    příkazy
OD

Nekonečná smyčka s výskokem uprostřed těla smyčky:

DO
    příkazy
    příkazy
    IF podmínka THEN
        EXIT
    FI
    příkazy
OD

Obrázek 51: Spuštění demonstračního příkladu po jeho překladu.

Programová smyčka typu FOR:

FOR proměnná=start TO end
DO
    příkazy
    příkazy
    příkazy
OD

Alternativní forma se specifikací kroku:

FOR proměnná=start TO end STEP step
DO
    příkazy
    příkazy
    příkazy
OD

Obrázek 52: Složitější program ukazující grafické schopnosti jazyku Action!

Programová smyčka typu WHILE:

WHILE podmínka
DO
    příkazy
    příkazy
    příkazy
OD

Programová smyčka typu REPEAT-UNTIL:

DO
    příkazy
    příkazy
    příkazy
    UNTIL podmínka
OD

Obrázek 53: Překlad příkladu do strojového kódu.

Deklarace procedury:

PROC název_procedury(parametry)
    příkazy
    příkazy
    příkazy
RETURN

Deklarace funkce:

type FUNC název_funkce(parametry)
    příkazy
    příkazy
    příkazy
RERUN výraz

Textová makra:

DEFINE size="256" makro
DEFINE begin = "DO", end = "OD"

Obrázek 54: Výsledek běhu předchozího příkladu.

17. FIG-Forth

If you're a frequent calculator user, you owe it to yourself to investigate the advantages of RPN. RPN stands for Reverse Polish Notation. Reverse Polish Notation was developed in 1920 by Jan Lukasiewicz as a way to write a mathematical expression without using parentheses and brackets. Hewlett-Packard Co., realizing that Lukasiewicz's method was superior to standard algebraic expressions when using calculators and computers, adapted RPN for its first hand-held scientific calculator, the HP35, in 1972.
Hewlett-Packard Development Company The RPN Method: An Overview and History

Dostáváme se k jazyku Forth (resp. jeho dialektu FIG-Forth), což je jazyk, který byl – alespoň podle mého názoru – pravděpodobně nejlepším a nejvíce vyhovujícím jazykem pro „malé“ osmibitové domácí mikropočítače vůbec – a to, že se více neprosadil, byla možná škoda.

Programovacímu jazyku Forth jsme se již na stránkách Rootu kdysi věnovali v samostatném seriálu. Tento jazyk, který je založený na konceptu dvou zásobníků (jeden je používaný pro operandy a druhý pro uložení návratových adres volajících funkcí), je známý mj. i tím, že jeho implementaci lze v nejjednodušší variantě provést v několika stovkách bajtů paměti, tj. přibližně s 300 až 500 strojovými instrukcemi a navíc se některé dialekty Forthu provozovaly bez použití operačního systému (Forthovské jazyky byly součástí i několika BIOSů). V takto malém počtu instrukcí bude složité uložit jakákoli nebezpečná zadní vrátka. Na druhou stranu je nutné poznamenat, že Forth tvoří svůj velmi zajímavý, ale dosti izolovaný svět, takže v něm pravděpodobně nikdy nevznikne překladač C ani dalšího vyššího programovacího jazyka (typicky se ovšem Forth spojuje s assemblerem, což je ostatně i logičtější).

Obrázek 55: Ze všech dnes popisovaných nástrojů má pouze FIG-Forth vlastní znakovou sadu.

V roce 1976 byla firma FORTH Inc. (jejím zakladatelem byl kdo jiný než Chuck Moore) požádána, aby Forth portovala na mikroprocesor CDP-1802 (mimochodem, tento procesor, určený pro vojenské a kosmické aplikace, měl velmi zajímavý instrukční soubor – viz například stránku Great Microprocessors of the Past and Present, popř. článek RCA 1802: poslední mohykán osmibitové éry mikroprocesorů). Nový produkt byl nazván microFORTH a v dalších letech byl portován na celou skupinu vzájemně odlišných mikroprocesorů, zejména Intel 8080, Motorola 6800, MOS 6502 a Zilog Z80. Systém microFORTH byl s úspěchem použit pro vytváření průmyslových a řídících aplikací, které využívaly právě tyto osmibitové mikroprocesory. Mnohé tyto systémy prý pracují až do dnešní doby (tomu ostatně po zhlédnutí historických sdělovacích a zabezpečovacích zařízení v–některých našich [polo]státních podnicích ochotně věřím – on také nebývá důvod měnit fungující zařízení).

Obrázek 56: Základní operace se zásobníkem operandů.

Všechny výše zmíněné mikroprocesory jsou osmibitové a v průmyslových aplikacích byly osazeny operační pamětí o typické kapacitě 16 kB. Tyto aplikace byly spouštěny většinou z pamětí EPROM nebo PROM, protože disky se používaly pouze v minipočítačích. Ostatní firmy pro tyto mikroprocesory dodávaly buď pouze assembler, nebo jazyk PL/M (raději na něj zapomeňte), ostatní jazyky byly buď příliš náročné na systémové prostředky (C, Pascal), nebo nevhodné pro programování složitějších aplikací (Basic). V této „konkurenci“ je jasné, že se Forth velmi dobře prosazoval, zejména jako náhrada assembleru.

Programovací jazyk Forth byl použit i na osmibitových domácích počítačích. Zde se významně projevila schopnost Forthu generovat krátký kód, který bylo možné zpracovat velmi jednoduchým interpreterem. Ten byl dlouhý pouze několik strojových instrukcí. Jednou z prvních aplikací Forthu v oblasti osmibitových počítačů byly některé systémové rutiny uložené v paměti ROM počítače ZX-81. Jednalo se o operace s hodnotami uloženými v pohyblivé řádové čárce. Pomocí Forthu byl vytvořen velmi krátký kód hojně používající smyčky a iterace. Běh rutin byl díky tomu pomalý, proto byl v dalších počítačích firmy Sinclair Research použit kód psaný přímo v assembleru, který však byl delší.

Obrázek 57: Operace se zásobníkem operandů – SWAP, ROT a OVER.

Osmibitové počítače ještě v době svého největšího rozmachu zažily vznik oblíbeného FIG Forthu (byl odvozen od Forthu-78 a výše zmíněného microFORTHu), jehož autoři si kladli za cíl vytvořit standard mezi různými dialekty Forthu i mezi různými mikroprocesorovými architekturami (například pro Intel 8080). A právě FIG-Forthem se budeme ve stručnosti zabývat v této kapitole. FIG Forth byl portován i na mikroprocesory MOS 6502, takže další přenos na počítače Atari (ale i na BBC Micro, či Commodore C64) byl relativně snadnou záležitostí. FIG Forth byl na Atari vybaven editorem jednotlivých obrazovek (screen), který se ovládal podobně jako Vi či spíše Ed: zadávalo se vždy číslo řádku a operace, která se má provést. Podporována byla všechna slova (v jiných programovacích jazycích funkce) FIG Forthu a díky možnosti přímého přístupu do paměti bylo možné manipulovat s čipy ANTIC, GTIA i POKEY a využít tak i multimediálních možností počítačů Atari. Ostatně prakticky celý manuál FIG Forthu se skládá z popisu jednotlivých slov.

Tip do clanku - special Computerworld

Poznámka: zajímavé je, že FIG Forth dokázal využít myš z Atari ST připojenou k osmibitovému Atari přes druhý joystickový port.

18. Co zbývá?

Mohlo by se zdát, že téma dnešního článku bylo kompletně vyčerpáno, ovšem ve skutečnosti to není v žádném případě pravda, protože i pro „malé“ domácí mikropočítače Atari vznikly i mnohé další programovací jazyky. Jedná se například o poměrně populární interpretry BASICu nazvané BASIC XL a BASIC XE, dále o některé cross assemblery, překladač jazyka Pascal, překladač jazyka C a dokonce jsou k dispozici i některé jazyky používající moderní výdobytky typu JIT překladače. Takovým jazykem je například FastBASIC.

19. Repositář s demonstračními příklady

Na GitHubu nalezneme – pochopitelně vedle zdrojových kódů psaných v moderních programovacích jazycích – mnohdy i vyložené obskurnosti, takže pravděpodobně nebude na škodu zveřejnit několik kódů naprogramovaných v Atari BASICu a taktéž v Turbo-BASICu XL. Vzhledem k odlišnostem mezi ASCII a ATASCII (tedy znakovou sadou používanou v osmibitových mikropočítačích Atari) byly zdrojové kódy převedeny do čitelné podoby, což prakticky znamená, že došlo k převodu znaku pro konec řádku a k dalším nepatrným úpravám (některé emulátory dokážou načíst i takto upravené soubory s využitím zařízení H5):

# Jméno souboru Stručný popis souboru Cesta
1 1d_array.bas práce s jednorozměrnými poli v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/1d_array.bas
2 2d_array.bas práce s dvourozměrnými poli v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/2d_array.bas
3 bubble_sort.bas algoritmus bublinkového třídění prvků v poli v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/bubble_sort.bas
4 factorial.bas výpočet faktoriálu v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/factorial.bas
5 function1.bas vykreslení průběhu nespojité funkce https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/function1.bas
6 function2.bas vykreslení průběhu funkce https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/function2.bas
7 game.bas jednoduchá hra naprogramovaná na dvou řádcích https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/game.bas
8 GCD.bas výpočet největšího společného dělitele v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BASIC/GCD.bas
9 harmonic.bas zjištění limitů FP hodnot https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/harmonic.bas
10 moire1.bas moaré v grafickém režimu 7 https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/moire1.bas
11 moire2.bas moaré v grafickém režimu 9 https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/moire2.bas
12 moire3.bas moaré v grafickém režimu 11 https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/moire3.bas
13 PI.bas výpočet Pi v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BASIC/PI.bas
14 PMG1.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/PMG1.bas
15 PMG2.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/PMG2.bas
16 printed1.bas problematika proměnné pojmenované PRINTED (zadáno uživatelem) https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/printed1.bas
17 printed2.bas problematika proměnné pojmenované PRINTED (pochopeno překladačem) https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/printed2.bas
18 slides.bas náhrada za neohrabaný PowerPoint https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/slides.bas
19 snowcrash.bas simulace „sněhu“ na televizoru bez příjmu signálu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/snowcrash.bas
20 strings.bas zpracování řetězců v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/strings.bas
       
21 1d_array.bas práce s jednorozměrnými poli v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/1d_array.bas
22 2d_array.bas práce s dvourozměrnými poli v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/2d_array.bas
23 bubble_sort.bas algoritmus bublinkového třídění prvků v poli v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/bubble_sort.bas
24 done.bas problém použití proměnné nazvané DONE https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/done.bas
25 factorial1.bas výpočet faktoriálu v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/factorial1.bas
26 factorial2.bas použití speciálních konstant nabízených Turbo BASICem https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/factorial2.bas
27 function1.bas vykreslení průběhu nespojité funkce https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/function1.bas
28 function2.bas vykreslení průběhu funkce https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/function2.bas
29 game.bas jednoduchá hra naprogramovaná na dvou řádcích https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/game.bas
30 GCD.bas výpočet největšího společného dělitele v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/GCD.bas
31 harmonic.bas zjištění limitů FP hodnot v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/harmonic.bas
32 moire1.bas moaré v grafickém režimu 7 https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/moire1.bas
33 moire2.bas moaré v grafickém režimu 9 https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/moire2.bas
34 moire3.bas moaré v grafickém režimu 11 https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/moire3.bas
35 PI.bas výpočet Pi v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/PI.bas
36 PMG1.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/PMG1.bas
37 PMG2.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/PMG2.bas
38 snowcrash.bas simulace „sněhu“ na televizoru bez příjmu signálu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/snowcrash.bas
39 strings.bas zpracování řetězců v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/strings.bas

20. Odkazy na Internetu

  1. Sedmdesátiny assemblerů: lidsky čitelný strojový kód
    https://www.root.cz/clanky/sed­mdesatiny-assembleru-lidsky-citelny-strojovy-kod/
  2. Programovací jazyk BASIC na osmibitových mikropočítačích
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-osmibitovych-mikropocitacich/
  3. Programovací jazyk BASIC na osmibitových mikropočítačích (2)
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-osmibitovych-mikropocitacich-2/#k06
  4. Programovací jazyk BASIC na herní konzoli Atari 2600
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-herni-konzoli-atari-2600/
  5. Stránka magazínu (diskmagu) FLOP
    http://flop.atariportal.cz/
  6. Action (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Action
  7. Assembler (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Assembler
  8. Basic (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Basic
  9. C (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=C
  10. Forth (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Forth
  11. Fortran (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Fortran
  12. Lisp (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Lisp
  13. Logo (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Logo
  14. Pascal (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Pascal
  15. Pilot (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Pilot
  16. PL65 (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=PL65
  17. Quick (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Quick
  18. WSFN (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=WSFN
  19. MAC/65 (Wikipedia)
    https://en.wikipedia.org/wiki/MAC/65
  20. Atari Assembler Editor
    https://en.wikipedia.org/wi­ki/Atari_Assembler_Editor#A­MAC
  21. cc65
    https://cc65.github.io/
  22. Grafika na osmibitových počítačích firmy Sinclair
    http://www.root.cz/clanky/grafika-na-osmibitovych-pocitacich-firmy-sinclair/
  23. Stránky RetroFestu
    http://retrofest.cz/
  24. RetroHerna
    http://retroherna.cz/
  25. BASIC
    http://cs.wikipedia.org/wiki/BASIC
  26. BASIC
    http://en.wikipedia.org/wiki/BASIC
  27. Rosetta Code – Category Basic
    http://rosettacode.org/wi­ki/Category:BASIC
  28. Dartmouth College Computation Center: 1964 – The original Dartmouth BASIC manual
    http://www.bitsavers.org/pdf/dar­tmouth/BASIC_Oct64.pdf
  29. The Original BASIC
    http://www.truebasic.com/
  30. BASIC – Beginners All-purpose Symbolic Instruction Code
    http://hopl.murdoch.edu.au­/showlanguage.prx?exp=176
  31. Turbo BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Turbo_BASIC
  32. Sinclair BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Sinclair_BASIC
  33. Action!
    https://atari8bitbot.com/action/
  34. Atari Logo
    https://atari8bitbot.com/atari-logo/
  35. Atari PILOT & Super PILOT
    https://atari8bitbot.com/atari-pilot/
  36. Turbo-BASIC XL
    https://atari8bitbot.com/turbo-basic-xl/
  37. Atari Assembler/Editor
    https://atari8bitbot.com/atari-assembler-editor/
  38. Strings in Atari BASIC
    http://www.cyberroach.com/a­nalog/an11/strings.htm
  39. String Arrays in Atari BASIC
    http://www.atarimagazines­.com/compute/issue11/52_1_STRIN­G_ARRAYS_IN_ATARI_BASIC.php
  40. An Atari BASIC Tutorial
    http://www.cyberroach.com/a­nalog/an25/basictutorial.htm
  41. Atari Logo
    https://en.wikipedia.org/wi­ki/Atari_Logo
  42. Computer art and animation : a user's guide to Atari logo
    https://archive.org/detail­s/Computer_Art_and_Animati­on
  43. Going into Action! with Atari XL/XE – Part 1 – Hello World!
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-1-hello-world/
  44. Going into Action! with Atari XL/XE – Part 2 – Graphics
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-2-graphics/
  45. Going into Action! with Atari XL/XE – Part 3 – More Variables, Memory and Pointers (ugh!)
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-3-more-variables-memory-and-pointers-ugh/
  46. Going into Action! with Atari XL/XE – Part 4 – Using VSCode and Action! with syntax highlighting
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-4-using-vscode-and-action-with-syntax-highlighting/
  47. Atari800 (emulátor)
    https://github.com/atari800/atari800
  48. Atari MAC/65 Tutorial
    https://www.youtube.com/wat­ch?v=RyBsGDJBXD0
  49. MAC/65 Manual
    http://www.mixinc.net/atari/mac65.htm
  50. BASIC 10 Liner Contest 2021
    https://atariage.com/forum­s/topic/316645-basic-10-liner-contest-2021/
  51. Hexadecimální prohlížeče a editory s textovým uživatelským rozhraním
    https://www.root.cz/clanky/he­xadecimalni-prohlizece-a-editory-s-textovym-uzivatelskym-rozhranim/
  52. Deep Blue C
    https://en.wikipedia.org/wi­ki/Deep_Blue_C
  53. Deep Blue C Compiler
    https://www.atariarchives­.org/APX/showinfo.php?cat=20166
  54. Historie vývoje počítačových her: simulace a strategické hry naprogramované Chrisem Crawfordem
    https://www.root.cz/clanky/historie-vyvoje-pocitacovych-her-simulace-a-strategicke-hry-naprogramovane-chrisem-crawfordem/
  55. Explore BASIC Programming Languages for the Atari 8-Bit Computers (30–60 mins)
    http://atariprojects.org/2020/08/29/ex­plore-different-basic-programming-languages-for-the-atari-8-bit-computers-30–60-mins/
  56. Learn How to Make a Game in BASIC XE (30–60 mins)
    http://atariprojects.org/2019/12/21/le­arn-how-to-make-a-game-in-basic-xe-30–60-mins/
  57. Atari BASIC XL (manuál)
    http://www.atarimania.com/8bit/fi­les/BASIC%20XL%20%C2%A4%20Se­cond%20Edition.pdf
  58. BASIC XE For Atari XL & XE
    https://www.atarimagazines­.com/compute/issue67/318_1_Re­views_BASIC_XE_For_Atari_XL_XE­.php

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.