ClojureScript 1.10.866 Release

Mostly a maintenance release, but the and/or compiler pass thing is somewhat neat. First, it might seem that such an optimization would not be that useful, but actually it's one of the most critical ones - we want to write the persistent data structure code in a language idiomatic way yet know that performance sensitive JavaScript code will be generated.

Here's the problem.

In Clojure `and` and `or` are just macros that expand to `let` + `if`, simple and elegant:

    (defmacro and
      ([] true)
      ([x] x)
      ([x & next]
       `(let [and# ~x]
          (if and# (and ~@next) and#))))

... except when you target JavaScript - which is not an expression oriented language. So `let` will be wrapped in an immediately invoked function expression (IIFE). Google Closure does elide these when it can, but it will give up after only a few levels of nesting. For an IIFE to appear in the middle of a conditional is a performance killer.

Another complication is that it's not safe to just use `&&` and `||` blindly because of `0` and the empty string and the other cases which are not false-y in Clojure(Script). Checks for JavaScript false-y values are a performance killer.

So years ago we implemented a simple form of type inference which annotates the AST with type information as a compiler pass on every node when possible. As long we know the JavaScript `if` will receive a boolean value we can elide the JS false-y value check.

But this is also exactly the information we need to safely run a following pass that looks for the above and/or syntactical patterns and optimize it. As long as each nested `if` is guaranteed to return a boolean, we can remove the local and use `&&` or `||` instead.

The and/or optimization pass ended up being ~120 lines of code with no actual dependencies on anything else in the ClojureScript analyzer or compiler because the ClojureScript AST is just plain EDN - https://github.com/clojure/clojurescript/blob/master/src/mai...

Happy to answer any further questions about this!

UPDATE: Also ClojureScript turned 10 years old this month :)

I haven't used clojure/clojurescript since more than 3-4 years. How far the performance of CLJS [:optimization :advanced] has come close to writing core js code ?

I still remember good old memories of using CLJS (around 2017-18), we were rewriting the android app for one of our clients ethanol selling company in Africa/kenya (which took roughly more than 6 months to write, test and deliver, still was crappy) in cordova/phonegap hybrid mobile app using CLJS, reagent and materialize.css. We did it in only 2 and half weeks with extensive test coverage. In my team only i knew clojure and played little bit with cljs and reagent while creating a to-do list app.

We never used to test the app after creating an android build, we were relying all the time chrome dev tools by hosting it as SPA app, writing test cases and fixing css & functionality issues if any. We were so confident that it will work as expected after exporting to .apk after simple codova/phonegap build process. More than 95% of the time, it always did.

I had to teach my other 2 teammates the basics of cljs and whole project development handling. It was the most challenging as well as productive 2 and half weeks of entire career. I never could imagine we could it develop it so fast with completely new language onboard. I had to play many tricks to allure my upper management to invest in a lisp dialect. I promised them to rewrite in under 6 weeks and ship to production. From 6 weeks commitment to 2 and half, we were on cloud 9. We also worked on weekends almost full time during that release.

Unfortunately due to some restrictions of supporting older android versions than 4.4 in kenya region we had to abandon the idea of hybrid app using cordova/phonegap after 3 months as more clients demanded.

As Clojure programmer since Clojure 1.1 I am so impressed with ClojureScript. I never had much use for ClojureScript but I always follow what going on. swannodette is the peak language maintenancer and helped push the initial idea further then I thought possible.

I remember the original talk by Rick and so much work was left. Congrats to the team.

P.S: Is there a real good ClojureScript library to work with maps and map data? Or a demo of how to do that kind of thing?

How is Google's Closure Compiler these days?

The last time I tried CLojurescript about 5 years ago it was the source of many a cryptic error, non-existent documentation, and no connection to any of the Javascript outside of Google-flavor javascript (such as not understanding either `require` or the then-new `import`s)

It looks like the documentation is as non-existent today, but it would be interesting to know how it fares in modern world.

I wonder if there's any interest from the ClojureScript community in pairing it with Deno for an easy-to-deploy Clojure alternative.

Random question: Can ClojureScript be compiled in the browser? I only looked at it when it first came out and at that time the ClojureScript compiler only ran via the JVM.

(I just don't understand this bracket)