Programovací jazyk Clojure 20: vývojová prostředí pro Clojure (integrace Vimu s REPL)

Pavel Tišnovský 23. 10. 2012

V dnešní části seriálu o vlastnostech programovacího jazyka Java i JVM budeme pokračovat v popisu vývojových prostředí použitelných při práci s programovacím jazykem Clojure. Minule jsme si popsali způsob integrace Clojure s vývojovým prostředím Eclipse, dnes se budeme zabývat „odlehčeným“ IDE založeným na textovém editoru Vim.

Obsah

1. Programovací jazyk Clojure 20: vývojová prostředí pro Clojure (integrace Vimu s REPL)

2. Plugin VimClojure

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

6. Instalace Nailgun serveru

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

9. Odkazy na Internetu

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/scrip­t.php?script_id=2501.

obr

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

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.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:

  1. A detailed installation Guide for VimClojure 2.2
    http://www.duenas.at/new_ho­mepage/vimclojure
  2. VimClojure : A filetype, syntax and indent plugin for Clojure
    http://www.vim.org/scripts/scrip­t.php?script_id=2501
  3. Textový editor Vim jako IDE: 3.část (omni completion)
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide-3-cast/
obr

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

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

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

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í VimuREPL 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:

  1. 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/vim­clojure/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:

  1. How I Tamed VimClojure
    http://blog.darevay.com/2010/10/how-i-tamed-vimclojure/
  2. github: vim-scripts / VimClojure
    https://github.com/vim-scripts/VimClojure
  3. Step by step setup guide
    https://groups.google.com/fo­rum/?fromgroups=#!msg/vim­clojure/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/sli­me.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

Obrázek 9: Příprava na spuštění REPL – obsah adresáře, z něhož se REPL bude spouštět.

obr

Obrázek 10: Spuštění nové pojmenované session nástroje screen.

obr

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.

  1. slime.vim
    http://s3.amazonaws.com/mps/slime.vim
  2. SLIME: The Superior Lisp Interaction Mode for Emacs
    http://common-lisp.net/project/slime/
  3. 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

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

Obrázek 13: Po prvním stisku Ctrl+C Ctrl+C se skript zeptá na jméno session (lze pouze potvrdit Enterem).

obr

Obrázek 14: Dále se zeptá na jméno okna (lze taktéž pouze potvrdit Enterem).

widgety

obr

Obrázek 15: Vybraná část programu je „magicky“ přenesena do REPL a tam vykonána.

obr

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

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

Poslední možnost změnit zdravotní pojišťovnu

DigiZone.cz: Banaxi: videa kdekoli na světě

Banaxi: videa kdekoli na světě

120na80.cz: Ochablé svaly mohou značit vážnou nemoc

Ochablé svaly mohou značit vážnou nemoc

Vitalia.cz: 5 nemocí, se kterými pomáhá urologie

5 nemocí, se kterými pomáhá urologie

DigiZone.cz: Na jaká videa se vlastně díváme

Na jaká videa se vlastně díváme

DigiZone.cz: Rapl: seriál, který vás smíří s ČT

Rapl: seriál, který vás smíří s ČT

DigiZone.cz: DVB-T2 ověřeno: seznam TV zveřejněn

DVB-T2 ověřeno: seznam TV zveřejněn

Lupa.cz: Patička e-mailu závazná jako vlastnoruční podpis?

Patička e-mailu závazná jako vlastnoruční podpis?

Podnikatel.cz: Udělali jsme velkou chybu, napsal Čupr

Udělali jsme velkou chybu, napsal Čupr

Vitalia.cz: Jak Ondra o astma přišel

Jak Ondra o astma přišel

Podnikatel.cz: Letáky? Lidi zuří, ale ony stále fungují

Letáky? Lidi zuří, ale ony stále fungují

Vitalia.cz: Antibakteriální mýdla nepomáhají, spíš škodí

Antibakteriální mýdla nepomáhají, spíš škodí

Podnikatel.cz: ČSSZ posílá přehled o důchodovém kontě

ČSSZ posílá přehled o důchodovém kontě

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

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

Vitalia.cz: Tesco nabízí desítky tun jídla zdarma

Tesco nabízí desítky tun jídla zdarma

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

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

Vitalia.cz: dTest odhalil ten nejlepší kečup

dTest odhalil ten nejlepší kečup

DigiZone.cz: Technisat připravuje trojici DAB

Technisat připravuje trojici DAB

Podnikatel.cz: Tyto pojmy k #EET byste měli znát

Tyto pojmy k #EET byste měli znát

DigiZone.cz: Digi Slovakia zařazuje stanice SPI

Digi Slovakia zařazuje stanice SPI