Hlavní navigace

Vestavěné objekty Small Basicu: práce s grafikou, časovačem, reakce na události

14. 10. 2021
Doba čtení: 33 minut

Sdílet

 Autor: Pavel Tišnovský
Ve druhém a současně i závěrečném článku o Small Basicu si ukážeme práci s vestavěnými objekty, zejména s grafickým oknem. Taktéž si popíšeme želví grafiku a systém událostí (a reakcí na ně). Zmíníme se i o alternativně ke Small Basicu, jímž je Basic-256.

Obsah

1. Vestavěné objekty Small Basicu: práce s grafikou, časovačem, reakce na události

2. Příklad volání metod objektů a změn jejich atributů

3. Základní operace s řetězci realizovaná přes objekt Text

4. Malá odbočka – programovací jazyk Logo

5. Želví grafika

6. Želví grafika ve Small Basicu

7. Další možnosti poskytované implementací želví grafiky

8. Objekt GraphicsWindow pro grafický výstup

9. Základní příkazy pro vykreslování

10. Specifikace barvy pozadí i barvy vykreslovaných objektů

11. Práce s grafikou na úrovni jednotlivých pixelů

12. Systém událostí – úvod do asynchronního programování

13. Reakce na stisk tlačítka myši nebo na stisk klávesy

14. Reakce na tik časovače

15. Ladění programů v prostředí Small Basicu

16. Alternativní projekt s licencí GPL: Basic-256

17. Stručné představení Basicu-256

18. Příloha: seznam klíčových slov Atari BASICu

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

20. Odkazy na Internetu

1. Vestavěné objekty Small Basicu: práce s grafikou, časovačem, reakce na události

Již v předchozím článku 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 vstupně-výstupní operace, práce s grafickým oknem, práce s želví grafikou, ale v neposlední řadě i operace s řetězci a poli. 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
i

Obrázek 1: V levé části uživatelského rozhraní Small Basicu se zobrazuje seznam všech dostupných objektů.

Ve Small Basicu jsou tyto globální funkce nahrazeny metodami objektu Text. Tímto poměrně elegantním způsobem bylo možné snížit počet rezervovaných slov na šestnáct a vyhnout se tak problémům, které v klasických BASICech způsobovaly desítky a někdy i stovky rezervovaných slov (ty mnohdy ani nemohly být součástí jména proměnné). Ostatně v osmnácté kapitole se můžete sami přesvědčit, kolik globálně viditelných rezervovaných slov má i relativně malý (v původním významu tohoto slova) Atari BASIC.

Obrázek 2: Seznam metod vybraného objektu.

A právě způsobem práce s objekty, které ve Small Basicu existují, se budeme zabývat v dnešním článku. Důležité je přitom již na začátku upozornit na to, že počet objektů je neměnný – objekty nelze přidávat a už vůbec ne definovat objekty nové (například na základě nějaké deklarace třídy atd.). Z tohoto pohledu se můžeme na existující objekty dívat i jako na jmenné prostory s uloženým stavem.

Obrázek 3: Seznam atributů vybraného objektu.

2. Příklad volání metod objektů a změn jejich atributů

Nejjednodušší operací s objekty je zavolání některé jejich metody. Například objekt nazvaný TextWindow má metodu WriteLine, která slouží pro výpis zprávy do textového okna – tím se mění (mutuje) i vlastní objekt, resp. přesněji řečeno jeho vnitřní stav. Volání je ze syntaktického hlediska realizováno dnes již standardní „tečkovou notací“, která je v IDE Small Basicu podporována technologií IntelliSense (automatické nabídky dostupných metod a atributů):

' Program typu "Hello, world!" naprogramovaný ve Small Basicu
 
TextWindow.WriteLine("Hello, world!")

Měnit atributy objektu je stejně snadné – atributům přiřadíme novou hodnotu. V následujícím demonstračním příkladu je změněna barva pozadí i barva popředí textového okna:

' Program typu "Hello, world!" naprogramovaný ve Small Basicu
' doplněný o změnu vlastností textového okna
 
TextWindow.BackgroundColor = "darkblue"
TextWindow.ForegroundColor = "yellow"
TextWindow.WriteLine("Hello, world!")

Výsledek by měl vypadat takto:

Obrázek 4: Změna barvy pozadí i textu v textovém oknu.

Poznámka: některé atributy a metody již není možné použít, i když z nějakého důvodu figurují v nápovědě:

Obrázek 5: I v tak malém a relativně moderním jazyku, jakým je Small Basic, už nalezneme nepodporované metody a atributy.

3. Základní operace s řetězci realizovaná přes objekt Text

Jak jsme si již řekli minule, nepodporuje Small Basic ani základní funkce pro zpracování řetězců; a to dokonce ani funkce LEFT$, MID$ a RIGHT$ zavedené právě společností Microsoft. Prakticky veškerou práci s řetězci obstarávají statické metody dostupné v objektu Text. Nalezneme zde především podporu spojování řetězců, převodu řetězce na velká či naopak malá písmena, získání podřetězce atd. Viz též následující příklad:

' Základní operace s řetězci realizovaná přes objekt Text
 
message = "Hello, world"
TextWindow.WriteLine(message)
 
message = Text.Append(message, "!")
TextWindow.WriteLine(message)
 
