Jak rychlý je Fast Basic v porovnání s ostatními interpretry BASICu?

Ve Fast Basicu je tomu jinak – programy v něm zapsané spíše připomínají modernější skriptovací jazyky a překlad je prováděn do bajtkódu. Fast Basic je možné (i se svým vývojovým prostředím) spustit přímo na počítači Atari, ovšem existuje i jeho (cross) překladač pro PC. Tento crosss překladač je zajímavý mj. i tím, že provádí i peephole optimalizace, takže dokáže nahradit sekvenci instrukcí bajtkódu kratší a rychlejší sekvencí popř. sekvenci přímo odstranit.

Otázkou ovšem zůstává, jak rychlé jsou vlastně programy psané ve Fast Basicu v porovnání s ostatními interpretry BASICů, které jsou dostupné pro počítače Atari. Všechny tyto interpretry (kromě originálního Atari BASICu) totiž mají jednu společnou vlastnost: v jejich manuálech se píše, že jsou rychlejší, než původní Atari Basic. Zbývá nám tedy jediné: vyvrátit nebo potvrdit tyto informace, porovnat rychlosti jednotlivých interpretrů a stanovit „výherce“.

Porovnávat budeme následující implementace BASIC:

Měření času v benchmarcích

Rychlost jednotlivých interpretrů programovacího jazyka BASIC se pokusíme zjistit s využitím dvojice jednoduchých benchmarků (a posléze doplníme třetí benchmark porovnávající pouze Atari BASIC, Turbo BASIC XL a Fast Basic). U všech tří benchmarků budeme měřit čas běhu části programu, přičemž pro měření použijeme časovač dostupný na adresách 18, 19 a 20, tj. jedná se o 24bitovou hodnotu, která se zvyšuje 50× nebo 60× za sekundu. Tento časovač (nazývaný taktéž hodiny reálného času) lze na začátku měření programově vynulovat, což nám zjednoduší výpočet celkového času (není nutné odečítat dvě 24bitové hodnoty). Toto vynulování lze provést ve všech BASICech zápisem na adresy 18, 19 i 20 příkazem POKE:

10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0

Na konci benchmarku zjistíme stav časovače a převedeme ho na sekundy podělením půlsnímkovou frekvencí (tedy 50 či 60 Hz podle použité televizní normy):

40 REM PRECTENI CASOVACE
41 REM (PLATNE PRO PAL)
42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
50 PRINT "FINISHED IN ";T;" SECONDS"

V praxi bude možné vynechat nejvyšší adresu (18), protože žádný výpočet nepřekročí 21 minut (cca 65536/50).

První benchmark: „snowcrash“

První benchmark, který v dnešním článku použijeme pro porovnání rychlostí interpretrů programovacího jazyka BASIC, je ve skutečnosti velmi jednoduchý. Testuje se v něm rychlost realizace počítaných programových smyček a taktéž rychlost zápisu do operační paměti. Tento benchmark po svém spuštění nejprve provede přepnutí do grafického režimu GRAPHICS 8 (rozlišení 320×160 pixelů s jedním bitem na pixel) a následně zaplní obrazovou paměť (pseudo)náhodnými hodnotami. Simuluje tak „sněžení“ analogového televizoru bez antény.

Zdrojový kód tohoto benchmarku, který je kompatibilní se všemi výše zmíněnými interpretry programovacího jazyka BASIC (až na Fast Basic!), vypadá následovně:

1 REM *****************************
2 REM Vyplneni obrazovky v rezimu
3 REM 320x160 nahodnym vzorkem.
4 REM
5 REM Implementace pro Atari BASIC
6 REM
7 REM Upraveno do podoby benchmarku
8 REM *****************************
9 REM
10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0
20 REM VLASTNI BENCHMARK
21 GRAPHICS 8
22 START=PEEK(88)+256*PEEK(89)
23 FINAL=START+320*160/8
30 FOR I=START TO FINAL
35 REM 17BITOVY POLY CITAC = RND
40 POKE I,PEEK(53770)
50 NEXT I
60 REM PRECTENI CASOVACE
70 REM (PLATNE PRO PAL)
80 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
90 PRINT "FINISHED IN ";T;" SECONDS"
99 END

Tento zdrojový kód nahrajeme do (libovolného) interpretru BASICu příkazem ENTER (například ENTER H:SNOWCRASH.BAS):

A následně příkazem RUN benchmark spustíme:

V případě Microsoft BASICu není příkaz ENTER dostupný, takže se použije:

LOAD "H:B.BAS"

Čas na dokončení tohoto benchmarku bude v případě Atari BASICu dosahovat přibližně 73 sekund:

Výsledky benchmarku pro různé interpretry jazyka BASIC kompatibilní s Atari BASICem

Výše uvedený benchmark je možné bez dalších úprav spustit i v ostatních interpretrech programovacího jazyka BASIC dostupných pro osmibitové Atari (je totiž naprogramován tak, aby byl plně kompatibilní, opět: kromě Fast Basicu). Dosažené časy vyplnění obrazové paměti náhodnými hodnotami se pochopitelně pro různé interpretry BASICu odlišují, a to dosti podstatně. Je to ostatně velmi dobře patrné při pohledu na tabulku s výsledky:

Vizualizace výsledků benchmarku:

Úprava benchmarku pro Fast Basic

