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
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
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
- Counterclockwise
http://code.google.com/p/counterclockwise/ - Clojure IDEs – The Grand Tour
http://www.bestinclass.dk/index.clj/2010/03/clojure-ides-the-grand-tour-getting-started.html - Light Table – a new IDE concept
http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concept/ - SICP (The Structure and Interpretation of Computer Programs)
http://mitpress.mit.edu/sicp/ - Pure function
http://en.wikipedia.org/wiki/Pure_function - Funkcionální programování
http://cs.wikipedia.org/wiki/Funkcionální_programování - Čistě funkcionální (datové struktury, jazyky, programování)
http://cs.wikipedia.org/wiki/Čistě_funkcionální - Clojure Macro Tutorial (Part I, Getting the Compiler to Write Your Code For You)
http://www.learningclojure.com/2010/09/clojure-macro-tutorial-part-i-getting.html - Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
http://www.learningclojure.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html - Clojure Macro Tutorial (Part III: Syntax Quote)
http://www.learningclojure.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html - Tech behind Tech: Clojure Macros Simplified
http://techbehindtech.com/2010/09/28/clojure-macros-simplified/ - Fatvat – Exploring functional programming: Clojure Macros
http://www.fatvat.co.uk/2009/02/clojure-macros.html - Eulerovo číslo
http://cs.wikipedia.org/wiki/Eulerovo_číslo - List comprehension
http://en.wikipedia.org/wiki/List_comprehension - List Comprehensions in Clojure
http://asymmetrical-view.com/2008/11/18/list-comprehensions-in-clojure.html - Clojure Programming Concepts: List Comprehension
http://en.wikibooks.org/wiki/Clojure_Programming/Concepts#List_Comprehension - Clojure core API: for macro
http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/for - cirrus machina – The Clojure for macro
http://www.cirrusmachina.com/blog/comment/the-clojure-for-macro/ - Clojure.org: Clojure home page
http://clojure.org/downloads - Clojure.org: Vars and the Global Environment
http://clojure.org/Vars - Clojure.org: Refs and Transactions
http://clojure.org/Refs - Clojure.org: Atoms
http://clojure.org/Atoms - Clojure.org: Agents as Asynchronous Actions
http://clojure.org/agents - A Couple of Clojure Agent Examples
http://lethain.com/a-couple-of-clojure-agent-examples/ - Clojure – Functional Programming for the JVM
http://java.ociweb.com/mark/clojure/article.html - Clojure quick reference
http://faustus.webatu.com/clj-quick-ref.html - 4Clojure
http://www.4clojure.com/ - ClojureDoc
http://clojuredocs.org/ - Clojure (Wikipedia EN)
http://en.wikipedia.org/wiki/Clojure - Clojure (Wikipedia CS)
http://cs.wikipedia.org/wiki/Clojure - Riastradh's Lisp Style Rules
http://mumble.net/~campbell/scheme/style.txt - Dynamic Languages Strike Back
http://steve-yegge.blogspot.cz/2008/05/dynamic-languages-strike-back.html - Scripting: Higher Level Programming for the 21st Century
http://www.tcl.tk/doc/scripting.html - Java Virtual Machine Support for Non-Java Languages
http://docs.oracle.com/javase/7/docs/technotes/guides/vm/multiple-language-support.html - New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
http://java.sun.com/developer/technicalArticles/DynTypeLang/ - JSR 223: Scripting for the JavaTM Platform
http://jcp.org/en/jsr/detail?id=223 - JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform
http://jcp.org/en/jsr/detail?id=292 - Java 7: A complete invokedynamic example
http://niklasschlimm.blogspot.com/2012/02/java-7-complete-invokedynamic-example.html - InvokeDynamic: Actually Useful?
http://blog.headius.com/2007/01/invokedynamic-actually-useful.html - A First Taste of InvokeDynamic
http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html - Java 6 try/finally compilation without jsr/ret
http://cliffhacks.blogspot.com/2008/02/java-6-tryfinally-compilation-without.html - An empirical study of Java bytecode programs
http://www.mendeley.com/research/an-empirical-study-of-java-bytecode-programs/ - Java quick guide: JVM Instruction Set (tabulka všech instrukcí JVM)
http://www.mobilefish.com/tutorials/java/java_quickguide_jvm_instruction_set.html - The JVM Instruction Set
http://mpdeboer.home.xs4all.nl/scriptie/node14.html - Control Flow in the Java Virtual Machine
http://www.artima.com/underthehood/flowP.html - Root.cz: Využití komprimovaných ukazatelů na objekty v JVM
http://www.root.cz/clanky/vyuziti-komprimovanych-ukazatelu-na-objekty-v-nbsp-jvm/ - 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/ - The JavaTM Virtual Machine Specification, Second Edition
http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html - The class File Format
http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html - javap – The Java Class File Disassembler
http://docs.oracle.com/javase/1.4.2/docs/tooldocs/windows/javap.html - javap-java-1.6.0-openjdk(1) – Linux man page
http://linux.die.net/man/1/javap-java-1.6.0-openjdk - Using javap
http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Using_javap.html - Examine class files with the javap command
http://www.techrepublic.com/article/examine-class-files-with-the-javap-command/5815354 - BCEL Home page
http://commons.apache.org/bcel/ - BCEL Manual
http://commons.apache.org/bcel/manual.html - Byte Code Engineering Library (Wikipedia)
http://en.wikipedia.org/wiki/BCEL - Java programming dynamics, Part 7: Bytecode engineering with BCEL
http://www.ibm.com/developerworks/java/library/j-dyn0414/ - Bytecode Engineering
http://book.chinaunix.net/special/ebook/Core_Java2_Volume2AF/0131118269/ch13lev1sec6.html - BCEL Tutorial
http://www.smfsupport.com/support/java/bcel-tutorial!/ - ASM Home page
http://asm.ow2.org/ - Seznam nástrojů využívajících projekt ASM
http://asm.ow2.org/users.html - ObjectWeb ASM (Wikipedia)
http://en.wikipedia.org/wiki/ObjectWeb_ASM - Java Bytecode BCEL vs ASM
http://james.onegoodcookie.com/2005/10/26/java-bytecode-bcel-vs-asm/ - Bytecode Outline plugin for Eclipse (screenshoty + info)
http://asm.ow2.org/eclipse/index.html - aspectj (Eclipse)
http://www.eclipse.org/aspectj/ - Aspect-oriented programming (Wikipedia)
http://en.wikipedia.org/wiki/Aspect_oriented_programming - AspectJ (Wikipedia)
http://en.wikipedia.org/wiki/AspectJ - EMMA: a free Java code coverage tool
http://emma.sourceforge.net/ - Cobertura
http://cobertura.sourceforge.net/ - FindBugs
http://findbugs.sourceforge.net/ - GNU Classpath
www.gnu.org/s/classpath/ - Java VMs Compared
http://bugblogger.com/java-vms-compared-160/ - JSRs: Java Specification Requests – JSR 223: Scripting for the Java Platform
http://www.jcp.org/en/jsr/detail?id=223 - Scripting for the Java Platform
http://java.sun.com/developer/technicalArticles/J2SE/Desktop/scripting/ - Scripting for the Java Platform (Wikipedia)
http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform - Java Community Process
http://en.wikipedia.org/wiki/Java_Specification_Request - Java HotSpot VM Options
http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html - Great Computer Language Shootout
http://c2.com/cgi/wiki?GreatComputerLanguageShootout - Java performance
http://en.wikipedia.org/wiki/Java_performance - Trying the prototype
http://mail.openjdk.java.net/pipermail/lambda-dev/2010-August/002179.html - Better closures (for Java)
http://blogs.sun.com/jrose/entry/better_closures - Lambdas in Java: An In-Depth Analysis
http://www.infoq.com/articles/lambdas-java-analysis - Class ReflectiveOperationException
http://download.java.net/jdk7/docs/api/java/lang/ReflectiveOperationException.html - Scala Programming Language
http://www.scala-lang.org/ - Run Scala in Apache Tomcat in 10 minutes
http://www.softwaresecretweapons.com/jspwiki/run-scala-in-apache-tomcat-in-10-minutes - Fast Web Development With Scala
http://chasethedevil.blogspot.cz/2007/09/fast-web-development-with-scala.html - Top five scripting languages on the JVM
http://www.infoworld.com/d/developer-world/top-five-scripting-languages-the-jvm-855 - Proposal: Indexing access syntax for Lists and Maps
http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/001108.html - Proposal: Elvis and Other Null-Safe Operators
http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000047.html - Java 7 : Oracle pushes a first version of closures
http://www.baptiste-wicht.com/2010/05/oracle-pushes-a-first-version-of-closures/ - Groovy: An agile dynamic language for the Java Platform
http://groovy.codehaus.org/Operators - Better Strategies for Null Handling in Java
http://www.slideshare.net/Stephan.Schmidt/better-strategies-for-null-handling-in-java - Control Flow in the Java Virtual Machine
http://www.artima.com/underthehood/flowP.html - Java Virtual Machine
http://en.wikipedia.org/wiki/Java_virtual_machine - ==, .equals(), compareTo(), and compare()
http://leepoint.net/notes-java/data/expressions/22compareobjects.html - New JDK7 features
http://openjdk.java.net/projects/jdk7/features/ - Project Coin: Bringing it to a Close(able)
http://blogs.sun.com/darcy/entry/project_coin_bring_close - CloseableFinder source code
http://blogs.sun.com/darcy/resource/ProjectCoin/CloseableFinder.java - Joe Darcy blog about JDK
http://blogs.sun.com/darcy - Java 7 – more dynamics
http://www.baptiste-wicht.com/2010/04/java-7-more-dynamics/ - New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
http://java.sun.com/developer/technicalArticles/DynTypeLang/index.html