TextWindow.WriteLine(Text.ConvertToUpperCase(message))
 
TextWindow.WriteLine(Text.GetSubText(message, 8, 5))
Poznámka: podtržená část zdrojového kódu ukazuje na zajímavou vlastnost Small Basicu – znaky řetězce začínají indexem 1 a nikoli 0! Převod některých algoritmů do Small Basicu tedy nebude zcela přímočarý.

Obrázek 6: Vybrané metody objektu Text.

4. Malá odbočka – programovací jazyk Logo

Historicky jedním z prvních programovacích jazyků, který byl vyvinut s ohledem na snadnou a efektivní výuku programování, je jazyk Logo, jehož první verze vznikla již v roce 1967, tj. o celé desetiletí dříve, než začaly být dostupné první typy domácích osmibitových počítačů, jejichž vliv na výuku programování je značný. Někteří lidé sice považují tento jazyk za pouhou dětskou hračku (určitou obdobu počítačových her), ovšem ve skutečnosti se jedná o velmi zajímavý koncept, který je neustále zdokonalován a používán, zejména na základních ale i středních školách, kde je využíván jak pro výuku algoritmizace, tak i jako pomůcka při názorné výuce geometrie.

Obrázek 7: UCB Logo je jedním z představitelů tradičních interpretrů jazyka Logo, vybavený systémem pro práci se želví grafikou. Tento interpret je dostupný pro většinu platforem, samozřejmě včetně Linuxu.

Programovací jazyk Logo je postaven na takzvané konstruktivní vzdělávací filozofií a je navržen k podpoře konstruktivního učení. Konstruktivismus vysvětluje znalosti a dovednosti, jak jsou vytvořeny žáky v jejich vlastních myslích, prostřednictvím vzájemné interakce s jinými lidmi a okolím. Tato zajímavá teorie je spojena především se švýcarským psychologem Jeanem Piagetem, který strávil mnoho času studováním a zdokumentováním procesu učení malých dětí. S Piagetem spolupracoval i Seymour Papert, který později stál u vzniku Loga.

Obrázek 8: Obrazec vzniklý pomocí želví grafiky a programu obsahujícího dvojici vnořených programových smyček typu „repeat“ (což je jednodušší obdoba cyklu FOR-NEXT).

Z programátorského hlediska je programovací jazyk Logo postaven na podobných principech jako například jazyk LISP (ostatně není bez zajímavosti, že první verze Loga byla implementována právě v LISPu), ovšem jeho syntaxe je odlišná, což v případě Loga vede k tvorbě čitelnějších programů, které se vizuálně odlišují od Lispovského „lesa závorek“. Navíc se matematické a logické výrazy v Logu zapisují v infixové podobě, na rozdíl od formy prefixové používané LISPem. Tvorba programů v Logu vede žáky k dekompozici problému na jednodušší podproblémy, ale i k opačnému postupu – tvorbě nových slov (což jsou pouze jinak pojmenované funkce), kterými se repertoár dostupných příkazů (slovník) postupně rozšiřuje – jazyk se „učí“ novým příkazům.

Poznámka: právě dekompozice je v Logu preferována zatímco ve Small Basicu je ji velmi těžké realizovat, protože při volání podprogramů nelze použít ani parametry ani návratové hodnoty.

Příklady zápisu programu používajícího programovou smyčku repeat, dále zmíněnou želví grafiku a definici nových slov příkazem to:

to kruznice :krok
    repeat 360 [
        forward :krok
        left 1
    ]
end
 
to kvet :pocet
    repeat :pocet [
        kruznice 1
        left 360/:pocet
    ]
end
 
draw
kvet 10

Obrázek 9: Ukázka použití želví grafiky v Logu.

5. Želví grafika

Jednou z nejznámějších a pro výuku algoritmizace taktéž nejužitečnějších vlastností programovacího jazyka Logo je takzvaná želví grafika, anglicky turtle graphics. Právě želví grafika velkou mírou přispěla k poměrně značné oblíbenosti a také rozšíření tohoto programovacího jazyka, především v zahraničním školství. V USA se zpočátku Logo šířilo spolu s počítačem Apple II a později Commodore C64 i Apple Macintosh, zatímco v Evropě se děti poprvé s Logem seznámily na domácích osmibitových počítačích, především na Atari, Spectru, v tuzemsku na PMD, Didaktiku, IQ 151 atd.

Pojďme si nyní říci základní informace o této zajímavé součásti Loga a také o začlenění želví grafiky do dalších programovacích jazyků a aplikací.

Obrázek 10: Další ukázka možností želví grafiky.

Základem želví grafiky je virtuální želva (turtle), která se na základě poměrně malé množiny příkazů dodávaných napsaným programem (skriptem) či přímo pomocí interaktivního zápisu příkazů, pohybuje po obrazovce a přitom za sebou vykresluje stopu složenou z úseček. Tato virtuální želva se tedy chová podobně jako reálná želva, která se pohybuje po hladké pískové pláži a zanechává za sebou stopu. Původní Logo nedisponovalo pouze virtuální (vykreslovanou) želvou, ale skutečným malým robotem ve tvaru želvy, který byl radiovým spojením propojen s řídicím počítačem a reagoval na základní příkazy: pohyb vpřed, pohyb vzad, otočení doleva a otočení doprava. Navíc uměl tento robot reagovat i na jeden „multimediální“ příkaz – zapnutí zvonku. Je zřejmé, že pro výuku malých dětí je pohybující se reálný předmět mnohem zajímavější než pouhý obrázek, na druhou stranu však byl (prý) pohyb robota poměrně nepřesný, zejména při otáčení (což dnes již není problém, ostatně řiditelných a programovatelných robotů dnes existuje velké množství).

