Sometimes Clojure

13. srpna 2011

Změna domény: clojure.cz

Tak je to už sedm měsíců, co píšu Sometimes Clojure. Včera jsem se jen tak z rozmaru podíval, jestli je volná doména clojure.cz. Byla. Tak jsem si ji vzal. Zatím se mi zdá, že jsem jediný, kdo o Clojure v Česku píše, tak co. Třeba jednou vznikne komunitní web, nebo něco. Ale teď je moje! My precious!! :-)

11. srpna 2011

Nazdar světe! říká ClojureScript

Tak jsem se neudržel a ClojureScript si vyzkoušel. Následuje popis (jednoho zápasu), jak si vyrobit Hello, world! v ClojureScriptu. Vzhledem k tomu, že ClojureScript je zatím v alpha verzi a Windows (kde jsem to musel z časových důvodů vyzkoušet) tradičně hází vývojářům klacky pod nohy :-/ se instalace, kompilace a vyzkoušení triviálního příkladu protáhlo na několik hodin. Nicméně zvítězil jsem a tady je výsledek.

Nebudu se zabývat instalací ClojureScriptu - je dobře popsána ve wiki projektu, Windows instalace je trochu dramatičtější. Navíc v případě Windows je problém, pokud se kompilace provádí v cestě s mezerami (Documents and Settings apod.), je při optimalizovaném překladu vyhozena výjimka.

Tak, máme nainstalováno? Spustíme z příkazové řádky příkaz cljsc (ClojureScript compiler):

C:\clojure-clojurescript\samples\my-hello>cljsc
Usage: "cljsc <file-or-dir> > out.js"
       "cljsc <file-or-dir> {:optimiztions :advanced} > out.js"

No. Co/k čemu ten ClojureScript vlastně je? ClojureScript je dialekt Clojure (spíš podmnožina). Nejdůležitější je jeho kompilátor, který umožňuje zkompilovat Clojure(Script) do JavaScriptu. Pokud by někoho zajímaly filozofické důvody pro vznik ClojureScriptu, jsou uvedeny ve wiki na stránce Rationale (odůvodnění). V podstatě jde asi o to, dostat Clojure i na jinou platformu než JVM, v tomto případě JavaScript VM.

ClojureScript kompilátor generuje JavaScript, který (záměrně) odpovídá konvenci JavaScriptové knihovny Google Closure. Důvod je zřejmý - (Google) Closure Compiler. Tím se vysvětlují dva způsoby použití kompilátoru cljsc:

cljsc <file-or-dir> > out.js spustí pouze ClojureScript kompilátor a výsledný soubor "slinkuje" s knihovnou Closure Library.
cljsc <file-or-dir> {:optimiztions :advanced} > out.js dělá totéž, plus ještě následně prožene výsledný kód Closure Compilerem, který kód zoptimalizuje a vytvoří jeden kompaktní soubor.

Takže, pojďme se podívat na ten příklad. Vytvořím soubor hello.cljs. Metadata ^:export u definice funkce říkají, aby název výsledné funkce nebyl kompilátorem minifikovaný.

(ns hello)

(defn ^:export greet [n]
    (str "Hello, " n "!"))

Následně ho zkompiluju:

cljsc hello.cljs {:optimizations :advanced} > hello.js

A výsledný kód zavolám v prohlížeči:

<html>
<head>
    <title>ClojureScript</title>
    <script src="hello.js" type="text/javascript">
</script>
</head>
<body>
    <script type="text/javascript">
            alert(hello.greet("ClojureScript"));
    </script>
</body>
</html>

A výsledek?

Uf! Byla to dřina. :-|

Když to vezmu prakticky, tak zatím ClojureScript moc použitelný není. Problém jsou hlavně chybějící nástroje. Pokud ale jednou bude zaintegrován například do Leiningenu nebo Mavenu, tak si dokážu představit, že třeba ve spojení s Compojure půjde vytvořit kompletní webovou (klient/server) aplikaci pouze v Clojure. To by bylo komfortní.

10. srpna 2011

PragPub píše o ClojureScriptu

V uplynulých dnech se mojí (Google Reader) čtečkou prohnala smršť zpráviček a anoncí o ClojureScriptu. Nevím, jestli to není jen hype, který se kumuluje kolem CoffeeScriptu. Navíc ClojureScript je již nějaký čas součástí knihovny clojure-contrib.

Každopádně aktuální číslo mého oblíbeného e-časopisu PragPub obsahuje článek o ClojureScriptu. Kromě HTML jsou k dispozici i formáty mobi, epub a PDF.

29. července 2011

Jak měnit neměnitelné. Refs

Clojure používá neměnitelná (immutable) data/objekty. Pokud potřebujeme měnitelná (mutable) data, řeší to Clojure "měnitelnou referencí na neměnitelný objekt" :-) Jedním z prostředků, které toto řeší jsou Refs: jsou to transakční reference, které umožňují bezpečné sdílení měnitelných úložišť pomocí systému STM (Software Transactional Memory).

Měnitelná reference (ref) se vytvoří funkcí ref, její hodnotu vrací buď funkce deref, nebo makro @:

(def my-ref (ref "immutable data"))
; #'user/my-ref
my-ref
; #<ref@18352d8: "immutable data">
@my-ref
; "immutable data"
(deref my-ref)
; "immutable data"

Pokud chceme referenci nastavit na jinou (neměnitelnou) hodnotu, slouží k tomu funkce ref-set:

(ref-set my-ref "another immutable data")
; IllegalStateException No transaction running  clojure.lang.LockingTransaction.getEx (LockingTransaction.java:208)

Jejda! Zapomněli jsme na transakci :-)

(dosync (ref-set my-ref "another immutable data"))
; "another immutable data"
@my-ref
; "another immutable data"

