Hlavní navigace

Small Basic: moderní reinkarnace BASICu určená pro výuku programování

12. 10. 2021
Doba čtení: 31 minut

Sdílet

 Autor: Pavel Tišnovský
Už jsme se několikrát zmínili o jazycích navržených pro výuku programování. Do této kategorie spadá i Small Basic, jehož jméno se sice odkazuje na klasické BASICy, ovšem jedná se o značně rozdílný dialekt.

Obsah

1. Jazyky určené (a někdy i vhodné) pro výuku programování

2. Když je „vizuální“ programování již náročné: projekt Small Basic

3. První seznámení se Small Basicem – program typu „Hello, world!“

4. Práce s proměnnými, základní datové typy

5. Předpřipravené objekty, manipulace s řetězci

6. Interaktivní vstup dat

7. Podmínky, strukturovaný příkaz typu if-then-else

8. Vnořené konstrukce if-then

9. Počítaná programová smyčka typu FOR-NEXT

10. Programová smyčka typu WHILE

11. Výpočet největšího společného dělitele – realizace v GW-BASICu a Small Basicu

12. Podprogramy

13. Převod programu postaveného na podprogramech z GW-BASICu do Small Basicu

14. Příkaz GOTO aneb vaříme špagety

15. Převod programu postaveného na GOTO z GW-BASICu do Small Basicu

16. Pole a mapy – překvapivě snadné téma

17. Pasti připravené ve Small Basicu

18. Obsah druhého článku o Small Basicu

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

20. Odkazy na Internetu

1. Jazyky určené (a někdy i vhodné) pro výuku programování

It's a bit like learning natural languages: the earlier the better.
Michael Kölling

V současnosti existuje a je aktivně používáno několik desítek programovacích jazyků, ať již jazyků interpretovaných či překládaných do nativního kódu nebo bajtkódu. Až na několik výjimek se však jedná o takové jazyky, které nejsou příliš vhodné pro první seznámení dětí s návrhem algoritmů a jednoduchých aplikací. Z tohoto důvodu vzniklo a stále ještě vzniká poměrně velké množství projektů, jejichž cílem je seznámit děti předškolního věku či děti na prvním stupni ZŠ se základem algoritmizace a mnohdy i s tvorbou počítačové grafiky (protože grafický výstup či dokonce animace jsou nepochybně atraktivní). Jmenujme například projekty Logo, Scratch, BYOB, Snap!, Alice, Android App Inventor, Starlogo, Etoys, DesignBlocks, Pocket Code, Hopscotch, Blockly, Greenfoot, Processing, GameMaker nebo právě Microsoft Small Basic, kterým se budeme zabývat dnes.

Obrázek 1: Moderní integrovaná vývojová prostředí jsou sice pro amatérské i profesionální programátory velmi užitečná, ovšem při výuce může jejich velká variabilita být v některých ohledech spíše kontraproduktivní.

Některé v praxi používané programovací jazyky (například Python či možná spíše Lua) je sice možné použít pro výuku programování, ovšem pro děti předškolního věku nebo pro děti na prvním stupni základních škol se podle mého názoru příliš nehodí, a to hned z několika důvodů. Jedním z těchto důvodů je nutnost zápisu algoritmů pomocí více či méně strukturovaného textu, jehož syntaxe je hlídána buď interpretrem či překladačem. Jedná se o nejdéle používaný způsob programování, jehož počátky můžeme hledat v hluboké počítačové minulosti, protože první překladač pracující se strojovým textem byl vytvořen již v rozmezí let 1951 až 1952 Grace Hopperovou v rámci projektu A-0 (Arithmetic Language version 0), který byl později následován známým FORTRANem navrženým Johnem W. Backusem a jeho vývojovým týmem. Ovšem v průběhu oněch cca šedesáti let se znovu a znovu objevovaly více či méně úspěšné pokusy o vizuální návrh algoritmů, tj. o tvorbu programů nikoli zápisem strukturovaného zdrojového textu, ale návrhem algoritmů pomocí diagramů vytvářených například s využitím myši, gesty či v minulosti pomocí světelného pera.

Obrázek 2: Bloky, z nichž se programy tvořené ve Scratchi skládají, jsou na základě své funkce rozděleny do osmi kategorií. Povšimněte si, že prostředí Scratche bylo téměř kompletně počeštěno; jedna z mála částí ponechaná v angličtině je nápověda k jednotlivým příkazům (i když i tato část se pravděpodobně brzy přeloží).

Poměrně dobře známé jsou například pokusy o přímý „překlad“ klasických vývojových diagramů, využití takzvaných kopenogramů atd. V současnosti někteří analytici a vývojáři využívají vizuální/grafický jazyk UML (což je ovšem jen pomůcka) či BPM (návrh business procesů, ovšem s vhodně zvolenými bloky se vlastně jedná o plnohodnotný jazyk). V oblasti software určeného pro výuku programování se využívá podobný princip, jako v případě vývojových diagramů – možnost zápisu (či možná lépe řečeno deklarace) algoritmů s využitím bloků představujících jednotlivé příkazy či volané funkce, které jsou doplněny o základní strukturované příkazy určené pro tvorbu rozhodovacích podmínek a programových smyček. Na tomto principu, tj. na vylepšených a vizuálně přitažlivějších vývojových diagramech, je postaven i projekt Scratch, v němž jsou uživatelům nabídnuty základní stavební bloky, z nichž se program skládá, přičemž je ponecháno pouze na uživateli, jakým způsobem tyto bloky využije ve svých programech.

Obrázek 3: Programy se ve Scratchi tvoří přetahováním příkazových bloků z oblasti umístěné v levé části okna do střední oblasti, zde nadepsané „Skripty“ (nová verze Scratche používá nepatrně odlišný design grafického uživatelského rozhraní).

Díky způsobu implementace skládání bloků pod sebe, popř. do sebe (s využitím „zámků“, podobně jako u puzzle) je zajištěno, že program bude po syntaktické stránce vždy v pořádku, což je důležité, protože odpadá pro děti nudná oprava překlepů, hledání chybějících středníků, hlídání párovosti závorek i další činnosti spojené s prací s běžnými programovacími jazyky. Uživatel se tedy musí starat o to podstatné – o sémantiku navrhované aplikace.