Obrázek 11: Při tvorbě tohoto obrázku se, na rozdíl od obrázků předchozích, již musely používat proměnné. Ovšem zajímavé je, že v Logu je možné programovat poměrně dlouho bez znalosti proměnných (protože jedinou „stavovou proměnnou“ je pozice a orientace želvy).

Dnešní implementace programovacího jazyka Logo většinou (kromě několika komerčních distribucí, například LEGO/Loga a několika amatérských projektů) touto možností již nedisponují, takže se budeme muset spokojit s virtuální želvou pohybující se na obrazovce. V některých implementacích Loga je želva zobrazena poměrně reálným obrázkem želvy viděné z ptačí perspektivy (jedná se například o Atari Logo, Commenius Logo, Imagine i dnes zmíněný modul turtle), většinou se však na obrazovce zobrazuje pouhý rovnoramenný trojúhelník, podobně jako ve hrách typu Xpilot nebo Asteroids. Jednotlivé implementace se od sebe také liší tím, zda za sebou želva stopu vykresluje „hlavičkou“, svým středem či „zadečkem“.

Obrázek 12: Zobecněný Pythagorův strom, jehož konstrukce je v Logu relativně jednoduchá, ovšem dosti složitá ve Small Basicu, vzhledem k problematickému volání podprogramů.

6. Želví grafika ve Small Basicu

I ve Small Basicu lze želví grafiku využít (ostatně jinak by předchozí dvě kapitoly postrádaly v tomto článku smysl). K tomuto účelu slouží metody a atributy objektu nazvaného příhodně Turtle. Zavoláním metody Show() se zobrazí grafická plocha a na ní je umístěna želva. Ta dokáže reagovat na základní příkazy, zejména na příkazy pro otočení a posun. Otočení želvy o 90° se provádí metodami TurnLeft a TurnRight (bez parametrů), posun želvy o zadaný počet kroků je pak zajištěn zavoláním metody Move.

Obrázek 13: Metody objektu Turtle.

Nyní již tedy známe všechny tři metody nutné pro vykreslení čtverce:

' Kreslení s využitím želví grafiky
 
Turtle.Show()
 
for i = 1 to 4
    Turtle.TurnLeft()
    Turtle.Move(100)
endfor

Obrázek 14: Výsledek předchozího příkladu.

Nepatrnou úpravou předchozího kódu vykreslíme hvězdu jedním tahem:

' Kreslení s využitím želví grafiky
 
Turtle.Show()
 
for i = 1 to 7
    Turtle.Turn(360*2/7)
    Turtle.Move(100)
endfor

Obrázek 15: Výsledek předchozího příkladu.

7. Další možnosti poskytované implementací želví grafiky

Pro urychlení vykreslení složitějších obrazců je vhodné želvu skrýt metodou Turtle.Hide() a nastavit nejvyšší rychlost vykreslování atributem Turtle.Speed. Viz též následující příklad:

' Kreslení s využitím želví grafiky
 
Turtle.Show()
Turtle.Hide()
Turtle.Speed = 10
 
vertexes = 9
 
for i = 1 to vertexes
    Turtle.Turn(360*2/vertexes)
    Turtle.Move(100)
endfor

Výsledek:

Obrázek 16: Obrazec, který není zakrytý želvou, která byla skryta.

Dále je možné metodami pojmenovanými Turtle.PenUp() a Turtle.PenDown() zvednout popř. spustit pomyslné kreslicí pero nad kreslicí plochu. V případě, že je pero zvednuto, pouze se přesouvá, ale nekreslí za sebou stopu (úsečku):

' Kreslení s využitím želví grafiky
 
Turtle.Show()
Turtle.Hide()
Turtle.Speed = 10
 
vertexes = 11
 
for i = 1 to vertexes
    Turtle.Turn(360*3/vertexes)
    Turtle.PenDown()
    Turtle.Move(50)
    Turtle.PenUp()
    Turtle.Move(50)
    Turtle.PenDown()
    Turtle.Move(50)
endfor

Výsledkem je tento obrazec:

Obrázek 17: Vliv příkazů PenUp a PenDown na tvar vykresleného obrazce.

8. Objekt GraphicsWindow pro grafický výstup

V úvodních kapitolách jsme si představili objekt nazvaný TextWindow. Již z názvu tohoto objektu je zřejmé, že slouží pro vstupně-výstupní operace s textem (popř. s numerickými hodnotami). Pro grafický výstup slouží objekt pojmenovaný opět jednoznačně – GraphicsWindow. Grafické okno není, na rozdíl od okna textového, automaticky zobrazeno při spuštění programu, takže je nutné o jeho zobrazení požádat explicitně. Pro tento účel slouží metoda Show():

' Grafický výstup
 
GraphicsWindow.Show()

