Obsah
1. Basic-256: další moderní reinkarnace BASICu určená pro výuku programování
3. První seznámení s Basicem-256
4. Operace s proměnnými, aritmetické výrazy
7. Rozhodovací konstrukce if-then a její varianty
8. Rozhodovací konstrukce case
9. Počítaná programová smyčka typu for-next
10. Programové smyčky typu while a do-until
11. Předčasný výskok z programových smyček, skok na začátek další iterace
12. Výpočet největšího společného dělitele realizovaný v Basicu-256
13. Příkaz goto a návěští (labels)
14. Podprogramy realizované příkazy gosub a return
15. Definice nových uživatelských funkcí
16. Definice a volání podprogramů (subrutin)
17. Základy práce s poli v Basicu-256
18. Popsané příkazy (klíčová slova) Basicu-256
19. Repositář s demonstračními příklady
1. Basic-256: další moderní reinkarnace BASICu určená pro výuku programování
Již v předchozím článku jsme se zmínili o existenci několika moderních dialektů programovacího jazyka BASIC, které mnohdy nemají s původním BASICem (až na jméno) příliš společného. A právě takovým poměrně moderním dialektem BASICu je Basic-256 zmíněný v dnešním článku. Důvod, proč je zde tato aplikace zmíněna je jednoduchý – v Basicu-256 se velmi snadno pracuje s grafikou, což je samozřejmě pro potřeby výuky ideální (je například velmi snadné vytvořit si programovou pomůcku pro výuku matematiky či geometrie). Může se tak jednat o poměrně zajímavou alternativu k minule a předminule popsanému Small Basicu (a to i díky použité licenci). Paradoxně je Basic-256 v praxi mnohem lepším jazykem pro delší programy, než Small Basic, a to díky tomu, že podporuje rozdělení celého problému na podprogramy (subrutiny) a funkce.
Basic-256 ve skutečnosti není „pouze“ programovacím jazykem, ale jedná se o desktopovou aplikaci, která obsahuje i jednoduše použitelné a přehledné integrované vývojové prostředí, jež zahrnuje editor zdrojových kódů, okno zajišťující textový vstup a výstup (což znamená, že se jedná o formu textového terminálu), okno určené pro grafický vstup a výstup (grafickým vstupem je myšlena reakce na pohyb myši a stisk tlačítek myši) a v neposlední řadě podporuje toto integrované vývojové prostředí i krokování vytvářeného programu. Oproti dříve popsanému Small Basicu se však zapsaný zdrojový kód nekontroluje ihned při zápisu, ale až při jeho spuštění, popř. při krokování. To znamená, že reakce na případné chyby v zápisu zdrojového kódu jsou odhaleny později, než by to bylo pro začátečníky žádoucí. Chybová hlášení většinou obsahují přesné informace nejenom o řádku, na kterém je chyba, ale i o znaku, kde se nalezená chyba vyskytuje.
Obrázek 1: Přehledné integrované vývojové prostředí Basicu-256, které obsahuje jak podporu pro textový výstup, tak i okno, do kterého je možné vykreslit grafický výstup prováděný vytvářenou aplikací. Toto vývojové prostředí podporuje i krokování vyvíjeným programem.
2. Instalace Basicu-256
Na rozdíl od Microsoft Small Basicu je nutné Basic-256 nainstalovat. Instalační soubory pro Windows, popř. přímo spustitelná verze pro Windows, je dostupná přímo z úvodní stránky https://basic256.org/. V případě Linuxu je situace (většinou) ještě snazší, neboť Basic-256 je možné nainstalovat přímo z repositáře dané distribuce. Takže například:
$ sudo apt-get install basic256 Reading package lists... Done Building dependency tree Reading state information... Done The following additional packages will be installed: espeak-data libespeak1 libportaudio2 libqt5multimedia5 libqt5printsupport5 libqt5serialport5 libqt5sql5 libqt5sql5-sqlite The following NEW packages will be installed: basic256 espeak-data libespeak1 libportaudio2 libqt5multimedia5 libqt5printsupport5 libqt5serialport5 libqt5sql5 libqt5sql5-sqlite 0 upgraded, 9 newly installed, 0 to remove and 0 not upgraded. Need to get 2 875 kB of archives. After this operation, 16,7 MB of additional disk space will be used. Do you want to continue? [Y/n]
Po instalaci by měl být dostupný příkaz basic256:
$ which basic256 /usr/bin/basic256
I (krátká) manuálová stránka:
$ man basic256
Obrázek 2: Ověření, která verze Basicu-256 byla nainstalována.
3. První seznámení s Basicem-256
Program typu „Hello, world!“ zapsaný v klasických BASICech pocházejících z osmdesátých let minulého století vypadá takto:
PRINT "Hello, world!"
V případě Basicu-256 je možné příkazy psát i malými písmeny, takže by tentýž program mohl vypadat následovně:
print "Hello, world!"
Komentáře lze zapisovat příkazem rem:
rem Ukázka komentářů v Basicu-256 rem Program typu "Hello, world!" print "Hello, world!"
Nebo zkráceně pomocí znaku „#“:
# Ukázka komentářů v Basicu-256 # Program typu "Hello, world!" print "Hello, world!"
V současnosti, kdy je prakticky každý osobní počítač současně i multimediální stanicí, by však měla moderní varianta programu typu „Hello, world!“ vypadat odlišně – počítač by tento pozdrav mohl říci. I to je v případě Basicu-256 možné, postačuje pouze namísto příkazu print zavolat funkci say:
say("Hello, world!")
4. Operace s proměnnými, aritmetické výrazy
V Basicu-256 je možné pracovat s běžnými skalárními datovými typy, konkrétně s numerickými hodnotami (s plovoucí řádovou čárkou, podmnožinou jsou pak celá čísla) i s řetězci. Proměnné není zapotřebí deklarovat, protože se vytvoří automaticky při prvním přiřazení:
rem Základní práce s proměnnými rem (numerické proměnné) a = 42 print a
Řetězcové proměnné musí končit znakem dolaru, čímž se Basic-256 v tomto ohledu přiblížil ke klasickým BASICům (a možná se pro začátečníky jedná o dobré řešení). Paměť pro řetězce se ovšem nemusí explicitně alokovat, což je u programovacího jazyku určeného pro začátečníky jen dobře:
rem Základní práce s proměnnými rem (řetězcové proměnné) a$ = "Hello, world!" print a$
Pochopitelně je dodržena priorita základních aritmetických operátorů, což si lze ostatně snadno ověřit na následujícím demonstračním příkladu:
rem Aritmetické výrazy, priority základní operátorů x = 10 y = 20 print (x + y) * 2 print x + (y * 2) print x + y*2
5. Operace s řetězci
Řetězce je možné snadno spojit operátorem + (který je tedy přetížený). Opět si povšimněte, že řetězce, resp. paměť pro řetězce není zapotřebí explicitně alokovat:
rem Operace s řetězci rem Alokace a spojování řetězců a$ = "Hello" b$ = "world" greeting$ = a$ + " " + b$ + "!" print greeting$
Pro získání podřetězce se používají funkce nazvané left, right a mid, které byly (i když s dolarem na konci) zavedeny v Microsoft Basicu již před přibližně čtyřiceti lety:
rem Operace s řetězci rem Získání podřetězců a$ = "Hello, world!" print left(a$, 5) print right(a$, 6) print mid(a$, 8, 5)
Většina funkcí pro modifikaci řetězce ve skutečnosti vrací nový řetězec:
rem Operace s řetězci rem Náhrada části řetězce za jiný řetězec a$ = "Hello, world!" print replace(a$, "world", "root.cz")
Konkrétně funkce replace ve výchozím nastavení nahrazuje všechny nalezené podřetězce, tedy odpovídá chováním spíše funkci replaceAll:
rem Operace s řetězci rem Opakovaná náhrada části řetězce za jiný řetězec a$ = "Hello, world!" print replace(a$, "o", "*")
Velikosti písmen hrají v Basicu-256 roli pouze při práci s řetězci:
rem Operace s řetězci rem Vliv velikosti znaků na operaci pro nahrazení a$ = "Hello, world!" print replace(a$, "O", "*")
Nahrazení lze ovšem provést bez ohledu na velikost písmen, a to použitím nepovinného čtvrtého parametru funkce replace:
rem Operace s řetězci rem Vliv velikosti znaků na operaci pro nahrazení a$ = "Hello, world!" print replace(a$, "O", "*", true)
6. Vstupně-výstupní operace
Pro ruční zadávání číselných údajů nebo textu (řetězců) slouží v klasických verzích BASICu příkaz nazvaný INPUT. Ten ovšem například v minule zmíněném Small Basicu nenajdeme. Z tohoto pohledu se Basic-256 více přibližuje klasickým dialektům programovacího jazyka BASIC, protože příkaz INPUT (klidně i psaný malými písmeny) opět podporuje, jak je to ostatně patrné i z dalšího demonstračního příkladu:
rem Základní vstupně-výstupní operace input "x = ", x input "y = ", y print "Result = "; print x+y
Zajistit lze i vstup řetězců:
rem Základní vstupně-výstupní operace input "jméno: ", name$ input "příjmení: ", surname$ print "Zadáno: " + name$ + " " + surname$
Základní výstupní operaci už známe – je zajištěna příkazem print, který dokáže vypsat jednu hodnotu či větší množství hodnot uspořádaných do sloupců. Tento příkaz lze zkrátit, ostatně podobně jako v klasických interpretrech BASICu, na jediný znak ? (tato možnost byla ovšem přidána až ve verzi 2.0).
7. Rozhodovací konstrukce if-then a její varianty
Součástí prakticky jakéhokoli Turingovsky kompletního programovacího jazyka je nějaká forma rozhodovací konstrukce, popř. speciální formy se stejným významem. Výjimkou pochopitelně není ani dnes popisovaný Basic-256, který obsahuje strukturovaný příkaz typu if-then-else, jenž je doplněn o další užitečnou konstrukci case. Základní tvar tohoto příkazu neobsahuje větev else, skládá se tedy z klíčových slov if, then a endif:
rem Rozhodovací konstrukce if-then
rem Základní varianta s jedinou větví
print "x = "
input x
if x < 0 then
print "Negative value"
endif
Takzvané úplné rozvětvení do dvou nezávislých větví se provede takto:
rem Rozhodovací konstrukce if-then
rem Rozšířená varianta s oběma větvemi
print "x = "
input x
if x < 0 then
print "Negative value"
else
print "Zero or positive value"
endif
V Basicu-256 je možné – na rozdíl od mnoha starších dialektů programovacího jazyka BASIC – vnořit prakticky libovolné množství rozhodovacích konstrukcí if-then. Tuto možnost si ukážeme na demonstračním příkladu, který ve „vnější“ podmínce testuje, zda je zadaná hodnota záporná a pokud ne (tedy když je kladná či nulová), provede další rozvětvení. Mimochodem – díky tomu, že za klíčovým slovem then se automaticky vytvoří nový programový blok, by v tomto jazyku nemělo tak snadno dojít k chybám typu goto fail (k těm dochází u těch programovacích jazyků, kde je blok volitelný):
rem Rozhodovací konstrukce if-then
rem Vnořené příkazy if-then
print "x = "
input x
if x < 0 then
print "Negative value"
else
if x > 0 then
print "Positive value"
else
print "Zero"
endif
endif
8. Rozhodovací konstrukce case
Ve skutečnosti mnohdy potřebujeme vytvořit několik větví, každou vykonanou po splnění určité podmínky. Takové zřetězení podmínek v mnoha jiných programovacích jazycích zajišťuje konstrukce obsahující klíčové slovo elseif (psáno dohromady) nebo else if. Naproti tomu v Basicu-256 je podporována odlišná konstrukce založená na zápisu většího množství podmínek za klíčové slovo case. Výsledek je (podle mého názoru) čitelnější, protože opticky nepreferuje první podmínku tak, jako je tomu v řetězci if-elseif-elseif…:
rem Rozhodovací konstrukce case
print "x = "
input x
begin case
case x < 0
print "Negative value"
case x > 0
print "Positive value"
else
print "Zero"
endcase
9. Počítaná programová smyčka typu for-next
Prakticky všechny dialekty programovacího jazyka BASIC podporují počítanou programovou smyčku typu for-next. Určitou výjimkou byl minule popsaný Small Basic, v němž bylo klíčové slovo next nahrazeno za nicneříkající endfor bez specifikovaného kontextu (tedy jména řídicí proměnné smyčky). Basic-256 se v tomto ohledu vrací ke kořenům, což je ostatně patrné i na následujícím programu s počítanou smyčkou:
rem Základní podoba programové smyčky for-next
for i = 1 to 10
print i
next i
Specifikovat je možné i krok, tedy hodnotu, o kterou se bude měnit počitadlo smyčky po každé iteraci:
rem Základní podoba programové smyčky for-next
rem se specifikací kroku
for i = 1 to 10 step 2
print i
next i
V případě, že jsou oba limity nastaveny na shodnou hodnotu, proběhne tělo smyčky přesně jednou (na rozdíl od některých starších interpretrů, které se v tomto ohledu chovají chybně):
rem Základní podoba programové smyčky for-next
rem s oběma limitami nastavenými na shodnou hodnotu
for i = 0 to 0
print i
next i
Již minule jsme si ukazovali příklad, ve kterém má dolní limit vyšší hodnotu než limit horní. Basic-256 na tuto situaci reaguje korektně, a to tak, že smyčka neproběhne ani jednou:
rem Základní podoba programové smyčky for-next
rem s dolním limitem vyšším než horní limit
for i = 1 to 0
print i
next i
Na rozdíl od (například) Pascalu je možné v BASICech měnit hodnotu počitadla o neceločíselný krok:
rem Základní podoba programové smyčky for-next
rem se záporným krokem.
for i = 1 to 0 step -0.3
print i
next i
Následující demonstrační příklad ukazuje jeden z problematických rysů Basicu-256: i když lze limity počítané programové smyčky specifikovat proměnnou, nebude případná změna této proměnné uvnitř smyčky reflektována, což je chování odlišné od Small Basicu. To mj. znamená, že zdaleka ne všechny algoritmy jsou jednoduše přenositelné na sémantické úrovni (syntaxe odlišná je, ale je snadné ji upravit):
rem Programová smyčka for-next
rem s postupně modifikovaným horním limitem
max = 5
for i = 1 to max
print i
max = max + 2
next i
Totéž platí i při snaze modifikovat hodnotu kroku – opět nebude nová hodnota korektně reflektována:
rem Programová smyčka for-next
rem s postupně modifikovaným krokem
s = 1
for i = 1 to 10 step s
print i
s = s / 2.0
next i
10. Programové smyčky typu while a do-until
Dalším typem programové smyčky je smyčka typu while. Ta například v GW-BASICu existuje ve variantě založené na klíčových slovech WHILE a WEND. V Basicu-256 je začátek smyčky (a podmínka) zapsána za klíčovým slovem while a konec smyčky je označen souslovím end while:
rem Základní podoba programové smyčky typu while
i = 1
while i < 1000
print i
i = i * 2
end while
Existuje i programová smyčka, v níž se podmínka pro ukončení testuje až po provedení těla smyčky. V Basicu-256 je tato smyčka reprezentována klíčovými slovy do a until:
rem Základní podoba programové smyčky typu do-until
i = 1
do
print i
i = i * 2
until i > 1000
11. Předčasný výskok z programových smyček, skok na začátek další iterace
Předčasný výskok z programové smyčky typu for-next se provádí příkazem exit for, který tedy odpovídá příkazu break z céčkovské větve programovacích jazyků:
for i = 1 to 100
print i
if i > 17 then
exit for
endif
next i
Podobným způsobem je možné vyskočit i z dalších typů programových smyček.
Existuje i příkaz typu continue, který provede okamžitý přeskok na podmínky určující, zda se má provést další iterace či nikoli:
for i = 1 to 20
if i % 2 = 0 then
continue for
endif
print i
next i
Varianta příkazu continue pro další typy programových smyček:
i = 0
while i <= 20
i = i + 1
if i % 2 = 0 then
continue while
endif
print i
end while
A konečně varianta continue, tentokrát pro smyčku do-until:
i = 0
do
i = i + 1
if i % 2 = 0 then
continue do
endif
print i
until i >= 20
12. Výpočet největšího společného dělitele realizovaný v Basicu-256
V článcích o GW-BASICu (PC-Basicu) i o Small Basicu jsme si ukázali program pro výpočet největšího společného dělitele dvou celých kladných čísel. Tento výpočet je možné s využitím programové smyčky typu while realizovat i v Basicu-256, a to například následujícím způsobem:
rem Výpočet největšího společného dělitele
print "x = "
input x
print "y = "
input y
while x<>y
if x>y then
x=x-y
endif
if x<y then
y=y-x
endif
end while
print "gcd = "
print x
13. Příkaz goto a návěští (labels)
Basic-256 by nebyl pravým BASICem, kdyby neobsahoval příkaz GOTO. Ovšem vzhledem k tomu, že se v tomto dialektu BASICu nepoužívají čísla řádků, je nutné cíl skoku definovat takzvaným návěštím neboli label. V naprosté většině algoritmů se příkazu goto snadno vyhneme, ovšem pro úplnost si ukažme příklad jeho použití:
i = 1
LOOP:
print i
i = i + 1
if i <= 10 then
goto LOOP
endif
Přepis algoritmu pro výpočet největšího společného dělitele lze přepsat nestrukturovaným způsobem tak, aby se použil právě příkaz goto:
rem *****************************
rem Výpočet největšího společného
rem dělitele.
rem
rem Úprava pro Basic-256
rem
rem *****************************
rem
rem
print "X = "
input x
print "Y = "
input y
LOOP:
if x = y then
print x
goto DONE
endif
if x > y then
x = x -y
goto LOOP
endif
if x < y then
y = y -x
goto LOOP
endif
DONE:
Je však nutné si dát pozor na to, aby jméno návěští nebylo shodné s nějakým klíčovým slovem (což je jedna z největších nevýhod těchto moderních BASICů – mají příliš velké množství klíčových slov, do kterých se lze relativně snadno „trefit“):
rem *****************************
rem Výpočet největšího společného
rem dělitele.
rem
rem Úprava pro Basic-256
rem
rem Nekorektní název cíle skoku
rem *****************************
rem
rem
print "X = "
input x
print "Y = "
input y
LOOP:
if x = y then
print x
goto END
endif
if x > y then
x = x -y
goto LOOP
endif
if x < y then
y = y -x
goto LOOP
endif
END:
14. Podprogramy realizované příkazy gosub a return
Basic-256 pochopitelně podporuje tvorbu podprogramů, podobně jako prakticky všechny starší implementace BASICu. Připomeňme si, že v klasických nestrukturovaných BASICech nebyl začátek podprogramu nijak označen – prostě se jednalo o jakýkoli programový řádek, na který se skákalo příkazem GOSUB (podprogram tedy ani nebyl pojmenován). Návrat z podprogramu byl řešen příkazem RETURN. V případě Basicu-256 lze tento postup stále použít, ovšem namísto čísla řádku se pochopitelně použije návěští. Alternativně lze ovšem deklarovat i plnohodnotné funkce a podprogramy, což si ukážeme v navazujících kapitolách. Nejdříve se však podívejme na jednoduchý demonstrační příklad, v němž jsou použita klíčová slova gosub a return:
rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití programové konstrukce
rem GOSUB-RETURN
rem
rem *****************************
for n=1 to 20
gosub FACTORIAL
print fact
next n
end
rem *****************************
rem Výpočet faktoriálu
rem *****************************
FACTORIAL:
fact=1
for i=n to 1 step -1
fact=fact*i
next i
return
15. Definice nových uživatelských funkcí
Mnohem silnější programovací technikou je ovšem definice nových uživatelských funkcí. Díky podpoře uživatelských funkcí je možné celý problém rozdělit na jednodušeji implementovatelné a testovatelné jednotky – a právě tvorba programů stylem „rozděl a panuj“ by se měla učit již v prvních nepatrně složitějších algoritmech. Podívejme se nyní na to, jak lze funkce použít v Basicu-256:
rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití definované uživatelské
rem funkce
rem
rem *****************************
for n=1 to 20
print factorial(n)
next n
end
rem *****************************
rem Výpočet faktoriálu
rem *****************************
function factorial(n)
fact=1
for i=n to 1 step -1
fact=fact*i
next i
return fact
end function
Vidíme, že pro návrat hodnoty z funkce je použito klíčové slovo return. Alternativně je však možné použít zápis, který více odpovídá původním „strukturovaným“ BASICům, tedy přiřazením návratové hodnoty do jména funkce:
rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití definované uživatelské
rem funkce
rem
rem *****************************
for n=1 to 20
print factorial(n)
next n
end
rem *****************************
rem Výpočet faktoriálu
rem *****************************
function factorial(n)
fact=1
for i=n to 1 step -1
fact=fact*i
next i
factorial = fact
end function
16. Definice a volání podprogramů (subrutin)
Basic-256 podporuje i tvorbu plnohodnotných (pojmenovaných) podprogramů, a to dokonce podprogramů s parametry. Nesmíme však zapomenout na to, že volání podprogramů je realizováno klíčovým slovem call, tedy odlišným způsobem, než volání funkcí:
rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití podprogramu.
rem
rem *****************************
for n=1 to 20
call factorial(n)
next n
end
rem *****************************
rem Výpočet faktoriálu
rem *****************************
subroutine factorial(n)
fact=1
for i=n to 1 step -1
fact=fact*i
next i
print fact
end subroutine
17. Základy práce s poli v Basicu-256
Vyzkoušejme si ještě práci s poli. Pole je – na rozdíl od řetězců – nutné alokovat, a to příkazem dim. Délku pole lze získat zcela unikátně – výrazem jméno_pole[?]:
rem Alokace pole a výpis délky pole dim a(10) print a[?]
Prvky pole lze procházet standardní počítanou smyčkou for-next:
rem Procházení prvky pole
rem S využitím standardní smyčky FOR-NEXT
dim a(10)
for i = 0 to a[?]-1
a[i] = 1/(i+1)
next i
for i = 0 to a[?]-1
print a[i]
next i
Nebo je možné použít specializovanou smyčku for-each:
rem Procházení prvky pole
rem S využitím smyčky FOR-EACH
dim a(10)
for i = 0 to a[?]-1
a[i] = 1/(i+1)
next i
for each item in a
print item
next item
18. Popsané příkazy (klíčová slova) Basicu-256
Jak je u různých dialektů programovacího jazyka BASIC zvykem, je struktura programů určována do velké míry použitými klíčovými slovy (neboli příkazy) a nikoli množstvím různých dalších znaků.
V dnešním článku jsme si popsali následující příkazy:
| # | Příkaz | Stručný popis příkazu |
|---|---|---|
| 1 | tisk hodnoty na textovou konzoli | |
| 2 | say | hlasité přečtení obsahu řetězce |
| 3 | rem | poznámka (lze nahradit znakem #) |
| 4 | input | interaktivní vstup (číslo nebo řetězec) |
| 5 | if | příkaz, za kterým následuje podmínka |
| 6 | then | začátek větve vykonané při splnění podmínky |
| 7 | endif | konec rozhodovacího příkazu if |
| 8 | else | začátek větve vykonané při nesplnění podmínky |
| 9 | begin case | začátek rozhodovací konstrukce s více podmínkami |
| 10 | case | začátek větve se specifikovanou podmínkou |
| 11 | endcase | konec rozhodovacího příkazu case |
| 12 | for | začátek počítané programové smyčky |
| 13 | to | klíčové slovo, za nímž následuje horní mez smyčky |
| 14 | step | klíčové slovo, za nímž následuje krok smyčky |
| 15 | next | konec počítané programové smyčky |
| 16 | while | začátek programové smyčky s testem na začátku |
| 17 | end while | konec programové smyčky s testem na začátku |
| 18 | do | začátek programové smyčky s testem na konci |
| 19 | until | konec programové smyčky s testem na konci |
| 20 | goto | nestrukturovaný skok na určené návěští (label) |
| 21 | gosub | skok do podprogramu realizovaný návěštím |
| 22 | return | návrat z podprogramu |
| 23 | function | začátek definice funkce |
| 24 | end function | konec definice funkce |
| 25 | subroutine | začátek definice podprogramu |
| 26 | end subroutine | konec definice podprogramu |
| 27 | call | volání podprogramu |
| 28 | dim | alokace pole |
| 29 | end | ukončení celého programu |
19. Repositář s demonstračními příklady
Všechny dnes popsané demonstrační příklady určené pro Basic-256 (a tudíž nekompatibilní s žádným jiným BASICem) byly uloženy do Git repositáře, který je dostupný na adrese https://github.com/tisnik/8bit-fame. Tyto příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý (dnes již poměrně rozsáhlý) repositář:
20. Odkazy na Internetu
- Stránka projektu Basic-256
https://basic256.org/ - So You Want to Learn to Program – BASIC-256 (Third Edition)
http://syw2l.org/?page_id=407 - Why Another BASIC?
https://basic256.org/2019/06/27/why-another-basic/ - Stránka projektu Small Basic
https://smallbasic-publicwebsite.azurewebsites.net/ - List of Programs Made with Small Basic
https://social.technet.microsoft.com/wiki/contents/articles/14013.list-of-programs-made-with-small-basic.aspx - Expert to Expert: The Basics of SmallBasic
https://channel9.msdn.com/blogs/charles/expert-to-expert-the-basics-of-smallbasic - The Developer’s Reference Guide to Small Basic
https://social.technet.microsoft.com/wiki/contents/articles/16767.the-developers-reference-guide-to-small-basic.aspx - Small Basic – Talking to Raspberry Pi
https://techcommunity.microsoft.com/t5/small-basic-blog/small-basic-talking-to-raspberry-pi/ba-p/337844 - Small Basic – Arduino
https://techcommunity.microsoft.com/t5/small-basic-blog/small-basic-arduino/ba-p/337762 - Small Basic + micro:bit
https://techcommunity.microsoft.com/t5/small-basic-blog/small-basic-micro-bit/ba-p/1968424 - #1 Learn Small Basic Programming – Introduction
https://www.youtube.com/watch?v=e_BaEPCa8OQ - #2 Learn Small Basic Programming – Input, Output & Variables
https://www.youtube.com/watch?v=VWekYLa33OI - #3 Learn Small Basic Programming – String Concatenation
https://www.youtube.com/watch?v=iWvIaOaT474 - Small Basic – The Programmer's Guide
https://www.i-programmer.info/programming/other-languages/5196-small-basic-the-programmers-guide.html - Rosetta Code: Category:Microsoft Small Basic
https://rosettacode.org/wiki/Category:Microsoft_Small_Basic - Fifty Years of BASIC, the Programming Language That Made Computers Personal
https://time.com/69316/basic/ - BBC BASIC i QBasic oslavují svá kulatá výročí
https://www.root.cz/clanky/bbc-basic-i-qbasic-oslavuji-sva-kulata-vyroci/ - What are the best BASIC-like programming languages?
https://www.slant.co/topics/9807/~basic-like-programming-languages - List of BASIC dialects
https://en.wikipedia.org/wiki/List_of_BASIC_dialects - GW-BASIC Documentation
https://hwiegman.home.xs4all.nl/gwbasic.html - Microsoft Open-Sources GW-BASIC
https://devblogs.microsoft.com/commandline/microsoft-open-sources-gw-basic/ - GW-BASIC na GitHubu
https://github.com/microsoft/GW-BASIC - Welcome to GW-BASIC
http://www.antonis.de/qbebooks/gwbasman/ - GWBASIC User's Manual
http://www.antonis.de/qbebooks/gwbasman/index2.html - The basics of BASIC, the programming language of the 1980s
https://www.youtube.com/watch?v=seM9SqTsRG4 - GW-BASIC User's Guide
https://hwiegman.home.xs4all.nl/gw-man/index.html - PC-BASIC 1.2.14 documentation
http://robhagemans.github.io/pcbasic/doc/1.2/ - PEEK and POKE
https://en.wikipedia.org/wiki/PEEK_and_POKE - GW-BASIC | DRAW Statement (video na Youtube)
https://www.youtube.com/watch?v=4I1CELY13M4 - Rozdíly mezi GW-BASIC a QBasicem
https://hwiegman.home.xs4all.nl/extern/Differences%20Between%20GW-BASIC%20and%20QBasic.htm - GW-Basic Programs
https://gwbasicprograms.blogspot.com/p/gw-basic-programs.html - GW-BASIC Resource
https://gw-basic.netlify.app/ - A page about GWBASIC Games & Other Programs
http://peyre.x10.mx/GWBASIC/ - Basic BASIC, 2nd Edition, James S. Coan
https://drive.google.com/uc?export=download&id=1Z12L7SO_gfNg3Ma_0eH2_Kz15YM-9dHl - Advanced BASIC, James S. Coan
https://drive.google.com/uc?export=download&id=1JafSpV_BLylWHMd16rDPorwv9wV9bLcy - Structured BASIC, 2nd Edition, James F. Clark (naskenovaná kniha)
https://drive.google.com/uc?export=download&id=1pT8y-8yJYS_SqvxF0fBHm6S-dlAt-Uy2 - Last Book of GW-Basic
https://www.geocities.ws/joseph_sixpack/btoc.html - SCIENTIFIC PROGRAMS WRITTEN IN BASIC (for PCs)
https://web.archive.org/web/20160323064356/http://www.scn.org/~bh162/basic_programs.html - Why I love programming on FreeDOS with GW-BASIC
https://opensource.com/article/21/6/freedos-gw-basic - Quite BASIC (web-based classic BASIC online programming environmen)
http://www.quitebasic.com/ - GFA-BASIC
http://sites.google.com/site/gfabasic16/ - E-mail od tvůrce GW-Basicu
http://www.classiccmp.org/pipermail/cctech/2005-April/042999.html - General Electric GE-400
http://www.feb-patrimoine.com/PROJET/ge400/ge-400.htm - GE-400 Time-sharing information systems:
http://www.computerhistory.org/collections/accession/102646147 - A brief history of the development of BASIC (pravděpodobně již nefunkční odkaz)
http://www.phys.uu.nl/~bergmann/history.html - History of BASIC (PDF)
http://www.q7basic.org/History%20of%20BASIC.pdf - Dartmouth College Computation Center. 1964.-The original Dartmouth BASIC manual
http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf - The Original BASIC
http://www.truebasic.com/ - BASIC – Beginners All-purpose Symbolic Instruction Code
http://hopl.murdoch.edu.au/showlanguage.prx?exp=176 - Dartmouth Time Sharing System
http://en.wikipedia.org/wiki/Dartmouth_Time_Sharing_System - General Electric (Wikipedia)
http://en.wikipedia.org/wiki/General_Electric - GE 225 vs. IBM 1401
http://ed-thelen.org/GE225-IBM1401.html - A GE-225 is found
http://ed-thelen.org/comp-hist/GE225.html - G.E. 200 Series Computers
http://www.smecc.org/g_e__200_series_computers.htm - DTSS – Dartmouth Time Sharing System
http://dtss.dartmouth.edu/index.php - John G. Kemeny: BASIC and DTSS: Everyone a Programmer
http://dtss.dartmouth.edu/everyoneaprogrammer.php - GE-200 series (Wikipedia)
http://en.wikipedia.org/wiki/GE-200_series - GE-400 series (Wikipedia)
http://en.wikipedia.org/wiki/GE-400_series - GE-600 series (Wikipedia)
http://en.wikipedia.org/wiki/GE-600_series - ZX Basic Manual
http://www.worldofspectrum.org/ZXBasicManual/ - ZX81 BASIC Programming
http://www.worldofspectrum.org/ZX81BasicProgramming/ - Sinclair BASIC History
http://scratchpad.wikia.com/wiki/Sinclair_BASIC_History - Sinclair BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Sinclair_BASIC - Sinclair BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/Sinclair_BASIC - Beta BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/Beta_BASIC - Beta BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Beta_BASIC - BETA BASIC NEWSLETTER No 8
http://spectrum128.ru/help/BetaBasicNewsletter8.pdf - R. T. RUSSELL: The home of BBC BASIC
http://www.rtrussell.co.uk/ - R. T. RUSSELL: A History of BBC BASIC
http://www.cix.co.uk/~rrussell/bbcbasic/history.html - SuperBASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/SuperBASIC - SuperBASIC (Wikipedia CZ)
http://en.wikipedia.org/wiki/SuperBASIC - Laser Basic/Laser Compiler
http://www.sincuser.f9.co.uk/049/laser.htm - Laser BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Laser_BASIC - BBC BASIC
http://www.bbcbasic.co.uk/bbcbasic.html - BBC BASIC
http://mdfs.net/Software/BBCBasic/ - BBC BASIC (Z80) for the ZX Spectrum
http://mdfs.net/Software/BBCBasic/Spectrum/ - BBC BASIC (Wikipedia CZ)
http://en.wikipedia.org/wiki/BBC_BASIC - BeebWiki – 8-bit Acorn Computer Wiky
http://beebwiki.jonripley.com/Main_Page - Porovnání osmibitů
http://porovnani8bitu.spaces.live.com/ - Rosetta Code – Main Page
http://rosettacode.org/wiki/Main_Page - Rosetta Code – Category Basic
http://rosettacode.org/wiki/Category:BASIC - QBasicJedi
http://www.freewebs.com/qbasicjedi/ - QBasic/QuickBasic Downloads
http://www.freewebs.com/qbasicjedi/qbdownloads.html - QuickBASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/QuickBASIC - QBasic.com
http://www.qbasic.com/ - QBasic (Wikipedia)
http://cs.wikipedia.org/wiki/QBasic - Dialling with QBASIC
http://www.mysundial.ca/tsp/qbasic.html - BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/BASIC - BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/BASIC - Turbo BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Turbo_BASIC - More BASIC Computer Games
http://www.atariarchives.org/morebasicgames/ - How to build an interpreter in Java, Part 1: The BASICs
http://www.javaworld.com/jw-05–1997/jw-05-indepth.html - INTEGER BASIC Reference
http://www.landsnail.com/a2ref2.htm - APPLESOFT Reference
http://www.landsnail.com/a2ref.htm - Applesoft Lite: Applesoft BASIC for the Replica-1
http://cowgod.org/replica1/applesoft/ - Simons' BASIC
http://en.wikipedia.org/wiki/Simons'_BASIC - Simon's Basic
http://www.lemon64.com/?mainurl=http%3A//www.lemon64.com/museum/list.php%3Flineoffset%3D54%26genre%3Dmanualmisc - BASIC
http://www.c64-wiki.com/index.php/BASIC - C64 Wiki: Simons Basic
http://www.c64-wiki.de/index.php/Simons_Basic - Simons' Basic (evaluation)
http://www.atarimagazines.com/creative/v9n11/60_Simons_Basic.php - Bill Gates' Personal Easter Eggs in 8 Bit BASIChttp://www.pagetable.com/?p=43
- Třicet let od vydání revolučního Turbo Pascalu 5.5
https://www.root.cz/clanky/tricet-let-od-vydani-revolucniho-turbo-pascalu-5–5/ - Let's make a small and simple GW-BASIC program!
https://www.youtube.com/watch?v=OyPUn74nj-s - Seriál Letní škola programovacího jazyka Logo
http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/ - Educational programming language
http://en.wikipedia.org/wiki/Educational_programming_language - Logo Tree Project:
http://www.elica.net/download/papers/LogoTreeProject.pdf
ČLÁNKY DO MAILU