ClojureScript Day #1 Important things to note This should be a dialog, not a lecture stop me, ask questions, understand deeply There are still many things I don’t know or haven’t decided some tasks will be research some pushback welcome I reserve BDFL rights :) This is an opportunity to get involved early stay flexible to avoid pain Welcome Chouser! One of my first and best users and contributors Someone whose opinions I value, and a Clojure expert Author of a Clojure book not (yet) working at Relevance! The first to walk down the ClojureScript road This is a key Clojure/core (with help) deliverable We do more than maintain, we lead community should be stunned (shhh!) I’m very excited about this aspect let’s knock this out of the park! Intro and rationale Problem statement Javascript is the only programmable technology in key target environments i.e. the browser nothing will change that for years to come Javascript has the greatest reach in other key environments i.e. mobile Javascript (the language) is not very robust Fewer good parts than bad parts Much convention and discipline required to avoid headaches Conventions differ between shops, libs Ever increasing pressure to create richer applications in these environments requiring more and larger libraries ordinary minification doesn’t scale up increasing requirements complexity can’t add language or environment complexity on top Rationale solving this problem will give developers important leverage empower them to tackle more difficult problems with greater confidence in the robustness of their solutions inspire next-generation approaches to web and mobile development Strategy Compile (a subset of) Clojure to Javascript reach everywhere JS does Clojure is simpler, more robust, more concise, more powerful overall than JS yet maps well to JS as implementation artifact Leverage best-of-breed JS appraoches Currently, IMO that is Google’s, with Closure compiler and libraries called gclosure hereafter Fortunately both open sourced Gclosure’s strategy is whole-program optimization resulting application includes only code actually used this is essential to writing large (and small) applications against large and manifold libraries while allowing those libs to be written in a straightforward, non-clever manner This is not just about the browser Node.js, plugins anywhere JS is accepted, any future JS-based environments Non-objectives complete Closure subset, but try to make identical features identical document differences porting large applications in their entirety portability layers unifying JS and Java cross platform reach is about moving core competencies and libraries, not everything Profit! ClojureScript becomes the most powerful language for generating the smallest and fastest JS applications ClojureScript runs everywhere JS runs This is Clojure’s client story This is Clojure’s mobile story A powerful tool for anyone willing to learn Clojure Tactics Don’t change Clojure itself even though it might make things easier track those things we’d like to be different, and work into Clojure dev schedule The ClojureScript compiler is written in Clojure The reader is Clojure’s Macros are written in Clojure therefor, no compiler at runtime, no eval browser-hosted REPL a non-target! also, some things that are runtime-reified in Clojure (namespaces, Vars) may not be in ClojureScript GClosure’s strategy requires JS to be written in a particular idiom especially for the most advanced optimization ClojureScript will always generate code compliant with advanced optimizations ClojureScript will use the same packaging and dependency strategy as gclosure The gclosure library is an accepted dependency but nothing else (other than base JS) ok, and maybe some stealing from GWT output, if we’re desperate but that’s really it in particular, use gclosure for all environmental conditionality we make no per-browser decisions ourselves The gclosure compiler is optional, but recommended for final delivery but don’t be too stupid without it The compiler has an enriched primitive set (vs Clojure’s) deftype defprotocol extend-type need no runtime lib allows bootstrap abstraction and data structures to be written in terms of these The runtime library is completely written in ClojureScript No Javascript! js* primitive escape hatch to reach gnarly stuff that ClojureScript won’t expose Presumptions JS is single-threaded, forever nevertheless, we will use Clojure reference primitives (at least atom) Roadmap Compiler It’s alive! a few more primitives to go output needs to be sussed out esp tested with gclosure compiler some niceties missing (load-file etc) Libraries Many core macros imported and work testing required some missing, like binding, dotimes This space intentionally left blank (core.cljs) that’s why you’re here! Much work, but following trodden ground Move the core abstractions to protocols Implement the core data structures with deftype copy fn impls, tweaking as needed Tooling ClojureScript written to the spec of gclosure Actual integration with tool chain TODO Deps builder Compilation with gclosure compiler drive through API for greatest control vs CLI finding/loading gclosure lib testing delivery REPL and other expected dev conveniences load (file), load-js Inside the compiler I will not be the only one who knows this! only 500 lines Recursive descent parser 2 phases analyze code data in -> AST data out all ordinary Clojure data each expr recursively analyzes nested exprs checks for correct structure emit AST data in -> print JS (via side effect to out) this allows with-out-str, or direct to file alternative - thread output stream, meh each expr recursively emits nested exprs Both analyze and emit are polymorphic using multimethods other than a little hand-routing at top of analyze, no global switch statement extend the compiler by defining parse and emit methods add special ops to specials set The threaded environment (env) most important, :context and :locals all name-introducing exprs (e.g. fn, let) augment the environment before passing to children Tricky bit - :context In ClojureScript everything is an expression but not in JS optimal output requires knowledge of the context :statement, :return, :expr non-exprs in expr contexts require transformation (usually a function wrapper) Primitives walkthrough if def fn* do let* loop* recur new set! ns deftype* . js* Macros walkthrough macroexpansion defprototype extend-type import-macros the core/core trick Evaluation model top down, form at a time just like Clojure just like JS What’s missing? validation that compilation ns resolved names exist in ns more correctness checking better error messages … strategy for apply What’s where src/clj/cljs/compiler.clj the compiler src/clj/cljs/core.clj core macros src/cljs/core.cljs core library Todo separate org file Breakout and tackle tasks we’ll substantially be in the same file ideas for making that work? Regroup and feedback