Fast Basic se od všech interpretrů BASICu zmíněných v úvodních kapitolách v několika ohledech odlišuje. Nejvýznamnějším rozdílem je, že tento BASIC není s ostatními BASICy kompatibilní na zcela fundamentální úrovni: neumožňuje totiž zapisovat čísla řádků. Navíc se výpočty (standardně) provádí se šestnáctibitovými hodnotami a aby toho nebylo málo, je nutné převést příkazy REM na styl zápisu poznámek začínajících znakem ' (apostrof). V důsledku to znamená nutnost přepisu benchmarku do nové podoby, což ovšem nebude příliš složité.

Začněme 16bitovými výpočty. Z tohoto důvodu budeme čas počítat jen se šestnáctibitovým rozsahem (což ovšem v praxi plně postačuje). Čas se uloží do proměnné s plovoucí řádovou čárkou, aby byl podíl T/50 proveden s přesností větší než jedna sekunda:

' PRECTENI CASOVACE
' (PLATNE PRO PAL)
T%=PEEK(19)*256+PEEK(20)
T%=T%/50
PRINT "FINISHED IN ";T%;" SECONDS"

V původním benchmarku je ovšem ještě jedna past. Jedná se o výpočet koncové adresy. Zde je nutné upravit druhou část, konkrétně přepsat 320*160/8 na 320/8*160:

START=PEEK(88)+256*PEEK(89)
FINAL=START+320/8*160

Výsledná podoba prvního benchmarku pro Fast Basic

První benchmark upravený a plně kompatibilní s Fast Basicem vypadá takto:

' *****************************
' Vyplneni obrazovky v rezimu
' 320x160 nahodnym vzorkem.
'
' Implementace pro Fast BASIC
'
' Upraveno do podoby benchmarku
' *****************************
'
' VYMAZANI CASOVACE
POKE 18,0
POKE 19,0
POKE 20,0
 
' VLASTNI BENCHMARK
GRAPHICS 8
 
START=PEEK(88)+256*PEEK(89)
FINAL=START+320/8*160
 
FOR I=START TO FINAL
' 17BITOVY POLY CITAC = RND
    POKE I,PEEK(53770)
NEXT I
 
' PRECTENI CASOVACE
' (PLATNE PRO PAL)
T%=PEEK(19)*256+PEEK(20)
T%=T%/50
PRINT "FINISHED IN ";T%;" SECONDS"
 
DO
LOOP

Celkové zhodnocení benchmarku: Fast Basic vs. pomalý zbytek světa

Jak je tento benchmark ve variantě pro Fast Basic rychlý? Podívejme se na screenshot:

Zde skutečně není pochyb o tom, že Fast Basic je nejenom rychlejší než Atari BASIC (to není žádné překvapení), ale dosti podstatným způsobem překonává i Turbo Basic XL:

Druhý benchmark: bubble sort

Druhý benchmark, s nímž se dnes setkáme, je založen na měření doby setřídění padesáti čísel algoritmem bubble sort. Opět si nejdříve ukažme implementaci v Atari BASICu, která je bez potřeby dalších úprav spustitelná i dalšími interpretry (samozřejmě kromě Fast Basicu):

1 REM *****************************
2 REM Algorismus bubble sort
3 REM
4 REM Implementace pro Atari BASIC
5 REM
6 REM Upraveno do podoby benchmarku
7 REM *****************************
8 REM
9 REM
10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0
20 REM VLASTNI BENCHMARK
21 MAX=50
22 DIM A(MAX)
23 FOR I=0 TO MAX
24 A(I)=INT(100*RND(0))
25 NEXT I
26 GOSUB 100:REM TISK OBSAHU POLE
27 FOR I=MAX-1 TO 0 STEP -1
28 PRINT ".";
29 FOR J=0 TO I
30 IF A(J)<A(J+1) THEN X=A(J):A(J)=A(J+1):A(J+1)=X
31 NEXT J
32 NEXT I
33 PRINT ""
34 PRINT "SORTED:"
35 GOSUB 100:REM TISK OBSAHU POLE
40 REM PRECTENI CASOVACE
41 REM (PLATNE PRO PAL)
42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
50 PRINT "FINISHED IN ";T;" SECONDS"
99 END
100 REM TISK OBSAHU POLE
101 FOR I=0 TO MAX
102 PRINT I,A(I)
103 NEXT I
104 RETURN

Podívejme se nyní na výsledky prvního benchmarku, který byl prakticky beze změn v programovém kódu spuštěn ve všech osmi klasických interpretrech programovacího jazyka BASIC dostupných na osmibitových Atari. Provedli jsme pouze jedinou změnu, a to na pátém řádku, kdy byl doplněn příkaz FAST, jenž umožňuje přepočítat čísla řádků do podoby umožňující rychlejší (přímé) skoky. A tato změna skutečně způsobila nepatrné vylepšení výsledků (pro BASIC XE se již v případě příkazu FAST vyžaduje 128kB RAM, takže by byl použitelný jen na Atari 130 XE):

Úprava benchmarku pro Fast Basic

Nyní si ukažme, jak bude vypadat úprava pro Fast Basic. Musíme zajistit, že se bude zpracovávat pole s hodnotami s plovoucí řádovou čárkou – nyní skutečně musíme přesně dodržet chování původního benchmarku. Výsledek bude vypadat následovně:

' BUBBLE SORT
' IMPLEMENTACE PRO FAST BASIC
' 
' ----------------------------
 
' ------------------------------
' VYMAZANI CASOVACE
' ------------------------------
POKE 18,0
POKE 19,0
POKE 20,0
 
