Hlavní navigace

Gorilla REPL: interaktivní prostředí pro programovací jazyk Clojure

Pavel Tišnovský

Gorilla REPL nabízí uživatelům jazyka Clojure interaktivní „webové“ prostředí inspirované například projekty IPython Notebook či Jupyter. Představíme si vlastnosti tohoto nástroje, jeho přednosti i zápory.

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

9. Výpis tabulek

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

15. Odkazy na Internetu

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

  1. Clojure 1: Úvod
    http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm/
  2. Clojure 2: Symboly, kolekce atd.
    http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-2-cast/
  3. 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/
  4. 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/
  5. 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/
  6. Clojure 6: Podpora pro paralelní programování
    http://www.root.cz/clanky/programovaci-jazyk-clojure-6-futures-nejsou-jen-financni-derivaty/
  7. Clojure 7: Další funkce pro paralelní programování
    http://www.root.cz/clanky/programovaci-jazyk-clojure-7-dalsi-podpurne-prostredky-pro-paralelni-programovani/
  8. 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/
  9. 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/
  10. Clojure 10: Kooperace mezi Clojure a Javou
    http://www.root.cz/clanky/programovaci-jazyk-clojure-10-kooperace-mezi-clojure-a-javou-pokracovani/
  11. Clojure 11: Generátorová notace seznamu/list comprehension
    http://www.root.cz/clanky/programovaci-jazyk-clojure-11-generatorova-notace-seznamu-list-comprehension/
  12. 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/
  13. 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/
  14. Clojure 14: Základy práce se systémem maker
    http://www.root.cz/clanky/programovaci-jazyk-clojure-14-zaklady-prace-se-systemem-maker/
  15. Clojure 15: Tvorba uživatelských maker
    http://www.root.cz/clanky/programovaci-jazyk-clojure-15-tvorba-uzivatelskych-maker/
  16. Clojure 16: Složitější uživatelská makra
    http://www.root.cz/clanky/programovaci-jazyk-clojure-16-slozitejsi-uzivatelska-makra/
  17. Clojure 17: Využití standardních maker v praxi
    http://www.root.cz/clanky/programovaci-jazyk-clojure-17-vyuziti-standardnich-maker-v-praxi/
  18. Clojure 18: Základní techniky optimalizace aplikací
    http://www.root.cz/clanky/programovaci-jazyk-clojure-18-zakladni-techniky-optimalizace-aplikaci/
  19. Clojure 19: Vývojová prostředí pro Clojure
    http://www.root.cz/clanky/programovaci-jazyk-clojure-19-vyvojova-prostredi-pro-clojure/
  20. 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/
  21. Clojure 21: ClojureScript aneb překlad Clojure do JS
    http://www.root.cz/clanky/programovaci-jazyk-clojure-21-clojurescript-aneb-preklad-clojure-do-javascriptu/
  22. Leiningen: nástroj pro správu projektů napsaných v Clojure
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure/
  23. 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/
  24. 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/
  25. 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/
  26. 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/
  27. 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/
  28. Programovací jazyk Clojure a databáze (1.část)
    http://www.root.cz/clanky/programovaci-jazyk-clojure-a-databaze-1-cast/
  29. Pluginy pro Leiningen
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-pluginy-pro-leiningen/
  30. 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/
  31. 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/
  32. 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/
  33. 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/
  34. 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/
  35. Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure
    http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure/
  36. 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/
  37. 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/
  38. Programovací jazyk Clojure a práce s Gitem
    http://www.root.cz/clanky/programovaci-jazyk-clojure-a-prace-s-gitem/
  39. Programovací jazyk Clojure a práce s Gitem (2)
    http://www.root.cz/clanky/programovaci-jazyk-clojure-a-prace-s-gitem-2/
  40. Programovací jazyk Clojure – triky při práci s řetězci
    http://www.root.cz/clanky/programovaci-jazyk-clojure-triky-pri-praci-s-retezci/
  41. Programovací jazyk Clojure – triky při práci s kolekcemi
    http://www.root.cz/clanky/programovaci-jazyk-clojure-triky-pri-praci-s-kolekcemi/
  42. Programovací jazyk Clojure – práce s mapami a množinami
    http://www.root.cz/clanky/programovaci-jazyk-clojure-prace-s-mapami-a-mnozinami/
  43. Programovací jazyk Clojure – základy zpracování XML
    http://www.root.cz/clanky/programovaci-jazyk-clojure-zaklady-zpracovani-xml/
  44. Programovací jazyk Clojure – testování s využitím knihovny Expectations
    http://www.root.cz/clanky/programovaci-jazyk-clojure-testovani-s-vyuzitim-knihovny-expectations/
  45. 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/
  46. Enlive – výkonný šablonovací systém pro jazyk Clojure
    http://www.root.cz/clanky/enlive-vykonny-sablonovaci-system-pro-jazyk-clojure/
  47. 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/
  48. Novinky v Clojure verze 1.8.0
    http://www.root.cz/clanky/novinky-v-clojure-verze-1–8–0/
  49. 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/
  50. 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/
  51. 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/
  52. 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

  1. Back to the Future: Lisp as a Base for a Statistical Computing System
    https://www.stat.auckland­.ac.nz/~ihaka/downloads/Com­pstat-2008.pdf
  2. gg4clj: a simple wrapper for using R's ggplot2 in Clojure and Gorilla REPL
    https://github.com/JonyEpsilon/gg4clj
  3. Analemma: a Clojure-based SVG DSL and charting library
    http://liebke.github.io/analemma/
  4. Clojupyter: a Jupyter kernel for Clojure
    https://github.com/roryk/clojupyter
  5. Communicating sequential processes
    https://en.wikipedia.org/wi­ki/Communicating_sequenti­al_processes
  6. The IPython Notebook
    http://ipython.org/notebook.html
  7. Jypyter: open source, interactive data science and scientific computing across over 40 programming languages
    https://jupyter.org/
  8. nbviewer: a simple way to share Jupyter Notebooks
    https://nbviewer.jupyter.org/
  9. Clojure core.async
    http://www.infoq.com/presen­tations/clojure-core-async
  10. core.async API Reference
    https://clojure.github.io/core.async/
  11. Clojure core.async Channels
    http://clojure.com/blog/2013/06/28/clo­jure-core-async-channels.html
  12. core.async examples
    https://github.com/clojure/co­re.async/blob/master/exam­ples/walkthrough.clj
  13. Timothy Baldridge – Core.Async
    https://www.youtube.com/wat­ch?v=enwIIGzhahw
  14. Designing Front End Applications with core.async
    http://go.cognitect.com/co­re_async_webinar_recording
  15. Mastering Concurrent Processes with core.async
    http://www.braveclojure.com/core-async/
  16. LispCast: Clojure core.async
    https://www.youtube.com/wat­ch?v=msv8Fvtd6YQ
  17. Julian Gamble – Applying the paradigms of core.async in ClojureScript
    https://www.youtube.com/wat­ch?v=JUrOebC5HmA
  18. Zip archiv s Clojure 1.8.0
    http://repo1.maven.org/ma­ven2/org/clojure/clojure/1­.8.0/clojure-1.8.0.zip
  19. Clojure 1.8 is now available
    http://clojure.org/news/2016/01/19/clo­jure18
  20. Changes to Clojure in Version 1.8
    https://github.com/clojure/clo­jure/blob/master/changes.md
  21. Socket Server REPL
    http://dev.clojure.org/dis­play/design/Socket+Server+REPL
  22. CLJ-1671: Clojure socket server
    http://dev.clojure.org/jira/browse/CLJ-1671
  23. CLJ-1449: Add clojure.string functions for portability to ClojureScript
    http://dev.clojure.org/jira/browse/CLJ-1449
  24. Launching a Socket Server
    http://clojure.org/referen­ce/repl_and_main#_launchin­g_a_socket_server
  25. API for clojure.string
    http://clojure.github.io/clo­jure/branch-master/clojure.string-api.html
  26. Clojars:
    https://clojars.org/
  27. Seznam knihoven na Clojars:
    https://clojars.org/projects
  28. Clojure Cookbook: Templating HTML with Enlive
    https://github.com/clojure-cookbook/clojure-cookbook/blob/master/07_webapps/7–11_enlive.asciidoc
  29. An Introduction to Enlive
    https://github.com/swannodette/enlive-tutorial/
  30. Enlive na GitHubu
    https://github.com/cgrand/enlive
  31. Expectations: příklady atd.
    http://jayfields.com/expectations/
  32. Expectations na GitHubu
    https://github.com/jaycfi­elds/expectations
  33. Lein-expectations na GitHubu
    https://github.com/gar3thjon3s/lein-expectations
  34. Testing Clojure With Expectations
    https://semaphoreci.com/blog/2014/09/23/tes­ting-clojure-with-expectations.html
  35. Clojure testing TDD/BDD libraries: clojure.test vs Midje vs Expectations vs Speclj
    https://www.reddit.com/r/Clo­jure/comments/1viilt/cloju­re_testing_tddbdd_librari­es_clojuretest_vs/
  36. Testing: One assertion per test
    http://blog.jayfields.com/2007/06/tes­ting-one-assertion-per-test.html
  37. Rewriting Your Test Suite in Clojure in 24 hours
    http://blog.circleci.com/rewriting-your-test-suite-in-clojure-in-24-hours/
  38. Clojure doc: zipper
    http://clojuredocs.org/clo­jure.zip/zipper
  39. Clojure doc: parse
    http://clojuredocs.org/clo­jure.xml/parse
  40. Clojure doc: xml-zip
    http://clojuredocs.org/clojure.zip/xml-zip
  41. Clojure doc: xml-seq
    http://clojuredocs.org/clo­jure.core/xml-seq
  42. Parsing XML in Clojure
    https://github.com/clojuredocs/guides
  43. Clojure Zipper Over Nested Vector
    https://vitalyper.wordpres­s.com/2010/11/23/clojure-zipper-over-nested-vector/
  44. Understanding Clojure's PersistentVector implementation
    http://blog.higher-order.net/2009/02/01/understanding-clojures-persistentvector-implementation
  45. Understanding Clojure's PersistentHashMap (deftwice…)
    http://blog.higher-order.net/2009/09/08/understanding-clojures-persistenthashmap-deftwice.html
  46. Assoc and Clojure's PersistentHashMap: part ii
    http://blog.higher-order.net/2010/08/16/assoc-and-clojures-persistenthashmap-part-ii.html
  47. Ideal Hashtrees (paper)
    http://lampwww.epfl.ch/pa­pers/idealhashtrees.pdf
  48. Clojure home page
    http://clojure.org/
  49. Clojure (downloads)
    http://clojure.org/downloads
  50. Clojure Sequences
    http://clojure.org/sequences
  51. Clojure Data Structures
    http://clojure.org/data_structures
  52. 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
  53. 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
  54. Clojure – Functional Programming for the JVM
    http://java.ociweb.com/mar­k/clojure/article.html
  55. Clojure quick reference
    http://faustus.webatu.com/clj-quick-ref.html
  56. 4Clojure
    http://www.4clojure.com/
  57. ClojureDoc (rozcestník s dokumentací jazyka Clojure)
    http://clojuredocs.org/
  58. Clojure (na Wikipedia EN)
    http://en.wikipedia.org/wiki/Clojure
  59. Clojure (na Wikipedia CS)
    http://cs.wikipedia.org/wiki/Clojure
  60. SICP (The Structure and Interpretation of Computer Programs)
    http://mitpress.mit.edu/sicp/
  61. Pure function
    http://en.wikipedia.org/wi­ki/Pure_function
  62. Funkcionální programování
    http://cs.wikipedia.org/wi­ki/Funkcionální_programová­ní
  63. Čistě funkcionální (datové struktury, jazyky, programování)
    http://cs.wikipedia.org/wi­ki/Čistě_funkcionální
  64. 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
  65. Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html
  66. Clojure Macro Tutorial (Part III: Syntax Quote)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html
  67. Tech behind Tech: Clojure Macros Simplified
    http://techbehindtech.com/2010/09/28/clo­jure-macros-simplified/
  68. Fatvat – Exploring functional programming: Clojure Macros
    http://www.fatvat.co.uk/2009/02/clo­jure-macros.html
  69. Eulerovo číslo
    http://cs.wikipedia.org/wi­ki/Eulerovo_číslo
  70. List comprehension
    http://en.wikipedia.org/wi­ki/List_comprehension
  71. List Comprehensions in Clojure
    http://asymmetrical-view.com/2008/11/18/list-comprehensions-in-clojure.html
  72. Clojure Programming Concepts: List Comprehension
    http://en.wikibooks.org/wi­ki/Clojure_Programming/Con­cepts#List_Comprehension
  73. Clojure core API: for macro
    http://clojure.github.com/clo­jure/clojure.core-api.html#clojure.core/for
  74. cirrus machina – The Clojure for macro
    http://www.cirrusmachina.com/blog/com­ment/the-clojure-for-macro/
  75. Riastradh's Lisp Style Rules
    http://mumble.net/~campbe­ll/scheme/style.txt
  76. Dynamic Languages Strike Back
    http://steve-yegge.blogspot.cz/2008/05/dynamic-languages-strike-back.html
  77. Scripting: Higher Level Programming for the 21st Century
    http://www.tcl.tk/doc/scripting.html
  78. Java Virtual Machine Support for Non-Java Languages
    http://docs.oracle.com/ja­vase/7/docs/technotes/gui­des/vm/multiple-language-support.html
  79. Třída java.lang.String
    http://docs.oracle.com/ja­vase/7/docs/api/java/lang/Strin­g.html
  80. Třída java.lang.StringBuffer
    http://docs.oracle.com/ja­vase/7/docs/api/java/lang/Strin­gBuffer.html
  81. Třída java.lang.StringBuilder
    http://docs.oracle.com/ja­vase/7/docs/api/java/lang/Strin­gBuilder.html
  82. StringBuffer versus String
    http://www.javaworld.com/ar­ticle/2076072/build-ci-sdlc/stringbuffer-versus-string.html
  83. Threading macro (dokumentace k jazyku Clojure)
    https://clojure.github.io/clo­jure/clojure.core-api.html#clojure.core/->
  84. Understanding the Clojure → macro
    http://blog.fogus.me/2009/09/04/un­derstanding-the-clojure-macro/
  85. clojure.inspector
    http://clojure.github.io/clo­jure/clojure.inspector-api.html
  86. The Clojure Toolbox
    http://www.clojure-toolbox.com/
  87. Unit Testing in Clojure
    http://nakkaya.com/2009/11/18/unit-testing-in-clojure/
  88. Testing in Clojure (Part-1: Unit testing)
    http://blog.knoldus.com/2014/03/22/tes­ting-in-clojure-part-1-unit-testing/
  89. API for clojure.test – Clojure v1.6 (stable)
    https://clojure.github.io/clo­jure/clojure.test-api.html
  90. Leiningen: úvodní stránka
    http://leiningen.org/
  91. Leiningen: Git repository
    https://github.com/techno­mancy/leiningen
  92. leiningen-win-installer
    http://leiningen-win-installer.djpowell.net/
  93. Clojure.org: Vars and the Global Environment
    http://clojure.org/Vars
  94. Clojure.org: Refs and Transactions
    http://clojure.org/Refs
  95. Clojure.org: Atoms
    http://clojure.org/Atoms
  96. Clojure.org: Agents as Asynchronous Actions
    http://clojure.org/agents
  97. Transient Data Structureshttp://clojure.or­g/transients