Obrázek 4: Editor bitmapových spritů zabudovaný přímo ve Scratchi.

2. Když je „vizuální“ programování již náročné: projekt Small Basic

„BASIC used to be on every computer a child touched – but today there's no easy way for kids to get hooked on programming.“

Scratch a od něj odvozené projekty je velmi populárním vývojovým nástrojem, ovšem s rostoucí délkou programů se stává jeho používání poměrně neefektivní, stejně jako v případě úpravy programů (zejména zápisy výrazů). Proto je – alespoň podle mého názoru – vhodné po dosažení určité úrovně přejít na standardnější typ tvorby programů – a to založeného na zápisu zdrojových kódů lety ověřeným způsobem a s případnou dopomocí formou nápovědy, kontextových nabídek atd. A právě tímto směrem se vydal i Small Basic, což je projekt založený na myšlenkách uveřejněných ve známém článku Why Johnny can’t code. Small Basic v současnosti existuje jak ve formě běžné aplikace pro Windows, tak i ve formě „webového integrovaného vývojového prostředí“, které je dostupné na adrese smallbasic-publicwebsite.azurewebsites.net/.

Poznámka: webové prostředí kupodivu funguje bez problémů i ve Firefoxu běžícího v Linuxu.

Samotný Small Basic je navržen poměrně minimalisticky, protože rozpoznává pouze čtrnáct klíčových slov a dva operátory zapsané slovy; další funkcionalita je „schována“ v jednotlivých modulech:

# Klíčové slovo Stručný popis klíčového slova
1 If začátek rozhodovací konstrukce
2 Then podmíněná větev v rozhodovací konstrukci
3 Else alternativní (nepovinná) větev v rozhodovací konstrukci
4 ElseIf další podmínka (opět nepovinná) v rozhodovací konstrukci
5 EndIf konec rozhodovací konstrukce
6 For začátek počítané programové smyčky for
7 To specifikace druhé limitní hodnoty počítané programové smyčky for
8 Step specifikace kroku (změny) počitadla v programové smyčce for
9 EndFor konec těla programové smyčky typu for
10 While začátek programové smyčky typu while se specifikací podmínky
11 EndWhile konec těla programové smyčky typu while
12 Sub začátek podprogramu se specifikací jeho jména
13 EndSub konec podprogramu začínajícího klíčovým slovem sub
14 Goto nestrukturovaný skok na jiné místo programu
     
15 And logická spojka – součin
16 Or logická spojka – součet

Small Basic podporuje jen globální proměnné (což zásadním způsobem omezuje jeho použití ve větších projektech!) a umožňuje zápis podprogramů, ovšem bez možnosti předání parametrů v argumentech. Další vlastnosti a omezení jsou zmíněny v dalším textu.

Obrázek 5: Uživatelské prostředí Small Basicu je navrženo takovým způsobem, aby obsahovalo pouze ty nejnutnější operace.

Poznámka: označení „Small“ se týká počtu klíčových slov jazyka a částečně i jeho vyjadřovací schopnosti. Samotná implementace „Small“ Basicu ovšem není v žádném případě „malá“, zejména v porovnání s klasickými BASICy, z nichž většina byla implementována v osmi kilobajtech ROM, některé větší pak v šestnácti kilobajtech (existují však i BASICy pro 2kB a 4kB ROM).

3. První seznámení se Small Basicem – program typu „Hello, world!“

Small Basic je možné začít používat přímo z webového prohlížeče. Webové integrované vývojové prostředí je dostupné na adrese smallbasic-publicwebsite.azurewebsites.net/. Samotné grafické uživatelské rozhraní je pojato minimalisticky, ale přesto zde nalezneme například i jednoduchý debugger a taktéž (pro začátečníky důležité) kontextové doplňování funkcí a metod, které jsou rozděleny do několika modulů:

Obrázek 6: Kontextové doplňování (resp. nabídka) názvů funkcí, atributů i metod (ty si, kromě dvou základních metod, popíšeme příště).

Po zápisu alespoň jednoho znaku z názvu funkce/metody/atributu se pochopitelně nabídka zúží:

Obrázek 7: Zúžení kontextové nabídky.

Obrázek 8: Automaticky se zobrazí i nápověda k vybranému identifikátoru, ale v mnoha prohlížečích je text nápovědy rozházen.

Případné chyby jsou okamžitě hlášeny již při zápisu jednotlivých řádků:

Obrázek 9: Nahlášená chyba.

Nyní si ukažme standardní program typu „Hello, world!“ v jeho variantě pro Small Basic. Ve standardním BASICu by tento program vypadal takto:

PRINT "Hello, world!"

Ovšem ve Small Basicu klíčové slovo PRINT neexistuje. Namísto toho musíme použít metodu WriteLine objektu TextWindow (i když začátečníkům není nutné pojmy „objekt“ a „metoda“ vysvětlovat a ani nikde v oficiální dokumentaci uvedeny nejsou):

TextWindow.WriteLine("Hello, world!")

Po spuštění tohoto programu by se měla otevřít textová konzole (ve stejném okně prohlížeče), do ní by se měla vypsat příslušná zpráva a za ní ještě informace o tom, že byl program úspěšně ukončen:

Obrázek 10: Zpráva vypsaná programem typu „Hello, world!“ současně s informací o úspěšném ukončení programu.

4. Práce s proměnnými, základní datové typy

Proměnné se vytvoří automaticky při jejich prvním použití v programu. Typicky se jedná o přiřazení hodnoty do proměnné. Přitom lze použít jak numerické hodnoty, tak i řetězce, a to bez explicitního uvedení typu proměnné (typ je přiřazen k hodnotě):

message = "Hello, world!"
TextWindow.WriteLine(message)
Poznámka: na rozdíl od klasických BASICů se tedy zcela obejdeme bez příkazu DIM a nepoužívají se ani suffixy $ pro označení proměnných obsahujících řetězce.

