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