MAX=50
DIM A%(MAX)
FOR I=0 TO MAX
    A%(I)=RAND(100)
NEXT I
EXEC PRINT_ARRAY
FOR I=MAX-1 TO 0 STEP -1
    PRINT ".";
    FOR J=0 TO I
        IF A%(J)<A%(J+1)
            X%=A%(J):A%(J)=A%(J+1):A%(J+1)=X%
        ENDIF
    NEXT J
NEXT I
PRINT ""
PRINT "SORTED:"
EXEC PRINT_ARRAY
 
' ------------------------------
' PRECTENI CASOVACE
' (PLATNE PRO PAL)
' ------------------------------
T=PEEK(19)*256+PEEK(20)
T=T/50
PRINT "FINISHED IN ";T;" SECONDS"
 
' ------------------------------
' KONEC
' ------------------------------
DO
LOOP
 
' ------------------------------
' TISK OBSAHU POLE
' ------------------------------
PROC PRINT_ARRAY
    FOR I=0 TO MAX
        PRINT I,A%(I)
    NEXT I
ENDPROC

Výsledek:

Bubble sort pole celočíselných prvků

Vzhledem k tomu, že Fast Basic dokáže pracovat s celočíselnými hodnotami i s poli obsahujícími celočíselné hodnoty, upravíme benchmark tak, aby řadil celočíselné prvky uložené v poli. Pochopitelně se jedná jen o doplnění předchozí sady benchmarků, protože měříme odlišné operace. Na druhou stranu nám to umožní zjistit, jak rychlé jsou celočíselné operace v porovnání s operacemi s FP hodnotami:

' BUBBLE SORT
' IMPLEMENTACE PRO FAST BASIC
' 
' ----------------------------
 
' ------------------------------
' VYMAZANI CASOVACE
' ------------------------------
POKE 18,0
POKE 19,0
POKE 20,0
 
MAX=50
DIM A(MAX)
FOR I=0 TO MAX
    A(I)=RAND(100)
NEXT I
EXEC PRINT_ARRAY
FOR I=MAX-1 TO 0 STEP -1
    PRINT ".";
    FOR J=0 TO I
        IF A(J)<A(J+1)
             X=A(J):A(J)=A(J+1):A(J+1)=X
        ENDIF
    NEXT J
NEXT I
PRINT ""
PRINT "SORTED:"
EXEC PRINT_ARRAY
 
' ------------------------------
' PRECTENI CASOVACE
' (PLATNE PRO PAL)
' ------------------------------
T%=PEEK(19)*256+PEEK(20)
T%=T%/50
PRINT "FINISHED IN ";T%;" SECONDS"
 
' ------------------------------
' KONEC
' ------------------------------
DO
LOOP
 
' ------------------------------
' TISK OBSAHU POLE
' ------------------------------
PROC PRINT_ARRAY
  FOR I=0 TO MAX
    PRINT I,A(I)
  NEXT I
ENDPROC

Výsledek:

Porovnání všech variant druhého benchmarku

Výsledky všech měření algoritmu pro bublinkové řazení si opět porovnáme (s tím, že celočíselná varianta je uvedena jen pro doplnění):

Z výsledků je patrné, že Fast Basic je opět výrazně rychlejší než ostatní interpretry. FP varianta algoritmu je přibližně dvakrát rychlejší oproti Turbo BASICu XL a cca pětkrát rychlejší, než Atari BASIC. A celočíselná varianta je (pochopitelně) ještě rychlejší, protože není nutné volat relativně pomalé FP rutiny uložené v ROM.

Třetí benchmark: vertikální posun spritu na obrazovce

Ve třetím a současně i posledním benchmarku se vykreslí sprite (první hráč) v režimu s 256 obrazovými řádky. Tento sprite je posléze 256× vertikálně posunut (jeho bitmapa je uložena v oblasti rezervované pro druhého hráče). Pro jednoduchost je paměťová oblast rezervovaná pro sprity umístěna na pevnou stránku paměti, což sice není zcela korektní, ovšem zjednoduší to výpočty stránek (musí být dělitelné čtyřmi resp. osmi atd. atd.). Tento benchmark existuje ve třech variantách:

1. Varianta pro Atari BASIC musí posun realizovat počítanou smyčkou a kombinací příkazu POKE a funkce PEEK
2. Varianta pro Turbo BASIC používá příkaz MOVE
3. Varianta pro FastBasic taktéž používá příkaz MOVE

Varianta třetího benchmarku pro Atari BASIC

První varianta třetího benchmarku je primárně určená pro Atari BASIC, ale bude spustitelná i v Turbo BASICu atd. Pokud se nechceme uchýlit k volání strojových subrutin, je přesun bitmapy řešen takto:

101 FOR I=0 TO 18
102 A=PEEK(MYPMBASE+256+I)
103 POKE MYPMBASE+I+Y,A

To je velmi (velmi) pomalé. Po spuštění benchmarku jsou jednotlivé přesuny bajtů viditelné. To ostatně uvidíme ve výsledcích.

Celý zdrojový kód benchmarku:

