Programovací jazyk Clojure 19: vývojová prostředí pro Clojure

Obsah

1. Programovací jazyk Clojure 19: vývojová prostředí pro Clojure

2. Projekt Counterclockwise aneb integrace Clojure do vývojového prostředí Eclipse

3. Vývoj aplikací v cyklu Edit-Compile-Run versus interaktivní způsob práce s jazykem

4. Postup instalace pluginu Counterclockwise do Eclipse

5. Vytvoření nového projektu

6. Tvorba zdrojových textů, nastavení vlastností pluginu Counterclockwise

7. Využití smyčky REPL přímo z Eclipse (interaktivní konzole)

8. Obsah následující části seriálu

9. Odkazy na Internetu

1. Programovací jazyk Clojure 19: vývojová prostředí pro Clojure

Až doposud jsme si při popisu programovacího jazyka Clojure i při uvádění demonstračních příkladů napsaných v tomto jazyce vystačili s „pouhou“ interaktivní smyčkou REPL (Read-Eval-Print-Loop), popř. s překladem aplikací uložených ve zdrojových souborech, u nichž je zvykem používat koncovku .clj, přímo do bajtkódu JVM (překlad může být vyvolán buď ze smyčky REPL, popř. ho je možné provést z příkazového řádku). S využitím interaktivní smyčky REPL zkombinované s textovým editorem je sice možné vytvářet i poměrně složité aplikace, ovšem mnozí programátoři namísto toho preferují využití vhodných integrovaných vývojových prostředí – IDE. V případě programovacího jazyka Clojure lze využít všechny tři nejznámější (nejenom) javovská IDE, tj. Eclipse, Netbeans i IDEU, protože pro všechna zmíněná integrovaná vývojová prostředí existují nadstavby (resp. přesněji řečeno zásuvné moduly – pluginy) umožňující editaci zdrojových kódů v Clojure i přímou komunikaci s paralelně běžící smyčkou REPL.

My se budeme nejdříve zabývat popisem pluginu Counterclockwise, jenž byl vytvořen pro použití v integrovaném vývojovém prostředí Eclipse. Eclipse je sice některými programátory chápáno jako vývojové prostředí určené primárně pro vývoj aplikací v Javě (Eclipse JDT, Eclipse for Java EE Developers), ovšem ve skutečnosti se jedná o nástroj s mnohem většími ambicemi, který může velmi dobře posloužit jako univerzální platforma využívaná i dalšími programovacími jazyky. Vývoj projektu Eclipse byl zahájen na přelomu tisíciletí ve společnosti IBM a v současnosti se jedná o aplikaci šířenou pod licencí EPL. EPL je licence v některých ohledech poněkud odlišná od známé GNU GPL, to však nijak neovlivňuje možnosti použití Eclipse ve funkci IDE. Původně se mělo jednat o integrované vývojové prostředí (IDE), které mělo představovat alternativu k tehdy již existujícímu prostředí Visual Age založeného na programovacím jazyku Smalltalk (toto prostředí je nicméně stále nabízeno, používáno a existuje okolo něj loajální komunita).

Eclipse však je, na rozdíl od již zmíněného prostředí Visual Age, postaveno na programovacím jazyku Java, čímž je zaručena jeho poměrně snadná přenositelnost na různé platformy (při troše snahy je dokonce možné Eclipse spustit i na tak poměrně nevýkonném zařízení, jako je Raspberry Pi). Samotné jádro projektu Eclipse je relativně malé, zejména v porovnání s některými „monolitickými“ vývojovými prostředími, ovšem díky koncepci rozšiřujících modulů je možné do Eclipse přidávat další funkce – nové typy editorů zdrojových textů, podporu pro další programovací či značkovací jazyky, ladicí nástroje, profilery, návrháře grafického uživatelského rozhraní, napojení na aplikační servery atd. Právě díky této otevřenosti platformy Eclipse bylo možné poměrně snadno vytvořit plugin Counterclockwise, jehož popisem se budeme zabývat v navazujících kapitolách.