Pokud chceme provést čtení hodnoty a zároveň její změnu v jednom kroku (= aplikovat na hodnotu funkci), je vhodné použít funkci alter:

(dosync (alter my-ref #(apply str (reverse %))))
; "atad elbatummi rehtona"
@my-ref
; "atad elbatummi rehtona"

Na reference je také možné přidat validace:

(def counter (ref 0 :validator number?))
; #'user/counter
(dosync (ref-set counter "string"))
; IllegalStateException Invalid reference state  clojure.lang.ARef.validate (ARef.java:33)
@counter
; 0
(dosync (ref-set counter 42))
; 42
@counter
; 42

O Refs jsem už jednou (trochu) psal. Z dnešního pohledu k tomu mám dvě výhrady:

místo ref-set jsem měl použít alter,
místo reference jsem měl použít atom.

ref-set je vhodné použít tehdy, pokud přiřazuji novou hodnotu (nepočítám ji). alter tehdy, pokud nad hodnotou provádím nějakou funkci (např. inkrementace, přidání hodnoty do kolekce apod.).

Při rozhodování, jestli použít ref nebo atom je podstatné, jestli využiju transakci - v transakci můžu updatovat více referencí. Pokud budu měnit pouze jedinou hodnotu (bez vazby na cokoli jiného) je vhodnější použít atom (a o těch až někdy příště).

24. července 2011

Nekonečná lenost sekvencí

Velmi silnou (a zajímavou) zbraní Clojure jsou sekvence (neboli seq, čti [si:k]). Sekvence je logický seznam, který implementuje jednoduché rozhraní ISeq a umožňuje sekvenční přístup k datům - a to nejenom k těm, u kterých bychom to čekali (kolekce = seznamy, mapy, apod.), ale i k těm, kde potřebné sekvenční implementační detaily chybí, např. stromové struktury (XML, adresáře), databázové result sety či textové soubory (buď jeden velký řetězec, nebo vektor řádků), I/O streamy, anebo obyčejné znakové řetězce (String).

Věc, na kterou bych se chtěl podívat je jednak lenost (laziness) a jednak (možná) nekonečnost (infiniteness) sekvencí. Laziness je známá např. z databázového/ORM světa, kdy se lazy typicky dotahují data v 1:N vztazích. Výhodou lazy sekvencí je:

odsunutí výpočtu, který možná nebude potřeba,
možnost práce s velkými daty, která se nevejdou do paměti,
odsunutí I/O operací, až budou opravdu potřeba.

Co se týká nekonečnosti, tam je to jasné - některé sekvence prostě jsou nekonečné: přirozená čísla, prvočísla, Fibonacciho posloupnost, atd.

Ukázkový příklad jsem převzal z knížky Programming Clojure a sice protože mi přišel tak dobrý, že se mi zdálo zbytečné vymýšlet příklad vlastní (ach ta lenost :-). Zajímá vás, jak vypadá milionté prvočíslo?

(use '[clojure.contrib.lazy-seqs :only (primes)])
; nil
(def ordinals-and-primes
  (map vector (iterate inc 1) primes))
; #'user/ordinals-and-primes
(first (drop 999999 ordinals-and-primes))
; [1000000 15485863]

Pro vysvětlení, Var primes obsahuje lazy sekvenci prvočísel, Var ordinals-and-primes obsahuje dvojice hodnot [pořadové-číslo prvočíslo]. Poslední příkaz (first (drop ... provede samotný výpočet sekvence prvočísel, zahodí prvních 999.999 hodnot a vrátí (pomocí first) tu 1.000.000tou. Vypočítat milion prvočísel chvilku trvá, takže třetí příkaz chvilku poběží. Spočítanou sekvenci už má pak ale Clojure nacachovanou, takže hodnoty pod milion nebo lehce nad vrací okamžitě.

17. července 2011

PragPub se věnuje Clojure

Vydavatelství The Pragmatic Bookshelf, které svého času založili někdejší signatáři Manifestu agilního vývoje softwaru Andy Hunt a Dave Thomas, vydává (zdarma) příjemný časopis, měsíčník PragPub. Aktuální červencové číslo se věnuje převážně Clojure. Jsou zde mmj. články o neměnnosti dat a kolekcích, nebo o DSL.

Kromě odkazovaného HTML vydání jsou na stránce vydaných čísel magazínu k dispozici i formáty mobi, epub a PDF.

15. června 2011

Rich Hickey: Radši trávím čas přemýšlením o problému

Skončil mi v Readeru zajímavý rozhovor s Richem Hickeym. Zajímavý byl i dotazovatel - Michael Fogus, autor knihy The Joy of Clojure. Rozhovor je trochu delší a dost špatně (typograficky) formátovaný, ale kvůli tomu obsahu stojí za to se tím prokousat.

Rich hovoří o svých zkušenostech programátora, co bylo před Clojure, co Clojure pozitivně a negativně ovlivnilo, apod. Zmíněn je také Richův seznam na Amazonu Clojure Bookshelf (mmch. inspirativní seznam pro čtení, už před časem jsem si tam pár kousků vybral).

Mmj. mě zaujalo, že Rich je spíš na debuggování (debugging master) a nepíše testy (TDD):

"If people think that spending fifty percent of their time writing tests maximizes their results—okay for them. I’m sure that’s not true for me—I’d rather spend that time thinking about my problem. I’m certain that, for me, this produces better solutions, with fewer defects, than any other use of my time."

A co dělá Rich pro zlepšení svých programátorských skillů?

"I read relentlessly. I don’t do any programming not directed at making the computer do something useful, so I don’t do any exercises. I try to spend more time thinking about the problem than I do typing it in."