10 REM ------------------------------
11 REM nastaveni spritu
12 REM ------------------------------
20 PMBASE=54279
21 RAMTOP=106
22 SDMCTL=559
23 GRACTL=53277
24 HPOSP0=53248
25 PCOLR0=704
30 GOSUB 1200:REM inicializace PMG
40 GOSUB 1000:REM vymazani prvniho hrace
50 GOSUB 1100:REM bitmapa prvniho hrace
60 REM ------------------------------
61 REM vymazani casovace
62 REM ------------------------------
70 POKE 18,0
71 POKE 19,0
72 POKE 20,0
80 REM ------------------------------
81 REM vlastni benchmark
82 REM ------------------------------
100 FOR Y=0 TO 255
101 FOR I=0 TO 18
102 A=PEEK(MYPMBASE+256+I)
103 POKE MYPMBASE+I+Y,A
104 NEXT I
105 NEXT Y
200 REM precteni casovace
201 REM (platne pro pal)
202 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
203 PRINT "FINISHED IN ";T;" SECONDS"
999 END
1000 REM ------------------------------
1001 REM
1002 REM vymazani oblasti prvniho hrace
1003 REM
1005 FOR I=MYPMBASE TO MYPMBASE+256
1006 POKE I,0
1007 NEXT I
1008 RETURN
1100 REM ------------------------------
1101 REM
1102 REM inicializace bitmapy prvniho hrace
1103 REM
1105 FOR I=MYPMBASE+256 TO MYPMBASE+256+17
1106 READ A
1107 POKE I,A
1108 NEXT I
1109 DATA 0,24,24,60,60,126,126,219,219,255,255,36,36,90,90,165,165,0
1110 RETURN
1200 REM ------------------------------
1201 REM
1202 REM inicializace PMG
1203 REM
1205 POKE PCOLR0,31
1206 REM stranka delitelna ctyrmi
1207 A=144
1208 POKE PMBASE,A
1209 MYPMBASE=256*A+1024
1210 POKE GRACTL,3
1211 POKE HPOSP0,120
1217 POKE SDMCTL,42+16
1220 RETURN

Varianta třetího benchmarku pro Turbo BASIC XL

Turbo BASIC XL je, jak vyplývá z předchozích benchmarků, podstatně rychlejší než původní Atari BASIC. Rychlost interpretru pochopitelně není vše, protože do značné míry záleží i na příkazech, které tento interpret podporuje. V Turbo BASICu XL se především (konečně!) objevuje příkaz MOVE určený pro přesuny (resp. přesněji řečeno kopie) bloků paměti:

101   MOVE MYPMBASE+256, MYPMBASE+Y, 18

Interně je pochopitelně tento příkaz implementován ve strojovém kódu, takže je mnohem rychlejší, než programová smyčka ukázaná v předchozí kapitole. To nám umožňuje přepsat třetí benchmark do mnohem rychlejší podoby:

10 ------------------------------
11 REM nastaveni spritu
12 ------------------------------
20 PMBASE=54279
21 RAMTOP=106
22 SDMCTL=559
23 GRACTL=53277
24 HPOSP0=53248
25 PCOLR0=704
30 EXEC INIT_PGM
40 EXEC ERASE_P0
50 EXEC INIT_P0_BITMAP
60 ------------------------------
61 REM vymazani casovace
62 ------------------------------
70 POKE 18,0
71 POKE 19,0
72 POKE 20,0
80 ------------------------------
81 REM vlastni benchmark
82 ------------------------------
100 FOR Y=0 TO 255
101   MOVE MYPMBASE+256, MYPMBASE+Y, 18
102 NEXT Y
200 REM precteni casovace
201 REM (platne pro pal)
202 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
203 PRINT "FINISHED IN ";T;" SECONDS"
999 END
1000 ------------------------------
1001 REM
1002 REM vymazani oblasti prvniho hrace
1003 REM
1004 PROC ERASE_P0
1005   FOR I=MYPMBASE TO MYPMBASE+256
1006     POKE I,0
1007   NEXT I
1008 ENDPROC
1100 ------------------------------
1101 REM
1102 REM inicializace bitmapy prvniho hrace
1103 REM
1104 PROC INIT_P0_BITMAP
1105   FOR I=MYPMBASE+256 TO MYPMBASE+256+17
1106     READ A
1107     POKE I,A
1108   NEXT I
1109   DATA 0,24,24,60,60,126,126,219,219,255,255,36,36,90,90,165,165,0
1110 ENDPROC
1200 ------------------------------
1201 REM
1202 REM inicializace PMG
1203 REM
1204 PROC INIT_PGM
1205   POKE PCOLR0,31
1206   REM stranka delitelna ctyrmi
1207   A=120
1208   POKE PMBASE,A
1209   MYPMBASE=256*A+1024
1210   POKE GRACTL,3
1211   POKE HPOSP0,120
1217   POKE SDMCTL,42+16
1220 ENDPROC

Varianta třetího benchmarku pro Fast Basic

Varianta benchmarku určená pro Fast Basic přímo vychází z příkladu, který jsme si ukázali minule. Povšimněte si, že můžeme využít nové příkazy pro práci s PMG (sprity) a taktéž můžeme vidět použití příkazu MOVE. Realizace příkladu je nepatrně odlišná, protože pole s bitmapou spritu není uloženo ihned za pamětí rezervovanou pro PMG, ovšem to nemá na rychlost benchmarku žádný vliv:

' textovy rezim
graphics 0
 
' povoleni zobrazeni spritu
pmgraphics 1
 
' adresa bloku pro hrace 1
P0Mem = pmadr(0)
 
' vymazani pameti hrace
mset P0Mem, 256, 0
 
' nastavení barvy hrace
setcolor -4, 1, 15
 
' horizontalni pozice hrace na obrazovce
pmhpos 0, 120
 
