Programovací jazyk Clojure 21: ClojureScript aneb překlad Clojure do JavaScriptu

Pavel Tišnovský 30. 10. 2012

Dnes se zmíníme o projektu ClojureScript. Zatímco původní implementace jazyka Clojure interně používá překlad funkcí do bajtkódu JVM, používá ClojureScript překlad do jazyka JavaScript. Je tedy jasné, kde může ClojureScript nalézt své oblasti použití: především na webu, popř. v oblasti mobilních aplikací.

Obsah

1. Programovací jazyk Clojure 21: ClojureScript aneb překlad Clojure do JavaScriptu

2. JavaScript jako jeden z nejpoužívanějších programovacích jazyků na straně klienta

3. JavaScript: assembler pro web?

4. Základní vlastnosti ClojureScriptu

5. Instalace překladače ClojureScriptu

6. Překlad programů z příkazové řádky a z REPL

7. Použití přeložených skriptů na webové stránce

8. Clojure na straně klienta i na straně serveru

9. Odkazy na Internetu

1. Programovací jazyk Clojure 21: ClojureScript aneb překlad Clojure do JavaScriptu

V předchozích dvaceti částech tohoto seriálu jsme se zabývali popisem programovacího jazyka Clojure, který byl ve své původní verzi implementován nad virtuálním strojem Javy (JVM). Na rozdíl od některých dalších jazyků odvozených od LISPu totiž Clojure nespadá do kategorie klasických interpretovaných jazyků, protože všechny uživatelem zapsané funkce či funkce načtené z knihoven jsou ihned při svém načtení smyčkou REPL nejprve zkompilovány do bajtkódu JVM a teprve poté je tento bajtkód spuštěn. To ve výsledku může vést k překladu bajtkódu JVM do nativního strojového kódu použitého mikroprocesoru, ovšem tato činnost (pokud k ní vůbec dojde) je již závislá pouze na konfiguraci konkrétního virtuálního stroje Javy a nemá prakticky nic společného s původním zdrojovým kódem naprogramovaným v Clojure. Nicméně JVM nemusí být jedinou platformou, na níž může být smyčka REPL programovacího jazyka Clojure spuštěna. Existuje totiž například i alternativní implementace Clojure pro platformu .NET (CLR).

Poněkud paradoxní přitom je, že implementace Clojure pro .NET (CLR) byla ve skutečnosti poněkud komplikovanější než původní implementace pro JVM, a to z toho důvodu, že virtuální stroj Javy (JVM) nepoužívá tak silnou kontrolu datových typů jako konkurenční CLR. Problémy nastaly především při implementaci seznamů, množin, vektorů a map, které jsou v JVM představovány obecnými datovými kontejnery (informace o generických datových typech jsou totiž odstraněny při překladu), ale v CLR je typová kontrola v této oblasti poněkud silnější. Nicméně se vraťme k dalším „alternativním“ implementacím jazyka Clojure. Další implementace nese název ClojureScript, a to z toho důvodu, že se programy napsané v Clojure nepřekládají do žádného bajtkódu virtuálního stroje, ale namísto toho se programy překládají (či přesněji řečeno transformují) do JavaScriptu. Díky tomu lze Clojure začít využívat i na těch místech, kde to původně nebylo možné – na webových stránkách (protože applety a JWS aplikace jsou již za svým zenitem) i na mobilních zařízeních, do nichž se mnohdy JVM neinstaluje z licenčních důvodů (viz též „kauzu Dalvik“).

2. JavaScript jako jeden z nejpoužívanějších programovacích jazyků na straně klienta

Programovací jazyk JavaScript pravděpodobně není zapotřebí čtenářům tohoto článku nijak podrobněji představovat. Tento jazyk se díky rozšíření webových prohlížečů a na nich postavených webových aplikací stal jedním z nejpoužívanějších programovacích jazyků na straně klientů (u serverů tomu tak – alespoň prozatím – není). Původně bylo možné JavaScript na klientech (tj. původně pouze ve webových prohlížečích) používat pouze ve velmi omezené míře, což velmi úzce souviselo s možnostmi nabízenými tehdejšími webovými prohlížeči a jazykem HTML. Webové stránky totiž nebylo možné s využitím skriptů modifikovat v takovém rozsahu jako dnes. Z tohoto důvodu se JavaScript používal pouze pro přidávání nových informací do stránky v době jejího načítání, v načtené stránce bylo možné číst a popř. i měnit informace zadávané do formulářů (jednořádkových i víceřádkových textových polí, checkboxů, listboxů a radio buttonů) a konečně mohl být JavaScript použit pro komunikaci mezi webovým klientem a pluginy, především pak s Javovskými applety. Tato funkcionalita, poprvé představená v Netscape Navigatoru pod názvem LiveConnext, je dodnes nabízena Java-pluginem.