2. Projekt Counterclockwise aneb integrace Clojure do vývojového prostředí Eclipse

Jak jsme si již řekli v předchozí kapitole, je projekt Counterclockwise vytvořen ve formě přídavného modulu (pluginu), který se instaluje do integrovaného vývojového prostředí Eclipse (verze 3.5 nebo vyšší). Funkce, které tento plugin nabízí vývojářům, lze zhruba rozdělit do tří částí. Jedná se především o správu projektů, kde se pod pojmem „projekt“ myslí množina zdrojových kódů (.clj), která může být spravována jako jeden celek. Celý projekt je tedy možné synchronizovat s lokálním či vzdáleným repositářem, vlastnosti editoru zdrojových textů lze nastavit pro každý projekt zvlášť atd. Druhou částí pluginu Counterclockwise je, jak zajisté očekáváte, specializovaný textový editor navržený takovým způsobem, aby vývojářům co nejvíce ulehčil zápis programů a samozřejmě i jejich následnou úpravu, včetně refaktoringu.

Můžeme zde tedy najít funkci pro zformátování zdrojového textu, zvýraznění párových závorek (to je zde kvůli poněkud specifickému zápisu programového kódu mnohem důležitější než například v Javě), zvýraznění bloku, v němž chybí pravá či levá závorka, doplňování názvů symbolů či jmen javovských metod, zobrazení dokumentace k právě zapisovanému názvu funkce či makra atd. Většinou se tento editor chová stejným způsobem, jako editor určený pro zápis javovských zdrojových kódů, což znamená i použití shodných klávesových zkratek, například Ctrl+Space pro vyhledání a následné doplnění jména symbolu atd.

Obrázek 1: Na tomto screenshotu jsou zobrazeny některé základní funkce nabízené pluginem Counterclockwise. V horní části můžeme vidět textový editor, který samozřejmě zvýrazňuje syntaxi (dokáže například rozeznat volání funkce a volání metody), včetně obarvení párových závorek různou barvou (párové závorky mají vždy stejnou barvu, která je odlišná od jiných párů závorek). V dolní části screenshotu můžeme vidět interaktivní konzoli, o níž se zmíníme v dalším textu. Editor dále dokáže doplňovat jména funkcí/metod (dialog s bílým pozadím uprostřed) a u vybírané funkce se navíc zobrazuje i počet jejich parametrů a nápověda (dialog se žlutým pozadím napravo). Informace o funkcích jsou získány přímo z jejich definic – jedná se o informaci, jenž lze získat například s využitím (doc funkce).

3. Vývoj aplikací v cyklu Edit-Compile-Run versus interaktivní způsob práce s jazykem

Ovšem existence editoru specializovaného na editaci zdrojových kódů napsaných v programovacím jazyku Clojure není zdaleka vše, co nám projekt Counterclockwise nabízí (na to by nám ostatně stačil jen vhodně nakonfigurovaný Vim), protože způsob vývoje v programovacím jazyce Clojure se v mnoha ohledech přibližuje způsobu vývoje v IPythonu, Logu, Matlabu, Squeaku a podobných interaktivních vývojových prostředích (dnes již možná i poněkud kuriózním příkladem je prostředí jazyka Forth). Counterclockwise totiž umožňuje, aby se vývojové prostředí Eclipse připojilo k serveru s běžícím interpretrem Clojure, díky čemuž je možné, aby programátoři interaktivně zapisovali výrazy (formy) na interaktivní konzoli a tyto výrazy byly následně ihned vyhodnoceny podobným způsobem, jako je tomu při přímém spuštění interpretru Clojure v terminálu (s tím rozdílem, že konzole podporuje zvýraznění syntaxe, doplňování kódu, zobrazení dokumentace atd. atd.).