' bitmapa hrace i se dvema "mazacimi" radky
DATA PMdata()  byte = 0, 24, 24, 60, 60, 126, 126, 219, 219, 255, 255, 36, 36, 90, 90, 165, 165, 0
 
' vymazani casovace
poke 18,0
poke 19,0
poke 20,0
 
' vlastni benchmark
for y=0 to 255
    ' kopie bitmapy hrace
    move adr(PMdata), P0Mem+y, 18
next y
 
' ------------------------------
' precteni casovace
' (platne pro pal)
' ------------------------------
t%=peek(19)*256+peek(20)
t%=t%/50
print "finished in ";t%;" seconds"
 
do
loop

Výsledky měření třetím benchmarkem

Třetí benchmark byl spuštěn celkem 4×, protože původní variantu určenou pro Atari BASIC jsem spustil i na Turbo BASICu XL. V tomto případě došlo ke trojnásobnému urychlení, což ovšem není tak podstatné, jako varianty s příkazem MOVE, které jsou v případě jak Turbo BASICu XL, tak i Fast Basicu rychlejší prakticky o dva řády v porovnání s původním Atari BASICem. Ovšem pro nás je důležitější porovnání obou variant s příkazem MOVE. Zde je Fast Basic více než dvakrát rychlejší, než Turbo BASIC XL:

Grafické porovnání výsledků:

Závěrečné zhodnocení

Fast Basic dostál svému jménu, protože je skutečně rychlejší (a to mnohdy výrazně), než ostatní interpretry programovacího jazyka BASIC, které byly dostupné pro osmibitové domácí mikropočítače Atari. Dokonce překonává i Turbo BASIC XL, který je v této oblasti etalonem. Větší rychlost Fast Basicu je do značné míry dána způsobem překladu (nikoli do tokenů, ale do bajtkódu), existencí peephole optimalizací (jen na PC s cross překladačem) a taktéž výrazně pomáhá možnost provádět výpočty s celočíselnými šestnáctibitovými hodnotami. Určitou nevýhodou (z dobového pohledu) je fakt, že se rozlišuje fáze editace a překladu, takže se zde poněkud vytratila interaktivnost, kterou zajišťovaly klasické interpretry BASICu. Pochopitelně se nedosahuje takové rychlosti, jako v případě jazyka Action! či při použití assembleru (to ovšem pravděpodobně nikdo ani neočekává), na druhou stranu stojí Fast Basic na cestě mezi optimalizovaným assemblerem a šnekovitě pomalým Atari BASICem spíše na straně assembleru.

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

Všechny demonstrační příklady, s nimiž jsme se v předchozích článcích i v článku dnešním seznámili a které jsou určeny pro překlad s využitím assembleru ca65, jsou dostupné, jak je zvykem, na GitHubu. V tabulce níže jsou uvedeny odkazy na jednotlivé zdrojové kódy příkladů psané v assembleru i „listingy“ vygenerované samotným assemblerem, ze kterých je patrné, jakým způsobem se jednotlivé příklady přeložily do výsledného XEX souboru:

Odkazy na Internetu

1. MOS 6502 instruction set
   http://www.6502.org/users/o­belisk/6502/instructions.html
2. EXE File Format Description
   https://gury.atari8.info/ref­s/file_formats_exe.php
3. XEX Filter – A toolkit to analyze and manipulate Atari binary files
   https://www.vitoco.cl/atari/xex-filter/index.html
4. chkxex.py
   https://raw.githubusercon­tent.com/seban-slt/tcx_tools/refs/heads/mas­ter/chkxex.py
5. ca65 Users Guide
   https://cc65.github.io/doc/ca65.html
6. cc65 Users Guide
   https://cc65.github.io/doc/cc65.html
7. ld65 Users Guide
   https://cc65.github.io/doc/ld65.html
8. da65 Users Guide
   https://cc65.github.io/doc/da65.html
9. Překladače jazyka C pro historické osmibitové mikroprocesory
   https://www.root.cz/clanky/prekladace-jazyka-c-pro-historicke-osmibitove-mikroprocesory/
10. Překladače programovacího jazyka C pro historické osmibitové mikroprocesory (2)
    https://www.root.cz/clanky/prekladace-programovaciho-jazyka-c-pro-historicke-osmibitove-mikroprocesory-2/
11. Getting Started Programming in C: Coding a Retro Game with C Part 2
    https://retrogamecoders.com/getting-started-with-c-cc65/
12. NES game development in 6502 assembly – Part 1
    https://kibrit.tech/en/blog/nes-game-development-part-1
13. NES 6502 Programming Tutorial – Part 1: Getting Started
    https://dev.xenforo.relay­.cool/index.php?threads/nes-6502-programming-tutorial-part-1-getting-started.858389/
14. Minimal NES example using ca65
    https://github.com/bbbradsmith/NES-ca65-example
15. List of 6502-based Computers and Consoles
    https://www.retrocompute.co.uk/list-of-6502-based-computers-and-consoles/
16. 6502 – the first RISC µP
    http://ericclever.com/6500/
17. 3 Generations of Game Machine Architecture
    http://www.atariarchives.or­g/dev/CGEXPO99.html
18. “Hello, world” from scratch on a 6502 — Part 1
    https://www.youtube.com/wat­ch?v=LnzuMJLZRdU
19. A Tour of 6502 Cross-Assemblers
    https://bumbershootsoft.wor­dpress.com/2016/01/31/a-tour-of-6502-cross-assemblers/