Role JavaScriptu tedy byla ještě v dobách kralování „dvojkových“ a „trojkových“ verzí obou tehdy nejpoužívanějších prohlížečů (Netscape Navigator + Internet Explorer) ještě relativně malá a většina funkcí byla v případě webových aplikací soustředěna na server, který pro každý požadavek vygeneroval novou dynamickou stránku, v níž byl JavaScript použit například pro pouhou kontrolu dat zadávaných do formuláře, popř. pro jednodušší triky, jakým byla například změna obrázků. Skripty psané v JavaScriptu byly většinou poměrně krátké, jednoduché a tudíž i poměrně přehledné. Ovšem společně s tím, jak se měnily schopnosti webových klientů, zejména v oblasti DOM (celá stránka je reprezentována modifikovatelným stromem tagů a jejich atributů) a možnosti asynchronní komunikace se serverem (AJAX založený na objektu XMLHttpRequest), se postupně začala měnit i role JavaScriptu, který se začal ve webových aplikacích používat v mnohem větší míře.

3. JavaScript: assembler pro web?

JavaScript se ovšem začal kromě webových prohlížečů používat i v dalších oblastech, například (pokud zůstaneme v oblasti Linuxu) v Gnome Shellu, při vývoji ucelených mobilních aplikací a dokonce i v oblasti databází (CouchDB…). A právě při vývoji větších aplikací (dejme tomu o rozsahu deseti tisíc řádků a více) se ukazuje, že JavaScript nemusí být tím nejvhodnějším programovacím jazykem a bylo by lepší použít některý jiný vyšší programovací jazyk. Problém JavaScriptu spočívá především v tom, že není příliš robustní pro tvorbu skutečně rozsáhlých aplikací. Mnoho moderních webových aplikací je totiž založeno na jediné stránce s velkým objemem JavaScriptu a JS knihoven a pokud se vyžaduje komunikace se serverem, je provedena asynchronně s využitím AJAXu. Velká část funkcionality aplikace se tedy přenesla ze serveru na klienta. „Drobný zádrhel“ ovšem spočívá v tom, že není vůbec jednoduché prosadit nový programovací jazyk v tak decentralizované oblasti, jako jsou webové prohlížeče (i když několik pokusů zde bylo, například VB od Microsoftu či dále zmíněný Dart).

Tlaky na použití jiných vhodnějších programovacích jazyků vedly ke vzniku takzvaných transpřekladačů, což jsou překladače, výsledkem jejichž činnosti není strojový kód (jako u běžných překladačů), ale kód v jiném vyšším programovacím jazyce, v našem případě samozřejmě v JavaScriptu. Idea transpřekladačů není ve skutečnosti nijak nová, protože se podobné nástroje používaly již před mnoha lety například pro Fortran (přidání dalších jazykových konstrukcí), a i první verze jazyka C++ byly transformovány do Céčka. JavaScript je v současnosti cílovým jazykem hned několika dalších programovacích jazyků. Chronologicky seřazeno se jedná o jazyk CoffeeScript (2009), který do JS přidává některé vysokoúrovňové operace pro práci se seznamy atd., což prý průměrně vede k ušetření zhruba jedné třetiny řádků kódu. Dále pak existuje dnes již dosti známý jazyk Dart (2011, Google) taktéž překládaný do JS, i když existuje snaha podporovat tento jazyk přímo v prohlížečích. Novým jazykem v této oblasti je TypeScript (2012, MS) a do JS dokáže kód transformovat i transpřekladač jazyka Haxe (ten ovšem kromě toho podporuje i mnoho dalších cílových jazyků).

Poznámka: ve skutečnosti není JavaScript vůbec špatným jazykem a zejména pro tvorbu kratších aplikací se nejedná o špatnou volbu, což je asi jeden z důvodů, proč je podporován i v Gnome Shellu. Ovšem při pokusu o psaní robustních aplikací se začínají projevovat některé jeho nedostatky (problém se skutečnými jmennými prostory, chování smyčky for-each, objektový a typový systém …) a taktéž jeho „prototypový“ přístup některým vývojářům zvyklým na klasické OOP nemusí plně vyhovovat.

4. Základní vlastnosti ClojureScriptu