Pochopitelně je podporována i práce s proměnnými obsahujícími numerické hodnoty. K dispozici je i standardní pětice aritmetických operátorů:

x = 10
y = 20
z = x + y
TextWindow.WriteLine(z)

Pro Small Basic je typické, že lze kombinovat numerické hodnoty s řetězci, což je ovšem na druhou stranu zdroj častých problémů:

message = "Result: "
x = 10
y = 20
z = x + y
TextWindow.WriteLine(message + z)

5. Předpřipravené objekty, manipulace s řetězci

Již v předchozím textu jsme se zmínili o předpřipravených objektech a jejich metodách popř. i o atributech. Tímto způsobem jsou řešeny například i operace s řetězci. V původních BASICech od společnosti Microsoft se například pro získání podřetězce daly použít vestavěné funkce pojmenované LEFT$, RIGHT$ a MID$:

1 REM *****************************
2 REM Prace s retezci, manipulace
3 REM s obsahem retezcu.
4 REM
5 REM Uprava pro GW-BASIC
6 REM
7 REM *****************************
8 REM
9 REM
30 A$="HELLO WORLD!"
40 PRINT A$
50 PRINT LEFT$(A$, 5)
60 PRINT RIGHT$(A$, 6)
70 PRINT MID$(A$, 7, 5)
999 END

Ve Small Basicu je namísto toho nutné použít funkce (nebo, chcete-li, třídní metody) objektu Text. Pro získání podřetězce se použije GetSubText:

txt = "www.root.cz"
message = Text.GetSubText(txt, 5, 4)
TextWindow.WriteLine(message)
Poznámka: na jednu stranu ve Small Basicu musíme používat dlouhé kombinace názvů objektů a metod, na stranu druhou se využitím „tečkové notace“ vyřešily dva problémy: již zmíněná kontextová nápověda a taktéž logické rozdělení funkcí podle jejich významu. Taktéž je nyní možné mít více funkcí se stejným jménem, ale s odlišným významem – postačuje, aby byly definovány jako metody v jiném objektu, který zde současně slouží jako jmenný prostor. Příkladem může být funkce/metoda nazvaná Show, která je použita několikrát, pokaždé ovšem v jiném kontextu a tím pádem i s odlišným chováním.

6. Interaktivní vstup dat

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 ve Small Basicu nenajdeme. Namísto toho je nutné použít některou funkci ze jmenného prostoru TextWindow. Konkrétně pro ruční zadání číselných údajů slouží funkce nazvaná ReadNumber, která dokonce ani neumožní zápis jiných než numerických znaků. Použití této důležité funkce (která mimochodem v mnoha jiných jazycích v takto jednoduše použitelné formě ani neexistuje!) je triviální:

TextWindow.Write("Circle radius = ")
r = TextWindow.ReadNumber()
 
area = Math.Pi * r * r
 
TextWindow.WriteLine("Circle area = " + area)
Poznámka: díky tomu, že se skutečně jedná o funkci, nebylo nutné do Small Basicu přidávat v mnoha ohledech nekoncepční příkaz INPUT.

Praktické použití této funkce je patrné z následující dvojice screenshotů:

Obrázek 11: Čekání na zápis čísla.

Obrázek 12: Výsledek výpočtu.

7. Podmínky, strukturovaný příkaz typu if-then-else

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 Small Basic, který obsahuje strukturovaný příkaz typu if-then-else, jenž lze ovšem rozšířit i o další zřetězené podmínky. Základní tvar tohoto příkazu neobsahuje větev else:

TextWindow.Write("Circle radius = ")
r = TextWindow.ReadNumber()
 
if r < 0 then
    TextWindow.WriteLine("Negative radius?!")
endif
 
area = Math.Pi * r * r
 
TextWindow.WriteLine("Circle area = " + area)
Poznámka: jak uvidíme dále, všechny příkazy, které tvoří bloky, končí klíčovým slovem začínajícím na end, v tomto případě konkrétně slovem endif.

Úplné rozvětvení do dvou nezávislých větví se provede takto:

TextWindow.Write("Circle radius = ")
r = TextWindow.ReadNumber()
 
if r < 0 then
    TextWindow.WriteLine("Negative radius?!")
else
    area = Math.Pi * r * r
 
    TextWindow.WriteLine("Circle area = " + area)
endif

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 zajišťuje konstrukce obsahující klíčové slovo elseif (psáno dohromady):

TextWindow.Write("Circle radius = ")
r = TextWindow.ReadNumber()
 
if r < 0 then
    TextWindow.WriteLine("Negative radius?!")
elseif r = 0 then
    TextWindow.WriteLine("Zero radius -> zero area")
else
    area = Math.Pi * r * r
    TextWindow.WriteLine("Circle area = " + area)
endif
Poznámka: větví elseif může být libovolné množství.

8. Vnořené konstrukce if-then

Ve Small Basicu 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 nepatrně upraveném předchozím 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ý):

TextWindow.Write("Circle radius = ")
r = TextWindow.ReadNumber()
 
if r < 0 then
    TextWindow.WriteLine("Negative radius?!")
else
    if r = 0 then
        TextWindow.WriteLine("Zero radius -> zero area")
    else
        area = Math.Pi * r * r
        TextWindow.WriteLine("Circle area = " + area)
    endif
endif

9. Počítaná programová smyčka typu FOR-NEXT

GW-BASIC, tedy poslední zástupce klasických BASICů, podporuje dva formáty strukturovaných programových smyček. Prvním typem smyčky je smyčka typu FOR-NEXT, která je použita v prakticky všech BASICech – ovšem její chování není všude stejné! A druhým typem smyčky je WHILE-WEND. Posléze byla do QBasicu (nástupce GW-BASICu) přidána i univerzální smyčka DO-LOOP, u níž lze zvolit test na začátku a/nebo i na konci. Small Basic se vrací v historii k GW-BASICu, protože opět podporuje jen dva typy programových smyček. Nejdříve se zmíníme o počítané programové smyčce typu FOR-NEXT.