20. Adventures with ca65
    https://atariage.com/forum­s/topic/312451-adventures-with-ca65/
21. example ca65 startup code
    https://atariage.com/forum­s/topic/209776-example-ca65-startup-code/
22. 6502 PRIMER: Building your own 6502 computer
    http://wilsonminesco.com/6502primer/
23. 6502 Instruction Set
    https://www.masswerk.at/6502/6502_in­struction_set.html
24. Chip Hall of Fame: MOS Technology 6502 Microprocessor
    https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-mos-technology-6502-microprocessor
25. Single-board computer
    https://en.wikipedia.org/wiki/Single-board_computer
26. www.6502.org
    http://www.6502.org/
27. 6502 PRIMER: Building your own 6502 computer – clock generator
    http://wilsonminesco.com/6502pri­mer/ClkGen.html
28. Great Microprocessors of the Past and Present (V 13.4.0)
    http://www.cpushack.com/CPU/cpu.html
29. Jak se zrodil procesor?
    https://www.root.cz/clanky/jak-se-zrodil-procesor/
30. Osmibitové mikroprocesory a mikrořadiče firmy Motorola (1)
    https://www.root.cz/clanky/osmibitove-mikroprocesory-a-mikroradice-firmy-motorola-1/
31. Mikrořadiče a jejich použití v jednoduchých mikropočítačích
    https://www.root.cz/clanky/mikroradice-a-jejich-pouziti-v-jednoduchych-mikropocitacich/
32. Mikrořadiče a jejich aplikace v jednoduchých mikropočítačích (2)
    https://www.root.cz/clanky/mikroradice-a-jejich-aplikace-v-jednoduchych-mikropocitacich-2/
33. 25 Microchips That Shook the World
    https://spectrum.ieee.org/tech-history/silicon-revolution/25-microchips-that-shook-the-world
34. Comparison of instruction set architectures
    https://en.wikipedia.org/wi­ki/Comparison_of_instructi­on_set_architectures
35. How To Start Learning Atari 8 Bit Assembly For Free
    https://forums.atariage.com/to­pic/300732-how-to-start-learning-atari-8-bit-assembly-for-free/
36. WUDSN (Demo Group)
    https://www.wudsn.com/
37. Machine Language For Beginners
    https://www.atariarchives.org/mlb/
38. Assembly language: all about I/O
    https://www.atarimagazines­.com/v3n8/AllAbout_IO.html
39. Sedmdesátiny assemblerů: lidsky čitelný strojový kód
    https://www.root.cz/clanky/sed­mdesatiny-assembleru-lidsky-citelny-strojovy-kod/
40. Color names
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Color%20names
41. ATASCII
    https://en.wikipedia.org/wiki/ATASCII
42. Put characters in display ram isn't ATASCII?
    https://forums.atariage.com/to­pic/359973-put-characters-in-display-ram-isnt-atascii/
43. ATASCII And Internal Character Code Values
    https://www.atariarchives­.org/mapping/appendix10.php
44. Reading ATASCII from the keyboard in assembly
    https://forums.atariage.com/to­pic/361733-reading-atascii-from-the-keyboard-in-assembly/
45. Why does the 6502 JSR instruction only increment the return address by 2 bytes?
    https://retrocomputing.stac­kexchange.com/questions/19543/why-does-the-6502-jsr-instruction-only-increment-the-return-address-by-2-bytes
46. Pushing return address to stack off by 1 byte
    https://forums.atariage.com/to­pic/378206-pushing-return-address-to-stack-off-by-1-byte/
47. Intel x86 documentation has more pages than the 6502 has transistors
    https://www.righto.com/2013/09/intel-x86-documentation-has-more-pages.html
48. Clearing a Section of Memory
    http://www.6502.org/source/ge­neral/clearmem.htm
49. Practical Memory Move Routines by Bruce Clark
    http://www.6502.org/source/ge­neral/memory_move.html
50. 6502 Assembly Programming Guide
    https://neumont-gamedev.github.io/posts/retrogamedev-6502-guide/
51. Off-by-one error
    https://en.wikipedia.org/wiki/Off-by-one_error
52. 6502 cycle times
    https://www.nesdev.org/wi­ki/6502_cycle_times
53. Atari TIA
    http://www.atarihq.com/danb/tia.shtml
54. TIA Playfield
    http://www.atarihq.com/dan­b/TIA/Playfield.shtml
55. Atari Inc.:
    ANTIC C012296 (NTSC) Revision D
    Atari Incorporated, Sunnyvale CA, 1982
56. Atari Inc.:
    GTIA C014805 (NTSC) Revision A
    Atari Incorporated, Sunnyvale CA, 1982
57. Atari 5200
    http://www.atariage.com/sof­tware_search.html?SystemID=5200
58. Atari 5200 Hardware and Accessories
    http://www.atariage.com/5200/ar­chives/hardware.html
59. Atari 5200 Screenshots
    http://www.atariage.com/sys­tem_items.html?SystemID=5200&I­temTypeID=SCREENSHOT
60. History of video game consoles (second generation): Wikipedia
    http://en.wikipedia.org/wi­ki/History_of_video_game_con­soles_(second_generation)
61. Atari 5200: Wikipedia
    http://en.wikipedia.org/wi­ki/Atari_5200
62. Player-Missile Graphics
    https://www.atariarchives­.org/agagd/chapter5.php
63. Sprite (computer graphics)
    https://en.wikipedia.org/wi­ki/Sprite_(computer_graphic­s)