Tvůrci programovacího jazyka ClojureScript se mohli při jeho implementaci vydat dvěma směry. První směr spočívá v implementaci smyčky REPL programovacího jazyka Clojure přímo v JavaScriptu, takže by se aplikace psané v Clojure buď interpretovaly JavaScriptovým „enginem“, nebo by se transformovaly do JavaScriptu s využitím transpřekladače naprogramovaného taktéž v JavaScriptu. Toto řešení by tedy bylo z větší části postaveno přímo na programovacím jazyku JavaScript, což by však bylo poněkud paradoxní, když víme, že JavaScript nemusí být pro větší projekty tím nejvhodnějším řešením. Z tohoto důvodu se tvůrci ClojureScriptu rozhodli pro jiný postup – transpřekladač je naprogramován přímo v „nativním“ Clojure, což znamená, že pro jeho spuštění potřebujeme JVM a samozřejmě i samotný jazyk Clojure. Zbylá část nového jazyka, tj. makra a většina knihoven, je naprogramována přímo v ClojureScriptu, což znamená, že bylo možné se zcela vyhnout nutnosti mít nějaké zdrojové kódy napsané v nahrazovaném JavaScriptu.

ClojureScript v současnosti podporuje většinu základní funkcionality programovacího jazyka Clojure, včetně (nekonečných) sekvencí i čtyř strukturovaných datových typů – seznamů, vektorů, množin a map. K této základní funkcionalitě jsou dodávány knihovny, jejichž zdrojový kód se taktéž transformuje do JavaScriptu. Smyčka REPL je naprogramována v Clojure a dokáže překládat zadávané formy do JavaScriptu přímo v runtime, podobně jako v původním Clojure byl překlad prováděn do bajtkódu JVM. Aby však bylo možné zadanou formu (dejme tomu funkci) transformovat do JavaScriptu a posléze spustit, musí mít smyčka REPL možnost přístupu k interpretru JS. Ten je představován již zmíněným projektem Rhino. Kromě této základní smyčky REPL již vzniklo několik pokusů o implementaci REPL přímo ve webovém prohlížeči, což může mít velký dopad na rychlost vývoje a testování nových webových aplikací, podobně jako má existence smyčky REPL v původním Clojure velký dopad na vývoj či opravu „živých“ aplikací přímo na serveru, bez nutnosti jejich restartu.

5. Instalace překladače ClojureScriptu

V této kapitole si řekneme, jakým způsobem je možné získat zdrojové kódy ClojureScriptu a jak posléze tyto zdrojové kódy přeložit. ClojureScript s poměrně velkou pravděpodobností nebude na vašem systému k dispozici ve formě instalačního balíčku, proto je většinou nutné provést překlad vlastními silami, což však ve skutečnosti není příliš obtížné. Zdrojové kódy lze získat buď ve formě ZIP archivu vygenerovaného GitHubem, nebo (což je snazší) je možné získat poslední verzi zdrojových kódů přímo s využitím nástroje git (samozřejmě se předpokládá, že tento nástroj máte k dispozici). Postačuje se přemístit do adresáře, v němž se má celý projekt vytvořit a zapsat následující příkaz:

git clone git://github.com/clojure/clojurescript.git

Jakmile je vytvořena lokální adresářová struktura projektu, lze provést jeho překlad a následné otestování. Pro vlastní překlad je nutné mít nainstalováno JDK (OpenJDK…) alespoň ve verzi 6, a to z toho důvodu, že právě do této verze JDK byl přidán balíček Rhino, což je skriptovací engine určený pro programovací jazyk JavaScript (resp. jeho standard ECMA-262), který byl kompletně napsán v Javě a navíc byl uvolněn jako open-source. Překlad ClojureScriptu lze provést více způsoby, nejjednodušší je však použití shellového skriptu nazvaného bootstrap uloženého v adresáři script:

cd clojurescript
./script/bootstrap

V průběhu překladu dojde ke stažení dalších knihoven z Internetu, proto je vhodné sledovat, zda není downloading těchto souborů zablokován firewallem apod. Výsledkem překladu je několik archivů uložených v podadresáři lib.