Obrázek 2: Hlavní menu vývojového prostředí Turbo Pascalu 1.0, na němž je velmi názorně vidět rozdělení vývoje do minimálně tří kroků: Edit, Compile, Run. Dnes je sice Turbo Pascal 1.0 muzeálním kouskem (tato verze pochází z roku 1983!), ovšem ve skutečnosti se v mnoha programovacích jazycích doposud vývoj stále rozděluje do zmíněných tří kroků, což sice nemusí být špatné řešení, ale mnohdy se nejedná o řešení nejrychlejší ani o řešení nejflexibilnější.

Je pravdou, že programátoři využívající programovací jazyky typu C, C++, C# či Java (pokud mám jmenovat ty nejpopulárnější kompilované programovací jazyky) tento interaktivní způsob vývoje většinou nepoužívají, protože jsou omezeni nutností rozdělit vývoj do tří oddělených kroků: editaci zdrojových textů, jejich překlad (někdy i slinkování) a spuštění výsledného binárního kódu. V případě programovacího jazyka Clojure a jeho interaktivní smyčky REPL se tyto kroky vlastně slévají v jediný kontinuální proces práce: vývojář může měnit kód „živé“ aplikace, může testovat jednotlivé funkce, měnit prostředí běžící aplikace atd. Tento kontinuální způsob vývoje a současného testování programů byl ostatně použit i v „pradávných“ interpretrech programovacího jazyka BASIC. Dokonce si dovolím říci, že právě zmíněná interaktivita BASICu činila tento jinak dosti omezený a dalo by se i říci, že špatně navržený jazyk tak přitažlivým pro začínající programátory.

Obrázek 3: Ukázka grafického uživatelského rozhraní projektu Squeak, v němž lze přímo měnit vlastnosti „živých“ objektů, posílat jim zprávy atd. Dokonce je možné přímo za běhu měnit vlastnosti samotného Squeaku.

4. Postup instalace pluginu Counterclockwise do Eclipse

V této kapitole si na sekvenci několika screenshotů ukážeme, jakým způsobem je možné do integrovaného vývojového prostředí Eclipse nainstalovat plugin Counterclockwise. Instalaci je možné provést buď ručně – pouhým zkopírováním všech potřebných balíčků do podadresáře eclipse/plugins – nebo komfortněji s využitím nástroje pro instalaci pluginů, který je přímo součástí Eclipse. Druhá možnost instalace pluginu je navíc i bezpečnější, protože se společně s pluginem automaticky doinstalují i potřebné závislosti. Instalaci pluginu Counterclockwise jsem prováděl do Eclipse JDT, což je základ platformy Eclipse doplněný o pluginy určené pro vývoj aplikací v programovacím jazyku Java (přesněji Java SE). Teoreticky je však možné Counterclockwise instalovat i do Eclipse for Java EE Developers či naopak do „pouhé“ základní instalace Eclipse od verze 3.5, ovšem to v praxi nedává příliš smysl, protože se programovací jazyk Clojure většinou používá současně s vývojem podpůrných modulů v Javě. Pro samotný běh Eclipse je samozřejmě nutné mít nainstalovanou i JVM, ideálně verze 6 či 7 (Oracle JDK, OpenJDK, IBM Java, …).

Obrázek 4: Nové přídavné moduly se do integrovaného vývojového prostředí Eclipse instalují (uznávám, že poněkud nelogicky) příkazem Help→Install New Software vyvolaným z hlavního menu.

Obrázek 5: Před instalací přídavného modulu Counterclockwise je nejprve nutné do Eclipse přidat umístění repositáře, v němž je tento modul uložen na Internetu. To se provede tlačítkem Add…, po jehož stisku se zobrazí formulář zobrazený na tomto screenshotu. Ve formuláři stačí vyplnit obě pole – jméno je libovolné, umístění repositáře je vždy http://ccw.cgrand.net/updatesite/.

