Obsah
1. Gorilla REPL: interaktivní prostředí pro programovací jazyk Clojure
2. Technologie, na níž je založen projekt Gorilla REPL
3. Vytvoření kostry projektu pro spuštění Gorilla REPL
4. Základy interaktivní práce s REPL
5. Jednoduché grafy: funkce gorilla-plot.core/list-plot
6. Vykreslení průběhů funkcí: funkce gorilla-plot.core/plot
7. Sloupcové grafy: funkce gorilla-plot.core/bar-chart
8. Histogramy: funkce gorilla-plot.core/histogram
10. Zápis a vykreslení vzorců ve formátu (La)TeXu
11. První omezení projektu: tvorba grafů
12. Druhé omezení projektu: použitý formát čísel
13. (Lepší) alternativy nabízené pro jiné programovací jazyky
14. Odkazy na předchozí části tohoto seriálu
1. Gorilla REPL: interaktivní prostředí pro programovací jazyk Clojure
V dnešním článku si popíšeme poměrně užitečný nástroj nazvaný Gorilla REPL, který vývojářům používajícím programovací jazyk Clojure nabízí interaktivní prostředí založené na běžném webovém prohlížeči. Toto prostředí obsahuje klasickou smyčku REPL (Read–Eval–Print–Loop), což mj. znamená, že se jednotlivé výrazy zapsané uživatelem mohou ihned vyhodnocovat s okamžitou zpětnou vazbou. Navíc však nástroj Gorilla REPL dokáže do okna prohlížeče vykreslovat základní grafy, a to jak s přímým využitím předaných dat (vektory či sekvence čísel), tak i při specifikaci funkce, jejíž průběh se má vykreslit (existují zde ovšem mnohá omezení, kterými se budu zabývat v navazujících kapitolách). Třešničkou na dortu je podpora pro práci se vzorci psanými v TeXu či LaTeXu.
Obrázek 1: Interaktivní prostředí nástroje Gorilla REPL spuštěné v běžném webovém prohlížeči (zde konkrétně ve Firefoxu).
Celé grafické uživatelské rozhraní Gorilla REPL napodobuje diář (notebook), do kterého se zapisují jak poznámky, tak i programový kód a jeho výsledek, takže se tento systém může hodit i pro tvorbu (interaktivních) prezentací, použití sdílené pracovní plochy atd. Ostatně v tomto ohledu není přístup zvolený autory Gorilla REPL nijak nový ani přelomový, protože například i populární IPython Notebook či nověji systém Jupyter používají podobnou technologii (i když založenou na jiném programovacím jazyku).
Obrázek 2: Nástroj Gorilla REPL obsahuje podporu pro doplňování názvů funkcí a maker společně se zobrazením nápovědy (programové dokumentace).
2. Technologie, na níž je založen projekt Gorilla REPL
Nástroj Gorilla REPL je založen na klasické technologii klient-server, kde klientem je webový prohlížeč spuštěný u uživatele (či uživatelů) a serverem je aplikace vyvinutá v programovacím jazyce Clojure a využívající v tomto seriálu již dříve popsaný webový server Clojure Ring. Výraz, popř. blok výrazů představujících programový kód napsaný v jazyce Clojure, je po stlačení klávesové zkratky Shift+Enter přenesen na server, kde je zpracován a výsledek je poslán zpět do prohlížeče. JavaScriptový kód na straně prohlížeče zajistí interpretaci získaných výsledků a jejich zařazení na správné místo do dynamické webové stránky (jedná se vlastně o dnes tak populární SPA – Single Page Application se všemi přednostmi a zápory, které toto řešení přináší). Výsledky poslané serverem na klienta mohou být různého typu; typicky se jedná o fragment HTML (tabulky atd.), obrázek typu SVG (graf, histogram), rastrový obrázek (graf získaný z R), vzorec vykreslený z TeXového či LaTeXového zdrojového kódu apod. Samotná architektura nástroje Gorilla REPL je otevřená a poměrně snadno rozšiřitelná, což znamená, že je v případě potřeby možné přidat například další typy grafů apod.
Obrázek 3: Standardní grafy jsou do stránky vkládány ve formátu SVG.
3. Vytvoření kostry projektu pro spuštění Gorilla REPL
Před spuštěním nástroje Gorilla REPL je nutné vykonat několik přípravných kroků. Předpokladem je, že máte nainstalován Leiningen, což je téma, kterému jsme se podrobně věnovali v tomto článku. Pokud máte Leiningen nainstalovaný, je nutné v jakémkoli adresáři vytvořit nový projekt, a to následujícím příkazem:
$ lein new app gorilla-test
Po provedení tohoto příkazu by se měla vytvořit struktura projektu:
├── doc
│ └── intro.md
├── LICENSE
├── project.clj
├── README.md
├── resources
├── src
│ └── gorilla_test
│ └── core.clj
└── test
└── gorilla_test
└── core_test.clj
6 directories, 6 files
Nás nyní bude zajímat pouze projektový soubor project.clj, který je nutné nepatrně upravit – přidat klíč :plugins a do jeho hodnoty (tou je vektor!) přidat „[lein-gorilla „0.3.6“]“. Výsledná podoba souboru project.clj by měla vypadat takto:
(defproject gorilla-test "0.1.0-SNAPSHOT"
:description "Project stub used to run Gorilla REPL"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.7.0"]]
:main ^:skip-aot gorilla-test.core
:target-path "target/%s"
:plugins [[lein-gorilla "0.3.6"]]
:profiles {:uberjar {:aot :all}})
Následně se nainstalují všechny balíčky, na nichž Gorilla REPL závisí:
$ lein deps
Po úspěšné instalaci všech závislých balíčků je již možné Gorilla REPL spustit, a to následovně:
$ lein gorilla Gorilla-REPL: 0.3.6 Started nREPL server on port 52660 Running at http://127.0.0.1:58615/worksheet.html . Ctrl+C to exit.
Vidíme, že se ve skutečnosti spustily dva typy serverů na dvou různých portech. Server typu nREPL se dá používat například z Emacsu či Vimu (což není téma tohoto článku), druhý server se ovládá přímo z webového prohlížeče.
Alternativně je možné specifikovat port, na němž má webový server běžet. Následující příklad by měl fungovat pro všechny uživatele; pokud budete chtít použít například port 80, je nutné mít práva roota a navíc na tomto portu již nesmí běžet jiný server (což je pochopitelné):
$ lein gorilla :port 8888 Gorilla-REPL: 0.3.6 Started nREPL server on port 53758 Running at http://127.0.0.1:8888/worksheet.html . Ctrl+C to exit.
4. Základy interaktivní práce s REPL
Po otevření diáře v prohlížeči, tj. po přechodu na adresu http://127.0.0.1:{port}/worksheet.html, se zobrazí uživatelské rozhraní projektu Gorilla REPL. V šedě podkreslených rámečcích jsou vstupy uživatele (výrazy jazyka Clojure), fialově orámovaný rámeček je aktivní. Vyhodnocení aktivního výrazu se provede klávesovou zkratkou Shift+Enter (samotná klávesa Enter provede odřádkování, takže není nutné celý výraz psát na jediný řádek) Povšimněte si, že první výraz je již automaticky předvyplněn – obsahuje import jednoho modulu a taktéž definici jmenného prostoru (samotné jméno je pseudonáhodné, což se hodí při sdílení více diářů). Dále si povšimněte poměrně nenápadné ikony v pravém horním rohu, pod níž se skrývá menu. Totéž menu je možné vyvolat dvojím stiskem klávesové zkratky Alt+G (tedy Alt+G Alt+G). V tomto menu naleznete několik zajímavých pomůcek, například Alt+G Alt+X pro vymazání jednoho záznamu, Alt+G Alt+B či Alt+G Alt+N pro vložení místa pro nový záznam atd.
Obrázek 4: Nápovědu k funkcím a makrům je možné si vypsat i přes clojure.repl/doc. Tato nápověda je přečtena přímo ze zdrojových kódů a měla by tudíž být stále aktuální.
5. Jednoduché grafy: funkce gorilla-plot.core/list-plot
Jak jsme si již řekli v úvodní kapitole, patří mezi užitečné vlastnosti projektu Gorilla REPL možnost vykreslování grafů. V případě, že vstupem do grafu mají být již dříve vypočtené či naměřené údaje, je možné použít funkci gorilla-plot.core/list-plot. V nejjednodušším případě se této funkci předá vektor (nebo obecná sekvence) s údaji, které se vynesou do grafu jako jednotlivé body, což je ukázáno na pátém obrázku:
Obrázek 5: Nejjednodušší typ grafu, v němž jsou vyneseny hodnoty uložené ve vektoru. Pro vykreslení tohoto grafu se používá SVG.
Pokud vyžadujete propojení jednotlivých bodů úsečkami, je možné funkci gorilla-plot.core/list-plot předat nepovinný parametr :joined a přiřadit mu hodnotu true. V mnoha případech je navíc nutné na jednom grafu zobrazit větší množství průběhů. K tomu slouží funkce gorilla-plot.core/compose, které je možné předat libovolné množství grafů. Výsledek spojení dvou průběhů, z nichž první používá propojené úsečky a druhý pouze izolované body, je zobrazeno na šestém obrázku:
Obrázek 6: Kombinace dvou průběhů do jediného grafu s využitím funkce compose. Oba průběhy zobrazují stejné hodnoty, jednou však s využitím samostatných bodů a podruhé propojením úsečkami.
Poznámka: případnou interpolaci či aproximaci je možné řešit různými způsoby, například použitím dalšího externího modulu.
6. Vykreslení průběhů funkcí: funkce gorilla-plot.core/plot
Pokud se namísto již naměřených dat má do grafu zobrazit průběh nějaké funkce, samozřejmě není nutné explicitně počítat jednotlivé hodnoty, které se nakonec vynesou do grafu. Namísto toho je výhodnější namísto funkce gorilla-plot.core/line-plot použít funkci nazvanou gorilla-plot.core/plot. Jedná se o funkci vyššího řádu, protože jejím prvním parametrem je jiná funkce, jejíž průběh se má zobrazit. Dalším parametrem je vektor obsahující minimální a maximální x-ovou hodnotu vstupující do funkce. Podívejme se na jednoduchý příklad – zobrazení průběhu funkce y=x-1:
Obrázek 7: Zobrazení průběhu funkce x-1.
Můžeme si nechat zobrazit i průběh složitější funkce, například sinc. Zde si povšimněte, že při deklaraci vlastní uživatelské funkce lze použít statickou funkci z modulu java.lang.Math:
Obrázek 8: U funkce sinc je patrné, že 100 vypočtených vzorků je pro tento průběh nedostatečný.
Pokud se na graf z obrázku 8 podíváte pozorněji, zjistíte, že by bylo vhodné zvýšit počet bodů, z nichž se průběh vygeneruje. To je jednoduché, protože funkci gorilla-plot.core/plot je možné předat nepovinný parametr :plot-points, ve kterém se specifikuje počet bodů (zde 1000). Dále jsme při tvorbě následujícího grafu (obrázek 9) použili odlišnou barvu vykreslování a navíc je barva vykreslování poloprůhledná. To se zde sice projeví jen změnou sytosti barvy, ovšem při exportu SVG a jeho následném použití v jiné aplikaci by to již bylo více patrné:
Obrázek 9: Zvýšení počtu (propojených) bodů na 1000; navíc se změnila i barva grafu.
Podívejme se ještě na nepatrně složitější příklad, v němž se používá nám již známá funkce gorilla-plot.core/compose. Navíc v tomto příkladu používám anonymní funkci, která změní amplitudu a posun průběhu sinc. Připomeňme si, že pro zápis anonymních funkcí existují v Clojure takzvaná reader makra # a %. První z těchto maker nahrazuje fn se závorkami, druhé makro pak může být použito jako jméno prvního parametru anonymní funkce:
Obrázek 10: Kombinace dvou průběhů a použití anonymní funkce.
Obrázek 11: I průběh funkce může být vykreslen pouze pomocí bodů.
7. Sloupcové grafy: funkce gorilla-plot.core/bar-chart
Dalším typem grafu, který je v nástroji Gorilla REPL podporován, jsou takzvané sloupcové grafy, které je možné vykreslit s využitím funkce nazvané gorilla-plot.core/bar-chart. Této funkci je nutné předat minimálně dva povinné parametry. První parametrem je vektor (či jiná sekvence) obsahující jména sloupců, druhým parametrem pak vektor (či opět jiný typ sekvence) s hodnotami. Vzhledem k tomu, že na x-ové ose jsou vynesena jména sloupců a ne vstupní hodnoty, je obtížné tento typ grafu spojit s výše uvedenými dalšími dvěma typy (výsledky s velkou pravděpodobností nebudou odpovídat očekávání). Příklad velmi jednoduchého sloupcového grafu je uveden na dvanáctém obrázku:
Obrázek 12: Ukázka použití jednoduchého sloupcového grafu.
8. Histogramy: funkce gorilla-plot.core/histogram
Čtvrtým a současně i posledním typem grafu, který je možné v nástroji Gorilla REPL použít, je histogram. Ten se vykresluje funkcí pojmenovanou logicky gorilla-plot.core/histogram. Povinným parametrem jsou podle očekávání data, která se mají do histogramu vykreslit, ovšem funkce gorilla-plot.core/histogram podporuje i další nepovinné parametry, zejména :normalize či :normalise řídicí normalizaci histogramu (jak vidíte, podporuje se dvojí forma zápisu, stejně tak například :color a :colour). Dalším mnohdy důležitým nepovinným parametrem je :bins, jehož hodnotou se řídí šířka intervalů (tříd), tj. nepřímo počet sloupců v histogramu. Podívejme se na několik ukázek, z nichž bude použití nepovinných parametrů :normalize a :bins patrné:
Obrázek 13: Histogram získaný z 200 pseudonáhodných hodnot vygenerovaných funkcí Math/random. Histogram není normalizovaný.
Obrázek 14: Zde jsme nedefinovali funkci „gauss“, která vrací hodnoty s téměř normálním rozložením. Celkem 10000 hodnot vrácených touto funkcí pak posloužilo k vytvoření dalšího nenormalizovaného histogramu.
Obrázek 15: Nepovinným parametrem :bins se řídí rozdělení vstupních dat do intervalů (tříd), což má přímý vliv na počet sloupců v histogramu.
Obrázek 16: Oproti předchozímu histogramu jsme zde provedli normalizaci. Postupně se nám začíná ukazovat klasický zvonovitý tvar Gaussovy křivky.
9. Výpis tabulek
V projektu Gorilla REPL nalezneme i poměrně užitečnou funkci nazvanou gorilla-repl.table/table-view. Tato funkce vezme svůj parametr, kterým je typicky dvourozměrná matice (tj. v Clojure vektor vektorů) a zobrazí hodnoty této matice v HTML tabulce. Podívejme se na velmi jednoduchý příklad s maticí s dvěma řádky a třemi sloupci:
Obrázek 17: Tabulka vytvořená z datové struktury „vektor vektorů“.
Mnohdy je však zapotřebí v tabulkové formě zobrazit hodnoty nějaké funkce a doplnit tak příslušný graf (do grafu se totiž hodnoty přímo vpisovat nedají). V tomto případě by bylo zapotřebí použít transponovanou matici (dva sloupce, mnoho řádků). Prozatím pro tento účel používám funkci transpose, jejíž zdrojový kód je zobrazen na dalším obrázku, ale domnívám se, že je tuto funkci možné napsat i kratším způsobem (přijde na řešení některý ze čtenářů?).
Obrázek 18: Výpis hodnot vracených funkcí gauss. Pro konverzi horizontálně orientované tabulky na tabulku orientovanou vertikálně jsem použil funkci transpose, jejíž kód je zobrazen v horní části screenshotu.
10. Zápis a vykreslení vzorců ve formátu (La)TeXu
Pro některé uživatele může být užitečná i další vlastnost nabízená nástrojem Gorilla REPL. Do vytvářeného diáře je totiž v případě potřeby možné vložit (přes MathJax) i velmi složité vzorce zapsané systémem používaným v TeXu a LaTeXu. Vzorec je převeden ze vstupního značkovacího jazyka do podoby vhodné pro prezentaci na webové stránce, přičemž je možné v kontextovém menu zobrazeném po kliknutí na výsledný vzorec zvolit jak technologii použitou při vykreslení (HTML, HTML+CSS, MathML, SVG), tak i stupeň zvětšení vybraného vzorce či všech vzorců, které se na stránce nachází. Ostatně podívejme se na screenshoty, kde na nichž jsou některé možnosti systému Gorilla REPL v součinnosti s MathJaxem ukázány (samozřejmě je však možné zapsat i složitější vzorce s maticemi, speciálními operátory atd.):
Obrázek 19: Ukázka importu jmenného prostoru gorilla-repl.latex a vykreslení několika vzorců do diáře.
Obrázek 20: V kontextovém menu si můžete zvolit zvětšení výsledných vzorců (zde konkrétně na 300%). Při tomto zvětšení ihned vyjde najevo, že funkce sin je ve skutečnosti vypsána špatně a že se měl použít zápis \sin (při renderingu se totiž použije odlišný font).
11. První omezení projektu: tvorba grafů
Při práci s nástrojem Gorilla REPL poměrně záhy zjistíme, že tento systém (minimálně ve své základní variantě, tj. bez přídavných pluginů) má mnohá omezení. Především se jedná o poměrně malé množství dostupných typů grafů, což začne vadit zejména ve chvíli, kdy je zapotřebí vykreslit průběh funkce se dvěma nezávislými proměnnými typu z=fce(x,y), popř. funkci typu (x,y)=fce(t) (Lissajousovy obrazce apod.) nebo dokonce funkci, která akceptuje a/nebo vrací komplexní čísla. Taktéž možnosti úpravy grafů a nastavení jejich stylů jsou (alespoň v současné verzi) poněkud omezené – týká se to například možnosti (či přesněji řečeno naopak nemožnosti) použití většího množství vertikálních os či nemožnosti použití logaritmického měřítka. V základní variantě nástroje Gorilla REPL nenajdeme ani podporu pro vykreslení křivek, které aproximují nebo interpolují naměřené popř. vypočtené hodnoty. To je samozřejmě možné relativně jednoduše napravit importem některého modulu (jmenného prostoru) do projektu, nicméně i tak nelze Gorilla REPL pokládat například za systém již od začátku připravený na provádění statistických výpočtů, na rozdíl od nástroje R.
12. Druhé omezení projektu: použitý formát čísel
Druhé omezení, o kterém je nutné se zmínit (a které by navíc bylo možné poměrně snadno napravit), spočívá v tom, že systém Gorilla REPL při práci s grafy interně používá numerické hodnoty s plovoucí řádovou čárkou s dvojitou přesností (v Javě se jedná o primitivní datový typ double). Kvůli tomuto omezení není možné v plném rozsahu využít všechny schopnosti programovacího jazyka Clojure, především pak možnost práce se zlomky (hodnota 1/3 se nepřevádí na reálné číslo, ale zůstává zlomkem) a taktéž s čísly s prakticky neomezenou přesností a rozsahem (pro jejich zápis použijte postfix M).
Obrázek 21: S využitím numerických hodnot o neomezeném rozsahu je možné vypočítat například i 200!, a to bez přetečení popř. vrácení nekonečna (pro jistotu jsem do diáře přidal i nápovědu k funkci nazvané *', která zajišťuje, že výsledek výpočtu nepřeteče ani nedojde k jeho zkreslení).
Podívejme se nyní na typický příklad – funkci pro výpočet faktoriálu jsem nepatrně upravil takovým způsobem, že se při výpočtu namísto funkce pojmenované * používá funkce nazvaná *', která automaticky zjistí, kdy se má přejít z výpočtů s celočíselným datovým typem long na výpočty s čísly s neomezeným rozsahem. Tato funkce pracuje korektně i pro n=200 (a samozřejmě i pro vyšší čísla, pokud máte dostatek trpělivosti), ovšem graf s průběhem funkce faktoriál není korektní, protože při převodu na double dojde k chybě, což je na grafu patrné poklesem průběhu k nule (dvakrát nepříjemné je, že se o tomto problému při převodu explicitně nedozvíte).
Obrázek 22: Problém však nastává při vykreslování grafů, protože některé výpočty jsou v Gorilla REPL omezeny na typ double (čísla s plovoucí řádovou čárkou s dvojnásobnou přesností).
13. (Lepší) alternativy nabízené pro jiné programovací jazyky
Mnozí čtenáři se po přečtení předchozích kapitol pravděpodobně ptají, zda je lepší použít Gorilla REPL namísto již zmíněného populárního nástroje IPython Notebook či novějšího a ambicióznějšího projektu Jupyter. IPython Notebook a zejména pak Jupyter jsou vyvíjeny mnohem větším množstvím programátorů a navíc se těší podpoře některých významných softwarových firem, takže vlastně není překvapivé, že tyto nástroje nabízí uživatelům mnohem více možností než systém Gorilla REPL, který je sice navržen modulárně, ale prozatím počet dostupných modulů není nijak závratný. Pro statistické výpočty, které je nutné prezentovat s využitím webového „diáře“, je pravděpodobně stále nejrozumnější použít R napojený (například) na Jupyter, ovšem ve chvíli, kdy je celý ekosystém postavený na programovacím jazyku Clojure, nemusí být použití Gorilla REPL špatnou volbou (navíc se zde nabízí propojení Gorilla REPL s již dříve popsanou knihovnou core.matrix). Podstatně zajímavější se jeví propojení Clojure, systému R a knihovny ggplot2, které je realizováno v projektu gg4clj.
14. Odkazy na předchozí části tohoto seriálu
- Clojure 1: Úvod
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm/ - Clojure 2: Symboly, kolekce atd.
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-2-cast/ - Clojure 3: Funkcionální programování
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-3-cast-funkcionalni-programovani/ - Clojure 4: Kolekce, sekvence a lazy sekvence
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-4-cast-kolekce-sekvence-a-lazy-sekvence/ - Clojure 5: Sekvence, lazy sekvence a paralelní programy
http://www.root.cz/clanky/clojure-a-bezpecne-aplikace-pro-jvm-sekvence-lazy-sekvence-a-paralelni-programy/ - Clojure 6: Podpora pro paralelní programování
http://www.root.cz/clanky/programovaci-jazyk-clojure-6-futures-nejsou-jen-financni-derivaty/ - Clojure 7: Další funkce pro paralelní programování
http://www.root.cz/clanky/programovaci-jazyk-clojure-7-dalsi-podpurne-prostredky-pro-paralelni-programovani/ - Clojure 8: Identity, stavy, neměnné hodnoty a reference
http://www.root.cz/clanky/programovaci-jazyk-clojure-8-identity-stavy-nemenne-hodnoty-a-referencni-typy/ - Clojure 9: Validátory, pozorovatelé a kooperace s Javou
http://www.root.cz/clanky/programovaci-jazyk-clojure-9-validatory-pozorovatele-a-kooperace-mezi-clojure-a-javou/ - Clojure 10: Kooperace mezi Clojure a Javou
http://www.root.cz/clanky/programovaci-jazyk-clojure-10-kooperace-mezi-clojure-a-javou-pokracovani/ - Clojure 11: Generátorová notace seznamu/list comprehension
http://www.root.cz/clanky/programovaci-jazyk-clojure-11-generatorova-notace-seznamu-list-comprehension/ - Clojure 12: Překlad programů z Clojure do bajtkódu JVM I:
http://www.root.cz/clanky/programovaci-jazyk-clojure-12-preklad-programu-z-clojure-do-bajtkodu-jvm/ - Clojure 13: Překlad programů z Clojure do bajtkódu JVM II:
http://www.root.cz/clanky/programovaci-jazyk-clojure-13-preklad-programu-z-clojure-do-bajtkodu-jvm-pokracovani/ - Clojure 14: Základy práce se systémem maker
http://www.root.cz/clanky/programovaci-jazyk-clojure-14-zaklady-prace-se-systemem-maker/ - Clojure 15: Tvorba uživatelských maker
http://www.root.cz/clanky/programovaci-jazyk-clojure-15-tvorba-uzivatelskych-maker/ - Clojure 16: Složitější uživatelská makra
http://www.root.cz/clanky/programovaci-jazyk-clojure-16-slozitejsi-uzivatelska-makra/ - Clojure 17: Využití standardních maker v praxi
http://www.root.cz/clanky/programovaci-jazyk-clojure-17-vyuziti-standardnich-maker-v-praxi/ - Clojure 18: Základní techniky optimalizace aplikací
http://www.root.cz/clanky/programovaci-jazyk-clojure-18-zakladni-techniky-optimalizace-aplikaci/ - Clojure 19: Vývojová prostředí pro Clojure
http://www.root.cz/clanky/programovaci-jazyk-clojure-19-vyvojova-prostredi-pro-clojure/ - Clojure 20: Vývojová prostředí pro Clojure (Vimu s REPL)
http://www.root.cz/clanky/programovaci-jazyk-clojure-20-vyvojova-prostredi-pro-clojure-integrace-vimu-s-repl/ - Clojure 21: ClojureScript aneb překlad Clojure do JS
http://www.root.cz/clanky/programovaci-jazyk-clojure-21-clojurescript-aneb-preklad-clojure-do-javascriptu/ - Leiningen: nástroj pro správu projektů napsaných v Clojure
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (2)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-2/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (3)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-3/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (4)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-4/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (5)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-5/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (6)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-6/ - Programovací jazyk Clojure a databáze (1.část)
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-databaze-1-cast/ - Pluginy pro Leiningen
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-pluginy-pro-leiningen/ - Programovací jazyk Clojure a knihovny pro práci s vektory a maticemi
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-knihovny-pro-praci-s-vektory-a-maticemi/ - Programovací jazyk Clojure a knihovny pro práci s vektory a maticemi (2)
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-knihovny-pro-praci-s-vektory-a-maticemi-2/ - Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk
http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk/ - Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk (2)
http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk-2/ - Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk (dokončení)
http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk-dokonceni/ - Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure
http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure/ - Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (2)
http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure-2/ - Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (3)
http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure-3/ - Programovací jazyk Clojure a práce s Gitem
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-prace-s-gitem/ - Programovací jazyk Clojure a práce s Gitem (2)
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-prace-s-gitem-2/ - Programovací jazyk Clojure – triky při práci s řetězci
http://www.root.cz/clanky/programovaci-jazyk-clojure-triky-pri-praci-s-retezci/ - Programovací jazyk Clojure – triky při práci s kolekcemi
http://www.root.cz/clanky/programovaci-jazyk-clojure-triky-pri-praci-s-kolekcemi/ - Programovací jazyk Clojure – práce s mapami a množinami
http://www.root.cz/clanky/programovaci-jazyk-clojure-prace-s-mapami-a-mnozinami/ - Programovací jazyk Clojure – základy zpracování XML
http://www.root.cz/clanky/programovaci-jazyk-clojure-zaklady-zpracovani-xml/ - Programovací jazyk Clojure – testování s využitím knihovny Expectations
http://www.root.cz/clanky/programovaci-jazyk-clojure-testovani-s-vyuzitim-knihovny-expectations/ - Programovací jazyk Clojure – některé užitečné triky použitelné (nejenom) v testech
http://www.root.cz/clanky/programovaci-jazyk-clojure-nektere-uzitecne-triky-pouzitelne-nejenom-v-testech/ - Enlive – výkonný šablonovací systém pro jazyk Clojure
http://www.root.cz/clanky/enlive-vykonny-sablonovaci-system-pro-jazyk-clojure/ - Nástroj Leiningen a programovací jazyk Clojure: tvorba vlastních knihoven pro veřejný repositář Clojars
http://www.root.cz/clanky/nastroj-leiningen-a-programovaci-jazyk-clojure-tvorba-vlastnich-knihoven-pro-verejny-repositar-clojars/ - Novinky v Clojure verze 1.8.0
http://www.root.cz/clanky/novinky-v-clojure-verze-1–8–0/ - Asynchronní programování v Clojure s využitím knihovny core.async
http://www.root.cz/clanky/asynchronni-programovani-v-clojure-s-vyuzitim-knihovny-core-async/ - Asynchronní programování v Clojure s využitím knihovny core.async (pokračování)
http://www.root.cz/clanky/asynchronni-programovani-v-clojure-s-vyuzitim-knihovny-core-async-pokracovani/ - Asynchronní programování v Clojure s využitím knihovny core.async (dokončení)
http://www.root.cz/clanky/asynchronni-programovani-v-clojure-s-vyuzitim-knihovny-core-async-dokonceni/ - Vytváříme IRC bota v programovacím jazyce Clojure
http://www.root.cz/clanky/vytvarime-irc-bota-v-programovacim-jazyce-clojure/
15. Odkazy na Internetu
- Back to the Future: Lisp as a Base for a Statistical Computing System
https://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf - gg4clj: a simple wrapper for using R's ggplot2 in Clojure and Gorilla REPL
https://github.com/JonyEpsilon/gg4clj - Analemma: a Clojure-based SVG DSL and charting library
http://liebke.github.io/analemma/ - Clojupyter: a Jupyter kernel for Clojure
https://github.com/roryk/clojupyter - Communicating sequential processes
https://en.wikipedia.org/wiki/Communicating_sequential_processes - The IPython Notebook
http://ipython.org/notebook.html - Jypyter: open source, interactive data science and scientific computing across over 40 programming languages
https://jupyter.org/ - nbviewer: a simple way to share Jupyter Notebooks
https://nbviewer.jupyter.org/ - Clojure core.async
http://www.infoq.com/presentations/clojure-core-async - core.async API Reference
https://clojure.github.io/core.async/ - Clojure core.async Channels
http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html - core.async examples
https://github.com/clojure/core.async/blob/master/examples/walkthrough.clj - Timothy Baldridge – Core.Async
https://www.youtube.com/watch?v=enwIIGzhahw - Designing Front End Applications with core.async
http://go.cognitect.com/core_async_webinar_recording - Mastering Concurrent Processes with core.async
http://www.braveclojure.com/core-async/ - LispCast: Clojure core.async
https://www.youtube.com/watch?v=msv8Fvtd6YQ - Julian Gamble – Applying the paradigms of core.async in ClojureScript
https://www.youtube.com/watch?v=JUrOebC5HmA - Zip archiv s Clojure 1.8.0
http://repo1.maven.org/maven2/org/clojure/clojure/1.8.0/clojure-1.8.0.zip - Clojure 1.8 is now available
http://clojure.org/news/2016/01/19/clojure18 - Changes to Clojure in Version 1.8
https://github.com/clojure/clojure/blob/master/changes.md - Socket Server REPL
http://dev.clojure.org/display/design/Socket+Server+REPL - CLJ-1671: Clojure socket server
http://dev.clojure.org/jira/browse/CLJ-1671 - CLJ-1449: Add clojure.string functions for portability to ClojureScript
http://dev.clojure.org/jira/browse/CLJ-1449 - Launching a Socket Server
http://clojure.org/reference/repl_and_main#_launching_a_socket_server - API for clojure.string
http://clojure.github.io/clojure/branch-master/clojure.string-api.html - Clojars:
https://clojars.org/ - Seznam knihoven na Clojars:
https://clojars.org/projects - Clojure Cookbook: Templating HTML with Enlive
https://github.com/clojure-cookbook/clojure-cookbook/blob/master/07_webapps/7–11_enlive.asciidoc - An Introduction to Enlive
https://github.com/swannodette/enlive-tutorial/ - Enlive na GitHubu
https://github.com/cgrand/enlive - Expectations: příklady atd.
http://jayfields.com/expectations/ - Expectations na GitHubu
https://github.com/jaycfields/expectations - Lein-expectations na GitHubu
https://github.com/gar3thjon3s/lein-expectations - Testing Clojure With Expectations
https://semaphoreci.com/blog/2014/09/23/testing-clojure-with-expectations.html - Clojure testing TDD/BDD libraries: clojure.test vs Midje vs Expectations vs Speclj
https://www.reddit.com/r/Clojure/comments/1viilt/clojure_testing_tddbdd_libraries_clojuretest_vs/ - Testing: One assertion per test
http://blog.jayfields.com/2007/06/testing-one-assertion-per-test.html - Rewriting Your Test Suite in Clojure in 24 hours
http://blog.circleci.com/rewriting-your-test-suite-in-clojure-in-24-hours/ - Clojure doc: zipper
http://clojuredocs.org/clojure.zip/zipper - Clojure doc: parse
http://clojuredocs.org/clojure.xml/parse - Clojure doc: xml-zip
http://clojuredocs.org/clojure.zip/xml-zip - Clojure doc: xml-seq
http://clojuredocs.org/clojure.core/xml-seq - Parsing XML in Clojure
https://github.com/clojuredocs/guides - Clojure Zipper Over Nested Vector
https://vitalyper.wordpress.com/2010/11/23/clojure-zipper-over-nested-vector/ - Understanding Clojure's PersistentVector implementation
http://blog.higher-order.net/2009/02/01/understanding-clojures-persistentvector-implementation - Understanding Clojure's PersistentHashMap (deftwice…)
http://blog.higher-order.net/2009/09/08/understanding-clojures-persistenthashmap-deftwice.html - Assoc and Clojure's PersistentHashMap: part ii
http://blog.higher-order.net/2010/08/16/assoc-and-clojures-persistenthashmap-part-ii.html - Ideal Hashtrees (paper)
http://lampwww.epfl.ch/papers/idealhashtrees.pdf - Clojure home page
http://clojure.org/ - Clojure (downloads)
http://clojure.org/downloads - Clojure Sequences
http://clojure.org/sequences - Clojure Data Structures
http://clojure.org/data_structures - The Structure and Interpretation of Computer Programs: 2.2.1 Representing Sequences
http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-15.html#%_sec2.2.1 - The Structure and Interpretation of Computer Programs: 3.3.1 Mutable List Structure
http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-22.html#%_sec3.3.1 - Clojure – Functional Programming for the JVM
http://java.ociweb.com/mark/clojure/article.html - Clojure quick reference
http://faustus.webatu.com/clj-quick-ref.html - 4Clojure
http://www.4clojure.com/ - ClojureDoc (rozcestník s dokumentací jazyka Clojure)
http://clojuredocs.org/ - Clojure (na Wikipedia EN)
http://en.wikipedia.org/wiki/Clojure - Clojure (na Wikipedia CS)
http://cs.wikipedia.org/wiki/Clojure - SICP (The Structure and Interpretation of Computer Programs)
http://mitpress.mit.edu/sicp/ - Pure function
http://en.wikipedia.org/wiki/Pure_function - Funkcionální programování
http://cs.wikipedia.org/wiki/Funkcionální_programování - Čistě funkcionální (datové struktury, jazyky, programování)
http://cs.wikipedia.org/wiki/Čistě_funkcionální - Clojure Macro Tutorial (Part I, Getting the Compiler to Write Your Code For You)
http://www.learningclojure.com/2010/09/clojure-macro-tutorial-part-i-getting.html - Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
http://www.learningclojure.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html - Clojure Macro Tutorial (Part III: Syntax Quote)
http://www.learningclojure.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html - Tech behind Tech: Clojure Macros Simplified
http://techbehindtech.com/2010/09/28/clojure-macros-simplified/ - Fatvat – Exploring functional programming: Clojure Macros
http://www.fatvat.co.uk/2009/02/clojure-macros.html - Eulerovo číslo
http://cs.wikipedia.org/wiki/Eulerovo_číslo - List comprehension
http://en.wikipedia.org/wiki/List_comprehension - List Comprehensions in Clojure
http://asymmetrical-view.com/2008/11/18/list-comprehensions-in-clojure.html - Clojure Programming Concepts: List Comprehension
http://en.wikibooks.org/wiki/Clojure_Programming/Concepts#List_Comprehension - Clojure core API: for macro
http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/for - cirrus machina – The Clojure for macro
http://www.cirrusmachina.com/blog/comment/the-clojure-for-macro/ - Riastradh's Lisp Style Rules
http://mumble.net/~campbell/scheme/style.txt - Dynamic Languages Strike Back
http://steve-yegge.blogspot.cz/2008/05/dynamic-languages-strike-back.html - Scripting: Higher Level Programming for the 21st Century
http://www.tcl.tk/doc/scripting.html - Java Virtual Machine Support for Non-Java Languages
http://docs.oracle.com/javase/7/docs/technotes/guides/vm/multiple-language-support.html - Třída java.lang.String
http://docs.oracle.com/javase/7/docs/api/java/lang/String.html - Třída java.lang.StringBuffer
http://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html - Třída java.lang.StringBuilder
http://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html - StringBuffer versus String
http://www.javaworld.com/article/2076072/build-ci-sdlc/stringbuffer-versus-string.html - Threading macro (dokumentace k jazyku Clojure)
https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/-> - Understanding the Clojure → macro
http://blog.fogus.me/2009/09/04/understanding-the-clojure-macro/ - clojure.inspector
http://clojure.github.io/clojure/clojure.inspector-api.html - The Clojure Toolbox
http://www.clojure-toolbox.com/ - Unit Testing in Clojure
http://nakkaya.com/2009/11/18/unit-testing-in-clojure/ - Testing in Clojure (Part-1: Unit testing)
http://blog.knoldus.com/2014/03/22/testing-in-clojure-part-1-unit-testing/ - API for clojure.test – Clojure v1.6 (stable)
https://clojure.github.io/clojure/clojure.test-api.html - Leiningen: úvodní stránka
http://leiningen.org/ - Leiningen: Git repository
https://github.com/technomancy/leiningen - leiningen-win-installer
http://leiningen-win-installer.djpowell.net/ - Clojure.org: Vars and the Global Environment
http://clojure.org/Vars - Clojure.org: Refs and Transactions
http://clojure.org/Refs - Clojure.org: Atoms
http://clojure.org/Atoms - Clojure.org: Agents as Asynchronous Actions
http://clojure.org/agents - Transient Data Structureshttp://clojure.org/transients
ČLÁNKY DO MAILU