64. Atari Graphics Demonstrations by Underground Software, 1985 | Atari 8 bit Demo
    https://www.youtube.com/wat­ch?v=h7N9EYSyCkw
65. Atari 8-bit Display List Interrupts: A Complete(ish) Tutorial
    https://playermissile.com/dli_tu­torial/
66. Atari Assembler Editor manual
    https://atariwiki.org/wiki/at­tach/Atari%20Assembler%20E­ditor/ATARI%20Assembler%20E­ditor%20User-s%20Manual-OCR.pdf
67. Atari 8-bit Fine Scrolling: A Complete(ish) Tutorial
    https://playermissile.com/scro­lling_tutorial/index.html
68. Atari Fine Scrolling
    https://www.atarimagazines­.com/compute/issue67/338_1_A­tari_Fine_Scrolling.php
69. CTIA / GTIA Pinout Diagram
    https://user.xmission.com/~tre­vin/atari/gtia_pinout.html
70. GTIA Modes
    https://page6.org/archive/is­sue_02/page_10.htm
71. 56 graphic modes
    https://www.atari800xl.eu/docs/kb/kb-hardware-0005-atari-8bit-56-graphic-modes.html
72. UNLOCKING THE 56 GRAPHIC MODES
    https://www.atarimagazines­.com/v3n5/allmodes.html
73. GTIA Modes 9, 10 & 11 + ANTIC data and color clocks
    https://forums.atariage.com/to­pic/366256-gtia-modes-9–10–11-antic-data-and-color-clocks/
74. ANTIC, GTIA and timing info
    https://atarimax.com/jindrou­sh.atari.org/atanttim.html
75. 6.10 Cycle timing
    https://github.com/AnimaIn­Corpore/A8E/blob/main/AHRM/6­.%20CTIA-GTIA/10.%20Cycle%20timing.md
76. Doug Neubauer
    https://en.wikipedia.org/wi­ki/Doug_Neubauer
77. POKEY
    https://en.wikipedia.org/wiki/POKEY
78. Inside the Atari 800XL
    https://www.goto10retro.com/p/800xl-inside
79. Grayscale Project – „Jam Session“ – Chiptune Visualization / Atari SAP
    https://www.youtube.com/watch?v=Qx-AHgvwrHo&list=PL92E73FD91764173B
80. POKEY MUSIC ( ATARI XL / XE ) =+ MUSIC FROM POLAND += DEMO
    https://www.youtube.com/wat­ch?v=5PswfMjMop4&list=RD5PswfMjMop4&star­t_radio=1
81. Atari.org
    http://www.atari.org/
82. Atari POKEY
    http://www.absoluteastrono­my.com/topics/Atari_POKEY
83. Chiptune
    http://www.absoluteastrono­my.com/topics/Chiptune
84. ASAP – Another Slight Atari Player
    http://asap.sourceforge.net/
85. Atari SAP music archive
    http://asma.atari.org/
86. RASTER Music Tracker (RMT)
    http://raster.infos.cz/ata­ri/rmt/rmt.htm
87. POKEY explorer
    https://github.com/ivop/pokey-explorer
88. POKEY C012294 Documentation
    https://7800.8bitdev.org/in­dex.php/POKEY_C012294_Docu­mentation
89. Pokey Registers
    https://user.xmission.com/~tre­vin/atari/pokey_regs.html
90. POKEY CO12294
    http://krap.pl/mirrorz/ata­ri/homepage.ntlworld.com/kry­ten_droid/Atari/800XL/ata­ri_hw/pokey.htm
91. De Re Atari: SOUND
    https://www.atariarchives­.org/dere/chapt07.php#H7_3_5
92. Paddle (game controller)
    https://en.wikipedia.org/wi­ki/Paddle_(game_controller)
93. Interfacing Your Atari
    https://www.atariarchives­.org/creativeatari/Interfa­cing_Your_Atari.php
94. Atari SIO
    https://en.wikipedia.org/wi­ki/Atari_SIO
95. Atari Chips
    https://atarimax.com/jindrou­sh.atari.org/achip.html
96. Table 4: Keyboard Code Index, KEYCODE: ATASCII
    https://www.atariarchives­.org/c3ba/kcindex.php
97. SIO2PC
    http://raster.atariportal­.cz/hw/sio2pc.htm
98. Using Serial Input/Output
    https://www.atarimagazines­.com/compute/issue64/insig­ht_atari.php
99. SIO ROUTINES
    https://www.atariarchives­.org/mmm/sio.php
100. ATARI 8 bit Serial Input/Output (SIO)
     https://allpinouts.org/pi­nouts/connectors/serial/a­tari-8-bit-serial-input-output-sio/
101. SIOspecs
     https://archive.org/details/SIOspecs
102. Interview with Joe Decuir
     http://www.atarimuseum.com/ar­ticles/joedecuir.html
103. USB AND OS/2
     http://www.os2voice.org/VNL/pas­t_issues/VNL1199H/vnewsf5­.htm
104. Standards and specs: The ins and outs of USB
     http://www.ibm.com/develo­perworks/power/library/pa-spec7.html
105. USB Class Codes
     http://www.usb.org/develo­pers/defined_class
106. Universal Serial Bus
     http://en.wikipedia.org/wiki/Usb
107. SMBus.org
     http://www.smbus.org
108. SMBus FAQ
     http://www.smbus.org/faq/faq.htm
109. System Management Bus
     http://en.wikipedia.org/wi­ki/System_Management_Bus
