Obsah
1. Programovací jazyk Clojure 20: vývojová prostředí pro Clojure (integrace Vimu s REPL)
3. Instalace pluginu VimClojure
4. Jak se vyznat v komplikovanějších zdrojových kódech Clojure aneb „duhové závorky“
5. Spuštění Clojure v rámci serveru Nailgun a volání REPL z Vimu
7. Alternativní integrace externě běžící smyčky REPL a Vimu: SLIME for Vim
8. SLIME for Vim: volání REPL přímo z Vimu
1. Programovací jazyk Clojure 20: vývojová prostředí pro Clojure (integrace Vimu s REPL)
V předchozí části seriálu o Javě i o virtuálním stroji Javy (JVM) jsme si popsali způsob instalace pluginu nazvaného Counterclockwise do integrovaného vývojového prostředí Eclipse. Tento plugin nabízí vývojářům poměrně velké množství funkcí, které je možné rozdělit do tří kategorií. Jednou z důležitých funkcí je správa projektů (projekt je skupina zdrojových souborů .clj se společnou konfigurací), která se v základních rysech podobá správě Javovských projektů, včetně možnosti používat systémy pro správu verzí atd. Dále tento plugin přidává do integrovaného vývojového prostředí Eclipse nový typ specializovaného textového editoru navrženého 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 (jednou z důležitých vlastností tohoto editoru je jeho schopnost barevně odlišit jednotlivé páry závorek).
Obrázek 1: Základní funkce nabízené pluginem Counterclockwise. V horní části je na tomto screenshotu zobrazen specializovaný textový editor, který samozřejmě zvýrazňuje syntaxi (dokáže například rozeznat volání funkce a volání metody), včetně unikátního obarvení párových závorek různou barvou. V dolní části screenshotu je umístěna interaktivní konzole. 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).
Třetí funkce pluginu Counterclockwise zajišťuje připojení Eclipse na smyčku REPL (Read-Eval-Print-Loop) programovacího jazyka Clojure, přičemž samotný jazyk je spuštěn jako samostatný proces (server), k němuž se Eclipse připojuje při vyhodnocování jednotlivých výrazů (či přesněji řečeno forem). Propojení integrovaného vývojového prostředí Eclipse s programovacím jazykem Clojure implementované v pluginu Counterclockwise je v současnosti již plně funkční a mnoho programátorů je s tímto řešením více než spokojeno. Pluginy umožňující tvorbu programů v Clojure existují i (minimálně) pro další dvě známá javovská IDE – konkrétně pro Netbeans i pro IDEU. Ovšem kromě těchto tří velmi schopných, ale taktéž poněkud „těžkotonážních“ IDE existují i další alternativní vývojová prostředí, která mohou některým vývojářům vyhovovat lépe, například kvůli menším systémovým nárokům, nebo z toho důvodu, že vývoj či opravy programů je nutné v některých případech provádět na vzdálených počítačích (například přes ssh apod.).
Obrázek 2: I v interaktivní konzoli (z níž se volá smyčka REPL spuštěná ve zvláštním procesu) je možné využívat automatické doplňování kódu, popř. i kontextovou nápovědu.
2. Plugin VimClojure
„vi is small, fast, and easy to use. Emacs is huge, slow and easy to use :)“
Alternativní vývojová prostředí zmíněná na konci předchozí kapitoly jsou většinou založena na využití (programátorských) textových editorů, jenž jsou doplněny o několik skriptů a popř. i o další externí nástroje, které se z textových editorů přes tyto skripty volají. Typickým příkladem tohoto typu alternativních vývojových prostředí je modul SLIME (Superior Lisp Interaction Mode for Emacs) určený, jak již jeho jméno napovídá, pro známý editor Emacs. SLIME zajišťuje integraci Emacsu s mnoha programovacími jazyky založenými na LISPu, a to včetně programovacího jazyka Clojure. Ovšem v dnešním článku se budu zabývat především popisem nástrojů určených pro „konkurenční“ textový editor Vim (ve verzi 6 a 7). Pro vývojáře, kteří se rozhodnou využít Vim pro vytváření a úpravu aplikací v programovacím jazyku Clojure, je určen plugin nazvaný jednoduše VimClojure, jehož poslední verzi je možné získat na adrese http://www.vim.org/scripts/script.php?script_id=2501.
Obrázek 3: Podadresář obsahující soubory se jmény všech funkcí, maker a globálních symbolů Clojure. Obsah těchto souborů je použit při omni completion.
Tento plugin, který je interně poměrně komplikovaný, nabízí vývojářům v první řadě různá vylepšení editace zdrojových kódů (s koncovkou .clj), včetně možnosti zobrazení „duhových závorek“, což je pro programovací jazyky založené na LISPu jedna z nejdůležitějších vlastností, kterou by měl každý slušný programátorský editor nabízet (viz též jeden z možných výkladů zkratky LISP – „Lost In Stupid Parenthesis“). Dále tento plugin v současné verzi obsahuje 20 souborů se seznamem funkcí, maker a „globálních“ symbolů deklarovaných ve standardních jmenných prostorech Clojure. Tyto soubory jsou při inicializaci pluginu VimClojure načteny a zpracovány takovým způsobem, aby všechna jména funkcí/maker/symbolů byla nabízena systémem „omni completion“, tj. jsou využity při použití klávesových zkratek CTRL+P a CTRL+N použitých ve vkládacím režimu (insert mode). Při editaci zdrojových kódů tedy postačuje napsat část jména (například „pri“) a po stisku CTRL+P/CTRL+N se v kontextovém menu nabídnou všechny funkce/makra/symboly začínající tímto prefixem („println“ atd-).
Obrázek 4: Příklad použití funkce omni completion v praxi při editaci zdrojového textu Clojure.
3. Instalace pluginu VimClojure
Instalace pluginu VimClojure je ve skutečnosti velmi jednoduchá – po stažení archivu je zapotřebí tento archiv rozbalit buď do adresáře ~/.vim/ (plugin sice bude použitelný pouze pro jednoho uživatele, ovšem je možné bez problémů zasahovat do jeho interní struktury) nebo do podadresáře /usr/share/vim/${verze_vimu} (v tomto případě bude plugin použitelný pro všechny uživatele). Obsah adresáře ~/.vim může vypadat v případě instalace většího množství pluginů následovně:
tree ~/.vim
.vim
|-- autoload
| |-- vimclojure
| | `-- util.vim
| `-- vimclojure.vim
|-- bin
| |-- clj
| |-- clj.bat
| |-- ng-server
| `-- ng-server.bat
|-- colors
| `-- vo_dark.vim
|-- doc
| |-- clojure.txt
| |-- taglist.txt
| `-- tags
|-- ftdetect
| |-- clojure.vim
| `-- vo_base.vim
|-- ftplugin
| |-- clojure
| | |-- completions-clojure.core.txt
| | |-- completions-clojure.data.txt
| | |-- completions-clojure.inspector.txt
| | |-- completions-clojure.java.browse.txt
| | |-- completions-clojure.java.io.txt
| | |-- completions-clojure.java.javadoc.txt
| | |-- completions-clojure.java.shell.txt
| | |-- completions-clojure.main.txt
| | |-- completions-clojure.pprint.txt
| | |-- completions-clojure.repl.txt
| | |-- completions-clojure.set.txt
| | |-- completions-clojure.stacktrace.txt
| | |-- completions-clojure.string.txt
| | |-- completions-clojure.template.txt
| | |-- completions-clojure.test.junit.txt
| | |-- completions-clojure.test.tap.txt
| | |-- completions-clojure.test.txt
| | |-- completions-clojure.walk.txt
| | |-- completions-clojure.xml.txt
| | `-- completions-clojure.zip.txt
| |-- clojure.vim
| |-- vo_base.vim
| |-- vo_hoist.vim
| `-- vo_checkbox.vim
|-- indent
| `-- clojure.vim
|-- plugin
| |-- clojure.vim
| `-- taglist.vim
|-- README.markdown
|-- slime.vim
|-- spell
| |-- cs.utf-8.add
| `-- cs.utf-8.add.spl
`-- syntax
|-- clojure.vim
`-- vo_base.vim
12 directories, 45 files
Plugin VimClojure je automaticky aktivován ve chvíli, kdy je otevřen soubor s koncovkou .clj, aby však tato aktivace proběhla korektně, je nutné ve .vimrc povolit detekci typů načítaných souborů a taktéž načítání skriptů používaných (nejenom) pro formátování zdrojových textů:
:filetype plugin on :filetype indent on
Popř. je možné oba příkazy sloučit do příkazu jednoho:
:filetype plugin indent on
Aktuální nastavení volby :filetype lze zjistit snadno:
:filetype
Taktéž je nutné v konfiguračním souboru .vimrc povolit zvýrazňování syntaxe:
:syntax on
Pokud i přesto plugin VimClojure nebude pracovat korektně, přesvědčte se, zda není editor Vim spuštěn v režimu kompatibility se stařičkým vi. Následující příkaz by měl vypsat text „nocompatible“:
:set compatible?
Pokud se vypíše text „compatible“, nebyl pravděpodobně nalezen soubor .vimrc, Vim byl spuštěn s přepínačem -C, popř. nebyl proveden příkaz set nocompatible z .vimrc (ovšem v takovém případě dokážete využít jen zhruba třetinu schopností Vimu).
Odkazy na stránky s dalšími informacemi o pluginu VimClojure i o funkci „omni completion“ nabízené nejnovějšími verzemi textového editoru Vim:
- A detailed installation Guide for VimClojure 2.2
http://www.duenas.at/new_homepage/vimclojure - VimClojure : A filetype, syntax and indent plugin for Clojure
http://www.vim.org/scripts/script.php?script_id=2501 - Textový editor Vim jako IDE: 3.část (omni completion)
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-3-cast/
Obrázek 5: Vim již v základní instalaci obsahuje podporu pro editaci zdrojových kódů LISPu, ovšem VimClojure jde v podpoře LISPu/Clojure ještě mnohem dále. Zajímavé je, že se tato volba používala již v původním editoru vi (i když měla poněkud odlišné chování), což jen ukazuje, že se v minulosti LISPovské jazyky v některých oblastech používaly častěji než dnes.
4. Jak se vyznat v komplikovanějších zdrojových kódech Clojure aneb „duhové závorky“
Jednou z nejdůležitějších a nejužitečnějších funkcí nabízených pluginem VimClojure je jeho schopnost použití takzvaných „duhových závorek“. Co se vlastně pod tímto názvem skrývá? Textový editor Vim samozřejmě dokáže nalézt párové závorky a zvýraznit druhou párovou závorku ve chvíli, kdy se nad první závorkou nachází kurzor. Navíc obsahuje i příkaz % pro skok na odpovídající druhou párovou závorku (funkci tohoto příkazu lze rozšířit tak, aby například doskakoval i na otevírací/uzavírací značky HTML či XML). Taktéž je relativně snadné všechny závorky obarvit s využitím příkazu :syntax. To je většinou dostačující například při práci se zdrojovými texty Javy, céčka či Pythonu, ovšem v programovacích jazycích odvozených od LISPu se kulaté závorky vyskytují v mnohem větším množství. Navíc není zvykem tyto závorky chápat jako začátek a konec bloku, tj. podobným způsobem, jako například složené závorky v céčku. To znamená, že odpovídající otevírací a uzavírací kulaté závorky v LISPu/Clojure nejsou umístěny ve stejném sloupci. Následující příklad je sice syntakticky i sémanticky správný, ale LISPaři se většinou tomuto způsobu zápisu vyhýbají (a mají k tomu velmi dobré důvody :-):
(defn fibonacci
[n]
(if (> n 2)
n
(+
(fibonacci (- n 2)) (fibonacci (- n 1))
)
)
)
Namísto toho se používá zápis, v němž jsou všechny uzavírací (pravé) závorky zapsány na jediném řádku:
(defn fibonacci
[n]
(if (> n 2)
n
(+ (fibonacci (- n 2)) (fibonacci (- n 1)))))
Co z toho vyplývá? Vyznat se v takto zapsaných programech může být problematické, když i v tak jednoduché funkci, jakou je rekurzivní výpočet Fibonacciho posloupnosti máme na konci uvedeno pět ukončovacích závorek. Obarvení všech závorek jednou barvou není v tomto případě dostačující, namísto toho by bylo výhodnější, aby každý pár závorek používal barvu jinou. A právě to zajišťuje funkce „duhových závorek“, kterou je však nutné v pluginu VimClojure nejprve povolit. To je ovšem velmi snadné – v konfiguračním souboru .vimrc postačuje nastavit hodnotu dvou konkrétních proměnných tak, jak je ukázáno na dalším screenshotu:
Obrázek 6: Příklad nastavení konfigurace pluginu VimClojure v souboru .vimrc.
Podívejte se nyní na rozdíl v zobrazení stejného zdrojového kódu bez a s použitím funkce „duhových závorek“:
Obrázek 7: Zdrojový kód Clojure se zvýrazněním syntaxe, ovšem se zákazem použití „duhových závorek“.
Obrázek 8: Zdrojový kód Clojure se zvýrazněním syntaxe a současně s povolením použití „duhových závorek“.
5. Spuštění Clojure v rámci serveru Nailgun a volání REPL z Vimu
Mezi další funkce, které plugin VimClojure vývojářům nabízí, patří i možnost propojení textového editoru Vim se smyčkou REPL programovacího jazyka Clojure. Toto propojení s sebou přináší relativně velké množství předností, například možnost ihned si odzkoušet a otestovat vytvářené funkce, tj. vše lze provádět bez nutnosti překladu či neustálého spouštění externích nástrojů. Dále je díky tomuto propojení umožněn přímý přístup k nápovědě přes (doc symbol). Aby byla kooperace mezi textovým editorem Vim a smyčkou REPL okamžitá, je nutné, aby byla smyčka REPL spuštěna jako samostatný proces, k němuž se Vim v případě potřeby připojí (je to tedy řešení, které bylo využité i v pluginu Counterclockwise pro Eclipse). Toto řešení s sebou přináší i další výhody, především možnost použít v REPL již dříve definované funkce, programátor nemusí čekat na spuštění nové instance Clojure atd.
Pro propojení Vimu s REPL se využívá další pomocný nástroj – jednoduchý server nazvaný Nailgun. Jedná se o poměrně jednoduchou utilitu, která běží v režimu serveru v JVM, přes niž je možné spouštět libovolný javovský program. Idea, na níž je server Nailgun postaven, je ve skutečnosti velmi jednoduchá – spouštění Javovských programů je pomalé zejména z toho důvodu, že je nejdříve nutné spustit virtuální stroj Javy, do něj načíst všechny potřebné třídy a až posléze zahájit běh programu. Pokud se podaří inicializaci JVM a načtení tříd provést pouze jedenkrát, bude každý další start aplikace mnohem rychlejší (v praxi dokonce může být rychlejší, než spuštění srovnatelné nativní aplikace – záleží to na množství dynamicky linkovaných knihoven). Nailgun se musí spustit v JVM s nastavenou cestou k java archivu s interpretrem programovacího jazyka Clojure a ihned po startu serveru se otevře port 2113, přes nějž je možné komunikovat s JVM, kde je Nailgun a současně i Clojure spuštěn. Na straně klienta je možné využít libovolný program, který dokáže pracovat se sockety. V našem případě to bude jednoduchý nativní klient spouštěný z Vimu.
Jeden z důvodů pro použití Nailgun serveru je popsán na následující stránce:
- Nailgun server
http://www.martiansoftware.com/nailgun/background.html
6. Instalace Nailgun serveru
Pro korektní funkci tohoto způsobu propojení Vimu a REPL je nejlepší postupovat podle návodu zveřejněného na této stránce: http://blog.darevay.com/2010/10/how-i-tamed-vimclojure/. Nejjednodušší je zkopírovat javovský archiv s Nailgun serverem do stejného adresáře, v němž je umístěn i interpret jazyka Clojure a následně server spustit pomocí příkazu:
java -cp server-2.3.0.jar:clojure-1.4.0.jar vimclojure.nailgun.NGServer
Volba -cp zajistí umístění všech tříd z obou vypsaných archivů na CLASSPATH.
Dále je nutné si stáhnout klientskou část (nativní) z adresy http://kotka.de/projects/vimclojure/vimclojure-nailgun-client-2.2.0.zip, rozbalit tento archiv a následně ho přeložit:
pavel@bender:~$ unzip vimclojure-nailgun-client-2.2.0.zip Archive: vimclojure-nailgun-client-2.2.0.zip creating: vimclojure-nailgun-client/ inflating: vimclojure-nailgun-client/Makefile inflating: vimclojure-nailgun-client/ng.exe creating: vimclojure-nailgun-client/ngclient/ inflating: vimclojure-nailgun-client/ngclient/ng.c pavel@bender:~$ make Building ng client. To build a Windows binary, type 'make ng.exe' gcc -Wall -pedantic -s -O3 -o ng ngclient/ng.c
Pokud vše proběhlo v pořádku (tj. v případě, že máte v počítači nainstalovaný GCC i všechny potřebné knihovny), měl by být výsledkem překladu soubor ng s právy nastavenými na -rwxr-xr-x. Tento soubor překopírujte do některého adresáře, na nějž ukazuje proměnná PATH, například do /usr/local/bin. Po těchto přípravných krocích by již mělo být možné využívat smyčku REPL jazyka Clojure přímo z Vimu způsobem, jaký je popsán v dokumentaci k VimClojure.
Další informace o konfiguraci Nailgun serveru a VimClojure:
- How I Tamed VimClojure
http://blog.darevay.com/2010/10/how-i-tamed-vimclojure/ - github: vim-scripts / VimClojure
https://github.com/vim-scripts/VimClojure - Step by step setup guide
https://groups.google.com/forum/?fromgroups=#!msg/vimclojure/aavuqfV8tzs/3BqE-hD5dIIJ
7. Alternativní integrace externě běžící smyčky REPL a Vimu: SLIME for Vim
Využití serveru Nailgun pro spuštění interpretru programovacího jazyka Clojure je sice (po chvilce ruční práce) funkční, ovšem nejedná se o řešení, které by bylo elegantní. Kromě samotného Vimu a interpretru Clojure je totiž nutné využívat další dva nástroje – server Nailgun naprogramovaný v Javě a nativního klienta, který se k Nailgunu připojuje a který je volán z Vimu. Že je toto řešení poněkud náchylné na různé chyby si uvědomili i další vývojáři a z tohoto důvodu vzniklo ještě jedno alternativní řešení, které mě osobně připadá být mnohem jednodušší a použitelnější. Interaktivní smyčka REPL interpretru jazyka Clojure je stále spouštěna v samostatném procesu, ovšem namísto toho, aby se interpreter spouštěl v „normálním“ terminálu (resp. ve virtuálním terminálu), je spuštěn v pojmenované session nástroje screen. Vzhledem k tomu, že je tato session pojmenovaná, je možné do příslušného okna poslat sekvenci znaků, které budou zpracovány stejným způsobem, jako by je uživatel napsal na klávesnici.
Odkaz na zdrojový kód skriptu slime.vim a odkazy na stránky s informacemi o SLIME pro Emacs:
Jaká sekvence znaků však bude do REPL poslána? O to se postará velmi jednoduchý Vimovský plugin nazvaný slime.vim (http://s3.amazonaws.com/mps/slime.vim), jehož jméno se odkazuje na již zmíněný plugin Slime určený pro editor Emacs. Tyto pluginy mají kromě jména společnou i další věc – pro přenos textu z Vimu do REPL se používá shodná klávesová zkratka Ctrl+C Ctrl+C. Podívejme se nejprve na to, jak se musí spustit Clojure v pojmenované session nástroje screen. Celý postup je ukázán na sekvenci tří obrázků:
Obrázek 9: Příprava na spuštění REPL – obsah adresáře, z něhož se REPL bude spouštět.
Obrázek 10: Spuštění nové pojmenované session nástroje screen.
Obrázek 11: V nové session se již může nastartovat REPL stejným způsobem, jak jsme si to ukazovali v úvodních částech tohoto seriálu.
- slime.vim
http://s3.amazonaws.com/mps/slime.vim - SLIME: The Superior Lisp Interaction Mode for Emacs
http://common-lisp.net/project/slime/ - SLIME pro editor Emacs (Wikipedia)
http://en.wikipedia.org/wiki/SLIME
8. SLIME for Vim: volání REPL přímo z Vimu
Pokud je již smyčka REPL programovacího jazyka Clojure spuštěna v session pojmenovaném „clojure“, lze v jiném okně či v jiném terminálu spustit samotný editor Vim a s využitím příkazu :source načíst a spustit skript slime.vim. Ideální je tento příkaz zavolat automaticky při načítání souborů s koncovkou .clj. Pokud je tento skript načten, je možné v jakémkoli okamžiku stisknout klávesovou zkratku Ctrl+C Ctrl+C. Skript se při prvním stisku této zkratky zeptá na jméno session a na okno – většinou jsou nabízené hodnoty správné, takže se jen potvrdí Enterem. Poté se již zcela automaticky celý odstavec vloží do vizuálního bloku (sekvence příkazů vip), vizuální blok se vloží do pojmenovaného registru y (sekvence příkazů "ry a nakonec se obsah tohoto registru přenese do okna, v němž běží REPL jazyka Clojure (tam se hned vyhodnotí, protože součástí přenášeného bloku je i koncový Enter).
Celý postup možná vypadá poněkud složitě, ve skutečnosti si však na tento nástroj velmi rychle zvyknete. Je ho samozřejmě možné upravovat a rozšiřovat, například využít klávesovou zkratku K (hledání slova pod kurzorem v manuálových stránkách) k tomu, aby se do REPL poslal příkaz (doc „hledané-slovo“) atd.
Podívejme se ještě na screenshoty, kde je ukázána kooperace mezi textovým editorem a interpretrem. Pro jednoduchost používám dva terminály, stejně tak je ale možné obě okna využívat z jediného terminálu – opět s využitím nástroje screen.
Obrázek 12: Textový editor Vim spuštěný v jiném terminálu (či v jiném okně nástroje screen). Přímo z Vimu je načten a proveden (spuštěn) skript slime.vim.
Obrázek 13: Po prvním stisku Ctrl+C Ctrl+C se skript zeptá na jméno session (lze pouze potvrdit Enterem).
Obrázek 14: Dále se zeptá na jméno okna (lze taktéž pouze potvrdit Enterem).
Obrázek 15: Vybraná část programu je „magicky“ přenesena do REPL a tam vykonána.
Obrázek 16: Další příklad – stlačení Ctrl+C Ctrl+C nad formou/výrazem (range 0 10) – nyní se vše provede bez dalších dotazů.
9. Odkazy na Internetu
- A detailed installation Guide for VimClojure 2.2
http://www.duenas.at/new_homepage/vimclojure - VimClojure : A filetype, syntax and indent plugin for Clojure
http://www.vim.org/scripts/script.php?script_id=2501 - Nailgun server
http://www.martiansoftware.com/nailgun/background.html - SLIME (Wikipedia)
http://en.wikipedia.org/wiki/SLIME - slime.vim
http://s3.amazonaws.com/mps/slime.vim - Textový editor Vim jako IDE: 1. část
http://www.root.cz/clanky/textovy-editor-vim-jako-ide/ - Textový editor Vim jako IDE: 2. část
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-2-cast/ - Textový editor Vim jako IDE: 3. část (omni completion)
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-3-cast/ - Textový editor Vim jako IDE: 4. část
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-4-cast/ - Textový editor Vim jako IDE: 5. část
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-5-cast/ - Textový editor Vim jako IDE: 6. část – Vim Script
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-6-cast-vim-script/ - Textový editor Vim jako IDE: 7. část – Vim Script
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-7-cast-vim-script/ - Textový editor Vim jako IDE: 8. část
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-8-cast/ - 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/ - 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/ - Přenos textů mezi Vimem a dalšími aplikacemi
http://www.root.cz/clanky/prenos-textu-mezi-vimem-a-dalsimi-aplikacemi/ - 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/ - Textový editor Vim: automatické formátování textů
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-14-cast-automaticke-formatovani-textu/ - Textový editor Vim: automatické formátování textů
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-automaticke-formatovani-textu-dokonceni/ - Textový editor Vim: editace XML a HTML
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-15-cast-editace-xml-a-html/ - 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/ - 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/ - Textový editor Vim: konfigurace a překlad Vimu
http://www.root.cz/clanky/textovy-editor-vim-jako-ide-18-cast-konfigurace-a-preklad-vimu/ - 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