Našli jste v článku chybu?

30. 3. 2016 9:43

R nebo Numpy (neregistrovaný)

Kdyz ted budu potrebovat nejake grafy + ruzne interpolacni krivky (to jeste neni jasne, podle toho co se sefikum bude libit :), je podle vas lepsi pouzit Numpy nebo jit primo do R? U Numpy bych mel vyhodu znalosti Pythonu (tedy nejsem aktivni programator v tomto jazyku, ale Python na urcite urovni da kazdy do dvou hodin), zase na druhou stranu R mi prijde o hodne nabusenejsi v tomto ohledu.

Jinak vstupem by byly obrovske tabulky v CSV, ty uz si dokazu vygenerovat z DB a dalsich toolu (ta vizual…

29. 3. 2016 20:56

Pro info: opravil jsem prikaz lein new project gorilla-test na lein new app gorilla-test. Dik za upozorneni!

120na80.cz: Boreliózu nelze žádným testem prokázat

Boreliózu nelze žádným testem prokázat

120na80.cz: Rovnátka, která nejsou vidět

Rovnátka, která nejsou vidět

Vitalia.cz: To nejhorší při horečce u dětí: Febrilní křeče

To nejhorší při horečce u dětí: Febrilní křeče

DigiZone.cz: SES zajistí HD pro M7 Group

SES zajistí HD pro M7 Group

DigiZone.cz: R2B2 a Hybrid uzavřely partnerství

R2B2 a Hybrid uzavřely partnerství

Podnikatel.cz: Chaos u EET pokračuje. Jsou tu další návrhy

Chaos u EET pokračuje. Jsou tu další návrhy

120na80.cz: 5 nejčastějších mýtů o kondomech

5 nejčastějších mýtů o kondomech

Lupa.cz: Kdo pochopí vtip, může jít do ČT vyvíjet weby

Kdo pochopí vtip, může jít do ČT vyvíjet weby

DigiZone.cz: V Plzni odstartovalo Radio 1

V Plzni odstartovalo Radio 1

Lupa.cz: Insolvenční řízení kvůli cookies? Vítejte v ČR

Insolvenční řízení kvůli cookies? Vítejte v ČR

Měšec.cz: Jak vymáhat výživné zadarmo?

Jak vymáhat výživné zadarmo?

Měšec.cz: U levneELEKTRO.cz už reklamaci nevyřídíte

U levneELEKTRO.cz už reklamaci nevyřídíte

DigiZone.cz: Sat novinky: slovenská TV8 HD i ruský NTV Mir

Sat novinky: slovenská TV8 HD i ruský NTV Mir

Vitalia.cz: Potvrzeno: Pobyt v lese je skvělý na imunitu

Potvrzeno: Pobyt v lese je skvělý na imunitu

Podnikatel.cz: Vládu obejde, kvůli EET rovnou do sněmovny

Vládu obejde, kvůli EET rovnou do sněmovny

Vitalia.cz: Nejlepší obranou při nachlazení je útok

Nejlepší obranou při nachlazení je útok

120na80.cz: Horní cesty dýchací. Zkuste fytofarmaka

Horní cesty dýchací. Zkuste fytofarmaka

Vitalia.cz: Pamlsková vyhláška bude platit jen na základkách

Pamlsková vyhláška bude platit jen na základkách

Root.cz: Certifikáty zadarmo jsou horší než za peníze?

Certifikáty zadarmo jsou horší než za peníze?

120na80.cz: Pánové, pečujte o svoje přirození a prostatu

Pánové, pečujte o svoje přirození a prostatu