110. SMBus Specifications
     http://www.smbus.org/specs
111. SMBus Control Method Interface Specification Version 1.0
     http://www.smbus.org/spec­s/smbus_cmi10.pdf
112. System Management Bus (SMBus) Specification Version 2.0
     http://www.smbus.org/spec­s/smbus20.pdf
113. Atari Connection Machine
     http://acm.atariportal.cz/s/con8bit/8bits
114. Atari Program Recorder
     https://en.wikipedia.org/wi­ki/Atari_Program_Recorder
115. THE ATARI CASSETTE
     https://www.atariarchives­.org/dere/chaptC.php
116. Turbo-2000
     https://www.atari-800.cz/turbo-2000
117. Atari XC12 FSK Decoder
     https://zeninstruments.blog­spot.com/2024/08/atari-xc12-fsk-decoder.html
118. Clock recovery
     https://en.wikipedia.org/wi­ki/Clock_recovery
119. Jiří Richter (programátor)
     https://cs.wikipedia.org/wi­ki/Ji%C5%99%C3%AD_Richter_(pro­gram%C3%A1tor)
120. Spectrum tape interface
     https://sinclair.wiki.zxnet­.co.uk/wiki/Spectrum_tape_in­terface
121. How Tape Loading Works
     https://lemmings.info/how-tape-loading-works/
122. CIO Reference
     https://atarifoundry.com/doc­s/forge/advanced-topics/cio-reference
123. The central input-output system in Atari computers
     https://www.atariarchives­.org/alp/chapter_9.php
124. ATR: chpt.1: Central Input/Output (CIO)
     https://www.atariarchives­.org/cfn/12/02/0010.php
125. NOTE and POINT
     https://atarifoundry.com/doc­s/forge/advanced-topics/note-point
126. Customizing the Atari Operating System Device Handlers: Part 1
     https://www.atarimagazines­.com/v8n2/customhandlers.html
127. Customizing the Atari Operating System Device Handlers: Part II
     https://www.atarimagazines­.com/v8n3/OperatingSystem­Handlers.html
128. Spectrum tape interface
     https://sinclair.wiki.zxnet­.co.uk/wiki/Spectrum_tape_in­terface
129. Turbo 2000
     http://wiki.oldcomp.cz/in­dex.php?title=Turbo_2000
130. Původní manuál k systému Turbo 2000
     http://wiki.oldcomp.cz/ima­ges/6/65/Zak_praha_1987_p2_tur­bo2000.pdf
131. Mark and space
     https://en.wikipedia.org/wi­ki/Mark_and_space
132. Obdélníkový průběh
     https://cs.wikipedia.org/wi­ki/Obd%C3%A9ln%C3%ADkov%C3%BD_pr%C5%AF­b%C4%9Bh
133. All you ever wanted to know about: Atari Cartridges
     https://atariwiki.org/wiki/Wi­ki.jsp?page=Cartridges
134. Manuál k MAC/65
     https://data.atariwiki.org/DOC/MAC-65_and_BUG-65_Rev._1.1-OSS-OCR.pdf
135. Manuál k DDT
     https://atariwiki.org/wiki/at­tach/DDT/DDT_1.0_Manual.pdf
136. MAC/65 na Atari wiki
     https://www.atariwiki.org/wi­ki/Wiki.jsp?page=Mac65
137. Madass – home page
     https://mads.atari8.info/
138. Mad-Assembler (GitHub)
     https://github.com/tebe6502/Mad-Assembler
139. The 6502/65C02/65C816 Instruction Set Decoded
     https://llx.com/Neil/a2/opcodes.html
140. Action
     https://atariwiki.org/wiki/Wi­ki.jsp?page=Action#top
141. Action: manuál
     https://www.atarimania.com/do­cuments/atari-action-reference-manual.pdf
142. Getting in on the Action 1
     https://atariwiki.org/wiki/Wi­ki.jsp?page=Getting%20in%20on%20the%20Ac­tion%201
143. Getting in on the Action 2
     https://atariwiki.org/wiki/Wi­ki.jsp?page=Getting%20in%20on%20the%20Ac­tion%202
144. Category:Action! na RosettaCode
     https://rosettacode.org/wi­ki/Category:Action!
145. Deep Blue C Compiler
     https://www.atarimania.com/games/atari-400–800-xl-xe-utilities-deep-blue-c-compiler-12478
146. DEEP BLUE C Manual
     https://www.atariarchives­.org/APX/showdocs.php?cat=20166
147. C/65
     https://www.atarimania.com/games/atari-400–800-xl-xe-utilities-c-65–19204
148. Getting Started Programming in C: Coding a Retro Game with C Part 2
     https://retrogamecoders.com/getting-started-with-c-cc65/
149. CC65 Advanced optimizations
     https://github.com/ilmenit/CC65-Advanced-Optimizations/tree/master/04-get%20rid%20of%20C%20stack
150. Bubble sort
     https://en.wikipedia.org/wi­ki/Bubble_sort
151. Repositář projektu Fast Basic
     https://github.com/dmsc/fastbasic
152. Fast Basic manual
     https://github.com/dmsc/fas­tbasic/blob/master/manual­.md
153. Fast Basic Cross Compiler
     https://github.com/dmsc/fas­tbasic/blob/master/compiler/U­SAGE.md
154. Short description of all Atari Basic instructions
     https://blog.3b2.sk/igi/Da­ta/Atari/Basic/abasic.html