Objekt typu GraphicsWindow nabízí metody pro kreslení základních grafických tvarů, několik atributů (barva kreslení, výška a šířka okna) atd.:

Obrázek 18: Metody objektu GraphicsWindow.

9. Základní příkazy pro vykreslování

Do grafického okna je možné vykreslovat základní grafické obrazce, mezi než patří úsečky, obdélníky, ale v neposlední řadě i text. Lze pochopitelně zvolit i barvu kreslení (popř. výplně), a to nastavením atributů PenColor a BrushColor. Použít lze jména barev, popř. šestici hexadecimálních cifer (jako v HTML a CSS) nebo barvové složky RGB:

' Grafický výstup
 
GraphicsWindow.Show()
 
GraphicsWindow.PenColor = "red"
GraphicsWindow.DrawRectangle(10, 10, 100, 100)
 
GraphicsWindow.PenColor = "blue"
GraphicsWindow.DrawLine(60, 50, 60, 70)
GraphicsWindow.DrawLine(50, 60, 70, 60)

Po spuštění předchozího demonstračního příkladu by se měl zobrazit červený čtverec a v něm modrý křížek:

Obrázek 19: Výsledek vykreslení jednoho obdélníka a dvou úseček.

10. Specifikace barvy pozadí i barvy vykreslovaných objektů

Ukažme si nyní, jak lze specifikovat barvu pozadí nebo popředí nikoli jménem, ale trojicí barevných složek v barvovém prostoru RGB. Tyto barvové složky mohou být zapsány šesticí hexadecimálních cifer, před nimiž je uveden znak #. Vždy dvojice cifer reprezentuje hodnotu jedné barvové složky v rozsahu 00 až FF neboli v desítkovém vyjádření 0 až 256:

' Grafický výstup
 
GraphicsWindow.Show()
GraphicsWindow.BackgroundColor = "#000000"
 
GraphicsWindow.PenColor = "#80ffff"
GraphicsWindow.DrawRectangle(10, 10, 100, 100)
 
GraphicsWindow.PenColor = "#ffff80"
GraphicsWindow.DrawLine(60, 50, 60, 70)
GraphicsWindow.DrawLine(50, 60, 70, 60)

Výsledek:

Obrázek 20: Odlišné barvy pozadí i barvy vykreslovaných objektů.

Alternativně je možné jednotlivé barvové složky přímo zapsat jako trojici hodnot od 0 do 255 a nechat si kód barvy vygenerovat metodou nazvanou GetColorFromRGB. Upravený kód předchozího demonstračního příkladu tedy bude vypadat následovně:

' Grafický výstup
 
GraphicsWindow.Show()
GraphicsWindow.BackgroundColor = GraphicsWindow.GetColorFromRGB(0,0,0)
 
GraphicsWindow.PenColor = GraphicsWindow.GetColorFromRGB(255, 0, 0)
GraphicsWindow.DrawRectangle(10, 10, 100, 100)
 
GraphicsWindow.PenColor = GraphicsWindow.GetColorFromRGB(0, 0, 255)
GraphicsWindow.DrawLine(60, 50, 60, 70)
GraphicsWindow.DrawLine(50, 60, 70, 60)

Výsledek:

Obrázek 21: Opět odlišné barvy pozadí i barvy vykreslovaných objektů.

Poznámka: jen pro zajímavost se podívejme, jak je práce s grafikou řešena v klasických BASICech. Ty většinou podporují příkazy PLOT a DRAWTO (či DRAW). První příkaz vykreslí jediný pixel, druhý příkaz úsečku. Oba příkazy přitom změní souřadnice „aktuálního bodu“, v němž začíná vykreslovaná úsečka. Průběh funkce lze vykreslit následovně:
1 REM *****************************
2 REM Vykresleni prubehu funkce
3 REM
4 REM Uprava pro Atari BASIC
5 REM
6 REM *****************************
7 REM
8 REM
9 REM
10 GRAPHICS 8+16
11 COLOR 1
12 PLOT 0,0:DRAWTO 0,191
13 PLOT 0,95:DRAWTO 319,95
18 PLOT 0,95
20 FOR I=1 TO 319
21 X=I/16
22 Y=60*SIN(X)
25 DRAWTO I,95-Y
30 NEXT I
999 GOTO 999:REM ZUSTAT V GRAFICE

11. Práce s grafikou na úrovni jednotlivých pixelů

Teoreticky je možné ke grafickému oknu přistupovat jako k pravidelné mřížce pixelů a modifikovat barvy jednotlivých pixelů. Pro tento účel se používá metoda nazvaná příznačně SetPixel. Můžeme tak vykreslit například celou barevnou škálu. Značnou nevýhodou tohoto postupu je fakt, že se jedná o značně pomalé operace, zejména při použití webové varianty Small Basicu, takže i jednoduché vyplnění plochy může trvat i několik minut!:

' Práce s grafikou na úrovni jednotlivých pixelů
 
GraphicsWindow.Show()
GraphicsWindow.BackgroundColor = GraphicsWindow.GetColorFromRGB(0,0,0)
 
for y = 0 to 255
    for x = 0 to 255
        color = GraphicsWindow.GetColorFromRGB(x, 0, y)
        GraphicsWindow.SetPixel(x, y, color)
    endfor
endfor

Část barevné škály vykreslená předchozím demonstračním příkladem:

Obrázek 22: Plocha s modifikovanými barvami pixelů.

12. Systém událostí – úvod do asynchronního programování

Některé rysy Small Basicu jsou velmi nízkoúrovňové a dokonce se tento programovací jazyk z určitého pohledu nachází až pod assemblerem (pouze globální proměnné atd.). Na druhou stranu zde však nalezneme vysokoúrovňové a na dobu vzniku elegantní jazykové konstrukce. Jedna z těchto konstrukcí slouží pro naprogramování reakce při vzniku nějaké asynchronní události.

Tento rys některých BASICů jsme si popsali v článku o GW-BASICu, takže možná neuškodí si připomenout, jak je tato problematika řešena právě v tomto dnes již historickém SW. Programová konstrukce pro obsluhu události začíná slovem ON, za kterým následuje typ události a poté buď příkaz skoku GOTO nebo skoku do podprogramu GOSUB.

Příkladem může být reakce na vznik chyby v programu, tedy konstrukce, která se v jiných BASICech řeší příkazem TRAP a v některých moderních programovacích jazycích konstrukcí try-catch. Při vzniku chyby se automaticky naplní proměnné ERL a ERR na číslo řádku a číslo (kód) chyby:

1 REM *****************************
2 REM Ukázka reakce na chybu
3 REM
4 REM Uprava pro GW-BASIC
5 REM
6 REM *****************************
7 REM
8 REM
9 REM
10 ON ERROR GOTO 1000
11 A = 10
12 PRINT A/0
999 END
1000 REM
1001 REM error handler
1002 REM
1003 PRINT "Chyba na radku:"; ERL
1004 PRINT "Kod chyby:"; ERR
1005 RESUME NEXT

Zajímavější je reakce na „tik“ časovače, přičemž frekvence tiků je zadána v sekundách (časovač je navíc nutné povolit). V následujícím programu je handler na řádku 1000 volán pravidelně každou sekundu:

1 REM *****************************
2 REM Ukázka handleru udalosti
3 REM
4 REM Uprava pro GW-BASIC
5 REM
6 REM *****************************
7 REM
8 REM
9 REM
10 ON TIMER(1) GOSUB 1000
20 PRINT "Waiting for timer ticks..."
30 TIMER ON
40 GOTO 30
999 END
1000 REM
1001 REM handler
1002 REM
1003 PRINT "tick"
1004 RETURN

Ve Small Basicu je systém událostí řešen – alespoň podle mého názoru – mnohem elegantnějším způsobem. Pro některé typy objektů (například pro grafickou obrazovku, časovač atd.) jsou totiž připraveny atributy, kterým lze přiřadit podprogram (subrutinu), která se má při vzniku dané události zavolat. Povolení zpracování událostí a současně i specifikace handleru události je tedy provedena jediným přiřazením, jak ostatně uvidíme v následujících dvou kapitolách na demonstračních příkladech.

13. Reakce na stisk tlačítka myši nebo na stisk klávesy

V případě, že aplikace musí reagovat na stisk tlačítka myši, použijeme handler (tedy podprogram), který se zaregistruje přiřazením identifikátoru podprogramu do atributu MouseDown objektu GraphicsWindow. Následující demonstrační příklad bude po stisku tlačítka myši vypisovat informace o pozici kurzoru myši. Souřadnice kurzoru jsou uloženy v atributech MouseX a MouseY stejného objektu, takže řešení je triviální:

' Události
 
GraphicsWindow.MouseDown = MouseClick
 
Sub MouseClick
    x = GraphicsWindow.MouseX
    y = GraphicsWindow.MouseY
    TextWindow.WriteLine("x: " + x + "   y: " +y)
EndSub

Prakticky stejným způsobem lze reagovat na stisk nějaké klávesy. V tomto případě je v atributu LastKey uloženo jméno klávesy ve formě řetězce:

' Události
 
GraphicsWindow.KeyDown = OnKeyDown
 
Sub OnKeyDown
    key = GraphicsWindow.LastKey
    TextWindow.WriteLine(key)
EndSub
Poznámka: podobně lze reagovat na stisk klávesy i v textovém okně.

14. Reakce na tik časovače

Často se setkáme s požadavkem nějakým způsobem reagovat na „tiknutí“ časovače. Časovač je ve Small Basicu představován objektem Timer, který má dva důležité atributy. Atributem Interval se určuje interval mezi jednotlivými tiky časovače, přičemž daná hodnota je specifikována v milisekundách. A druhý atribut, který se jmenuje Tick slouží k registraci podprogramu, který bude pravidelně volán. Následující demonstrační příklad zobrazí aktuální datum a čas a obnoví tuto informaci přibližně každou sekundu:

' Události
 
Timer.Interval = 1000
Timer.Tick = OnTick
 
Sub OnTick
    TextWindow.WriteLine(Clock.Date + " " + Clock.Time)
EndSub
Poznámka: časovač je možné v případě potřeby i pozastavit. Small Basic však umožňuje používat pouze jediný časovač, neboť objekt Timer nelze naklonovat.

15. Ladění programů v prostředí Small Basicu