Poznámka: FOR-NEXT píšu schválně jako odkaz na klasické BASICy. Ve Small Basicu se namísto NEXT používá klíčové slovo endfor.

Základní typ této smyčky postupně počítá hodnoty od 1 do 10 včetně. Lze ovšem použít i čísla s desetinnou tečkou:

for i = 1 to 10
    TextWindow.WriteLine(i)
endfor

Následující smyčka bude vykonána přesně jednou (některé další BASICy ji ovšem nevykonají ani jednou!):

for i = 1 to 1
    TextWindow.WriteLine(i)
endfor

Naopak následující smyčka nebude vykonána ani jednou, na rozdíl od Atari BASICu, který chybně smyčku zavolá s hodnotou jedna:

for i = 1 to 0
    TextWindow.WriteLine(i)
endfor

Zvolit lze i krok, který může být záporný:

for i = 10 to 1 step -1
    TextWindow.WriteLine(i)
endfor

Nejsme ovšem (na rozdíl od například Pascalu) omezeni jen na celočíselné hodnoty:

for i = 0 to 5.5 step 0.5
    TextWindow.WriteLine(i)
endfor

Dokonce je možné průběžně měnit limit smyčky, počítat se bude s novým limitem (mnoho klasických BASICů naproti tou výraz s limitami spočítá pouze jednou na začátku):

limit = 2
for i = 0 to limit step 0.7
    TextWindow.WriteLine(i + " catching up " + limit)
    limit = limit + 0.6
endfor

Příklad postupně změny kroku, což je taktéž umožněno:

delta = 1
for i = 0 to 1000 step delta
    TextWindow.WriteLine(i)
    delta = delta * 2
endfor

A další příklad, tentokrát počítající druhé mocniny dvojky poněkud neobvyklým způsobem:

delta = 1
for i = 1 to 1000 step delta
    TextWindow.WriteLine(i)
    delta = i
endfor
Poznámka: smyčka FOR-NEXT je díky tomu, že jsou limity i krok počítány znovu v každé iteraci, velmi flexibilní (což zdaleka neplatí pro ostatní implementace BASICu).

10. Programová smyčka typu WHILE

Druhým a současně i posledním typem programové smyčky je smyčka typu WHILE, která opakovaně vykoná tělo funkce jen v případě, že je splněna zapsaná podmínka. Tato smyčka je ve Small Basicu zapisována dvojicí klíčových slov while a endwhile, čímž se podařilo odstranit dosti škaredé klíčové slovo WEND. Ukažme si nyní typický příklad použití této programové smyčky pro zobrazení mocninné řady o základu 2:

pwr = 1
while pwr <= 1024
    TextWindow.WriteLine(pwr)
    pwr = pwr * 2
endwhile

Pokud není podmínka splněna již na začátku, nebude tělo smyčky vykonáno ani jednou:

pwr = 1
while pwr > 1024
    TextWindow.WriteLine(pwr)
    pwr = pwr * 2
endwhile

Poměrně často se ovšem setkáme s horší situací – s nekonečnou smyčkou, která není ve webové verzi Small Basicu dobře ošetřena, protože ji není možné snadno ukončit:

pwr = 1
while pwr < 1024
    TextWindow.WriteLine(pwr)
endwhile

11. Výpočet největšího společného dělitele – realizace v GW-BASICu a Small Basicu

V dnešním článku se několikrát setkáme s programem zapsaným ve starším GW-BASICu, což je zastánce klasických BASICů, a ve Small Basicu. Porovnáním stylu zápisů obou variant lze zjistit kam (a zda vůbec) se vývoj v oblasti BASICu za posledních 38 let posunul.

Začneme jednou variantou algoritmu určeného pro výpočet největšího společného dělitele dvou celých kladných čísel. Jeho realizace založená na programové smyčce typu WHILE může v GW-BASICu vypadat následovně:

1 REM *****************************
2 REM Výpočet největšího společného
3 REM dělitele postavený na smyčce
4 REM typu WHILE-WEND.
5 REM
6 REM Uprava pro GW-BASIC
7 REM *****************************
8 REM
9 REM
10 PRINT "X=";
20 INPUT X
30 PRINT "Y=";
40 INPUT Y
50 WHILE X<>Y
60   IF X>Y THEN X=X-Y
70   IF X<Y THEN Y=Y-X
80 WEND
90 PRINT "GCD: ";X
91 END

Přepis tohoto programu do Small Basicu je prakticky doslovný a ukazuje jen minimální rozdíly – zejména „blokový“ zápis příkazů, které se mají provést při splnění dané podmínky:

' *****************************
' Výpočet největšího společného
' dělitele postavený na smyčce
' typu WHILE.
' 
' Úprava pro Small Basic
' *****************************
 
TextWindow.Write("X = ")
x = TextWindow.ReadNumber()
 
TextWindow.Write("Y = ")
y = TextWindow.ReadNumber()
 
while x<>y
    if x>y then
        x=x-y
    endif
    if x<y then
        y=y-x
    endif
endwhile
 
TextWindow.WriteLine("GCD = " + x)

12. Podprogramy

Small Basic 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 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ě Small Basicu je zvolen odlišný přístup, který byl představen v Q-Basicu. Podprogram je pojmenován příkazem Sub, za kterým na dalších řádcích následuje tělo podprogramu. Celý podprogram je ukončen příkazem endsub. Pro volání podprogramu se ve Small Basicu nepoužívá příkaz GOSUB, ale přímo název podprogramu, za kterým následují prázdné kulaté závorky:

Sub Foobar
    TextWindow.WriteLine("Foobar")
endsub
 
Foobar()
Poznámka: i když prázdné závorky naznačují, že by bylo možné podprogramu předat nějaké parametry, není to ve skutečnosti pravda. Všechny proměnné (a parametry lze považovat za formu proměnných) jsou totiž ve Small Basicu globální. Kulaté závorky jsou použity jen pro jednoznačné určení, že se jedná o volání podprogramu. Mimochodem – nemožnost používat klasické argumenty a parametry omezuje prakticky zvládnutelnou velikost programů psaných ve Small Basicu.