Další informace o projektu Rhino (využitého například smyčkou REPL) lze nalézt na těchto stránkách:

  1. Rhino: JavaScript for Java
    http://www.mozilla.org/rhino
  2. JavaScript engine (Wikipedia)
    http://en.wikipedia.org/wi­ki/JavaScript_engine
  3. Rhino (JavaScript engine)
    http://en.wikipedia.org/wi­ki/Rhino_(JavaScript_engi­ne)
  4. Rhino: JavaScript for Java
    http://www.mozilla.org/rhino/
  5. Podpora skriptovacích jazyků v JDK6 a OpenJDK6
    http://www.root.cz/clanky/podpora-skriptovacich-jazyku-v-jdk6-a-openjdk6/
  6. Podpora skriptovacích jazyků v JDK6 a OpenJDK6 (2.část)
    http://www.root.cz/clanky/podpora-skriptovacich-jazyku-v-jdk6-a-openjdk6–2-cast/
  7. Podpora skriptovacích jazyků v JDK6 a OpenJDK6 (3.část)
    http://www.root.cz/clanky/podpora-skriptovacich-jazyku-v-jdk6-a-openjdk6–3-cast/
  8. JSR 223: Scripting for the JavaTM Platform
    http://jcp.org/en/jsr/detail?id=223
  9. JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform
    http://jcp.org/en/jsr/detail?id=292

6. Překlad programů z příkazové řádky a z REPL

Pokud se překlad transpřekladače ClojureScriptu podařil, můžeme si vyzkoušet provést transformaci zdrojového kódu naprogramovaného v Clojure do JavaScriptu. Nejprve je zapotřebí vytvořit soubor obsahující nějaký jednoduchý zdrojový text. Bude se jednat o soubor s názvem test.cljs, jenž bude obsahovat jediný řádek kódu:

(println "Hello world!")

Překlad, či přesněji řečeno transformaci tohoto zdrojového textu do JavaScriptu, lze provést nejjednodušeji z příkazové řádky nástrojem cljsc, který se nachází v podadresáři bin:

$ ./bin/cljsc test.cljs > test.js

Pokud skončí překlad/transformace s chybou, je nutné zkontrolovat, zda se v podadresáři lib nacházejí všechny potřebné knihovny – clojure*.jar, rhino.jar atd.

Alternativně lze tomuto nástroji předat i další parametry. V následujícím příkladu je zapnuta optimalizace výsledného JavaScriptového kódu prováděná přes Google Closure (Closure, nikoli Clojure – zde je shoda jmen v podstatě jen náhodná):

$ ./bin/cljsc test.cljs '{:optimizations :advanced}' > test.js

Při vývoji je mnohdy výhodné spustit překlad přímo ze smyčky REPL. I to je samozřejmě možné, postačuje zavolat funkci build ze jmenného prostoru cljsc:

(cljsc/build "test.cljs" {:optimizations :advanced :output-to "test.js"})

7. Použití přeložených skriptů na webové stránce

V dalším demonstračním příkladu bude ukázán překlad a následné použití přeloženého skriptu na webové stránce. Použijeme poněkud komplikovanější zdrojový text, v němž je deklarována funkce nazvaná hello_world, která se nachází ve jmenném prostoru hello. Povšimněte si, že se ve jméně této funkce nepoužívá pomlčka, jak je tomu v LISPovských jazycích zvykem, protože by došlo k problémům při následném volání transformované funkce z JavaScriptu. Dále je u této funkce nastaven atribut export:

widgety

; vytvoreni noveho jmenneho prostoru
(ns hello)
 
; deklarace funkce hello_world ve jmennem prostoru hello
(defn ^:export hello_world [message]
  (str "Hello " message))

Překlad se opět provede s využitím nástroje ./bin/cljsc; výsledné skripty by měly být uloženy v podadresáři out (pokud neexistuje, je tento adresář automaticky vytvořen). Vytvořený skript lze otestovat přímo na webové stránce, kde je pouze zapotřebí upravit cesty v případě, že bude stránka umístěna na serveru (ovšem nejjednodušší je stránku prostě vytvořit tam, kde jsou uloženy skripty a přímo ji otevřít v prohlížeči):

<html>
 
    <head>
        <title>ClojureScript test</title>
        <script type="text/javascript" src="out/goog/base.js"></script>
        <script type="text/javascript" src="hello.js"></script>
        <script type="text/javascript">goog.require('hello');</script>
    </head>
 
    <body>
        <h1>ClojureScript test</h1>
        <script type="text/javascript">
            alert(hello.hello_world("ClojureScript"));
        </script>
    </body>
 
</html>

8. Clojure na straně klienta i na straně serveru

Díky existenci ClojureScriptu je možné programovací jazyk Clojure využít jak na straně klienta, tak i na straně serveru. To může programátorům ulehčit vývoj, protože je například možné jak na serveru, tak i na klientu použít stejné datové struktury založené na seznamech, vektorech, množinách a mapách. Teoreticky by taktéž bylo možné implementovat například agenty na serveru, kteří by čekali na událost vzniklou ve webovém prohlížeči, ovšem namísto ručního programování je vhodnější využít již hotovou funkcionalitu nabízenou například knihovnou ClojureScript One, jejíž zdrojové kódy jsou dostupné na adrese https://github.com/brento­nashworth/one. Možnostmi nabízenými touto knihovnou se možná budeme zabývat v některém z dalších pokračování tohoto seriálu.

