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

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 Java^TM Platform
   http://jcp.org/en/jsr/detail?id=223
9. JSR 292: Supporting Dynamically Typed Languages on the Java^TM 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:

; 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 Java^TM Platform
    http://jcp.org/en/jsr/detail?id=223
67. JSR 292: Supporting Dynamically Typed Languages on the Java^TM 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 Java^TM 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