Do prostředí Small Basicu je zabudován i jednoduchý debugger. Ten podporuje krokování programů, zobrazuje jména (globálních) proměnných a taktéž volaných podprogramů. Díky tomu, že nejsou podporovány ani lokální proměnné ani parametry volaných funkcí (podprogramů), je prostředí debuggeru do značné míry zjednodušeno. Debugger si můžete snadno vyzkoušet, například na následujícím algoritmu pro výpočet největšího společného dělitele dvou celých čísel (a otestovat si, co se stane, pokud čísla nebudou celá nebo nebudou kladná):

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)

Obrázek 23: Ladění (krokování) programu v prostředí Small Basicu.

16. Alternativní projekt s licencí GPL: Basic-256

Pod pojmem „BASIC“ se může skrývat široké množství programovacích jazyků, které mnohdy nemají s původním prakticky nestrukturovaným BASICem známým z dob osmibitových mikropočítačů prakticky nic společného. Mnohdy právě naopak: některé moderní jazyky, v jejichž názvu se vyskytuje slovo „BASIC“ jsou plně strukturované, některé podporují objektově orientované programování (založené buď na třídách či na posílání zpráv objektům), mnohé BASICy nabízí uživatelům i pokročilé datové typy, jako jsou asociativní pole atd. A právě takovým poměrně moderním dialektem BASICu je Basic-256 zmíněný v tomto článku. Důvod, proč je zde tato aplikace zmíněna je jednoduchý – v Basic-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 výše popsanému Small Basicu (a to i díky použité licenci).

Obrázek 24: Informace o projektu Basic-256.

17. Stručné představení Basicu-256

Jak již bylo napsáno v předchozím odstavci, Basic-256 se od klasické školy BASICu v mnoha ohledech odklání, což je ostatně jen dobře. Jedná se o interpret doplněný o jednoduché vývojové prostředí s grafickým uživatelským rozhraním, který byl navržen s ohledem na to, aby se tento dialekt mohl použít při výuce programování, především na středních školách (podle mého názoru se však hodí spíše na základní školy). Tomu odpovídá jak jednoduchost a přehlednost vlastního vývojového prostředí, tak i sémantika jazyka, která samozřejmě podporuje strukturované programování. Na Internetu je dostupná cca 300stránková učebnice programování, v níž jsou použity příklady naprogramované právě v Basicu-256. Nejedná se však v žádném případě o učebnici, která by pouze popisovala syntaxi tohoto jazyka, právě naopak – ukázána je například práce se základními datovými strukturami (seznamy, zásobníkem, frontou) spolu s vysvětlením, jak jsou tyto datové struktury a operace nad nimi interně implementovány. Kromě toho lze v této učebnici najít i mnohé základní algoritmy, například řazení prvků v posloupnosti.

Obrázek 25: Uživatelské rozhraní je velmi jednoduše ovladatelné, což je pro tuto skupinu aplikací základní požadavek.

Poznámka: zajímavé je, že i tento dialekt BASICu vznikl na základě již minule zmíněného článku Why Johnny can’t code. To je další pojítko mezi Basicem-256 na straně jedné a Small Basicem na straně druhé.

Obrázek 26: Do bitmapy je možné vykreslit mřížku, což je velmi užitečné, neboť se tak zvýrazní souřadnicový systém tvořící základ prakticky všech grafických knihoven (minimálně těch 2D).

Basicu-256 jsou k dispozici prakticky všechny základní příkazy určené pro tvorbu strukturovaných programů složených z funkcí, subrutin (podprogramů), programových smyček a rozvětvení. Nalezneme zde i typicky BASICovou smyčku typu For-Next, která je podle mého názoru čitelnější, než podobně koncipovaná smyčka používaná v jazycích C, C++, Java či JavaScript. Podívejme se jen ve stručnosti na základní příklady:

i = 1
while i<1000
   print i
   i=i*2
end while
 
1
2
4
8
16
32
64
128
256
512

Specifikace kroku smyčky:

for i=10 to 0 step -2
   print i
next i
 
10
8
6
4
2
0

Smyčka s testem na konci:

x=10
do
   print x
   x=x/2
until x<0.1
 
10
5
2.5
1.25
0.625
0.3125
0.15625

Strukturovaný rozeskok resp. rozvětvení:

for i=0 to 20
   print i;
   if i % 2 =0 then
      print " sude"
   else
      print " liche"
   endif
next i
 
Zaciname
0 sude
1 liche
2 sude
3 liche
4 sude
5 liche
6 sude
7 liche
8 sude
9 liche
10 sude
11 liche
12 sude
13 liche
14 sude
15 liche
16 sude
17 liche
18 sude
19 liche
20 sude

Obrázek 27: Práce s rastrovou grafikou je v Basicu-256 skutečně snadná.

Tip do článku - root - cybersecurity

Poznámka: podrobnější informace o Basicu-256 budou uvedeny v samostatném článku.

18. Příloha: seznam klíčových slov Atari BASICu

V úvodních kapitolách jsme se zmínili o tom, že zavedením objektů se počet klíčových slov a příkazů Small Basicu podařilo zredukovat prakticky na minimum – 14 příkazů a 2 operátory. Jen pro zajímavost si uveďme klíčová slova (což jsou příkazy a vestavěné funkce) Atari BASICu implementovaného v pouhých osmi kilobajtech ROM. Všechna tato klíčová slova jsou vytvořena v globálním jmenném prostoru a mnohá z nich nejsou kompatibilní s dalšími BASICy – v tom nejhorším případě mají dokonce zcela odlišný význam (příkladem je příkaz CLR, který v jiných BASICech maže obrazovku):