13. Převod programu postaveného na podprogramech z GW-BASICu do Small Basicu

S podprogramy jsme se setkali již v článku věnovanému GW-BASICu, kde jsme si kromě mnoha dalších příkladů ukázali i program pro výpočet přibližné hodnoty konstanty π. V tomto algoritmu je uvnitř programové smyčky volán podprogram. Celý výpočet realizovaný v původním GW-BASICu vypadá následovně:

1 REM *****************************
2 REM Výpočet hodnoty konstanty PI
3 REM postavený na smyčce
4 REM typu WHILE-WEND.
5 REM
6 REM Uprava pro GW-BASIC
7 REM *****************************
8 REM
9 REM
10 N=1
20 WHILE N<=2000
25   GOSUB 1000: REM COMPUTE_PI
30   PRINT N,PI
35   N=N*2
40 WEND
999 END
1000 REM
1001 REM SUBRUTINA PRO VYPOCET PI
1010   PI=4
1015   J=3
1020   WHILE J<=N+2
1030     PI=PI*(J-1)/J*(J+1)/J
1040     J=J+2
1050   WEND
1060 RETURN

Převod do Small Basicu je poměrně přímočarý a výsledek vypadá takto:

' *****************************
' Výpočet hodnoty konstanty PI
' postavený na smyčce
' typu WHILE
' 
' Uprava pro Small Basic
' *****************************
'
'
N=1
while N <= 2000
   computePi()
   TextWindow.Writeline("N=" + N + " PI=" + PI)
   N = N * 2
endwhile
 
sub computePi
    PI = 4
    J = 3
    while J <= N + 2
      PI=PI*(J-1)/J*(J+1)/J
      J=J+2
    endwhile
endsub
Poznámka: jak již víme z předchozího textu, bylo by možné první programovou smyčku přepsat takovým způsobem, že by se použila konstrukce for-next.

14. Příkaz GOTO aneb vaříme špagety

Ve Small Basicu nalezneme i nestrukturovaný příkaz GOTO, který slouží pro skok do jiného místa v daném programovém bloku a dokonce i do programové smyčky (což jiné BASICy typicky nedovolují). Cíl skoku je označen návěštím (label), což je identifikátor, za nímž je zapsána dvojtečka (Small Basic se tedy i přes všechny snahy nezbavil všech speciálních znaků). Podívejme se nyní na základní způsob použití tohoto (mnohými teoretiky po právu odsuzovanému) příkazu, zde použitému pro implementaci programové smyčky, v níž se podmínka testuje na konci smyčky:

i = 1
 
LOOP:
    TextWindow.WriteLine(i)
    i = i + 1
    if i <= 10 then
        goto LOOP
    endif
Poznámka: příkaz GOTO je možné použít i pro implementaci konstrukcí, pro něž se v jiných jazycích používají klíčová slova break a continue. Taktéž pochopitelně umožňuje výskok z vnořených smyček atd.

Je povolen skok do smyčky:

GOTO target
 
for i = 1 to 10
target:
    TextWindow.WriteLine(i)
endfor

Ze smyčky lze pochopitelně vyskočit:

for i = 1 to 10
    TextWindow.WriteLine(i)
    if i > 5 then
        GOTO end
    endif
endfor
 
end:

Ovšem skok do podprogramu již není povolen:

sub foo
    target:
    TextWindow.WriteLine(i)
endsub
 
foo()
GOTO target
Poznámka: implementace příkazu GOTO není tak přímočará, jako je tomu v jiných BASICech. V případě starších BASICů bylo nutné při výskoku ze smyčky (nebo i podprogramu!) odstranit ze zásobníku pomocné automaticky vytvořené hodnoty – limity smyčky, čísla řádků pro návrat z podprogramu/návrat na začátek smyčky atd. příkazem pop. To ve Small Basicu není nutné.

15. Převod programu postaveného na GOTO z GW-BASICu do Small Basicu

Opět si ukážeme převod algoritmu postaveného na příkazu GOTO z již popsaného GW-BASICu do Small Basicu. Bude se jednat o algoritmus výpočtu největšího společného dělitele dvou celých kladných čísel (podmínka kladnosti ovšem není kontrolována), kde se na základě porovnání dvou mezihodnot explicitně skáče na začátek programové smyčky:

1 REM *****************************
2 REM Vypocet nejvetsiho spolecneho
3 REM delitele.
4 REM
5 REM Uprava pro GW-BASIC
6 REM
7 REM *****************************
8 REM
9 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
999 END

Převod tohoto algoritmu do Small Basicu je přímočarý a výsledek je díky použití návěští namísto čísel řádků čitelnější:

' *****************************
' Vypocet nejvetsiho spolecneho
' delitele.
' 
' Uprava pro Small Basic
' 
' *****************************
'
'
 
TextWindow.Write("X = ")
x = TextWindow.ReadNumber()
 
TextWindow.Write("Y = ")
y = TextWindow.ReadNumber()
 