9. Odkazy na Internetu

  1. ClojureScript One: Index
    http://clojurescriptone.com/in­dex.html
  2. ClojureScript One: Documentation
    http://clojurescriptone.com/do­cumentation.html
  3. ClojureScript One: Wiki
    https://github.com/brento­nashworth/one/wiki
  4. ClojureScript: Quick Start
    https://github.com/clojure/clo­jurescript/wiki/Quick-Start
  5. Getting Started with ClojureScript (and FW/1)
    http://corfield.org/entry/getting-started-with-clojurescript-and-fw-1
  6. First ClojureScript experiences: using Raphaël
    http://maurits.wordpress.com/2012/02/13/fir­st-clojurescript-experiences-using-raphael/
  7. Raphaël-JavaScript Library
    http://raphaeljs.com/
  8. A detailed installation Guide for VimClojure 2.2
    http://www.duenas.at/new_ho­mepage/vimclojure
  9. VimClojure : A filetype, syntax and indent plugin for Clojure
    http://www.vim.org/scripts/scrip­t.php?script_id=2501
  10. Nailgun server
    http://www.martiansoftware­.com/nailgun/background.html
  11. SLIME (Wikipedia)
    http://en.wikipedia.org/wiki/SLIME
  12. slime.vim
    http://s3.amazonaws.com/mps/slime.vim
  13. Textový editor Vim jako IDE: 1. část
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide/
  14. Textový editor Vim jako IDE: 2. část
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-2-cast/
  15. Textový editor Vim jako IDE: 3. část (omni completion)
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-3-cast/
  16. Textový editor Vim jako IDE: 4. část
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-4-cast/
  17. Textový editor Vim jako IDE: 5. část
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-5-cast/
  18. Textový editor Vim jako IDE: 6. část – Vim Script
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-6-cast-vim-script/
  19. Textový editor Vim jako IDE: 7. část – Vim Script
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-7-cast-vim-script/
  20. Textový editor Vim jako IDE: 8. část
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-8-cast/
  21. Textový editor Vim jako IDE: 9. část – pluginy Netrw a snipMate
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-9-cast-pluginy-netrw-a-snipmate/
  22. Textový editor Vim jako IDE: 10. část – různé tipy a triky
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-10-cast-ruzne-tipy-a-triky/
  23. Přenos textů mezi Vimem a dalšími aplikacemi
    http://www.root.cz/clanky/prenos-textu-mezi-vimem-a-dalsimi-aplikacemi/
  24. Textový editor Vim: konfigurace pravítka a stavového řádku
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-12-cast-konfigurace-pravitka-a-stavoveho-radku/
  25. Textový editor Vim: automatické formátování textů
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-14-cast-automaticke-formatovani-textu/
  26. Textový editor Vim: automatické formátování textů
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-automaticke-formatovani-textu-dokonceni/
  27. Textový editor Vim: editace XML a HTML
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-15-cast-editace-xml-a-html/
  28. Textový editor Vim: kooperace mezi Vimem a skripty
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-16-cast-kooperace-mezi-vimem-a-skriptovacimi-jazyky/
  29. Textový editor Vim: kooperace mezi Vimem a jazykem Perl
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-17-cast-kooperace-mezi-vimem-a-jazykem-perl/
  30. Textový editor Vim: konfigurace a překlad Vimu
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-18-cast-konfigurace-a-preklad-vimu/
  31. Counterclockwise
    http://code.google.com/p/cou­nterclockwise/
  32. Clojure IDEs – The Grand Tour
    http://www.bestinclass.dk/in­dex.clj/2010/03/clojure-ides-the-grand-tour-getting-started.html
  33. Light Table – a new IDE concept
    http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concept/
  34. SICP (The Structure and Interpretation of Computer Programs)
    http://mitpress.mit.edu/sicp/
  35. Pure function
    http://en.wikipedia.org/wi­ki/Pure_function
  36. Funkcionální programování
    http://cs.wikipedia.org/wi­ki/Funkcionální_programová­ní
  37. Čistě funkcionální (datové struktury, jazyky, programování)
    http://cs.wikipedia.org/wi­ki/Čistě_funkcionální
  38. 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
  39. Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html
  40. Clojure Macro Tutorial (Part III: Syntax Quote)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html
  41. Tech behind Tech: Clojure Macros Simplified
    http://techbehindtech.com/2010/09/28/clo­jure-macros-simplified/
  42. Fatvat – Exploring functional programming: Clojure Macros
    http://www.fatvat.co.uk/2009/02/clo­jure-macros.html
  43. Eulerovo číslo
    http://cs.wikipedia.org/wi­ki/Eulerovo_číslo
  44. List comprehension
    http://en.wikipedia.org/wi­ki/List_comprehension
  45. List Comprehensions in Clojure
    http://asymmetrical-view.com/2008/11/18/list-comprehensions-in-clojure.html
  46. Clojure Programming Concepts: List Comprehension
    http://en.wikibooks.org/wi­ki/Clojure_Programming/Con­cepts#List_Comprehension
  47. Clojure core API: for macro
    http://clojure.github.com/clo­jure/clojure.core-api.html#clojure.core/for
  48. cirrus machina – The Clojure for macro
    http://www.cirrusmachina.com/blog/com­ment/the-clojure-for-macro/
  49. Clojure.org: Clojure home page
    http://clojure.org/downloads
  50. Clojure.org: Vars and the Global Environment
    http://clojure.org/Vars
  51. Clojure.org: Refs and Transactions
    http://clojure.org/Refs
  52. Clojure.org: Atoms
    http://clojure.org/Atoms
  53. Clojure.org: Agents as Asynchronous Actions
    http://clojure.org/agents
  54. A Couple of Clojure Agent Examples
    http://lethain.com/a-couple-of-clojure-agent-examples/
  55. Clojure – Functional Programming for the JVM
    http://java.ociweb.com/mar­k/clojure/article.html
  56. Clojure quick reference
    http://faustus.webatu.com/clj-quick-ref.html
  57. 4Clojure
    http://www.4clojure.com/
  58. ClojureDoc
    http://clojuredocs.org/
  59. Clojure (Wikipedia EN)
    http://en.wikipedia.org/wiki/Clojure
  60. Clojure (Wikipedia CS)
    http://cs.wikipedia.org/wiki/Clojure
  61. Riastradh's Lisp Style Rules
    http://mumble.net/~campbe­ll/scheme/style.txt
  62. Dynamic Languages Strike Back
    http://steve-yegge.blogspot.cz/2008/05/dynamic-languages-strike-back.html
  63. Scripting: Higher Level Programming for the 21st Century
    http://www.tcl.tk/doc/scripting.html
  64. Java Virtual Machine Support for Non-Java Languages
    http://docs.oracle.com/ja­vase/7/docs/technotes/gui­des/vm/multiple-language-support.html
  65. New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
    http://java.sun.com/develo­per/technicalArticles/Dyn­TypeLang/
  66. JSR 223: Scripting for the JavaTM Platform
    http://jcp.org/en/jsr/detail?id=223
  67. JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform
    http://jcp.org/en/jsr/detail?id=292
  68. Java 7: A complete invokedynamic example
    http://niklasschlimm.blog­spot.com/2012/02/java-7-complete-invokedynamic-example.html
  69. InvokeDynamic: Actually Useful?
    http://blog.headius.com/2007/01/in­vokedynamic-actually-useful.html
  70. A First Taste of InvokeDynamic
    http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html
  71. Java 6 try/finally compilation without jsr/ret
    http://cliffhacks.blogspot­.com/2008/02/java-6-tryfinally-compilation-without.html
  72. An empirical study of Java bytecode programs
    http://www.mendeley.com/research/an-empirical-study-of-java-bytecode-programs/
  73. Java quick guide: JVM Instruction Set (tabulka všech instrukcí JVM)
    http://www.mobilefish.com/tu­torials/java/java_quickgu­ide_jvm_instruction_set.html
  74. The JVM Instruction Set
    http://mpdeboer.home.xs4a­ll.nl/scriptie/node14.html
  75. Control Flow in the Java Virtual Machine
    http://www.artima.com/under­thehood/flowP.html
  76. Root.cz: Využití komprimovaných ukazatelů na objekty v JVM
    http://www.root.cz/clanky/vyuziti-komprimovanych-ukazatelu-na-objekty-v-nbsp-jvm/
  77. Root.cz: JamVM aneb alternativa k HotSpotu nejenom pro embedded zařízení a chytré telefony
    http://www.root.cz/clanky/jamvm-aneb-alternativa-k-hotspotu-nejenom-pro-embedded-zarizeni-tablety-a-chytre-telefony/
  78. The JavaTM Virtual Machine Specification, Second Edition
    http://java.sun.com/docs/bo­oks/jvms/second_edition/html/VMSpec­TOC.doc.html
  79. The class File Format
    http://java.sun.com/docs/bo­oks/jvms/second_edition/html/Clas­sFile.doc.html
  80. javap – The Java Class File Disassembler
    http://docs.oracle.com/ja­vase/1.4.2/docs/tooldocs/win­dows/javap.html
  81. javap-java-1.6.0-openjdk(1) – Linux man page
    http://linux.die.net/man/1/javap-java-1.6.0-openjdk
  82. Using javap
    http://www.idevelopment.in­fo/data/Programming/java/mis­cellaneous_java/Using_javap­.html
  83. Examine class files with the javap command
    http://www.techrepublic.com/ar­ticle/examine-class-files-with-the-javap-command/5815354
  84. BCEL Home page
    http://commons.apache.org/bcel/
  85. BCEL Manual
    http://commons.apache.org/bcel/ma­nual.html
  86. Byte Code Engineering Library (Wikipedia)
    http://en.wikipedia.org/wiki/BCEL
  87. Java programming dynamics, Part 7: Bytecode engineering with BCEL
    http://www.ibm.com/develo­perworks/java/library/j-dyn0414/
  88. Bytecode Engineering
    http://book.chinaunix.net/spe­cial/ebook/Core_Java2_Volu­me2AF/0131118269/ch13lev1sec6­.html
  89. BCEL Tutorial
    http://www.smfsupport.com/sup­port/java/bcel-tutorial!/
  90. ASM Home page
    http://asm.ow2.org/
  91. Seznam nástrojů využívajících projekt ASM
    http://asm.ow2.org/users.html
  92. ObjectWeb ASM (Wikipedia)
    http://en.wikipedia.org/wi­ki/ObjectWeb_ASM
  93. Java Bytecode BCEL vs ASM
    http://james.onegoodcooki­e.com/2005/10/26/java-bytecode-bcel-vs-asm/
  94. Bytecode Outline plugin for Eclipse (screenshoty + info)
    http://asm.ow2.org/eclipse/index.html
  95. aspectj (Eclipse)
    http://www.eclipse.org/aspectj/
  96. Aspect-oriented programming (Wikipedia)
    http://en.wikipedia.org/wi­ki/Aspect_oriented_program­ming
  97. AspectJ (Wikipedia)
    http://en.wikipedia.org/wiki/AspectJ
  98. EMMA: a free Java code coverage tool
    http://emma.sourceforge.net/
  99. Cobertura
    http://cobertura.sourceforge.net/
  100. FindBugs
    http://findbugs.sourceforge.net/
  101. GNU Classpath
    www.gnu.org/s/classpath/
  102. Java VMs Compared
    http://bugblogger.com/java-vms-compared-160/
  103. JSRs: Java Specification Requests – JSR 223: Scripting for the Java Platform
    http://www.jcp.org/en/jsr/de­tail?id=223
  104. Scripting for the Java Platform
    http://java.sun.com/develo­per/technicalArticles/J2SE/Des­ktop/scripting/
  105. Scripting for the Java Platform (Wikipedia)
    http://en.wikipedia.org/wi­ki/Scripting_for_the_Java_Plat­form
  106. Java Community Process
    http://en.wikipedia.org/wi­ki/Java_Specification_Requ­est
  107. Java HotSpot VM Options
    http://www.oracle.com/technet­work/java/javase/tech/vmop­tions-jsp-140102.html
  108. Great Computer Language Shootout
    http://c2.com/cgi/wiki?Gre­atComputerLanguageShootout
  109. Java performance
    http://en.wikipedia.org/wi­ki/Java_performance
  110. Trying the prototype
    http://mail.openjdk.java.net/pi­permail/lambda-dev/2010-August/002179.html
  111. Better closures (for Java)
    http://blogs.sun.com/jrose/en­try/better_closures
  112. Lambdas in Java: An In-Depth Analysis
    http://www.infoq.com/articles/lambdas-java-analysis
  113. Class ReflectiveOperationException
    http://download.java.net/jdk7/doc­s/api/java/lang/Reflective­OperationException.html
  114. Scala Programming Language
    http://www.scala-lang.org/
  115. Run Scala in Apache Tomcat in 10 minutes
    http://www.softwaresecret­weapons.com/jspwiki/run-scala-in-apache-tomcat-in-10-minutes
  116. Fast Web Development With Scala
    http://chasethedevil.blog­spot.cz/2007/09/fast-web-development-with-scala.html
  117. Top five scripting languages on the JVM
    http://www.infoworld.com/d/developer-world/top-five-scripting-languages-the-jvm-855
  118. Proposal: Indexing access syntax for Lists and Maps
    http://mail.openjdk.java.net/pi­permail/coin-dev/2009-March/001108.html
  119. Proposal: Elvis and Other Null-Safe Operators
    http://mail.openjdk.java.net/pi­permail/coin-dev/2009-March/000047.html
  120. Java 7 : Oracle pushes a first version of closures
    http://www.baptiste-wicht.com/2010/05/oracle-pushes-a-first-version-of-closures/
  121. Groovy: An agile dynamic language for the Java Platform
    http://groovy.codehaus.org/Operators
  122. Better Strategies for Null Handling in Java
    http://www.slideshare.net/Step­han.Schmidt/better-strategies-for-null-handling-in-java
  123. Control Flow in the Java Virtual Machine
    http://www.artima.com/under­thehood/flowP.html
  124. Java Virtual Machine
    http://en.wikipedia.org/wi­ki/Java_virtual_machine
  125. ==, .equals(), compareTo(), and compare()
    http://leepoint.net/notes-java/data/expressions/22com­pareobjects.html
  126. New JDK7 features
    http://openjdk.java.net/pro­jects/jdk7/features/
  127. Project Coin: Bringing it to a Close(able)
    http://blogs.sun.com/darcy/en­try/project_coin_bring_clo­se
  128. CloseableFinder source code
    http://blogs.sun.com/darcy/re­source/ProjectCoin/Closea­bleFinder.java
  129. Joe Darcy blog about JDK
    http://blogs.sun.com/darcy
  130. Java 7 – more dynamics
    http://www.baptiste-wicht.com/2010/04/java-7-more-dynamics/
  131. New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
    http://java.sun.com/develo­per/technicalArticles/Dyn­TypeLang/index.html
