Kapitoly z dějin informatiky 3 Vývoj software ve 20. století

Kapitoly z dějin informatiky 3
Vývoj software ve 20. století
Michal Musílek
Centrum talentů M&F&I, Univerzita Hradec Králové, 2010
Obsah
Předmluva .......................................................................................................................................................... 3
7
Vývoj programování počítačů, programovací jazyky ................................................................................. 4
7.1 Strojový kód ........................................................................................................................................... 4
7.2 Jazyk symbolických adres (assembly language) .................................................................................... 5
7.3 Vyšší programovací jazyky zrozené v 50. letech 20. století................................................................... 6
7.4 Výběr z procedurálních programovacích jazyků 60. a 70. let 20. století ............................................... 8
7.5 Funkcionální programovací jazyky ........................................................................................................ 9
7.6 Dětské programovací jazyky ................................................................................................................ 10
7.7 Logické programovací jazyky .............................................................................................................. 11
8
Operační systémy a uživatelská rozhraní .................................................................................................. 12
8.1 Vznik operačních systémů sálových počítačů ...................................................................................... 12
8.2 Operační systém UNIX ........................................................................................................................ 13
8.3 Operační systémy unixového typu na osobních počítačích .................................................................. 14
8.4 Vývoj uživatelských rozhraní počítačů ................................................................................................ 15
8.5 Grafická uživatelská rozhraní počítačů ................................................................................................ 17
2
Předmluva
Toto vyprávění o nejzajímavějších momentech historického vývoje informatiky vzniklo jako
studijní text pro nadané zájemce o informatiku (případně výpočetní techniku či matematiku) z řad
středoškolských studentů v rámci projektu Centrum talentů MFI Pedagogické fakulty Univerzity
Hradec Králové. Stejně dobře může posloužit i jejich učitelům pro zpestření výuky informatiky.
Historie informatiky nebo, chcete-li, výpočetní techniky začíná už v době starověkých civilizací
výpočetními pomůckami (abakus, čínské počítací hůlky) a pokračuje v novověku od dob renesance
dokonalejšími mechanickými kalkulátory buď digitálními (konstrukce Shickardova, Pascalova,
Leibnizova, Colmarova, Odhnerova), nebo analogovými (logaritmické pravítko), aby v 19. století
mechanická etapa vývoje vyvrcholila velkolepými projekty jednoúčelových počítačů – diferenčních
strojů, jež dokázaly automaticky počítat a tisknout tabulky matematických funkcí, a Hollerithových
děrnoštítkových systémů, jež dokázaly zpracovávat rozsáhlé relační databáze. Těmto tématům byl
věnován první díl mého vyprávění.
Masovému rozvoji informačních technologií ve 20. století, jdoucímu ruku v ruce s prudkým
vývojem elektroniky, projevujícímu se rychlým zvyšováním výkonu počítačů při současném
zmenšování jejich rozměrů, byl zasvěcen druhý díl kapitol z dějin informatiky. Věnoval jsem jej
zcela hardware elektronických počítačů, jak číslicových, tak analogových, včetně vstupních
a výstupních (periferních) zařízení. Zmínil jsem se také o vzájemném ovlivňování výpočetní,
záznamové a sdělovací techniky, které nakonec vedlo k jejich současnému propojení.
Poslední, třetí díl publikace je věnován vývoji programovacích jazyků různého typu, operačních
systémů a uživatelských rozhraní počítačů. Na rozdíl od předchozích dvou dílů jsem zde mohl
postihnout jen některé směry vývoje, protože software je mnohem více rozrůzněný než hardware
a tak zdaleka není možné postihnout vše, co se odehrálo. Nezabýval jsem se zatím vůbec historií
aplikačního software různého typu, protože na to by plánovaný rozsah textu nemohl stačit. Cílem
bylo jen načrtnout některé hlavní „dějové linky“ a probudit v čtenářích zájem o dějiny informatiky,
do nichž historie software bezesporu patří.
Přeji vám, milí čtenáři, aby vás čtení kapitol z historie informatiky bavilo alespoň tak, jako mne
těšilo je pro vás psát.
V Hradci Králové v dubnu 2010
Michal Musílek
3
7
Vývoj programování počítačů, programovací jazyky
7.1 Strojový kód
První počítače měly velmi daleko k dnešním univerzálním nástrojům, provádějícím výpočty,
zpracovávajícím informace různých druhů a umožňujícím rychlou komunikaci prostřednictvím
světové počítačové sítě internet. První počítače prováděly skutečně „pouze“ výpočty, které předtím
ručně realizovaly týmy lidských počtářů. V angličtině se právě v tuto dobu posunul význam slova
computer od původního počtář (člověk profesionálně provádějící výpočty) k počítač (stroj, který
provádí výpočty).
První generace počítačů se programovala ručním propojováním vodičů (propojováním zdířek
spojovacími vodiči na ovládacím panelu, přepínáním přepínačů apod.), k němuž s o něco později
přidalo čtení vstupních instrukcí a dat z papírové děrné pásky. Přeprogramování počítače na jinou
úlohu byl pracný úkon, který vyžadoval trpělivost a pečlivost a souhru několika členů týmu. Kromě
programátorů, kteří vymysleli a zapsali algoritmus, byli potřeba kodéři, kteří přepsali celý program
do posloupnosti dvojkových čísel a operátoři, kteří řídili vlastní spuštění a provedení kódu. Ladění
programu bylo velmi obtížné a časově náročné, protože pro něj neexistovaly žádné pomůcky.
Odborníků s potřebným matematickým vzděláním bylo v době 2. světové války málo, muži sloužili
v armádě. Proto byly k službě u prvních počítačů ve větším počtu povolány také ženy. Záhy se to
ukázalo být velmi dobrým řešením, protože tolik potřebné přesnosti, pečlivosti a trpělivosti nutné
při programování prvních počítačů měly
ženy více než jejich mužští kolegové.
Jednou z prvních programátorek byla
Kathleen McNulty (* 1921), která
pracovala nejprve jako počtářka (computer)
na výpočtech balistických tabulek pro
armádu USA a v roce 1943 se spolu s pěti
dalšími ženami stala první programátorkou
počítače ENIAC. Možná, že je nejznámější
z týmu programátorek i proto, že se po válce
stala druhou ženou ovdovělého Johna
Mauchlyho a společně pečovali o pět dětí.
Obr. 72 Kathleen McNulty, Alyse Snyder a Sis Stump
Další nevýhodou první generace byla neexistence jednotících norem. Co počítač, to originál s jinou
sadou příkazů procesoru, s jiným strojovým kódem. Programátor musel myslet nejen na algoritmus,
ale i na uložení kódu v operační paměti, stejně jako na alokaci paměti pro všechny proměnné, pole
proměnných atd. To vše v absolutní pozici v paměti, tedy konkrétní instrukce programu (početní
operace, rozhodovací operace, skok v programu, …) měla v podstatě předem pevně dané místo
operační paměti, ve kterém byla uložena.
4
7.2 Jazyk symbolických adres (assembly language)
S rozvojem výpočetní techniky bylo brzy zřejmé, že software (strojový kód) zaostává za možnostmi
hardware a že je potřeba vymyslet novou „technologii“ programování, která by využití počítačů
nebrzdila. Prvním krokem od strojového kódu k symbolickému jazyku přístupnému člověku byla
skupina jazyků symbolických adres (JSA; angl. assembly language), které místo číselných kódů pro
jednotlivé instrukce procesoru používaly symbolické zkratky (např. ADD pro součet, JMP pro skok,
MOV pro přesun hodnoty z paměti do registru) a současně nepožadovaly absolutní alokaci paměti,
místo níž použily symbolické adresy, jejichž konkretizaci pak zařídil překladač typu assembler
(tedy „sestavovač“, program, který z programu v JSA sestaví strojový kód). Často se nesprávně
název assembler používá i pro JSA, ve skutečnosti je assembler historicky první typem překladače
programovacího jazyka, který překlad z JSA do strojového kódu provádí na několik průchodů, při
nichž postupně provede potřebnou alokaci paměti pro vlastní program i pro potřebné proměnné.
Assemblery se pro některé speciální úlohy používají i v současnosti. Např. tam, kde je nutný přímý
přístup k hardware (ovladače zařízení), vysoký výpočetní výkon, nebo řízení procesů v reálném
čase. V JSA se také psaly první operační systémy pro sálové počítače. Dalším typickým prvkem,
který usnadní programování v JSA, je zavedení pseudoinstrukcí a maker, čímž se zjednoduší zápis
opakujících se částí kódu. Jde o předstupeň plnohodnotných podprogramů.
JSA jsou tak jako strojový kód vázané na konkrétní typ, resp. konkrétní řadu procesorů. Programy
napsané v JSA pro určitý hardware nejsou buď přenositelné vůbec, nebo přenositelné jen s velkými
obtížemi na jinou hardwarovou platformu. JSA přinesly programátorům velké zjednodušení práce,
byly typickým nástrojem druhé generace počítačů, ale bylo zřejmé, že ani ony nejsou elegantním
a jednoduchým řešením zápisu algoritmů. Na cestě od stroje k člověku bylo potřeba učinit další
krok.
Obr. 73 Ukázka strojového kódu (vlevo) a JSA (vpravo) v emulátoru procesoru Intel 8086
5
7.3 Vyšší programovací jazyky zrozené v 50. letech 20. století
Třetí generaci softwaru představují obecné problémově orientované programovací jazyky. Často se
jim říká také vyšší programovací jazyky a myslí se tím, že se od nízké úrovně strojového kódu či
JSA dostali značně vysoko směrem k algoritmickému myšlení člověka plánujícího složitý výpočet.
Podobně označení „problémově orientovaný“ znamená, že programátor nemusí myslet na procesor
a jeho instrukční sadu, ale může se plně soustředit na problém, který chce vyřešit. V praxi to značí
nezávislost na konkrétním hardware, a tedy snadnou přenositelnost napsaných programů.
Takových programovacích jazyků existovala už na konci 50. let celá řada. Kdybychom se snažili
postihnout celou šíři vývoje, hrozilo by, že ztratíme potřebný nadhled. Proto se soustředíme pouze
na tři nejvýznamnější představitele vývoje, za něž považuji jazyky FORTRAN, COBOL a ALGOL.
Jazyk FORTRAN (z angl. FORmula TRANslator) vyvíjela ve firmě IBM od roku 1954 skupina,
kterou vedl John Backus (1924 – 2007). Důraz při vývoji jazyka a překladače byl kladen
na rychlost a efektivnost zejména vědecko-technických výpočtů, přenositelnost nebyl na prvním
místě, protože šlo o projekt orientovaný na sálové počítače IBM řady 700. Díky této koncepci se
FORTRAN stal jedním z nejrozšířenějších programovacích jazyků své doby. Vývoj jazyka
intenzivně pokračoval do roku 1963 (FORTRAN IV), jazyk byl později normalizován (standardy
ANSI a ISO), byly vydávány jeho nové verze a své uživatele má ještě dnes (FORTRAN 2008).
John Backus je znám také jako spolutvůrce Backus-Naurovy formy pro popis gramatik formálních
jazyků. Používá se jak pro popis gramatik programovacích jazyků, instrukčních sad, komunikačních
protokolů a dokonce i částí gramatik skutečných jazyků. Ještě před jazykem FORTRAN vyvinul
jazyk Speedcoding, který se však nerozšířil. Později spolupracoval na vývoji jazyka ALGOL a také
podnítil zájem o funkcionální programování, o němž budeme mluvit později.
Jazyk COBOL (z angl. COmmon Business Oriented Language) byl oficiálně vydán roku 1959
sdružením CODASYL, založeným z iniciativy Ministerstva obrany USA. Administrativní pokyn
vlády USA z roku 1960 pak nařídil vybavit překladačem COBOLu každý komerčně instalovaný
počítač, čímž došlo jeho k masovému rozšíření. Matkou COBOLu bývá nazývána Grace Hopper
(1906 – 1992), která stavěla na předchozích zkušenostech z práce matematičky a programátorky
ve firmě Eckert-Mauchly Corporation (výrobce počítačů BINAC a UNIVAC), pro níž a pro firmu
Remington Rand zpracovala programovací jazyky FLOW-MATIC a MATH-MATIC. Tato dáma je
autorkou první příručky počítačové terminologie a matkou myšlenky použití jednotné matematické
notace a jednoduchých anglických příkazů k sestavení zápisu programu v podobě srozumitelné
člověku i počítači. COBOL umožnil kromě vědecko-technických výpočtů také základní zpracování
databází. Po formální stránce nedosáhl přehlednosti FORTRANu či ALGOLu, ale z praktického
hlediska šlo o snadno implementovatelný a dobře použitelný programovací jazyk pro běžné rutinní
výpočty v komerční sféře.
Oba výše uvedené jazyky vznikly v USA a odtud se šířily do celého světa. Třetí – programovací
jazyk ALGOL (z angl. ALGOrithmic Language) vznikl z iniciativy evropského Odborného výboru
pro programování (GAMM), která na společném zasedání s americkou ACM (Association for
Computing Machinery) v roce 1958 vydala první verzi jazyka – ALOGOL 58. Velmi rychle byla
6
zapracována řada připomínek a vylepšení a vydána verze ALGOL 60. Významný podíl na vývoji
konečné verze ALGOL 68 měl svými pracemi, věnovanými operativní sémantice, holandský
informatik Adriaan van Wijngaarden (1916 – 1987). Jazyk ALGOL se od konce 60. let dále
nevyvíjel, nikdy nedosáhl tak masového rozšíření v praxi jako FORTRAN či COBOL, ale se stal
obecně uznávaným standardem pro publikování algoritmů v odborných časopisech a zároveň byl
východiskem a inspirací pro řadu dalších programovacích jazyků, např. Pascal, Simula 67 či Ada.
Ukázka zápisu programu v jazyce ALGOL 68. Program najde pomocí Eratosthenova síta všechna
prvočísla menší než 100 a vypíše je:
begin # Algol-68 prime number sieve, functional style #
proc error = (string s) void:
(print(( newline, " error: ", s, newline)); goto stop);
proc one to = (int n) list:
(proc f = (int m,n) list: (m>n | nil | cons(m, f(m+1,n))); f(1,n));
mode
mode
proc
proc
proc
proc
list = ref node;
node = struct (int h, list t);
cons = (int n, list l) list: heap node := (n,l);
hd
= (list l) int: ( l is nil | error("hd nil"); skip | h of l );
tl
= (list l) list: ( l is nil | error("tl nil"); skip | t of l );
show = (list l) void: ( l isnt nil | print((" ",whole(hd(l),0)));
show(tl(l)));
proc filter = (proc (int) bool p, list l) list:
if l is nil then nil
elif p(hd(l)) then cons(hd(l), filter(p,tl(l)))
else filter(p, tl(l))
fi;
proc sieve = (list l) list:
if l is nil then nil
else
proc not multiple = (int n) bool: n mod hd(l) ≠ 0;
cons(hd(l), sieve( filter( not multiple, tl(l) )))
fi;
proc primes = (int n) list: sieve( tl( one to(n) ));
show( primes(100) )
end
7
7.4 Výběr z procedurálních programovacích jazyků 60. a 70. let 20. století
V roce 1961 přinesla titulní strana časopisu „Communications of the ACM“ (Vol. 4, No. 1) seznam
73 různých programovacích jazyků a v průběhu 60. let tento počet dál prudce rostl. Proto se budeme
věnovat opět jen několika vybraným jazykům. Hlavním hlediskem pro výběr je rozšířenost jazyků
v programátorské praxi.
Velmi populárním jazykem je pro svoji jednoduchost BASIC (Bigginer’s All-purpose Symbolic
Instruction Code), který roku 1963 navrhli John Kemeny (1926 – 1992) a Thomas Kurtz (*1928)
a který zažil obrovský rozmach v 80. letech jako základní programovací nástroj na osmibitových
domácích počítačích a v současnosti zažívá comeback díky firmě Microsoft a jejím produktům
Visual Basic, MS Office (makrojazyk VBA) a MS Internet Explorer (skriptovací jazyk VB Script).
Společnou nevýhodou FORTRANu a BASICu je fakt, že nenutí
programátory k přehledným, dobře strukturovaným zápisům. Proto se i
sám tvůrce programu může s určitým časovým odstupem špatně
orientovat ve zdrojovém kódu, který vypracoval. To spolu s otázkou
přesného popisu struktury dat, která pak usnadní psaní algoritmu,
motivovalo profesora Niklause Wirtha (*1934) z Vysoké školy
technické v Curychu k vytvoření programovacího jazyka Pascal. Pro
svoji perfektní strukturovanost je Pascal ideálním jazykem pro výuku
programování na vysokoškolské úrovni. První implementaci Pascalu
realizoval Niklaus Wirth v roce 1970.
Obr. 74 Niklaus Wirth
Popularizaci jazyka prospěla levná a přitom kvalitní implementace Turbo Pascal, díky které se
masově rozšířil na osobních počítačích typu IBM PC. Ta vznikla ve firmě Borland v roce 1983
a hlavní zásluhy na jejím vývoji mají dánský programátor Anders Hejlsberg (*1960) a francouzský
informatik Philippe Kahn (*1962). Jazyk Pascal je dodnes součástí vývojového prostředí Delphi.
Kromě toho existují open source alternativy Free Pascal a Lazarus. Niklaus Wirth navrhl několik
dalších programovacích jazyků (Algol W, Modula, Oberon) a je autorem vynikající, dodnes
používané učebnice programování Algorithms + Data Structures = Programs.
Dalším významným jazykem začátku 70. let byl v roce 1972 programovací jazyk C. Jeho autorem
je Denis Ritchie (*1941). Referenční příručku „The C Programming Language“ napsal v roce 1978
společně s Brianem Kernighanem (*1941). Popsaná verze se stala de facto standardem K&R
jazyka C. O jazyce C se jšetě zmíníme v následující kapitole, věnované operačním systémům.
Na přelomu 60. a 70. let se objevují také první objektově orientované jazyky. Nejprve jazyk Simula
norských informatiků Ole-Johana Dahla (1931 – 2002) a Kristena Nigaarda (1926 – 2002), který
sice nebyl masově rozšířený, ale svým přístupem k řešení problémů položil základy objektově
orientovaného programování. Na práce norských průkopníků pak navázal americký počítačový
vědec Alan Key (*1940) s jazykem Smalltalk, který svou důslednou objektovostí byl mimo jiné
vhodný k programování grafických aplikací. Díky tomu se Allan Key stal také tvůrcem grafického
uživatelského rozhraní se systémem překrývajících se oken, jaké známe z moderních operačních
8
systémů pro osobní počítače. Zajímavé je, že Alana Keye kromě prací norských předchůdců
ovlivnil také Seymour Papert (autor jazyka LOGO), který ho přivedl ke studiu konstruktivismu.
Posledním procedurálním jazykem, který bych rád zmínil, je Forth. Vyvinul jej roku 1970, nejprve
pro svoji osobní potřebu Charles Moore (*1938) a použil jej pro ovládání soustavy radioteleskopů
v Národní radio-astronomické observatoři (NRAO) na hoře Kitt Peak v Arizoně. O jazyk však měli
zájem další programátoři a rychle se rozšířil, i když ne tak masově jako výše uvedené jazyky. Roku
1973 založil Charles Moore společnost Forth inc. a začal jazyk nabízet komerčně. Roku 1976 se
jazyk stal standardem programování v Mezinárodní astronomické unii. Dodnes je udržován a dále
rozvíjen. Forth je typický prací se zásobníky a použitím postfixové notace. Nepotřebuje pro svoji
práci operační systém a hodí se pro programování řídících a měřicích systémů, založených
na mikroprocesorech s kratší délkou slova (dnes 8, 16 bit), tedy ve vestavěných (angl. embedded)
systémech a pro práci v reálném čase
7.5 Funkcionální programovací jazyky
Již jsme se zmínili, že John Backus (1924 – 2007) podnítil zájem o funkcionální programování.
Přestože byl autorem komerčně velmi úspěšného procedurálního jazyka FORTRAN, nepovažoval
procedurální přístup za jediný možný. Při převzetí Turingovy ceny v roce 1977 přednesl přednášku
s názvem Může být programování osvobozeno od von Neumannova stylu?, v níž představil projekt
jazyka FP. Tento projekt byl dokončen a distribuován, na rozdíl od pozdějšího FL (Function Level),
který zůstal na úrovni firemního projektu IBM a distribuován nebyl. Podnítil však zájem o směr
deklarativního programování, kterému říkáme funkcionální.
Moderním funkcionálním jazykem je Miranda, navržená v roce 1985 britským informatikem
Davidem Turnerem (*19..) a její následník Haskell vyvinutý v roce 1990 skupinou informatiků a
dále zdokonalovaný v současnosti. Jazyk Haskell je pojmenován po matematikovi, který vybudoval
matematické základy funkcionálního programování. Byl to Haskell Brooks Curry (1900 – 1982),
zakladatel kombinatorické logiky.
Mnohem starším funkcionálním jazykem je LISP (LISt Processing), který pochází z roku 1960.
Jeho autorem je John McCarthy (1927), který je známý také svým výrazným podílem na vymezení
pojmu umělá inteligence. V oblasti umělé inteligence je LISP stále využíván. Má jednoduchou
strukturu, protože nerozlišuje mezi kódem a daty. Na vše se dívá jako na seznamy. Problematická je
nutnost používání velkého množství závorek. Staví na něm některé systémy pro zpracování jazyků,
ať přirozených (editor textů Emacs), či formálních (systém počítačové algebry Maxima). Vychází
z něj další programovací jazyky (Smalltalk, Scheme) a dokonce i dětský programovací jazyk Logo.
9
7.6 Dětské programovací jazyky
Již jsme se zmínili, že ideálním jazykem pro výuku neobjektového procedurálního programování
na vysokoškolské úrovni je Pascal. Který jazyk však máme zvolit, chceme-li učit programovat žáky
základní školy, nebo středoškoláky? Existuje několik jazyků vhodných pro výuku programování,
nebo, chcete-li, k rozvoji algoritmického myšlení. Protože s výukou algoritmizace je nejlépe začít
už v dětském věku, tj. na základní škole (všimněte si, že neříkám na 2. Stupni ZŠ), říká se jim často
„dětské programovací jazyky“. To samozřejmě neznamená, že by nebyly vhodné pro počáteční
výuku algoritmizace u adolescentů a dospělých.
Vlajkovou lodí této kategorie programovacích jazyků je Logo, které je zároveň plnohodnotným
programovacím jazykem vycházejícícm z LISPu. Navrhl ho v roce 1967 matematik, informatik
a pedagog Seymour Papert (*1928) na základě konstruktivistických teorií švýcarského filozofa,
přírodovědce a psychologa Jeana Piageta (1896 – 1980). Logo je známé svojí želví geometrií, jde
však o plnohodnotný funkcionální programovací jazyk, použitelný i v oblasti umělé inteligence.
Existuje celá řada implementací loga, např. zdařilé Comenius Logo a Imagine Logo z dílny autorů
Andreje Blaha, Ivana Kalaše a Petra Tomcsányie z Univerzity Komenského v Bratislavě.
Mnohem jednodušším prostředím je Karel, jazyk který navrhl Richard Pattis v roce 1981. Nazval
jej Karel (nikoliv Charles) na počest Karla Čapka, který dal světu slovo robot ve své světoznámé
divadelní hře RUR. Robot Karel nenásilně uváděl jeho studenty do tajů programování pomocí světa
v podobě čtvercové sítě, čtyř základních příkazů (krok, vlevo v bok, polož a zvedni) a dvou testů (je
zeď?, je značka?) a příkazů pro vytvoření struktury (podmínka, cyklus). Tento přístup se používá
často i dnes, kdy se Karel implementuje jako program v některém programovacím jazyce (Pascal,
C, Java). Studenti pak začnou úvod do algoritmizace v Karlově světě, následně si ukážou zdrojový
kód prostředí a plynule přejdou k výuce daného jazyka. Karel je ovšem také ideální prostředí
pro seznámení se základy algoritmizace v rámci povinné výuky informatiky na základní škole.
K novým projektům patří například Alice kolektivu autorů z Carnegie Mellon University, která učí
děti programovat ve trojrozměrném světě animovaných postav. Postava Alice je také inspirována
literaturou, známou knihou z roku 1865 Alice’s Adventures in Wonderland anglického matematika,
logika, spisovatele a fotografa Charlese Dodgsona (1832 – 1898).
Úspěšný je také projekt Baltík – Baltie – Baltazar českého informatika Bohumíra Soukupa.
Vizuální prostředí (volitelně 3D či 2D) je propojeno s osvojováním syntaxe programovacích jazyků
C a C#. Hlavní postavou je zde malý kouzelník Baltík, kterému děti pomáhají vyčarovat objekty a
potom ovlivňovat jejich vlastnosti a chování.
K výuce základů programování jsou poměrně vhodné také některé jednoduché skriptovací jazyky,
které interpretují např. webové prohlížeče. K nim patří JavaScript a VBScript. V tomto případě však
nejde o dětské programovací jazyky s prostředím blízkým světu dětí.
10
7.7 Logické programovací jazyky
Roku 1972 navrhl francouzský informatik Alain Colmerauer (*1941) deklarativní, neprocedurální
jazyk Prolog, založený na predikátové logice prvního řádu. Deklarativní jazyk je přímým opakem
procedurálního, to znamená, že popíšeme výchozí situaci (zadání) a cíl výpočtu, ale vůbec neříkáme
jakým postupem by se program měl k výsledku dostat. Počítač vlastně výsledek vyvozuje ze zadání
pomocí pravidel formální matematické logiky. Proto mluvíme o logickém programování.
Následující ukázka kódu v jazyce Prolog řeší obecný algebrogram na součet dvou čísel. Úkolem
řešitele je nahradit písmena číslicemi (stejné písmeno samozřejmě představuje vždy stejnou číslici):
%priklad zadani otazky
%soucet([0,M,O,R,E],[0,S,E,N,D],[M,O,N,E,Y]).
%reseni [Bratko 1985]
soucet(Slovo1,Slovo2,[H|T]):- %slova zadana v seznamech
s(Slovo1,Slovo2,[H|T],
0,0,
%rad desitek
[1,2,3,4,5,6,7,8,9,0],_),not(H=0).
s([],[],[],0,0,Cisla,Cisla).
s([H1|T1],[H2|T2],[H|T],C1,C,Cislo1,Cislo):s(T1,T2,T,C1,C2,Cislo1,Cislo2),
soucetcis(H1,H2,C2,H,C,Cislo2,Cislo).
soucetcis(H1,H2,C1,H,C,Cislo1,Cislo):del(H1,Cislo1,Cislo2),
del(H2,Cislo2,Cislo3),
del(H,Cislo3,Cislo),
S is H1+H2+C1,
H is S mod 10,
C is S // 10.
del(A,L,L):- nonvar(A),!.
del(A,[A|L],L).
del(A,[B|L],[B|L1]):- del(A,L,L1).
Novějším logickým programovacím jazykem je jazyk Gödel, který roku 1992 vytvořila dvojice
informatiků John Lloyd a Patricia Hillová. Byl nazván na počest rakouského logika, matematika
a filozofa, brněnského rodáka Kurta Gödla (1906 – 1978).
11
8
Operační systémy a uživatelská rozhraní
8.1 Vznik operačních systémů sálových počítačů
První generace počítačů neměla operační systém (OS) a jednu ze tří základních funkcí OS – předání
vstupů počítači a získání výstupů z počítače – řešil každý jednotlivý program individuálně. Potřebné
procedury se musely programovat či přizpůsobovat znovu a znovu. Řešení do značné míry záviselo
na hardware, tedy na použitých vstupních a výstupních zařízeních. Zpracování úloh bylo zásadně
dávkové, to znamená, že stroj načetl dávku děrných štítků (program a data), nebo úsek děrné pásky,
či magnetické pásky, pak vše zpracoval a vytiskl požadované výstupy. Další program bylo možné
zavést a spustit až po dokončení předcházejícího.
Podobná situace pokračovala i u počítačů druhé generace. Elektronky byly nahrazeny tranzistory,
místo strojového kódu a JSA zaujaly vyšší programovací jazyky (FORTRAN, COBOL, ALGOL),
ale počítače stále pracovaly dávkově, v danou chvíli běžel jen jeden program. Přitom počítačový čas
(potřebná doba pro běh určitého programu) byl, měřeno dnešními měřítky, velmi drahý a uživatelé
počítače se zapisovali do pořadníků. Tím vyvstala potřeba automatizovat a tím urychlit zavádění
programů do operační paměti a umožnit běh několika úloh různého typu současně. Některá úloha je
náročná na paměť, jiná na výkon procesoru, další má mohutné tiskové výstupy a mohlo by být
výhodné je spustit současně, aby žádná část hardware sálového počítače nezahálela. První operační
systém pro sálové počítače byly vyvíjeny ve 2. polovině 60. let 20. století. Zhruba ve stejné době se
jako konstrukční prvek hardware začínají používat první integrované obvody. Počítače mají OS až
počínaje 3. generací.
Je zajímavé, že vývoj OS začal velmi velkorysým projektem Multics (MULTiplexed Information
and Computing Service), který měl umožnit mnohouživatelský multitasking až pro 1000 současně
připojených uživatelů k supervýkonnému sálovému počítači (mainframe) GE-645 firmy General
Elecrtic. Vývoj OS Multics byl spuštěn v roce 1964 a podílely se na něm Bellovy laboratoře firmy
AT&T, General Electric a MIT. Projekt Multics přinesl spoustu dobrých myšlenek a částečných
řešení, ale byl až příliš velkorysý, takže po pěti letech, v roce 1969 rozhodlo vedení AT&T, hlavní
řešitel projektu, vývoj zastavit pro jeho velkou složitost a časovou a finanční náročnost zastavit.
Ve vývoji pak pokračovala firma Honeywell až do roku 1985 a OS Multics byl rutinně používán
Kanadským úřadem národní obrany až do roku 2000. Nikdy se však masově nerozšířil a nebyl
komerčně úspěšný. Jeho obrovským přínosem je, že na jeho základech byl postavem UNIX.
Zhruba ve stejné době, v roce 1967 vyvinula firma IBM pro své počítače řady 360 výrazně
jednodušší operační systém MFT (Multiprogramming with a Fixed number of Tasks). Jak říká
název OS, počet současně spuštěných úloh byl shora omezen pevně daným číslem. IBM souběžně
vyvíjela také systém MVT (Multiprogramming with a Variable Number of Tasks), který však byl
mnohem složitější a nebyl příliš spolehlivý, takže se v praxi téměř nepoužíval. OS MFT se používal
také u pozdější řady počítačů IBM 370 a ve verzi MFT II byl počet současně spuštěných úloh
zvýšen tak, že z praktického hlediska uživatele neomezoval.
12
8.2 Operační systém UNIX
Když byl v roce 1969 firmou AT&T zastaven projekt Multics, zůstaly „mozky“ vývojového týmu
v Bellových laboratořích a začaly hned pracovat na novém víceuživatelském a multitaskingovém
operačním systému, ale tentokrát s důrazem na jednoduchost. Původní název projektu Unics (Unary
Information and Computing Service) byl později změněn na UNIX. Revolučním počinem bylo
přeprogramování celého operačního systému v jazyce C v roce 1973. Do té doby byly všechny OS
programovány výhradně v JSA.
Hlavními tvůrci OS UNIX jsou Kenneth Thompson (*1943) a Dennis Ritchie (*1941). Kenneth
Thompson byl vedoucím týmu projektu Multics, společně s Denisem Ritchiem vyvinuli OS UNIX,
samostatně vytvořil programovací jazyk B (předchůdc jazyka C), byl propagátorem myšlenky užití
regulárních výrazů v informatice, společně s Robertem Pikem (*1956) navrhli znakovou sadu
UTF-8 a podíleli se po UNIXu také na vývoji OS Plan 9. Kenneth Thompson je mimo jiné nadšený
šachista a propagátor počítačového šachu, tvůrce software pro šachový počítač Bell. Druhým
hlavním autorem UNIXu je člen týmu Multics Dennis Ritchie, autor programovacího jazyka C.
Společně s Brianem Kernighanem (*1942) napsali v roce 1978 knihu (The C Programming
Language), kterou de facto definovali standard jazyka C, nazývaný podle iniciál jejich příjmení
K&R. Brian Kernighan je autorem názvu OS Unics a mimo jiné je spoluautorem skriptovacího
jazyka AWK.
Obr. 75 Kenneth Thompson
Obr. 76 Dennis Ritchie
Obr. 77 Brian Kernighan
Kenneth Thompson a Dennis Ritchie obdrželi za vývoj OS UNIX v roce 1983 Turingovu cenu
a v roce 1999 převzali z rukou prezidenta USA Billa Clintona Státní medaili za technologii.
Operační systém UNIX se dále vyvíjí a zdokonaluje. Ochranou známku UNIX vlastní nyní
konsorcium The Open Grup a požaduje certifikaci podle Single UNIX Specification. Kromě toho se
UNIX stal se základem mnoha dalších operačních systémů unixového typu (Unix-like systems),
jako jsou XENIX, MINIX, Linux (různě nazývané distribuce), FreeBSD, OpenBSD, NetBSD,
Mac OS X, Solaris.
13
8.3 Operační systémy unixového typu na osobních počítačích
Od počátku 80. let soupeřily spolu na trhu osobních počítačů především dvě firmy. Firma IBM,
která se svojí otevřenou stavebnicovou koncepcí dokázala stlačit ceny, a proto byla komerčně více
úspěšná, a firma Apple, která sázela na kompaktnost a jednotný elegantní design. Je zajímavé, že na
obou platformách se úspěšně prosadily operační systémy unixového typu.
Prvním operačním systémem unixového typu pro IBM PC kompatibilní počítače
byl MINIX (MINI uniX) amerického vysokoškolského profesora informatiky,
trvale žijícího v Amsterdamu (Nizozemí) Andrewa Tanenbauma (*1944). Je
sympatické, že tento odborník sám sebe označuje za v první řadě učitele
informatiky. Cílem MINIXu, který vytvořil v roce 1987, bylo především naučit
studenty, jak pracuje OS. Napsal knihu, kde vše podrobně popsal a do přílohy
dal všechny zdrojové kódy. Současně nabídl zdrojové kódy zájemcům na sadě
disket.
Obr. 78 Andrew Tanenbaum
Jedním z jeho studentů (na dálku - prostřednictvím diskuze ve fóru na internetu)
byl Linus Torvalds (*1969), finský programátor, nyní žijící v USA. Linus
Torvalds se MINIXem inspiroval, převzal souborový systém, ale vypracoval
svůj vlastní operační systém. Chtěl jej nazvat Freax (z angl. Free + Freak +
uniX), ale dříve než to stihl udělat, dovolil kamarádovi vystavit systém na síti.
Ari Lemmke vystavil systém na FTP serveru v adresáři Linux (LINUsův uniX)
a nový OS měl jméno. Linus Torvalds se vždy zabýval a stále zabývá pouze
jádrem OS, do jehož vývoje se zapojila řada dalších lidí a on sám už dnes jen
koordinuje práce a rozhoduje o tom, jaký kód se stane součástí jádra.
Obr. 79 Linus Torvalds
Pro uživatele se pak vytvářejí balíčky, které vznikají spojením jádra, utilit a aplikačního software
a kterým se říká linuxové distribuce. Přínosem Linuxu je důsledné dodržení standardů POSIX
(Portable Operating System Interface) pro rozhraní OS, díky němuž je převod programů mezi
jednotlivými typy UNIXu (a tím spíš mezi distribucemi a verzemi Linuxu) velmi snadné, snadnější
než mezi různými verzemi MS Windows.
K OS unixového typu přešla také firma Apple se svými počítači Macintosh, a to od roku 2001, kdy
po verzi klasického Mac OS 9 změnila směr vývoje. Novou verzi nazvala Mac OS X a založila ji
na zkušenostech s OS NeXTSTEP, zkušenostech se svým klasickým Mac OS a dalších unixových
komponentách z různých zdrojů. Základ systému Mac OS X uvolnila firma Apple pod názvem
Darwin. Upravenou verzi Mac OS X používají také zařízení iPhone a iPod.
14
8.4 Vývoj uživatelských rozhraní počítačů
Uživatelským rozhraním rozumíme technickou realizaci interakce a komunikace mezi člověkem
(uživatelem stroje) a počítačem (nebo jiným strojem). Signály počítače i jiných automatizovaných
zařízení může člověk vnímat zrakem, sluchem či hmatem. V tomto smyslu patří mezi uživatelská
rozhraní zvukové rozhraní s hlasovým syntezátorem, či tzv. braillský řádek, které umožňují užívat
počítač nevidomým. Běžný uživatel počítače ovšem vnímá naprostou většinu informací z počítače
prostřednictvím zraku, takže v užším slova smyslu rozumíme uživatelským rozhraním optickou
informaci na monitoru. V praxi je tato informace doplněna ještě o jednoduché zvukové signály
a signalizační diody (LED), které indikují např. zapnutí počítače, činnost pevného disku, připojení
počítače k místní počítačové síti (metalické, wi-fi), osobní síti (Bluetooth), nebo nastavení
přepínačů klávesnice (Caps Lock, Num Lock, Scroll Lock). Nejvíce pozornosti však uživatelé
právem věnují informacím na obrazovce monitoru. Své povely pak předávají počítači především
prostřednictvím klávesnice a myši.
Historický vývoj vzhledu informací na obrazovkách proběhl ve třech základních etapách. Masově
se nyní používá ta nejnovější a nejdokonalejší, ale ve speciálních aplikacích a na úrovni základního
operačního systému může být pro svoji jednoduchost a malé hardwarové nároky použita i jedna
ze starších variant. Uživatelská rozhraní dělíme na:
CLI
TUI
GUI
…
…
…
…
…
…
Command Line Interface
Text User Interface
Graphical User Interface
příkazový řádek ,
textové uživatelské rozhraní,
grafické uživatelské rozhraní.
Příkazový řádek byl typickým uživatelským rozhraním prvních operačních systémů. Jeho zavedení
šlo ruku v ruce s nástupem textových (znakových) terminálů. Výhodou CLI je z pohledu uživatele
jednoznačnost příkazů a jejich velká variabilita použitím přepínačů a parametrů, z pohledu počítače
nízká hardwarová náročnost a z pohledu programátora snadnější práce při vytváření uživatelského
rozhraní. Nevýhodou je nutnost relativně složitého zaškolení uživatele počítače. CLI nenabízí
uživateli na výběr žádné řešení, ale jen prázdné místo za dohodnutou sekvencí znaků, které říkáme
výzva (prompt). Tím vyžaduje od nezkušeného uživatele značné úsilí, a proto jej nelze doporučit
začátečníkům a svátečním uživatelům počítače.
Pro své nesporné výhody je stále využíván jako rozhraní operačního systému UNIX a jeho klonů
(např. Linux). Nezastupitelný je při ovládání některých typů aplikačního software, jako jsou třeba
systémy počítačové algebry (CAS – Computer Algebra System). Počítač zobrazuje výzvu (prompt)
a za ní kurzor, zpravidla blikající, naznačující, že je očekáván vstup uživatele. Uživatel zapíše vstup
jako krátký text a odešle jej počítači stiskem k tomu určené klávesy (Enter).
Krokem vstříc k uživateli je textové uživatelské rozhraní. Využívá maximálně možností barevných
textových (znakových) monitorů, uživateli nabízí jednoduché uživatelské dialogy (výběr z několika
možností) a alternativní ovládání myší nebo klávesnicí v celé řadě situací a funkcí. Rozmach TUI
nastal s vývojovým prostředím Turbo Pascal 5.5 firmy Borland, které obsahovalo nástroje pro jeho
snadné vytváření.
15
Obr. 80 Typická ukázka textového uživatelského rozhraní – dialog pro otevření souboru k editaci
Obr. 81 Manažer souborů v okně s dvěma panely Midnight Commander pod OS Linux
Uživatelé osobních počítačů typu IBM PC v 90. letech si jistě pamatují, jakým ulehčením práce se
soubory a složkami bylo použití programu Norton Commander, který představoval moderní textové
uživatelské rozhraní, v porovnání se zadáváním odpovídajících příkazů MS DOSu do příkazového
řádku.
16
Textové uživatelské rozhraní představovalo určitý vývojový mezistupeň mezi příkazovým řádkem
a grafickým uživatelským rozhraním. Dnes se používá jako určitý kompromis mezi CLI a GUI, lze
ho snadno používat na starších, méně výkonných počítačích. Kdo si na něj zvykne, může mít
k dispozici kvalitní textový editor (Vim), souborový manažer (Midnight Commander), či prohlížeč
webových stránek (Lynx), aniž by potřeboval výkonný procesor a velkou paměť.
8.5 Grafická uživatelská rozhraní počítačů
Grafické uživatelské rozhraní se zrodilo v roce 1973 ve vývojovém centru PARC firmy Xerox. Jeho
hlavním duchovním otcem byl Alan Key (*1940). Na práci Alana Keye potom navázal Merzouga
Wilberts, který v roce 1980 doplnil myšlenku grafického rozhraní o okna, v nichž běží jednotlivé
aplikace a vzniklé interaktivní uživatelské prostředí nazval WIMP (Windows, Icons, Menus,
Pointing device). Zkušeností členů vývojového týmu PARC využila firma Apple Computer
pro GUI svého operačního systému pro počítače Apple Macintosh v první polovině roku 1984. Šlo
o první komerčně úspěšné GUI, které navíc bylo součástí operačního systému. Ve druhé polovině
roku 1985 použila myšlenky firma Microsoft, která vydala grafickou nadstavbu operačního systému
MS DOS a nazvala ji Windows 1.0. Zhruba ve stejné době byl pro systémy typu UNIX vyvinut
standard X Window System, který je pod unixovými systémy, včetně Linuxu, používán dodnes.
Často bývá nazýván krátce X11, nebo jen X.
Obr. 82 Grafické uživatelské rozhraní a prostředí pracovní plochy GNOME 2.28
17
Firma Microsoft šla cestou monolitního operačního systému, jehož je GUI nedílnou součástí
(počínaje verzí Windows 95). Unixové systémy zůstaly naopak u mikrojádra, které se GUI vůbec
nezabývá, na které navazuje X Window System zobrazující grafické objekty a na něm postavené
konkrétní prostředí pracovní plochy. To je teprve GUI, s kterým interaguje uživatel počítače. Mezi
nejznámější prostředí pracovní plochy pod OS Linux, BSD či Solaris patří GNOME (GNU Network
Object Model Environment) a KDE (K Desktop Environment), obě vyvíjená od roku 1997.
Obr. 82 Grafické uživatelské rozhraní a prostředí pracovní plochy KDE 4.30
18