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

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/.

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:

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.

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)

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)

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)

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)

Ú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

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.

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

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()

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

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

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

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)

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.

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.

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ář:

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