LOOP:
if x = y then
    TextWindow.WriteLine("GCD = " + 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:

16. Pole a mapy – překvapivě snadné téma

Součástí jazyka Small Basic jsou i pole. Ve starších dialektech programovacího jazyka BASIC bylo nutné pole před přístupem do něho alokovat, a to typicky příkazem DIM. Navíc se různé dialekty BASICu lišily v tom, zda první prvek pole má mít index roven nule či jedničce. Snaha o sjednocení vedla k tomu, že některé novější BASICy nabízí možnost volby hodnoty indexu prvního prvku – například příkazem OPTION BASE (což je případ GW-BASICu nebo taktéž Q-Basicu). V případě Small Basicu je situace jednodušší a méně matoucí, zejména pro začínající uživatele, protože pole lze začít používat bez nutnosti jeho alokace a indexy prvků mohou být (prakticky) libovolné. Celé pole lze navíc vypsat jako celek:

values[0] = 10
values[1] = 20
 
TextWindow.WriteLine(values)

Naprosto stejná syntaxe je použita i při práci s mapami. Ve skutečnosti jsou běžná pole jen speciálním případem map neboli asociativních polí. Opět si ukažme, jak lze mapu začít používat, a to bez nutnosti její alokace či jakékoli definice:

users["Rich"] = "Hickey"
users["Rob"] = "Pike"
users["Guido"] = "van Rossum"
users["John"] = "Kemeny"
users["Niklaus"] = "Wirth"
users["Kenneth"] = "Iverson"
 
TextWindow.WriteLine(users)
Poznámka: do pole lze přidávat nové prvky, modifikovat prvky stávající a samozřejmě zjišťovat hodnoty prvků. Pro další operace s poli jsou určeny funkce, které lze najít ve jmenném prostoru Array, o němž se pochopitelně zmíníme příště.

17. Pasti připravené ve Small Basicu

Na návrhu Small Basicu je patrné, že se jeho tvůrci snažili o maximální zjednodušení tohoto jazyka pro začátečníky. Ovšem některé snahy o zjednodušení mohou vést k problematickému a mnohdy i těžko vysvětlitelnému chování. Například následující demonstrační příklad korektně vypíše zprávu říkající:

10 added to 20 is equal to 30
Program has ended.

Kód tohoto příkladu vypadá takto a vidíme v něm kombinaci (spojení) numerických hodnot s řetězci:

x = 10
y = 20
z = x + y
TextWindow.WriteLine(x + " added to " + y + " is equal to " + z)

Co se však stane v případě, kdy budeme chtít vypsat zprávu „10 + 20 = 30“? Takový program by mělo být možné (analogicky) zapsat tímto způsobem:

x = 10
y = 20
z = x + y
TextWindow.WriteLine(x + " + " + y + " = " + z)

Ve skutečnosti se ovšem vypíše:

30 = 30
Program has ended.

V tomto případě byl interpret Small Basicu až příliš „chytrý“, protože rozpoznal zapsaný výraz (ignoroval zde přitom uvozovky), který vyhodnotil.

Poznámka: některá další úskalí plynoucí z příliš „chytrého“ typového systému Small Basicu si ukážeme příště.

18. Obsah druhého článku o Small Basicu

V navazujícím (a současně pravděpodobně i posledním) článku o Small Basicu si přiblížíme některé jmenné prostory (nebo chcete-li moduly), které je možné a mnohdy nutné použít při tvorbě aplikací v tomto jazyku. Výběr modulů je relativně velký, ovšem i jejich základní sada je užitečná – kromě vstupu a výstupu nabízí i práci s poli, matematické funkce, kreslení do k tomu vytvořeného okna, želví grafiku, operaci s grafickými objekty, tvorbu formulářů se základními ovládacími prvky, operace se soubory, práci se zvukem, síťové operace atd. atd. Rozšiřující moduly umožňují například komunikaci s Arduinem, microbitem či Raspberry Pi (ovšem ne všechny zmíněné moduly jsou použitelné ve webové variantě Small Basicu).

Obrázek 13: Nápověda k jednotlivým modulům.

Root školení Elk

Obrázek 14: Obsah vybraného modulu.

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

Všechny dnes popisované demonstrační příklady určené pro Small Basic (a z tohoto důvodu 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ář:

# Příklad Stručný popis Adresa
1 01_hello_world.bas implementace programy typu „Hello, world!“ ve Small Basicu https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/01_hello_world.bas
2 02_string_variable.bas základní manipulace s řetězci uloženými do proměnných https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/02_string_variable.bas
3 03_numeric_variables.bas základní manipulace s numerickými hodnotami uloženými do proměnných https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/03_numeric_variables.bas
4 04_string_and_int.bas kombinace řetězců a numerických hodnot https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/04_string_and_int.bas
5 05_string_subtext.bas získání podřetězce, využití tečkové notace https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/05_string_subtext.bas
6 06_input.bas interaktivní vstup numerických údajů z konzole https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/06_input.bas
7 07_if_then.bas programová rozhodovací konstrukce if-then v základní podobě https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/07_if_then.bas
8 08_if_then_else.bas programová rozhodovací konstrukce if-then-else https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/08_if_then_else.bas
9 09_if_elseif_then_else.bas rozšíření if-then-else o větvi elseif https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/09_if_elseif_then_else­.bas
10 10_nested_ifs.bas vnořené bloky if-then https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/10_nested_ifs.bas
11 11_for_next.bas programová smyčka typu for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/11_for_next.bas
12 12_for_next_same_limits.bas nastavení shodného horního i dolního limitu ve smyčce for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/12_for_next_same_limit­s.bas
13 13_for_next_no_loop.bas programová smyčka, jejíž tělo neproběhne ani jednou https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/13_for_next_no_loop.bas
14 14_for_next_downward.bas nastavení záporného kroku smyčky typu for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/14_for_next_downward.bas
15 15_for_next_step.bas neceločíselný krok v programové smyčce typu for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/15_for_next_step.bas
16 16_for_next_variable_limit.bas změna horního limitu programové smyčky typu for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/16_for_next_variable_li­mit.bas
17 17_for_next_variable_step.bas průběžná modifikace kroku programové smyčky typu for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/17_for_next_variable_step­.bas
18 18_for_next_variable_step.bas průběžná modifikace kroku programové smyčky typu for-next https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/18_for_next_variable_step­.bas
19 19_while.bas standardní programová smyčka typu while https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/19_while.bas
20 20_while_never.bas programová smyčka typu while, jejíž tělo neproběhne ani jednou https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/20_while_never.bas
21 21_while_endless.bas nekonečná programová smyčka https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/21_while_endless.bas
22 22_GCD.bas implementace algoritmu NSD realizovaná smyčkou typu while https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/22_GCD.bas
23 23_sub.bas subrutiny/podprogramy https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/23_sub.bas
24 24_pi.bas výpočet konstanty Pi založená na použití podprogramů https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/24_pi.bas
25 25_goto.bas nestrukturovaný příkaz GOTO https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/25_goto.bas
26 26_goto_GCD.bas implementace algoritmu NSD realizovaná příkazy GOTO https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/26_goto_GCD.bas
27 27_array.bas pole ve Small Basicu https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/27_array.bas
28 28_maps.bas mapy (asociativní pole) ve Small Basicu https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/28_maps.bas
29 29_trap1_bas problémy Small Basicu, první část https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/29_trap1_bas
30 30_trap2.bas problémy Small Basicu, druhá část https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/30_trap2.bas

20. Odkazy na Internetu

  1. Stránka projektu Small Basic
    https://smallbasic-publicwebsite.azurewebsites.net/
  2. List of Programs Made with Small Basic
    https://social.technet.mi­crosoft.com/wiki/contents/ar­ticles/14013.list-of-programs-made-with-small-basic.aspx
  3. Expert to Expert: The Basics of SmallBasic
    https://channel9.msdn.com/blog­s/charles/expert-to-expert-the-basics-of-smallbasic
  4. The Developer’s Reference Guide to Small Basic
    https://social.technet.mi­crosoft.com/wiki/contents/ar­ticles/16767.the-developers-reference-guide-to-small-basic.aspx
  5. Small Basic – Talking to Raspberry Pi
    https://techcommunity.micro­soft.com/t5/small-basic-blog/small-basic-talking-to-raspberry-pi/ba-p/337844
  6. Small Basic – Arduino
    https://techcommunity.micro­soft.com/t5/small-basic-blog/small-basic-arduino/ba-p/337762
  7. Small Basic + micro:bit
    https://techcommunity.micro­soft.com/t5/small-basic-blog/small-basic-micro-bit/ba-p/1968424
  8. #1 Learn Small Basic Programming – Introduction
    https://www.youtube.com/wat­ch?v=e_BaEPCa8OQ
  9. #2 Learn Small Basic Programming – Input, Output & Variables
    https://www.youtube.com/wat­ch?v=VWekYLa33OI
  10. #3 Learn Small Basic Programming – String Concatenation
    https://www.youtube.com/wat­ch?v=iWvIaOaT474
  11. Small Basic – The Programmer's Guide
    https://www.i-programmer.info/programming/other-languages/5196-small-basic-the-programmers-guide.html
  12. Rosetta Code: Category:Microsoft Small Basic
    https://rosettacode.org/wi­ki/Category:Microsoft_Sma­ll_Basic
  13. Fifty Years of BASIC, the Programming Language That Made Computers Personal
    https://time.com/69316/basic/
  14. BBC BASIC i QBasic oslavují svá kulatá výročí
    https://www.root.cz/clanky/bbc-basic-i-qbasic-oslavuji-sva-kulata-vyroci/
  15. What are the best BASIC-like programming languages?
    https://www.slant.co/topic­s/9807/~basic-like-programming-languages
  16. List of BASIC dialects
    https://en.wikipedia.org/wi­ki/List_of_BASIC_dialects
  17. GW-BASIC Documentation
    https://hwiegman.home.xs4a­ll.nl/gwbasic.html
  18. Microsoft Open-Sources GW-BASIC
    https://devblogs.microsof­t.com/commandline/microsoft-open-sources-gw-basic/
  19. GW-BASIC na GitHubu
    https://github.com/microsoft/GW-BASIC
  20. Welcome to GW-BASIC
    http://www.antonis.de/qbe­books/gwbasman/
  21. GWBASIC User's Manual
    http://www.antonis.de/qbe­books/gwbasman/index2.html
  22. The basics of BASIC, the programming language of the 1980s
    https://www.youtube.com/wat­ch?v=seM9SqTsRG4
  23. GW-BASIC User's Guide
    https://hwiegman.home.xs4all.nl/gw-man/index.html
  24. PC-BASIC 1.2.14 documentation
    http://robhagemans.github­.io/pcbasic/doc/1.2/
  25. PEEK and POKE
    https://en.wikipedia.org/wi­ki/PEEK_and_POKE
  26. GW-BASIC | DRAW Statement (video na Youtube)
    https://www.youtube.com/wat­ch?v=4I1CELY13M4
  27. Rozdíly mezi GW-BASIC a QBasicem
    https://hwiegman.home.xs4a­ll.nl/extern/Differences%20Bet­ween%20GW-BASIC%20and%20QBasic.htm
  28. GW-Basic Programs
    https://gwbasicprograms.blog­spot.com/p/gw-basic-programs.html
  29. GW-BASIC Resource
    https://gw-basic.netlify.app/
  30. A page about GWBASIC Games & Other Programs
    http://peyre.x10.mx/GWBASIC/
  31. Basic BASIC, 2nd Edition, James S. Coan
    https://drive.google.com/uc?ex­port=download&id=1Z12L7SO_gfNg3Ma_0­eH2_Kz15YM-9dHl
  32. Advanced BASIC, James S. Coan
    https://drive.google.com/uc?ex­port=download&id=1JafSpV_BLyl­WHMd16rDPorwv9wV9bLcy
  33. Structured BASIC, 2nd Edition, James F. Clark (naskenovaná kniha)
    https://drive.google.com/uc?ex­port=download&id=1pT8y-8yJYS_SqvxF0fBHm6S-dlAt-Uy2
  34. Last Book of GW-Basic
    https://www.geocities.ws/jo­seph_sixpack/btoc.html
  35. SCIENTIFIC PROGRAMS WRITTEN IN BASIC (for PCs)
    https://web.archive.org/web/20160323064356/htt­p://www.scn.org/~bh162/ba­sic_programs.html
  36. Why I love programming on FreeDOS with GW-BASIC
    https://opensource.com/ar­ticle/21/6/freedos-gw-basic
  37. Quite BASIC (web-based classic BASIC online programming environmen)
    http://www.quitebasic.com/
  38. GFA-BASIC
    http://sites.google.com/si­te/gfabasic16/
  39. E-mail od tvůrce GW-Basicu
    http://www.classiccmp.org/pi­permail/cctech/2005-April/042999.html
  40. General Electric GE-400
    http://www.feb-patrimoine.com/PROJET/ge400/ge-400.htm
  41. GE-400 Time-sharing information systems:
    http://www.computerhistory­.org/collections/accession/102646147
  42. A brief history of the development of BASIC (pravděpodobně již nefunkční odkaz)
    http://www.phys.uu.nl/~ber­gmann/history.html
  43. History of BASIC (PDF)
    http://www.q7basic.org/His­tory%20of%20BASIC.pdf
  44. Dartmouth College Computation Center. 1964.-The original Dartmouth BASIC manual
    http://www.bitsavers.org/pdf/dar­tmouth/BASIC_Oct64.pdf
  45. The Original BASIC
    http://www.truebasic.com/
  46. BASIC – Beginners All-purpose Symbolic Instruction Code
    http://hopl.murdoch.edu.au­/showlanguage.prx?exp=176
  47. The History of the Mainframe Computer
    http://www.vikingwaters.com/htmlpa­ges/MFHistory.htm
  48. Dartmouth Time Sharing System
    http://en.wikipedia.org/wi­ki/Dartmouth_Time_Sharing_Sys­tem
  49. General Electric (Wikipedia)
    http://en.wikipedia.org/wi­ki/General_Electric
  50. GE 225 vs. IBM 1401
    http://ed-thelen.org/GE225-IBM1401.html
  51. A GE-225 is found
    http://ed-thelen.org/comp-hist/GE225.html
  52. G.E. 200 Series Computers
    http://www.smecc.org/g_e__200_se­ries_computers.htm
  53. DTSS – Dartmouth Time Sharing System
    http://dtss.dartmouth.edu/index.php
  54. John G. Kemeny: BASIC and DTSS: Everyone a Programmer
    http://dtss.dartmouth.edu/e­veryoneaprogrammer.php
  55. GE-200 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-200_series
  56. GE-400 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-400_series
  57. GE-600 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-600_series
  58. ZX Basic Manual
    http://www.worldofspectrum­.org/ZXBasicManual/
  59. ZX81 BASIC Programming
    http://www.worldofspectrum­.org/ZX81BasicProgramming/
  60. Sinclair BASIC History
    http://scratchpad.wikia.com/wi­ki/Sinclair_BASIC_History
  61. Sinclair BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Sinclair_BASIC
  62. Sinclair BASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/Sinclair_BASIC
  63. Beta BASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/Beta_BASIC
  64. Beta BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Beta_BASIC
  65. BETA BASIC NEWSLETTER No 8
    http://spectrum128.ru/hel­p/BetaBasicNewsletter8.pdf
  66. R. T. RUSSELL: The home of BBC BASIC
    http://www.rtrussell.co.uk/
  67. R. T. RUSSELL: A History of BBC BASIC
    http://www.cix.co.uk/~rrus­sell/bbcbasic/history.html
  68. SuperBASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/SuperBASIC
  69. SuperBASIC (Wikipedia CZ)
    http://en.wikipedia.org/wi­ki/SuperBASIC
  70. Laser Basic/Laser Compiler
    http://www.sincuser.f9.co­.uk/049/laser.htm
  71. Laser BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Laser_BASIC
  72. BBC BASIC
    http://www.bbcbasic.co.uk/bbcba­sic.html
  73. BBC BASIC
    http://mdfs.net/Software/BBCBasic/
  74. BBC BASIC (Z80) for the ZX Spectrum
    http://mdfs.net/Software/BBCBa­sic/Spectrum/
  75. BBC BASIC (Wikipedia CZ)
    http://en.wikipedia.org/wi­ki/BBC_BASIC
  76. BeebWiki – 8-bit Acorn Computer Wiky
    http://beebwiki.jonripley­.com/Main_Page
  77. Porovnání osmibitů
    http://porovnani8bitu.spa­ces.live.com/
  78. Rosetta Code – Main Page
    http://rosettacode.org/wiki/Main_Page
  79. Rosetta Code – Category Basic
    http://rosettacode.org/wi­ki/Category:BASIC
  80. QBasicJedi
    http://www.freewebs.com/qbasicjedi/
  81. QBasic/QuickBasic Downloads
    http://www.freewebs.com/qba­sicjedi/qbdownloads.html
  82. QuickBASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/QuickBASIC
  83. QBasic.com
    http://www.qbasic.com/
  84. QBasic (Wikipedia)
    http://cs.wikipedia.org/wiki/QBasic
  85. Dialling with QBASIC
    http://www.mysundial.ca/tsp/qba­sic.html
  86. BASIC (Wikipedia EN)
    http://en.wikipedia.org/wiki/BASIC
  87. BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wiki/BASIC
  88. Turbo BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Turbo_BASIC
  89. More BASIC Computer Games
    http://www.atariarchives.or­g/morebasicgames/
  90. How to build an interpreter in Java, Part 1: The BASICs
    http://www.javaworld.com/jw-05–1997/jw-05-indepth.html
  91. INTEGER BASIC Reference
    http://www.landsnail.com/a2ref2.htm
  92. APPLESOFT Reference
    http://www.landsnail.com/a2ref.htm
  93. Applesoft Lite: Applesoft BASIC for the Replica-1
    http://cowgod.org/replica1/applesoft/
  94. Simons' BASIC
    http://en.wikipedia.org/wi­ki/Simons'_BASIC
  95. Simon's Basic
    http://www.lemon64.com/?ma­inurl=http%3A//www.lemon64­.com/museum/list.php%3Fli­neoffset%3D54%26genre%3Dma­nualmisc
  96. BASIC
    http://www.c64-wiki.com/index.php/BASIC
  97. C64 Wiki: Simons Basic
    http://www.c64-wiki.de/index.php/Simons_Basic
  98. Simons' Basic (evaluation)
    http://www.atarimagazines­.com/creative/v9n11/60_Si­mons_Basic.php
  99. Bill Gates' Personal Easter Eggs in 8 Bit BASIChttp://www.pagetable.com/?p=43
  100. 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/
  101. Let's make a small and simple GW-BASIC program!
    https://www.youtube.com/wat­ch?v=OyPUn74nj-s