Našli jste v článku chybu?
Lupa.cz: Hackeři mají data z půlmiliardy účtů Yahoo

Hackeři mají data z půlmiliardy účtů Yahoo

120na80.cz: Co je padesátkrát sladší než cukr?

Co je padesátkrát sladší než cukr?

Vitalia.cz: Jaký je rozdíl mezi brambůrky a chipsy?

Jaký je rozdíl mezi brambůrky a chipsy?

DigiZone.cz: Test: brýle pro virtuální realitu Exos Urban

Test: brýle pro virtuální realitu Exos Urban

Podnikatel.cz: Zorientujte se. Odkdy se vás týká EET?

Zorientujte se. Odkdy se vás týká EET?

Vitalia.cz: Kterou dýni můžete jíst za syrova?

Kterou dýni můžete jíst za syrova?

Vitalia.cz: Když všichni seli řepku, on vsadil na dýně

Když všichni seli řepku, on vsadil na dýně

Podnikatel.cz: Znáte už 5 novinek k #EET

Znáte už 5 novinek k #EET

Podnikatel.cz: Instalatér, malíř a elektrikář. "Vymřou"?

Instalatér, malíř a elektrikář. "Vymřou"?

DigiZone.cz: Světový pohár v přímém přenosu na ČT

Světový pohár v přímém přenosu na ČT

DigiZone.cz: Ginx TV: pořad o počítačových hráčích

Ginx TV: pořad o počítačových hráčích

Podnikatel.cz: Babišovi se nedá věřit, stěžovali si hospodští

Babišovi se nedá věřit, stěžovali si hospodští

DigiZone.cz: Funbox 4K v DVB-T2 má ostrý provoz

Funbox 4K v DVB-T2 má ostrý provoz

Podnikatel.cz: Byla finanční manažerka, teď cvičí jógu

Byla finanční manažerka, teď cvičí jógu

Vitalia.cz: Tahák, jak vyzrát nad zápachem z úst

Tahák, jak vyzrát nad zápachem z úst

Vitalia.cz: Tohle jsou nejlepší česká piva podle odborníků

Tohle jsou nejlepší česká piva podle odborníků

DigiZone.cz: Parlamentní listy: kde končí PR...

Parlamentní listy: kde končí PR...

Podnikatel.cz: EET pro e-shopy? Postavené na hlavu

EET pro e-shopy? Postavené na hlavu

Lupa.cz: Další Češi si nechali vložit do těla čip

Další Češi si nechali vložit do těla čip

Podnikatel.cz: Dva měsíce na EET. Budou stačit?

Dva měsíce na EET. Budou stačit?