Klíčové slovo Typ/oblast Stručný popis
BYE control switch to built-in Self Test program
CLOAD I/O loads tokenized program from cassette tape (see CSAVE, LOAD)
CLOSE I/O closes a given I/O channel with flush (see OPEN, PUT, GET)
CLR memory clears variables from memory and stack as well
COLOR graphics select/chooses logical color value for drawing
CONT control continues program execution after STOP statement
CSAVE I/O saves tokenized program into cassette tape (see CLOAD, SAVE)
DATA memory used to store data as list of values (numeric, string)
DEG control switches internal state to enable degrees for trig.functions
DIM memory defines and allocates an array or matrix
DOS control switch to DOS (Disk Operating System) if available
DRAWTO graphics draws a line from current position (PLOT) to given coordinates
END control finishes execution of the program and closes open I/O channels
ENTER I/O loads and merges into memory a plain text program (in ATASCII)
FOR control beginning of a for loop (see TO, STEP, and NEXT)
GET I/O reads one byte from a given I/O channel (see PUT)
GOSUB control jumps to a subroutine, put current line number onto stack
GOTO control jumps to given program line (can be stored in variable)
GO TO control dtto
GRAPHICS graphics sets the specified graphics node, clear screen for modes <16
IF control evaluate the condition and executes next commands if true
INPUT I/O read stream from specified I/O channel, converts to num/string
LET control assigns a value to a named variable. Fully optional on Atari.
LIST I/O lists the program to screen, printer, or any other device
LOAD I/O loads a tokenized program from specified device (see SAVE)
LOCATE graphics read color or character code from specified coordinates
LPRINT I/O prints program source code onto a printer (see PRINT)
NEW control erase program source code, erase all variables too
NEXT control next iteration of a for loop for specified variable (see FOR)
NOTE I/O returns the current position on a given I/O channel (see POINT)
ON control used together with GOTO statement to perform computed jump
OPEN I/O initializes and open I/O channel (see CLOSE, PUT, GET)
PLOT graphics draws a point (pixel) at given coordinates (see DRAWTO)
POINT I/O sets the current position on a given I/O channel (see NOTE)
POKE memory writes one byte of data into memory location (see DPOKE, PEEK)
POP control removes return address from the stack (see GOSUB, RETURN)
POSITION graphics sets the position of the graphics cursor (see PLOT, DRAWTO)
PRINT I/O writes text to an I/O channel or onto screen if not specified
PUT I/O writer one byte from a given I/O channel (see GET)
RAD control switches internal state to enable radians for trig.functions
READ memory reads data from DATA statement, increment internal DATA ptr.
REM comment used to create a comment in a program (rest of line is ignored)
RESTORE memory sets the position where to read data from a DATA statement
RETURN control ends a subroutine, return to statement following GOSUB
RUN control starts execution of a program; can be started from device too
SAVE I/O writes a tokenized program to device (see LOAD)
SETCOLOR graphics maps a logical color to physical color: hue + level (see COLOR)
SOUND sound starts or stops playing a tone on a sound channel (see END)

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