Obrázek 6: Eclipse následně prozkoumá obsah repositáře a posléze nabídne ke stažení a instalaci v něm přítomné moduly. V našem případě je situace velmi jednoduchá, protože repositář obsahuje jen jediný plugin. Ten je nutné vybrat (zatržený checkbox) a poté stisknout tlačítko Next >.

Obrázek 7: Detaily s informacemi o instalovaném pluginu.

Obrázek 8: Společně s pluginem Counterclockwise se budou instalovat i závislé pluginy. V případě, že je Counterclockwise instalován do Eclipse JDT, měl by seznam závislých pluginů být relativně krátký, ovšem v mém případě je tomu jinak, jelikož jsem již dříve odinstaloval plugin Mylyn (popravdě řečeno mi není zřejmé, proč je již v základní instalaci Eclipse JDT :-). Na tomto formuláři je nutné hromadně odsouhlasit licenci – viz též dvojice radio buttonů zobrazená v pravé dolní části formuláře.

Obrázek 9: Instalace může probíhat buď na pozadí, nebo je možné ponechat zobrazen dialog s podrobnostmi o instalaci. Na závěr je nutné Eclipse restartovat. Pracovní prostředí se však restartem nezmění, pouze přibudou další položky v hlavním menu i některé nové pohledy (views).

5. Vytvoření nového projektu

Prakticky ihned po restartu integrovaného vývojového prostředí Eclipse je možné si vyzkoušet způsob vývoje aplikací v programovacím jazyce Clojure přímo v IDE. Nejdříve je však nutné vytvořit nový projekt, což je velmi snadné, protože se použije prakticky stejný postup, jaký se používá při tvorbě nového projektu v Javě, Pythonu atd. (záleží jen na tom, podpora pro které jazyky je v Eclipse v daném okamžiku nainstalována). Postup při tvorbě nového projektu je opět ukázán na několika (vlastně pouze na dvou) screenshotech. Vytvoření nového „Clojure“ projektu je možné dosáhnout hned několika způsoby. Buď se z hlavního menu vybere příkaz: File → New → Project, nebo se stlačí pravé tlačítko myši na pohledu „Package Explorer“ a vybere se příkaz New → Project, popř. se alternativně na hlavní nástrojové liště vybere první ikona zleva, která zobrazuje okno se značkou plus (+).

