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
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
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
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 ENDi
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.
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))
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.
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ů.
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
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
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.
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).
V 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á.
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) |
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ář:
20. Odkazy na Internetu
- Stránka projektu Small Basic
https://smallbasic-publicwebsite.azurewebsites.net/ - List of Programs Made with Small Basic
https://social.technet.microsoft.com/wiki/contents/articles/14013.list-of-programs-made-with-small-basic.aspx - Expert to Expert: The Basics of SmallBasic
https://channel9.msdn.com/blogs/charles/expert-to-expert-the-basics-of-smallbasic - The Developer’s Reference Guide to Small Basic
https://social.technet.microsoft.com/wiki/contents/articles/16767.the-developers-reference-guide-to-small-basic.aspx - Small Basic – Talking to Raspberry Pi
https://techcommunity.microsoft.com/t5/small-basic-blog/small-basic-talking-to-raspberry-pi/ba-p/337844 - Small Basic – Arduino
https://techcommunity.microsoft.com/t5/small-basic-blog/small-basic-arduino/ba-p/337762 - Small Basic + micro:bit
https://techcommunity.microsoft.com/t5/small-basic-blog/small-basic-micro-bit/ba-p/1968424 - #1 Learn Small Basic Programming – Introduction
https://www.youtube.com/watch?v=e_BaEPCa8OQ - #2 Learn Small Basic Programming – Input, Output & Variables
https://www.youtube.com/watch?v=VWekYLa33OI - #3 Learn Small Basic Programming – String Concatenation
https://www.youtube.com/watch?v=iWvIaOaT474 - Small Basic – The Programmer's Guide
https://www.i-programmer.info/programming/other-languages/5196-small-basic-the-programmers-guide.html - Rosetta Code: Category:Microsoft Small Basic
https://rosettacode.org/wiki/Category:Microsoft_Small_Basic - Fifty Years of BASIC, the Programming Language That Made Computers Personal
https://time.com/69316/basic/ - BBC BASIC i QBasic oslavují svá kulatá výročí
https://www.root.cz/clanky/bbc-basic-i-qbasic-oslavuji-sva-kulata-vyroci/ - What are the best BASIC-like programming languages?
https://www.slant.co/topics/9807/~basic-like-programming-languages - List of BASIC dialects
https://en.wikipedia.org/wiki/List_of_BASIC_dialects - GW-BASIC Documentation
https://hwiegman.home.xs4all.nl/gwbasic.html - Microsoft Open-Sources GW-BASIC
https://devblogs.microsoft.com/commandline/microsoft-open-sources-gw-basic/ - GW-BASIC na GitHubu
https://github.com/microsoft/GW-BASIC - Welcome to GW-BASIC
http://www.antonis.de/qbebooks/gwbasman/ - GWBASIC User's Manual
http://www.antonis.de/qbebooks/gwbasman/index2.html - The basics of BASIC, the programming language of the 1980s
https://www.youtube.com/watch?v=seM9SqTsRG4 - GW-BASIC User's Guide
https://hwiegman.home.xs4all.nl/gw-man/index.html - PC-BASIC 1.2.14 documentation
http://robhagemans.github.io/pcbasic/doc/1.2/ - PEEK and POKE
https://en.wikipedia.org/wiki/PEEK_and_POKE - GW-BASIC | DRAW Statement (video na Youtube)
https://www.youtube.com/watch?v=4I1CELY13M4 - Rozdíly mezi GW-BASIC a QBasicem
https://hwiegman.home.xs4all.nl/extern/Differences%20Between%20GW-BASIC%20and%20QBasic.htm - GW-Basic Programs
https://gwbasicprograms.blogspot.com/p/gw-basic-programs.html - GW-BASIC Resource
https://gw-basic.netlify.app/ - A page about GWBASIC Games & Other Programs
http://peyre.x10.mx/GWBASIC/ - Basic BASIC, 2nd Edition, James S. Coan
https://drive.google.com/uc?export=download&id=1Z12L7SO_gfNg3Ma_0eH2_Kz15YM-9dHl - Advanced BASIC, James S. Coan
https://drive.google.com/uc?export=download&id=1JafSpV_BLylWHMd16rDPorwv9wV9bLcy - Structured BASIC, 2nd Edition, James F. Clark (naskenovaná kniha)
https://drive.google.com/uc?export=download&id=1pT8y-8yJYS_SqvxF0fBHm6S-dlAt-Uy2 - Last Book of GW-Basic
https://www.geocities.ws/joseph_sixpack/btoc.html - SCIENTIFIC PROGRAMS WRITTEN IN BASIC (for PCs)
https://web.archive.org/web/20160323064356/http://www.scn.org/~bh162/basic_programs.html - Why I love programming on FreeDOS with GW-BASIC
https://opensource.com/article/21/6/freedos-gw-basic - Quite BASIC (web-based classic BASIC online programming environmen)
http://www.quitebasic.com/ - GFA-BASIC
http://sites.google.com/site/gfabasic16/ - E-mail od tvůrce GW-Basicu
http://www.classiccmp.org/pipermail/cctech/2005-April/042999.html - General Electric GE-400
http://www.feb-patrimoine.com/PROJET/ge400/ge-400.htm - GE-400 Time-sharing information systems:
http://www.computerhistory.org/collections/accession/102646147 - A brief history of the development of BASIC (pravděpodobně již nefunkční odkaz)
http://www.phys.uu.nl/~bergmann/history.html - History of BASIC (PDF)
http://www.q7basic.org/History%20of%20BASIC.pdf - Dartmouth College Computation Center. 1964.-The original Dartmouth BASIC manual
http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf - The Original BASIC
http://www.truebasic.com/ - BASIC – Beginners All-purpose Symbolic Instruction Code
http://hopl.murdoch.edu.au/showlanguage.prx?exp=176 - Dartmouth Time Sharing System
http://en.wikipedia.org/wiki/Dartmouth_Time_Sharing_System - General Electric (Wikipedia)
http://en.wikipedia.org/wiki/General_Electric - GE 225 vs. IBM 1401
http://ed-thelen.org/GE225-IBM1401.html - A GE-225 is found
http://ed-thelen.org/comp-hist/GE225.html - G.E. 200 Series Computers
http://www.smecc.org/g_e__200_series_computers.htm - DTSS – Dartmouth Time Sharing System
http://dtss.dartmouth.edu/index.php - John G. Kemeny: BASIC and DTSS: Everyone a Programmer
http://dtss.dartmouth.edu/everyoneaprogrammer.php - GE-200 series (Wikipedia)
http://en.wikipedia.org/wiki/GE-200_series - GE-400 series (Wikipedia)
http://en.wikipedia.org/wiki/GE-400_series - GE-600 series (Wikipedia)
http://en.wikipedia.org/wiki/GE-600_series - ZX Basic Manual
http://www.worldofspectrum.org/ZXBasicManual/ - ZX81 BASIC Programming
http://www.worldofspectrum.org/ZX81BasicProgramming/ - Sinclair BASIC History
http://scratchpad.wikia.com/wiki/Sinclair_BASIC_History - Sinclair BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Sinclair_BASIC - Sinclair BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/Sinclair_BASIC - Beta BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/Beta_BASIC - Beta BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Beta_BASIC - BETA BASIC NEWSLETTER No 8
http://spectrum128.ru/help/BetaBasicNewsletter8.pdf - R. T. RUSSELL: The home of BBC BASIC
http://www.rtrussell.co.uk/ - R. T. RUSSELL: A History of BBC BASIC
http://www.cix.co.uk/~rrussell/bbcbasic/history.html - SuperBASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/SuperBASIC - SuperBASIC (Wikipedia CZ)
http://en.wikipedia.org/wiki/SuperBASIC - Laser Basic/Laser Compiler
http://www.sincuser.f9.co.uk/049/laser.htm - Laser BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Laser_BASIC - BBC BASIC
http://www.bbcbasic.co.uk/bbcbasic.html - BBC BASIC
http://mdfs.net/Software/BBCBasic/ - BBC BASIC (Z80) for the ZX Spectrum
http://mdfs.net/Software/BBCBasic/Spectrum/ - BBC BASIC (Wikipedia CZ)
http://en.wikipedia.org/wiki/BBC_BASIC - BeebWiki – 8-bit Acorn Computer Wiky
http://beebwiki.jonripley.com/Main_Page - Porovnání osmibitů
http://porovnani8bitu.spaces.live.com/ - Rosetta Code – Main Page
http://rosettacode.org/wiki/Main_Page - Rosetta Code – Category Basic
http://rosettacode.org/wiki/Category:BASIC - QBasicJedi
http://www.freewebs.com/qbasicjedi/ - QBasic/QuickBasic Downloads
http://www.freewebs.com/qbasicjedi/qbdownloads.html - QuickBASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/QuickBASIC - QBasic.com
http://www.qbasic.com/ - QBasic (Wikipedia)
http://cs.wikipedia.org/wiki/QBasic - Dialling with QBASIC
http://www.mysundial.ca/tsp/qbasic.html - BASIC (Wikipedia EN)
http://en.wikipedia.org/wiki/BASIC - BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/BASIC - Turbo BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Turbo_BASIC - More BASIC Computer Games
http://www.atariarchives.org/morebasicgames/ - How to build an interpreter in Java, Part 1: The BASICs
http://www.javaworld.com/jw-05–1997/jw-05-indepth.html - INTEGER BASIC Reference
http://www.landsnail.com/a2ref2.htm - APPLESOFT Reference
http://www.landsnail.com/a2ref.htm - Applesoft Lite: Applesoft BASIC for the Replica-1
http://cowgod.org/replica1/applesoft/ - Simons' BASIC
http://en.wikipedia.org/wiki/Simons'_BASIC - Simon's Basic
http://www.lemon64.com/?mainurl=http%3A//www.lemon64.com/museum/list.php%3Flineoffset%3D54%26genre%3Dmanualmisc - BASIC
http://www.c64-wiki.com/index.php/BASIC - C64 Wiki: Simons Basic
http://www.c64-wiki.de/index.php/Simons_Basic - Simons' Basic (evaluation)
http://www.atarimagazines.com/creative/v9n11/60_Simons_Basic.php - Bill Gates' Personal Easter Eggs in 8 Bit BASIChttp://www.pagetable.com/?p=43
- Třicet let od vydání revolučního Turbo Pascalu 5.5
https://www.root.cz/clanky/tricet-let-od-vydani-revolucniho-turbo-pascalu-5–5/ - Let's make a small and simple GW-BASIC program!
https://www.youtube.com/watch?v=OyPUn74nj-s - Seriál Letní škola programovacího jazyka Logo
http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/ - Educational programming language
http://en.wikipedia.org/wiki/Educational_programming_language - Logo Tree Project:
http://www.elica.net/download/papers/LogoTreeProject.pdf