Všechny minule i dnes popsané demonstrační příklady určené pro Small Basic (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ář:

# 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
     
31 31_text_window.bas objekt typu TextWindow https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/31_text_window.bas
32 32_foreground_background.bas nastavení barvy popředí a pozadí textového okna https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/32_foreground_backgrou­nd.bas
33 33_text_object.bas objekt typu Text a některé jeho metody https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/33_text_object.bas
34 34_turtle_square.bas želví grafika: vykreslení čtverce https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/34_turtle_square.bas
35 35_turtle_star.bas želví grafika: vykreslení hvězdy https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/35_turtle_star.bas
36 36_turtle_hide_speed.bas želví grafika: schování želvy, nastavení největší rychlosti kreslení https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/36_turtle_hide_speed.bas
37 37_turtle_pen_up_pen_down.bas želví grafika: spuštění a zvednutí kreslicího pera https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/37_turtle_pen_up_pen_dow­n.bas
38 38_graphics_window.bas objekt typu GraphicsWindow https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/38_graphics_window.bas
39 39_graphics_draw.bas kreslení do grafického okna https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/39_graphics_draw.bas
40 40_hex_colors.bas nastavení barvy šesticí hexadecimálních číslic https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/40_hex_colors.bas
41 41_rgb_colors.bas nastavení barvy smícháním trojice základních barev https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/41_rgb_colors.bas
42 42_set_pixel.bas vybarvení jednotlivých pixelů https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/42_set_pixel.bas
43 43_mouse_click_event.bas událost: kliknutí tlačítkem myši https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/43_mouse_click_event.bas
44 44_key_down_event.bas událost: stisk klávesy https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/44_key_down_event.bas
45 45_timer_tick_event.bas událost: tik časovače https://github.com/tisnik/8bit-fame/blob/master/Small%20Ba­sic/45_timer_tick_event.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. Dartmouth Time Sharing System
    http://en.wikipedia.org/wi­ki/Dartmouth_Time_Sharing_Sys­tem
  48. General Electric (Wikipedia)
    http://en.wikipedia.org/wi­ki/General_Electric
  49. GE 225 vs. IBM 1401
    http://ed-thelen.org/GE225-IBM1401.html
  50. A GE-225 is found
    http://ed-thelen.org/comp-hist/GE225.html
  51. G.E. 200 Series Computers
    http://www.smecc.org/g_e__200_se­ries_computers.htm
  52. DTSS – Dartmouth Time Sharing System
    http://dtss.dartmouth.edu/index.php
  53. John G. Kemeny: BASIC and DTSS: Everyone a Programmer
    http://dtss.dartmouth.edu/e­veryoneaprogrammer.php
  54. GE-200 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-200_series
  55. GE-400 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-400_series
  56. GE-600 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-600_series
  57. ZX Basic Manual
    http://www.worldofspectrum­.org/ZXBasicManual/
  58. ZX81 BASIC Programming
    http://www.worldofspectrum­.org/ZX81BasicProgramming/
  59. Sinclair BASIC History
    http://scratchpad.wikia.com/wi­ki/Sinclair_BASIC_History
  60. Sinclair BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Sinclair_BASIC
  61. Sinclair BASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/Sinclair_BASIC
  62. Beta BASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/Beta_BASIC
  63. Beta BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Beta_BASIC
  64. BETA BASIC NEWSLETTER No 8
    http://spectrum128.ru/hel­p/BetaBasicNewsletter8.pdf
  65. R. T. RUSSELL: The home of BBC BASIC
    http://www.rtrussell.co.uk/
  66. R. T. RUSSELL: A History of BBC BASIC
    http://www.cix.co.uk/~rrus­sell/bbcbasic/history.html
  67. SuperBASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/SuperBASIC
  68. SuperBASIC (Wikipedia CZ)
    http://en.wikipedia.org/wi­ki/SuperBASIC
  69. Laser Basic/Laser Compiler
    http://www.sincuser.f9.co­.uk/049/laser.htm
  70. Laser BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Laser_BASIC
  71. BBC BASIC
    http://www.bbcbasic.co.uk/bbcba­sic.html
  72. BBC BASIC
    http://mdfs.net/Software/BBCBasic/
  73. BBC BASIC (Z80) for the ZX Spectrum
    http://mdfs.net/Software/BBCBa­sic/Spectrum/
  74. BBC BASIC (Wikipedia CZ)
    http://en.wikipedia.org/wi­ki/BBC_BASIC
  75. BeebWiki – 8-bit Acorn Computer Wiky
    http://beebwiki.jonripley­.com/Main_Page
  76. Porovnání osmibitů
    http://porovnani8bitu.spa­ces.live.com/
  77. Rosetta Code – Main Page
    http://rosettacode.org/wiki/Main_Page
  78. Rosetta Code – Category Basic
    http://rosettacode.org/wi­ki/Category:BASIC
  79. QBasicJedi
    http://www.freewebs.com/qbasicjedi/
  80. QBasic/QuickBasic Downloads
    http://www.freewebs.com/qba­sicjedi/qbdownloads.html
  81. QuickBASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/QuickBASIC
  82. QBasic.com
    http://www.qbasic.com/
  83. QBasic (Wikipedia)
    http://cs.wikipedia.org/wiki/QBasic
  84. Dialling with QBASIC
    http://www.mysundial.ca/tsp/qba­sic.html
  85. BASIC (Wikipedia EN)
    http://en.wikipedia.org/wiki/BASIC
  86. BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wiki/BASIC
  87. Turbo BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Turbo_BASIC
  88. More BASIC Computer Games
    http://www.atariarchives.or­g/morebasicgames/
  89. How to build an interpreter in Java, Part 1: The BASICs
    http://www.javaworld.com/jw-05–1997/jw-05-indepth.html
  90. INTEGER BASIC Reference
    http://www.landsnail.com/a2ref2.htm
  91. APPLESOFT Reference
    http://www.landsnail.com/a2ref.htm
  92. Applesoft Lite: Applesoft BASIC for the Replica-1
    http://cowgod.org/replica1/applesoft/
  93. Simons' BASIC
    http://en.wikipedia.org/wi­ki/Simons'_BASIC
  94. Simon's Basic
    http://www.lemon64.com/?ma­inurl=http%3A//www.lemon64­.com/museum/list.php%3Fli­neoffset%3D54%26genre%3Dma­nualmisc
  95. BASIC
    http://www.c64-wiki.com/index.php/BASIC
  96. C64 Wiki: Simons Basic
    http://www.c64-wiki.de/index.php/Simons_Basic
  97. Simons' Basic (evaluation)
    http://www.atarimagazines­.com/creative/v9n11/60_Si­mons_Basic.php
  98. Bill Gates' Personal Easter Eggs in 8 Bit BASIChttp://www.pagetable.com/?p=43
  99. 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/
  100. Let's make a small and simple GW-BASIC program!
    https://www.youtube.com/wat­ch?v=OyPUn74nj-s
  101. Seriál Letní škola programovacího jazyka Logo
    http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/
  102. Educational programming language
    http://en.wikipedia.org/wi­ki/Educational_programmin­g_language
  103. Logo Tree Project:
    http://www.elica.net/downlo­ad/papers/LogoTreeProject­.pdf

Autor článku

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