Ve všech případech integrované vývojové prostředí Eclipse zobrazí nový dialog, v němž lze vybrat typ projektu. Obsah tohoto dialogu je zobrazen na obrázku číslo 10 (konkrétní položky zde zobrazené se ve skutečnosti mohou lišit v závislosti na tom, jaké moduly jsou v Eclipse v daný okamžik nainstalovány:

Obrázek 10: Dialog „New Project“. V tomto dialogu je nejprve nutné najít a rozbalit uzel s názvem „Clojure“ a posléze v něm vybrat položku nazvanou „Clojure Project“. V případě, že tento uzel a/nebo položku v něm nemůžete najít, znamená to s velkou pravděpodobností, že se plugin Counterclockwise buď vůbec nenainstaloval, nebo došlo k nějakému problému při jeho inicializaci. Detaily je většinou možné najít v menu Help pod položkou About Eclipse, která zobrazí dialog, v němž lze vyčíst informace o všech aktuálně nainstalovaných pluginech. Při hledání případných chyb lze taktéž použít příkaz Window → Show View → Error Log, popř. prozkoumat obsah podadresáře eclipse/plugins.

Obrázek 11: Nastavení vlastností projektu Clojure je ve skutečnosti velmi jednoduché, protože v mnoha případech pouze dostačuje zvolit jméno projektu a následně stlačit tlačítko Finish. Po stisku tohoto tlačítka se řízení vrátí zpět na pracovní plochu, kde je (většinou) zobrazena perspektiva Java.

6. Tvorba zdrojových textů, nastavení vlastností pluginu Counterclockwise

Po vytvoření nového projektu by se tento projekt měl objevit v okně Package Explorer, samozřejmě pod jménem zadaném uživatelem. Důležitý je především adresář src, do něhož jsou ukládány jednotlivé zdrojové soubory, které mají většinou koncovku .clj (zdrojové soubory neukládejte do jiného adresáře, neboť by je Eclipse správně nezpracovalo). Definice jednotlivých funkcí a maker jsou většinou rozděleny do většího množství souborů, přičemž každý soubor odpovídá jednomu jmennému prostoru (namespace). To znamená, že se na začátku každého souboru bude nacházet volání makra (ns název_jmenného_prostoru). Tuto konvenci pojmenování jmenných prostorů a souborů s funkcemi a makry jednotlivých jmenných souborů sice není nutné dodržet, ale zejména u větších projektů je výhodnější vhodné jmenné prostory vytvořit již v době návrhu aplikace. Vlastní editace zdrojových textů není ničím překvapivá, protože editor jazyka Clojure nabízí jak automatické doplňování jmen volaných funkcí (výchozí zkratkou je Ctrl+Space), tak i zobrazení krátké nápovědy ke každému symbolu – to samozřejmě za předpokladu, že je nápověda k dispozici.

Obrázek 12: Rozdělení projektu do jmenných prostorů a editace zdrojových textů v jednotlivých souborech. Libovolný zdrojový text (tj. skript) lze spustit z kontextového menu po výběru příkazu Run as Clojure.

V menu Window → Preferences (viz též screenshot číslo 13) je možné nastavit vlastnosti pluginu Counterclockwise. Změnit je možné vlastnosti editoru zdrojových textů (na výběr jsou dva režimy činnosti), způsob barevného zvýraznění jednotlivých lexikálních a syntaktických kategorií atd. Veškeré nastavení zde provedené se projeví globálně na všech projektech, ovšem ve skutečnosti je možné použít pro každý projekt individuální nastavení (pokud se například v jednom projektu preferuje jiné odsazení, není problém ho skutečně nastavit pro jeden vybraný projekt).

Obrázek 13: Formulář s nastavením pluginu Counterclockwise. Nejčastěji se mění vlastnosti editoru, způsob spuštění interpretru Clojure (smyčky REPL) a taktéž způsob barevného zvýraznění jednotlivých lexikálních či syntaktických kategorií.

7. Využití smyčky REPL přímo z Eclipse (interaktivní konzole)

Ve třetí kapitole jsme se zmínili o tom, že plugin Counterclockwise umožňuje, aby se integrované vývojové prostředí Eclipse připojilo k samostatně běžící smyčce REPL, s níž pak může programátor komunikovat. Smyčka REPL programovacího jazyka Clojure je nastartována jako (lokální) server, na jehož otevřený a samozřejmě i předem známý port se Eclipse připojí. Příkaz pro připojení naleznete v menu Window. Jakmile Eclipse spustí samostatně běžící server a připojí se k němu, je možné (opět přes menu Window) otevřít pohled REPL. Ten se chová jako inteligentní a samozřejmě i interaktivní konzole se zvýrazněním syntaxe, pamětí již zadaných příkazů, kontextovou nápovědou i doplňováním kódu. Některé možnosti nabízené touto konzolí jsou zobrazeny na screenshotech číslo 14 a 15. Interaktivní konzoli lze využít například pro rychlé otestování nových funkcí, překlad vybraných funkcí a/nebo jmenných prostorů atd.

Obrázek 14: Integrované vývojové prostředí Eclipse po připojení ke smyčce REPL.

Obrázek 15: I v interaktivní konzoli je možné využívat automatické doplňování kódu, popř. kontextovou nápovědu.

8. Obsah následující části seriálu

V následující části seriálu o Javě i o virtuálním stroji Javy (JVM) budeme pokračovat v popisu vývojových prostředí vhodných pro tvorbu aplikací s využitím programovacího jazyka Clojure. Nejprve se zmíním o projektu nazvaném VimClojure, z jehož názvu je patrné, že se jedná o integraci jazyka Clojure a textového editoru Vim. I při této integraci je interpret programovacího jazyka Clojure (resp. smyčka REPL) spuštěn jako server, s nímž se vzdáleně komunikuje z textového editoru. Dále bych se chtěl zmínit o jednom velmi netradičním vývojovém prostředí, které se jmenuje Light Table a jehož autorem je Chris Granger. Jedná se o vývojové prostředí ovládané přes webový prohlížeč (což patrně někoho může odradit), které je zajímavé především tím, že prakticky ve všech ohledech mění tradiční pohled na IDE, které většinou kombinují funkci textových editorů, debuggerů a více či méně dokonalých správců projektů.

9. Odkazy na Internetu

1. Counterclockwise
   http://code.google.com/p/cou­nterclockwise/
2. Clojure IDEs – The Grand Tour
   http://www.bestinclass.dk/in­dex.clj/2010/03/clojure-ides-the-grand-tour-getting-started.html
3. Light Table – a new IDE concept
   http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concept/
4. SICP (The Structure and Interpretation of Computer Programs)
   http://mitpress.mit.edu/sicp/
5. Pure function
   http://en.wikipedia.org/wi­ki/Pure_function
6. Funkcionální programování
   http://cs.wikipedia.org/wi­ki/Funkcionální_programová­ní
7. Čistě funkcionální (datové struktury, jazyky, programování)
   http://cs.wikipedia.org/wi­ki/Čistě_funkcionální
8. 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
9. Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
   http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html
10. Clojure Macro Tutorial (Part III: Syntax Quote)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html
11. Tech behind Tech: Clojure Macros Simplified
    http://techbehindtech.com/2010/09/28/clo­jure-macros-simplified/
12. Fatvat – Exploring functional programming: Clojure Macros
    http://www.fatvat.co.uk/2009/02/clo­jure-macros.html
13. Eulerovo číslo
    http://cs.wikipedia.org/wi­ki/Eulerovo_číslo
14. List comprehension
    http://en.wikipedia.org/wi­ki/List_comprehension
15. List Comprehensions in Clojure
    http://asymmetrical-view.com/2008/11/18/list-comprehensions-in-clojure.html
16. Clojure Programming Concepts: List Comprehension
    http://en.wikibooks.org/wi­ki/Clojure_Programming/Con­cepts#List_Comprehension
17. Clojure core API: for macro
    http://clojure.github.com/clo­jure/clojure.core-api.html#clojure.core/for
18. cirrus machina – The Clojure for macro
    http://www.cirrusmachina.com/blog/com­ment/the-clojure-for-macro/
19. Clojure.org: Clojure home page
    http://clojure.org/downloads
20. Clojure.org: Vars and the Global Environment
    http://clojure.org/Vars
21. Clojure.org: Refs and Transactions
    http://clojure.org/Refs
22. Clojure.org: Atoms
    http://clojure.org/Atoms
23. Clojure.org: Agents as Asynchronous Actions
    http://clojure.org/agents
24. A Couple of Clojure Agent Examples
    http://lethain.com/a-couple-of-clojure-agent-examples/
25. Clojure – Functional Programming for the JVM
    http://java.ociweb.com/mar­k/clojure/article.html
26. Clojure quick reference
    http://faustus.webatu.com/clj-quick-ref.html
27. 4Clojure
    http://www.4clojure.com/
28. ClojureDoc
    http://clojuredocs.org/
29. Clojure (Wikipedia EN)
    http://en.wikipedia.org/wiki/Clojure
30. Clojure (Wikipedia CS)
    http://cs.wikipedia.org/wiki/Clojure
31. Riastradh's Lisp Style Rules
    http://mumble.net/~campbe­ll/scheme/style.txt
32. Dynamic Languages Strike Back
    http://steve-yegge.blogspot.cz/2008/05/dynamic-languages-strike-back.html
33. Scripting: Higher Level Programming for the 21st Century
    http://www.tcl.tk/doc/scripting.html
34. Java Virtual Machine Support for Non-Java Languages
    http://docs.oracle.com/ja­vase/7/docs/technotes/gui­des/vm/multiple-language-support.html
35. New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
    http://java.sun.com/develo­per/technicalArticles/Dyn­TypeLang/
36. JSR 223: Scripting for the Java^TM Platform
    http://jcp.org/en/jsr/detail?id=223
37. JSR 292: Supporting Dynamically Typed Languages on the Java^TM Platform
    http://jcp.org/en/jsr/detail?id=292
38. Java 7: A complete invokedynamic example
    http://niklasschlimm.blog­spot.com/2012/02/java-7-complete-invokedynamic-example.html
39. InvokeDynamic: Actually Useful?
    http://blog.headius.com/2007/01/in­vokedynamic-actually-useful.html
40. A First Taste of InvokeDynamic
    http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html
41. Java 6 try/finally compilation without jsr/ret
    http://cliffhacks.blogspot­.com/2008/02/java-6-tryfinally-compilation-without.html
42. An empirical study of Java bytecode programs
    http://www.mendeley.com/research/an-empirical-study-of-java-bytecode-programs/
43. 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
44. The JVM Instruction Set
    http://mpdeboer.home.xs4a­ll.nl/scriptie/node14.html
45. Control Flow in the Java Virtual Machine
    http://www.artima.com/under­thehood/flowP.html
46. Root.cz: Využití komprimovaných ukazatelů na objekty v JVM
    http://www.root.cz/clanky/vyuziti-komprimovanych-ukazatelu-na-objekty-v-nbsp-jvm/
47. 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/
48. The Java^TM Virtual Machine Specification, Second Edition
    http://java.sun.com/docs/bo­oks/jvms/second_edition/html/VMSpec­TOC.doc.html
49. The class File Format
    http://java.sun.com/docs/bo­oks/jvms/second_edition/html/Clas­sFile.doc.html
50. javap – The Java Class File Disassembler
    http://docs.oracle.com/ja­vase/1.4.2/docs/tooldocs/win­dows/javap.html
51. javap-java-1.6.0-openjdk(1) – Linux man page
    http://linux.die.net/man/1/javap-java-1.6.0-openjdk
52. Using javap
    http://www.idevelopment.in­fo/data/Programming/java/mis­cellaneous_java/Using_javap­.html
53. Examine class files with the javap command
    http://www.techrepublic.com/ar­ticle/examine-class-files-with-the-javap-command/5815354
54. BCEL Home page
    http://commons.apache.org/bcel/
55. BCEL Manual
    http://commons.apache.org/bcel/ma­nual.html
56. Byte Code Engineering Library (Wikipedia)
    http://en.wikipedia.org/wiki/BCEL
57. Java programming dynamics, Part 7: Bytecode engineering with BCEL
    http://www.ibm.com/develo­perworks/java/library/j-dyn0414/
58. Bytecode Engineering
    http://book.chinaunix.net/spe­cial/ebook/Core_Java2_Volu­me2AF/0131118269/ch13lev1sec6­.html
59. BCEL Tutorial
    http://www.smfsupport.com/sup­port/java/bcel-tutorial!/
60. ASM Home page
    http://asm.ow2.org/
61. Seznam nástrojů využívajících projekt ASM
    http://asm.ow2.org/users.html
62. ObjectWeb ASM (Wikipedia)
    http://en.wikipedia.org/wi­ki/ObjectWeb_ASM
63. Java Bytecode BCEL vs ASM
    http://james.onegoodcooki­e.com/2005/10/26/java-bytecode-bcel-vs-asm/
64. Bytecode Outline plugin for Eclipse (screenshoty + info)
    http://asm.ow2.org/eclipse/index.html
65. aspectj (Eclipse)
    http://www.eclipse.org/aspectj/
66. Aspect-oriented programming (Wikipedia)
    http://en.wikipedia.org/wi­ki/Aspect_oriented_program­ming
67. AspectJ (Wikipedia)
    http://en.wikipedia.org/wiki/AspectJ
68. EMMA: a free Java code coverage tool
    http://emma.sourceforge.net/
69. Cobertura
    http://cobertura.sourceforge.net/
70. FindBugs
    http://findbugs.sourceforge.net/
71. GNU Classpath
    www.gnu.org/s/classpath/
72. Java VMs Compared
    http://bugblogger.com/java-vms-compared-160/
73. JSRs: Java Specification Requests – JSR 223: Scripting for the Java Platform
    http://www.jcp.org/en/jsr/de­tail?id=223
74. Scripting for the Java Platform
    http://java.sun.com/develo­per/technicalArticles/J2SE/Des­ktop/scripting/
75. Scripting for the Java Platform (Wikipedia)
    http://en.wikipedia.org/wi­ki/Scripting_for_the_Java_Plat­form
76. Java Community Process
    http://en.wikipedia.org/wi­ki/Java_Specification_Requ­est
77. Java HotSpot VM Options
    http://www.oracle.com/technet­work/java/javase/tech/vmop­tions-jsp-140102.html
78. Great Computer Language Shootout
    http://c2.com/cgi/wiki?Gre­atComputerLanguageShootout
79. Java performance
    http://en.wikipedia.org/wi­ki/Java_performance
80. Trying the prototype
    http://mail.openjdk.java.net/pi­permail/lambda-dev/2010-August/002179.html
81. Better closures (for Java)
    http://blogs.sun.com/jrose/en­try/better_closures
82. Lambdas in Java: An In-Depth Analysis
    http://www.infoq.com/articles/lambdas-java-analysis
83. Class ReflectiveOperationException
    http://download.java.net/jdk7/doc­s/api/java/lang/Reflective­OperationException.html
84. Scala Programming Language
    http://www.scala-lang.org/
85. Run Scala in Apache Tomcat in 10 minutes
    http://www.softwaresecret­weapons.com/jspwiki/run-scala-in-apache-tomcat-in-10-minutes
86. Fast Web Development With Scala
    http://chasethedevil.blog­spot.cz/2007/09/fast-web-development-with-scala.html
87. Top five scripting languages on the JVM
    http://www.infoworld.com/d/developer-world/top-five-scripting-languages-the-jvm-855
88. Proposal: Indexing access syntax for Lists and Maps
    http://mail.openjdk.java.net/pi­permail/coin-dev/2009-March/001108.html
89. Proposal: Elvis and Other Null-Safe Operators
    http://mail.openjdk.java.net/pi­permail/coin-dev/2009-March/000047.html
90. Java 7 : Oracle pushes a first version of closures
    http://www.baptiste-wicht.com/2010/05/oracle-pushes-a-first-version-of-closures/
91. Groovy: An agile dynamic language for the Java Platform
    http://groovy.codehaus.org/Operators
92. Better Strategies for Null Handling in Java
    http://www.slideshare.net/Step­han.Schmidt/better-strategies-for-null-handling-in-java
93. Control Flow in the Java Virtual Machine
    http://www.artima.com/under­thehood/flowP.html
94. Java Virtual Machine
    http://en.wikipedia.org/wi­ki/Java_virtual_machine
95. ==, .equals(), compareTo(), and compare()
    http://leepoint.net/notes-java/data/expressions/22com­pareobjects.html
96. New JDK7 features
    http://openjdk.java.net/pro­jects/jdk7/features/
97. Project Coin: Bringing it to a Close(able)
    http://blogs.sun.com/darcy/en­try/project_coin_bring_clo­se
98. CloseableFinder source code
    http://blogs.sun.com/darcy/re­source/ProjectCoin/Closea­bleFinder.java
99. Joe Darcy blog about JDK
    http://blogs.sun.com/darcy
100. Java 7 – more dynamics
     http://www.baptiste-wicht.com/2010/04/java-7-more-dynamics/
101. 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