From ef4376fef9ba1fa77a12da5a92afcc5897d06e12 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 10:22:18 -0500 Subject: [PATCH 01/33] wip --- content/news/2025-11-24-release.adoc | 82 ++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 content/news/2025-11-24-release.adoc diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc new file mode 100644 index 00000000..7e201676 --- /dev/null +++ b/content/news/2025-11-24-release.adoc @@ -0,0 +1,82 @@ += 1.12.108 Release +ClojureScript Team +2025-11-25 12:00:00 +:jbake-type: post + +ifdef::env-github,env-browser[:outfilesuffix: .adoc] + +We're happy to announce a new release of ClojureScript. If you're an existing +user of ClojureScript please read over the following release notes carefully. + +This a major feature release with a significant number of enhancements. Before diving in note that Google Closure Compiler has been updated to `v20250820`. + +For a complete list of fixes, changes, and enhancements to +ClojureScript see +https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.108[here] + +## ECMAScript 2016 Language Specification + +ClojureScript, outside of a few small exceptions, has generated ECMAScript 3rd edition (1999) compatible code. We avoided any newer constructs because they only presented two undesirable outcomes: increased code size due to polyfilling and decreased performance due to yet unoptimized paths in JavaScript virtual machines. + +Nine years have passed since the ECMAScript 2016 was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` https://vincentrolfs.dev/blog/ts-var[continue to fail] to deliver any value for ClojureScript, features like `Proxy` and `Reflect` solve real problems at low, low prices. + +ClojureScript will now generate ES2016. + +## `cljs.proxy` + +While ClojureScript always had a strong interop story, it was never as complete as Clojure on the JVM due to the lack of common interfaces, i.e. `java.util.Map`. ClojureScript values must be marshalled to JavaScript values, generating a significant amount of computational waste. + +Enter `cljs.proxy`. This new experimental namespace uses ES2016 Proxy to lazily bridge ClojureScript maps and vectors to JavaScript. JavaScript code can now see ClojureScript maps as objects and vectors as array likes. `cljs.proxy` was carefully written to add very little overhead for object access patterns over a direct `-lookup` call. + +[source,clojure] +``` +(require '[cljs.proxy :refer [builder]] + '[goog.object :as gobj]) + +(def proxy (builder)) +(def proxied-map (proxy {:foo 1 :bar 2})) + +(gobj/get proxied-map "foo") ;; => 1 +``` + +The feature needs significant tire kicking, but we believe this approach offers considerable value over existing practice. + +## Clojure Method Values + +ClojureScript now supports Clojure 1.12 method value syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need `:param-tags` hinting or involved compiler analysis for good performance and In many situations, like foreign libraries, the required type information would not be available. + +[source,clojure] +``` +(refer-global :only '[String]) +(map String/.toUpperCase ["foo" "bar" "baz"]) ;; => ("FOO" "BAR" "BAZ") +``` + +## `:refer-global` and `:require-global` + +`:refer-global` lets a namespace declare what thing from the global environment are needed without `js` prefixing. It can also be combined with `:rename`. + +[source,clojure] +``` +(refer-global :only '[Date] :rename '{Date my-date}) +(my-date/new) +``` + +`:require-global` lets you use JavaScripy librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity. Hypermedia frameworks in particular have returned to the simpler world where at most you needed exactly one dependency to be productive. + +Add the one script tag you need and use it from ClojureScript. + +## `:lite-mode` and `:elide-to-string` + +While ClojureScript enables writing ambitious programs for JavaScript targets, not allows are ambitious. There is light scripting, say for a blog, that is not currentlt well served by ClojureScript. + +ClojureScript packs in a very large number of features and produces a small artifact, usually starting at 20K compressed. Thanks to Google Closure Compiler tree-shaking, you could use a lot functionality from Google Closure Library and expect your final artifact to increase slowly. + +Still the hard 20K compressed wall remained. After some time in the hammock we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they were more decoupled and involved less code. By tweaking the compiler to emit calls these instead under `:lite-mode` we could let tree-shaking sort it out. + +The other code issue in ClojureScript programs is printing. While necessary to deliver the LISP experience at the REPL, for many smaller programs, the machinery is dead weight. `:elide-to-string` removes the `toString` implementations for the ClojureScript collection. + +Combining these two new experimental flags cuts artifact size by a third. Note they cannot be used to make larger ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings are a wash. + +However for people who know that they want to build something ver small, yet not give up on the bits of `cljs.core` and Google Closure Library that they, these two new flags offer great value. + +We're excited to hear feedback about all these new features! \ No newline at end of file From 700f7c028333c315943f16c1a76573c2b2dcb0b8 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 11:49:55 -0500 Subject: [PATCH 02/33] wip --- content/news/2025-11-24-release.adoc | 49 +++++++++++++++++++--------- 1 file changed, 34 insertions(+), 15 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 7e201676..dc38b390 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -16,15 +16,15 @@ https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.108[here] ## ECMAScript 2016 Language Specification -ClojureScript, outside of a few small exceptions, has generated ECMAScript 3rd edition (1999) compatible code. We avoided any newer constructs because they only presented two undesirable outcomes: increased code size due to polyfilling and decreased performance due to yet unoptimized paths in JavaScript virtual machines. +ClojureScript, outside of a few small exceptions, has generated ECMAScript 3rd edition (1999) compatible code. We avoided any newer constructs because historically they offered undesirable outcomes: increased code size due to polyfilling and decreased performance due to yet unoptimized paths in JavaScript virtual machines. -Nine years have passed since the ECMAScript 2016 was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` https://vincentrolfs.dev/blog/ts-var[continue to fail] to deliver any value for ClojureScript, features like `Proxy` and `Reflect` solve real problems at low, low prices. +Nine years have passed since the ECMAScript 2016 was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` surprisingly https://vincentrolfs.dev/blog/ts-var[fail] to deliver much value for ClojureScript, features like `Proxy` and `Reflect` solve real problems at low, low prices. -ClojureScript will now generate ES2016. +ClojureScript will use ES2016 moving foward where it delivers value and performance benefits. ## `cljs.proxy` -While ClojureScript always had a strong interop story, it was never as complete as Clojure on the JVM due to the lack of common interfaces, i.e. `java.util.Map`. ClojureScript values must be marshalled to JavaScript values, generating a significant amount of computational waste. +ClojureScript interop story, while strong, was never as complete as Clojure on the JVM due to the lack of common interfaces, i.e. `java.util.Map`. ClojureScript values had to be marshalled to JavaScript values via `clj->js`, generating a significant amount of computational waste. Enter `cljs.proxy`. This new experimental namespace uses ES2016 Proxy to lazily bridge ClojureScript maps and vectors to JavaScript. JavaScript code can now see ClojureScript maps as objects and vectors as array likes. `cljs.proxy` was carefully written to add very little overhead for object access patterns over a direct `-lookup` call. @@ -39,11 +39,11 @@ Enter `cljs.proxy`. This new experimental namespace uses ES2016 Proxy to lazily (gobj/get proxied-map "foo") ;; => 1 ``` -The feature needs significant tire kicking, but we believe this approach offers considerable value over existing practice. +This feature needs commmunity tire kicking, but we believe this approach offers sizeable benefits over existing practice. ## Clojure Method Values -ClojureScript now supports Clojure 1.12 method value syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need `:param-tags` hinting or involved compiler analysis for good performance and In many situations, like foreign libraries, the required type information would not be available. +ClojureScript now supports Clojure 1.12 method value syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need manual `:param-tags` hinting for good performance, and it covers the many cases where type information will simply not be available to the ClojureScript compiler. [source,clojure] ``` @@ -53,7 +53,7 @@ ClojureScript now supports Clojure 1.12 method value syntax as well as static fi ## `:refer-global` and `:require-global` -`:refer-global` lets a namespace declare what thing from the global environment are needed without `js` prefixing. It can also be combined with `:rename`. +`:refer-global` lets a namespace declare what definitions from the global environment should available in the current namespace without `js` prefixing. It can be combined with `:rename`. [source,clojure] ``` @@ -61,22 +61,41 @@ ClojureScript now supports Clojure 1.12 method value syntax as well as static fi (my-date/new) ``` -`:require-global` lets you use JavaScripy librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity. Hypermedia frameworks in particular have returned to the simpler world where at most you needed exactly one dependency to be productive. +`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that simplify tooling complexity. Hypermedia frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. -Add the one script tag you need and use it from ClojureScript. +ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build Web Components and want to side-step the JavaScript dependency churn and tooling burden entirely. + +[source,clojure] +``` +(require-global '[Idiomorph :as idio]) +(idio/morph ...) +``` ## `:lite-mode` and `:elide-to-string` -While ClojureScript enables writing ambitious programs for JavaScript targets, not allows are ambitious. There is light scripting, say for a blog, that is not currentlt well served by ClojureScript. +While ClojureScript enables writing ambitious programs for JavaScript targets, not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. + +ClojureScript always produced a reasonably small artifact, usually starting at 20K compressed. And thanks to Google Closure Compiler tree-shaking, you could leverage powerful functionality from Google Closure Library and expect the size of your final artifact to increase slowly. -ClojureScript packs in a very large number of features and produces a small artifact, usually starting at 20K compressed. Thanks to Google Closure Compiler tree-shaking, you could use a lot functionality from Google Closure Library and expect your final artifact to increase slowly. +Still the hard 20K compressed wall remained. After some time in the hammock, we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they are decoupled and involve less code. By tweaking the ClojureScript compiler to emit calls to the older constructors instead under a new `:lite-mode` flag, tree-shaking can eliminate the now unused fancier data structures. -Still the hard 20K compressed wall remained. After some time in the hammock we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they were more decoupled and involved less code. By tweaking the compiler to emit calls these instead under `:lite-mode` we could let tree-shaking sort it out. +The other code size issue in ClojureScript programs is printing. While necessary to deliver the LISP experience at the REPL, for less ambitious artifacts the machinery is just dead weight. `:elide-to-string` removes the `toString` implementations for the ClojureScript collections. -The other code issue in ClojureScript programs is printing. While necessary to deliver the LISP experience at the REPL, for many smaller programs, the machinery is dead weight. `:elide-to-string` removes the `toString` implementations for the ClojureScript collection. +Combining these two new experimental flags cuts the starting artifact size by a third. However, it's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided by `:lite-mode` are a wash. -Combining these two new experimental flags cuts artifact size by a third. Note they cannot be used to make larger ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings are a wash. +Bu for people who know that they want to build something very compact, yet not give up on the bits of `cljs.core` and Google Closure Library that they need, these two new flags offer great value. -However for people who know that they want to build something ver small, yet not give up on the bits of `cljs.core` and Google Closure Library that they, these two new flags offer great value. +The following program is 6K Brotli compressed with `:lite-mode` + `:elide-to-string` +true. + +[source,clojure] +``` +(->> (map inc (range 10)) + (filter even?) + (partition 2) + (drop 1) + (mapcat identity) + into-array) +``` We're excited to hear feedback about all these new features! \ No newline at end of file From 0e57d8d5db18e56805af189c9be85fdf2b01f38f Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 11:55:50 -0500 Subject: [PATCH 03/33] tweaks --- content/news/2025-11-24-release.adoc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index dc38b390..6e357e4e 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -77,13 +77,13 @@ While ClojureScript enables writing ambitious programs for JavaScript targets, n ClojureScript always produced a reasonably small artifact, usually starting at 20K compressed. And thanks to Google Closure Compiler tree-shaking, you could leverage powerful functionality from Google Closure Library and expect the size of your final artifact to increase slowly. -Still the hard 20K compressed wall remained. After some time in the hammock, we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they are decoupled and involve less code. By tweaking the ClojureScript compiler to emit calls to the older constructors instead under a new `:lite-mode` flag, tree-shaking can eliminate the now unused fancier data structures. +Still the hard 20K compressed wall remained. After some time in the hammock, we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they are decoupled and involve less code. By tweaking the ClojureScript compiler to emit calls to the older constructors instead under a new `:lite-mode` flag, tree-shaking can eliminate the persistent implementations. -The other code size issue in ClojureScript programs is printing. While necessary to deliver the LISP experience at the REPL, for less ambitious artifacts the machinery is just dead weight. `:elide-to-string` removes the `toString` implementations for the ClojureScript collections. +The other code size issue in ClojureScript programs is printing. While required to deliver the LISP experience at the REPL, for less ambitious artifacts the machinery is just dead weight. `:elide-to-string` removes the `toString` implementations for collections types improving tree-shaking. -Combining these two new experimental flags cuts the starting artifact size by a third. However, it's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided by `:lite-mode` are a wash. +Combining these two new experimental flags cuts the starting artifact size by two thirds. However, it's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided by `:lite-mode` are a wash. -Bu for people who know that they want to build something very compact, yet not give up on the bits of `cljs.core` and Google Closure Library that they need, these two new flags offer great value. +But for people who know that they want to build something very compact, yet not give up on the bits of `cljs.core` and Google Closure Library that they need, these two new flags offer great value. The following program is 6K Brotli compressed with `:lite-mode` + `:elide-to-string` true. From 801fbdc16a7b0bb58c8795e9eeb9ae072ec43947 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 11:58:43 -0500 Subject: [PATCH 04/33] wip --- content/news/2025-11-24-release.adoc | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 6e357e4e..5a7dfcb0 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -98,4 +98,12 @@ true. into-array) ``` -We're excited to hear feedback about all these new features! \ No newline at end of file +We're excited to hear feedback about all these new features! + +## Contributors + +Thanks to all of the community members who contributed to ClojureScript 1.12.108 + +* Michel Borkent +* Paula Gearon +* Roman Liutikov From 94648b98095f448896f2c79f2763788cf3f79503 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:05:45 -0500 Subject: [PATCH 05/33] typo --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 5a7dfcb0..6a55c735 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -24,7 +24,7 @@ ClojureScript will use ES2016 moving foward where it delivers value and performa ## `cljs.proxy` -ClojureScript interop story, while strong, was never as complete as Clojure on the JVM due to the lack of common interfaces, i.e. `java.util.Map`. ClojureScript values had to be marshalled to JavaScript values via `clj->js`, generating a significant amount of computational waste. +ClojureScript's interop story, while strong, was never as complete as Clojure on the JVM due to the lack of common interfaces, i.e. `java.util.Map`. ClojureScript values had to be marshalled to JavaScript values via `clj->js`, generating a significant amount of computational waste. Enter `cljs.proxy`. This new experimental namespace uses ES2016 Proxy to lazily bridge ClojureScript maps and vectors to JavaScript. JavaScript code can now see ClojureScript maps as objects and vectors as array likes. `cljs.proxy` was carefully written to add very little overhead for object access patterns over a direct `-lookup` call. From e3c9632aa5797e46d411b43716d73db62c2455f8 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:06:22 -0500 Subject: [PATCH 06/33] tweak --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 6a55c735..f99d9b3f 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -26,7 +26,7 @@ ClojureScript will use ES2016 moving foward where it delivers value and performa ClojureScript's interop story, while strong, was never as complete as Clojure on the JVM due to the lack of common interfaces, i.e. `java.util.Map`. ClojureScript values had to be marshalled to JavaScript values via `clj->js`, generating a significant amount of computational waste. -Enter `cljs.proxy`. This new experimental namespace uses ES2016 Proxy to lazily bridge ClojureScript maps and vectors to JavaScript. JavaScript code can now see ClojureScript maps as objects and vectors as array likes. `cljs.proxy` was carefully written to add very little overhead for object access patterns over a direct `-lookup` call. +Enter `cljs.proxy`. This new experimental namespace uses ES2016 Proxy to lazily bridge ClojureScript maps and vectors to JavaScript. JavaScript code can now see ClojureScript maps as objects and vectors as array-likes. `cljs.proxy` was carefully written to add very little overhead for object access patterns over a direct `-lookup` call. [source,clojure] ``` From 03675e18d21873621e365fa9fccc2039ea4ee2f6 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:23:30 -0500 Subject: [PATCH 07/33] comma --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index f99d9b3f..c4a1030a 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -8,7 +8,7 @@ ifdef::env-github,env-browser[:outfilesuffix: .adoc] We're happy to announce a new release of ClojureScript. If you're an existing user of ClojureScript please read over the following release notes carefully. -This a major feature release with a significant number of enhancements. Before diving in note that Google Closure Compiler has been updated to `v20250820`. +This a major feature release with a significant number of enhancements. Before diving in, note that Google Closure Compiler has been updated to `v20250820`. For a complete list of fixes, changes, and enhancements to ClojureScript see From 6f0e0face0f6b72e21ad00bc72e41331b399f2b4 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:27:29 -0500 Subject: [PATCH 08/33] change language --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index c4a1030a..b2b62ae2 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -43,7 +43,7 @@ This feature needs commmunity tire kicking, but we believe this approach offers ## Clojure Method Values -ClojureScript now supports Clojure 1.12 method value syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need manual `:param-tags` hinting for good performance, and it covers the many cases where type information will simply not be available to the ClojureScript compiler. +ClojureScript now supports Clojure 1.12 method value syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need manual `:param-tags` for disambiguation, and it covers the many cases where type information will simply not be available to the ClojureScript compiler. [source,clojure] ``` From 99c5d89c70c928efee4777a523387504353fde79 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:30:46 -0500 Subject: [PATCH 09/33] tweak --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index b2b62ae2..9e3cffa5 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -61,7 +61,7 @@ ClojureScript now supports Clojure 1.12 method value syntax as well as static fi (my-date/new) ``` -`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that simplify tooling complexity. Hypermedia frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. +`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that eliminate it. Hypermedia frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build Web Components and want to side-step the JavaScript dependency churn and tooling burden entirely. From c8b5414a5db1d2612d0da955db3ec13f34d08994 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:31:32 -0500 Subject: [PATCH 10/33] tweak --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 9e3cffa5..079090eb 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -63,7 +63,7 @@ ClojureScript now supports Clojure 1.12 method value syntax as well as static fi `:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that eliminate it. Hypermedia frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. -ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build Web Components and want to side-step the JavaScript dependency churn and tooling burden entirely. +ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build Web Components and want to sidestep the JavaScript dependency churn and tooling burden. [source,clojure] ``` From bf0473ac5bbc4d851a66b62df8825cf35539249c Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 12:33:12 -0500 Subject: [PATCH 11/33] tweak --- content/news/2025-11-24-release.adoc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 079090eb..74633647 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -85,8 +85,7 @@ Combining these two new experimental flags cuts the starting artifact size by tw But for people who know that they want to build something very compact, yet not give up on the bits of `cljs.core` and Google Closure Library that they need, these two new flags offer great value. -The following program is 6K Brotli compressed with `:lite-mode` + `:elide-to-string` -true. +The following program is 6K Brotli compressed with `:lite-mode` and `:elide-to-string`. [source,clojure] ``` From ff42ff3456a63897fb78cb43fbe99a696a6c4cf7 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 13:32:54 -0500 Subject: [PATCH 12/33] change release number --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 74633647..d5486fa4 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -1,4 +1,4 @@ -= 1.12.108 Release += 1.12.110 Release ClojureScript Team 2025-11-25 12:00:00 :jbake-type: post From 77cdda616d321e5baa7718178aa9f99f08f214a7 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 13:42:03 -0500 Subject: [PATCH 13/33] links --- content/news/2025-11-24-release.adoc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index d5486fa4..ff2f061a 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -12,13 +12,13 @@ This a major feature release with a significant number of enhancements. Before d For a complete list of fixes, changes, and enhancements to ClojureScript see -https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.108[here] +https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.110[here] ## ECMAScript 2016 Language Specification -ClojureScript, outside of a few small exceptions, has generated ECMAScript 3rd edition (1999) compatible code. We avoided any newer constructs because historically they offered undesirable outcomes: increased code size due to polyfilling and decreased performance due to yet unoptimized paths in JavaScript virtual machines. +ClojureScript, outside of a few small exceptions, has generated https://www.ecma-international.org/wp-content/uploads/ECMA-262_3rd_edition_december_1999.pdf[ECMAScript 3rd edition (1999)] compatible code. We avoided any newer constructs because historically they offered undesirable outcomes: increased code size due to polyfilling and decreased performance due to yet unoptimized paths in JavaScript virtual machines. -Nine years have passed since the ECMAScript 2016 was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` surprisingly https://vincentrolfs.dev/blog/ts-var[fail] to deliver much value for ClojureScript, features like `Proxy` and `Reflect` solve real problems at low, low prices. +Nine years have passed since the https://262.ecma-international.org/7.0/[ECMAScript 2016] was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` surprisingly https://vincentrolfs.dev/blog/ts-var[fail] to deliver much value for ClojureScript, features like https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy[Proxy] and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect[Reflect] solve real problems at low, low prices. ClojureScript will use ES2016 moving foward where it delivers value and performance benefits. @@ -43,7 +43,7 @@ This feature needs commmunity tire kicking, but we believe this approach offers ## Clojure Method Values -ClojureScript now supports Clojure 1.12 method value syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need manual `:param-tags` for disambiguation, and it covers the many cases where type information will simply not be available to the ClojureScript compiler. +ClojureScript now supports https://clojure.org/reference/java_interop#methodvalues[Clojure 1.12 method value] syntax as well as static field syntax. `PersistentVector/EMPTY` works, but also `String/.toUpperCase` and `Object/new`. Thanks to ES2016 `Reflect` we do not need manual `:param-tags` for disambiguation, and it covers the many cases where type information will simply not be available to the ClojureScript compiler. [source,clojure] ``` @@ -83,7 +83,7 @@ The other code size issue in ClojureScript programs is printing. While required Combining these two new experimental flags cuts the starting artifact size by two thirds. However, it's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided by `:lite-mode` are a wash. -But for people who know that they want to build something very compact, yet not give up on the bits of `cljs.core` and Google Closure Library that they need, these two new flags offer great value. +But for people who know that they want to build something very compact, yet not give up on useful bits of `cljs.core` and Google Closure Library, these two new flags deliver more control. The following program is 6K Brotli compressed with `:lite-mode` and `:elide-to-string`. From c2ccaa953ef9ad125c769d0f0a7519ce7d969398 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 13:53:02 -0500 Subject: [PATCH 14/33] more links --- content/news/2025-11-24-release.adoc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index ff2f061a..970bb556 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -61,9 +61,9 @@ ClojureScript now supports https://clojure.org/reference/java_interop#methodvalu (my-date/new) ``` -`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that eliminate it. Hypermedia frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. +`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that eliminate it. https://hypermedia.systems[Hypermedia] frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. -ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build Web Components and want to sidestep the JavaScript dependency churn and tooling burden. +ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build https://developer.mozilla.org/en-US/docs/Web/API/Web_components[Web Components] and want to sidestep the JavaScript dependency churn and tooling burden. [source,clojure] ``` From 40d56525970a2a46f7f14e7237908f03f5184e1c Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 14:20:43 -0500 Subject: [PATCH 15/33] compiler flag --- content/news/2025-11-24-release.adoc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 970bb556..b7dd581a 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -77,9 +77,9 @@ While ClojureScript enables writing ambitious programs for JavaScript targets, n ClojureScript always produced a reasonably small artifact, usually starting at 20K compressed. And thanks to Google Closure Compiler tree-shaking, you could leverage powerful functionality from Google Closure Library and expect the size of your final artifact to increase slowly. -Still the hard 20K compressed wall remained. After some time in the hammock, we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they are decoupled and involve less code. By tweaking the ClojureScript compiler to emit calls to the older constructors instead under a new `:lite-mode` flag, tree-shaking can eliminate the persistent implementations. +Still the hard 20K compressed wall remained. After some time in the hammock, we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they are decoupled and involve less code. By tweaking the ClojureScript compiler to emit calls to the older constructors instead under a new `:lite-mode` compiler flag, tree-shaking can eliminate the persistent implementations. -The other code size issue in ClojureScript programs is printing. While required to deliver the LISP experience at the REPL, for less ambitious artifacts the machinery is just dead weight. `:elide-to-string` removes the `toString` implementations for collections types improving tree-shaking. +The other code size issue in ClojureScript programs is printing. While required to deliver the LISP experience at the REPL, for less ambitious artifacts the machinery is just dead weight. The `:elide-to-string` compiler flag removes the `toString` implementations for collections types improving tree-shaking. Combining these two new experimental flags cuts the starting artifact size by two thirds. However, it's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided by `:lite-mode` are a wash. From fe5732efe89e79beec852367bacbd991de8af0b2 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 14:21:23 -0500 Subject: [PATCH 16/33] update quick start --- content/guides/quick-start.adoc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/content/guides/quick-start.adoc b/content/guides/quick-start.adoc index 9d2660e7..6bc7358f 100644 --- a/content/guides/quick-start.adoc +++ b/content/guides/quick-start.adoc @@ -15,7 +15,7 @@ part of this tutorial are a web browser and an installation of https://clojure.org/guides/getting_started[Clojure]. On Windows you will need https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html[Java 21] and the -https://github.com/clojure/clojurescript/releases/download/r1.12.42/cljs.jar[standalone +https://github.com/clojure/clojurescript/releases/download/r1.12.110/cljs.jar[standalone ClojureScript JAR]. Note that the requirement of a web browser excludes headless environments, and we then recommend skimming to the Node.js portion of the tutorial. @@ -45,7 +45,7 @@ If you are on macOS or Linux your `deps.edn` file should contain the following: [source,clojure] ---- -{:deps {org.clojure/clojurescript {:mvn/version "1.12.42"}}} +{:deps {org.clojure/clojurescript {:mvn/version "1.12.110"}}} ---- In your favorite text editor edit the `src/hello_world/core.cljs` to @@ -308,7 +308,7 @@ Modify your `deps.edn` file: [source,clojure] ---- -{:deps {org.clojure/clojurescript {:mvn/version "1.12.42"} +{:deps {org.clojure/clojurescript {:mvn/version "1.12.110"} cljsjs/react-dom {:mvn/version "16.2.0-3"}}} ---- From 6c44bf4893342f66636bc5fc6daa9a02e6563265 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 14:26:34 -0500 Subject: [PATCH 17/33] add new compiler options --- content/reference/compiler-options.adoc | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/content/reference/compiler-options.adoc b/content/reference/compiler-options.adoc index c9d28db5..162e2b85 100644 --- a/content/reference/compiler-options.adoc +++ b/content/reference/compiler-options.adoc @@ -691,6 +691,18 @@ Whether to elide `use strict` statements in JavaScript output. Defaults to `true :elide-strict false ---- +[[elide-to-string]] +=== :elide-to-string + +EXPERIMENTAL. Elide `.toString` implementations from ClojueScript +collections. Intended to be paired with `:lite-mode`. Useful only for +simpler programs. + +[source,clojure] +---- +:elide-to-string true +---- + [[fingerprint]] === :fingerprint @@ -804,6 +816,18 @@ Defaults to the empty vector `[]` "src/org/example/example.js"] ---- +[[lite-mode]] +=== :lite-mode + +EXPERIMENTAL. Clojure data literals will emit constructor calls to lighter weight +copy-on-write data structures. Enable smaller advanced compiled artifacts +for less complex programs. + +[source,clojure] +---- +:lite-mode true +---- + [[nodejs-rt]] === :nodejs-rt From 8027e03d32aaed6c23150115b818b1620c1d8c01 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 15:04:15 -0500 Subject: [PATCH 18/33] bump version --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index b7dd581a..57e2e3bb 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -101,7 +101,7 @@ We're excited to hear feedback about all these new features! ## Contributors -Thanks to all of the community members who contributed to ClojureScript 1.12.108 +Thanks to all of the community members who contributed to ClojureScript 1.12.110 * Michel Borkent * Paula Gearon From 132e7d350cafecd6608b87fe280e343288151b84 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 15:11:57 -0500 Subject: [PATCH 19/33] clarify :lite-mode --- content/reference/compiler-options.adoc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/content/reference/compiler-options.adoc b/content/reference/compiler-options.adoc index 162e2b85..af749cf5 100644 --- a/content/reference/compiler-options.adoc +++ b/content/reference/compiler-options.adoc @@ -819,9 +819,10 @@ Defaults to the empty vector `[]` [[lite-mode]] === :lite-mode -EXPERIMENTAL. Clojure data literals will emit constructor calls to lighter weight -copy-on-write data structures. Enable smaller advanced compiled artifacts -for less complex programs. +EXPERIMENTAL. Clojure data literals will emit constructor calls to +lighter weight copy-on-write data structures. Results in smaller +advanced compiled artifacts. Useful only for simpler programs. See +also `:elide-to-string`. [source,clojure] ---- From c809cd706f6ff910fde731a2e7a0d52ed9dbad16 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 15:26:52 -0500 Subject: [PATCH 20/33] less verbiage in the :lite-mode section --- content/news/2025-11-24-release.adoc | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 57e2e3bb..468d1b61 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -73,15 +73,13 @@ ClojureScript now supports hypermedia-centric development approaches where you m ## `:lite-mode` and `:elide-to-string` -While ClojureScript enables writing ambitious programs for JavaScript targets, not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. +Not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. -ClojureScript always produced a reasonably small artifact, usually starting at 20K compressed. And thanks to Google Closure Compiler tree-shaking, you could leverage powerful functionality from Google Closure Library and expect the size of your final artifact to increase slowly. +How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. By having ClojureScript compiler to emit calls to the older constructors instead under the new `:lite-mode` compiler flag, tree-shaking can eliminate the heavier persistent implementations. -Still the hard 20K compressed wall remained. After some time in the hammock, we decided to travel all the way back to 2011 and bring back the original data structures that Rich Hickey and Think Relevance included in the standard library. While not as efficient, they are decoupled and involve less code. By tweaking the ClojureScript compiler to emit calls to the older constructors instead under a new `:lite-mode` compiler flag, tree-shaking can eliminate the persistent implementations. +Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. -The other code size issue in ClojureScript programs is printing. While required to deliver the LISP experience at the REPL, for less ambitious artifacts the machinery is just dead weight. The `:elide-to-string` compiler flag removes the `toString` implementations for collections types improving tree-shaking. - -Combining these two new experimental flags cuts the starting artifact size by two thirds. However, it's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided by `:lite-mode` are a wash. +Combining these two experimental flags cuts the starting artifact size by two thirds. It's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided are a wash. But for people who know that they want to build something very compact, yet not give up on useful bits of `cljs.core` and Google Closure Library, these two new flags deliver more control. From 1b279cbe0731e1f3567b0ddd476dda68daff072c Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 15:29:07 -0500 Subject: [PATCH 21/33] tweak --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 468d1b61..abbed272 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -75,7 +75,7 @@ ClojureScript now supports hypermedia-centric development approaches where you m Not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. -How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. By having ClojureScript compiler to emit calls to the older constructors instead under the new `:lite-mode` compiler flag, tree-shaking can eliminate the heavier persistent implementations. +How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. By having ClojureScript compiler to emit calls to the older constructors with the new `:lite-mode` compiler flag, tree-shaking can eliminate the heavier persistent implementations. Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. From 5bb2cd9b1d6234e89c685a675c1543a0d992f730 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 16:10:56 -0500 Subject: [PATCH 22/33] wip --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index abbed272..369842b0 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -75,7 +75,7 @@ ClojureScript now supports hypermedia-centric development approaches where you m Not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. -How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. By having ClojureScript compiler to emit calls to the older constructors with the new `:lite-mode` compiler flag, tree-shaking can eliminate the heavier persistent implementations. +How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. By having the ClojureScript compiler emit calls to the older constructors with the new `:lite-mode` compiler flag, tree-shaking can eliminate the heavier persistent implementations. Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. From 4d2e7c4747d2ea0d879e60a29bcf5f9fea5b4357 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 16:13:53 -0500 Subject: [PATCH 23/33] tweaks --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 369842b0..c7d0818c 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -75,7 +75,7 @@ ClojureScript now supports hypermedia-centric development approaches where you m Not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. -How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. By having the ClojureScript compiler emit calls to the older constructors with the new `:lite-mode` compiler flag, tree-shaking can eliminate the heavier persistent implementations. +How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. Setting the new `:lite-mode` compiler to `true` makes the ClojureScript compiler emit calls to the older constructors and tree-shaking can eliminate the heavier persistent implementations. Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. From bd676786106b836c6424f1c40632c29062357f72 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 16:16:33 -0500 Subject: [PATCH 24/33] wip --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index c7d0818c..cfe8ff7a 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -75,7 +75,7 @@ ClojureScript now supports hypermedia-centric development approaches where you m Not all programs we might want to write require ambition. There are light scripting use cases, say for a blog, that are not currently well served by ClojureScript. -How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. Setting the new `:lite-mode` compiler to `true` makes the ClojureScript compiler emit calls to the older constructors and tree-shaking can eliminate the heavier persistent implementations. +How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. Setting the new `:lite-mode` compiler flag to `true` makes the ClojureScript compiler emit calls to the older constructors and tree-shaking can eliminate the heavier persistent implementations. Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. From 823459d7c6781fc08c972e3180b0ce19b8234532 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 17:13:50 -0500 Subject: [PATCH 25/33] wip --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index cfe8ff7a..2daadf00 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -63,7 +63,7 @@ ClojureScript now supports https://clojure.org/reference/java_interop#methodvalu `:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that eliminate it. https://hypermedia.systems[Hypermedia] frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. -ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojueScript / Google Closure Library primarily to build https://developer.mozilla.org/en-US/docs/Web/API/Web_components[Web Components] and want to sidestep the JavaScript dependency churn and tooling burden. +ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojureScript / Google Closure Library primarily to build https://developer.mozilla.org/en-US/docs/Web/API/Web_components[Web Components] and want to sidestep the JavaScript dependency churn and tooling burden. [source,clojure] ``` From b9084741b1ed14fcb27e97775a876a21505f2797 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 20:29:22 -0500 Subject: [PATCH 26/33] wip --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 2daadf00..73074580 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -79,7 +79,7 @@ How to break the 20K compressed wall? After some time in the hammock, we decided Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. -Combining these two experimental flags cuts the starting artifact size by two thirds. It's important to understand these flags cannot be used to make *large* ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided are a wash. +Combining these two experimental flags cuts the starting artifact size by two thirds. It's important to understand these flags cannot be used to make large ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided are a wash. But for people who know that they want to build something very compact, yet not give up on useful bits of `cljs.core` and Google Closure Library, these two new flags deliver more control. From 1afc31cd1fc2170f441fcd467f33567336aeec49 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 21:04:27 -0500 Subject: [PATCH 27/33] typos and tweaks --- content/news/2025-11-24-release.adoc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 73074580..da695f25 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -20,7 +20,7 @@ ClojureScript, outside of a few small exceptions, has generated https://www.ecma Nine years have passed since the https://262.ecma-international.org/7.0/[ECMAScript 2016] was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` surprisingly https://vincentrolfs.dev/blog/ts-var[fail] to deliver much value for ClojureScript, features like https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy[Proxy] and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect[Reflect] solve real problems at low, low prices. -ClojureScript will use ES2016 moving foward where it delivers value and performance benefits. +ClojureScript will use ES2016 moving forward where it delivers value and performance benefits. ## `cljs.proxy` @@ -77,11 +77,11 @@ Not all programs we might want to write require ambition. There are light script How to break the 20K compressed wall? After some time in the hammock, we decided to travel back to 2011 and resurface the original data structures that Rich Hickey and co. included in the standard library. While not as efficient, they are decoupled and smaller. Setting the new `:lite-mode` compiler flag to `true` makes the ClojureScript compiler emit calls to the older constructors and tree-shaking can eliminate the heavier persistent implementations. -Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to better tree-shaking. +Printing is another blocker for very compact artifacts. Many simpler programs will never recursively print EDN. The `:elide-to-string` compiler flag removes the `toString` implementations leading to improved tree-shaking. -Combining these two experimental flags cuts the starting artifact size by two thirds. It's important to understand these flags cannot be used to make large ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings provided are a wash. +Combining these two experimental flags cuts the initial artifact size by two thirds. It's important to understand these flags cannot be used to make large ClojureScript programs smaller - once you have enough dependencies or rely on enough features, the savings are a wash. -But for people who know that they want to build something very compact, yet not give up on useful bits of `cljs.core` and Google Closure Library, these two new flags deliver more control. +But for people who know that they want to build something very compact, yet not give up on useful bits of `cljs.core` and Google Closure Library, these two new flags provide more control. The following program is 6K Brotli compressed with `:lite-mode` and `:elide-to-string`. From 926cb1ae2da063686a099724b4ff0a007a8d1297 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Sun, 23 Nov 2025 21:15:45 -0500 Subject: [PATCH 28/33] tweak --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index da695f25..af03fabf 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -18,7 +18,7 @@ https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.110[here] ClojureScript, outside of a few small exceptions, has generated https://www.ecma-international.org/wp-content/uploads/ECMA-262_3rd_edition_december_1999.pdf[ECMAScript 3rd edition (1999)] compatible code. We avoided any newer constructs because historically they offered undesirable outcomes: increased code size due to polyfilling and decreased performance due to yet unoptimized paths in JavaScript virtual machines. -Nine years have passed since the https://262.ecma-international.org/7.0/[ECMAScript 2016] was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` surprisingly https://vincentrolfs.dev/blog/ts-var[fail] to deliver much value for ClojureScript, features like https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy[Proxy] and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect[Reflect] solve real problems at low, low prices. +Nine years have passed since the https://262.ecma-international.org/7.0/[ECMAScript 2016] was released and the major JavaScript virtual machines now offer great performance across the specification. While language constructs like `let` surprisingly https://vincentrolfs.dev/blog/ts-var[fail] to deliver much value for ClojureScript, features like https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy[Proxy] and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect[Reflect] solve real problems at low prices. ClojureScript will use ES2016 moving forward where it delivers value and performance benefits. From 572eff095e13f4c874b0ddf963be620c5d69b114 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Mon, 24 Nov 2025 00:25:59 -0500 Subject: [PATCH 29/33] 110 -> 112 --- content/news/2025-11-24-release.adoc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index af03fabf..4a869d76 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -1,4 +1,4 @@ -= 1.12.110 Release += 1.12.112 Release ClojureScript Team 2025-11-25 12:00:00 :jbake-type: post @@ -12,7 +12,7 @@ This a major feature release with a significant number of enhancements. Before d For a complete list of fixes, changes, and enhancements to ClojureScript see -https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.110[here] +https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.112[here] ## ECMAScript 2016 Language Specification @@ -99,7 +99,7 @@ We're excited to hear feedback about all these new features! ## Contributors -Thanks to all of the community members who contributed to ClojureScript 1.12.110 +Thanks to all of the community members who contributed to ClojureScript 1.12.112 * Michel Borkent * Paula Gearon From 41cca6e0f55091f33e1f9ca6b051b41fc7f275ef Mon Sep 17 00:00:00 2001 From: davidnolen Date: Mon, 24 Nov 2025 08:40:35 -0500 Subject: [PATCH 30/33] link --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 4a869d76..0dcfb590 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -61,7 +61,7 @@ ClojureScript now supports https://clojure.org/reference/java_interop#methodvalu (my-date/new) ``` -`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and there is a growing population of developers moving to technologies that eliminate it. https://hypermedia.systems[Hypermedia] frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. +`:require-global` lets you use JavaScript librares that you included as script tags on the page without any further build configuration. JavaScript build tooling brings a considerable amount of additional complexity and now https://helixguard.ai/blog/malicious-sha1hulud-2025-11-24[risk] and there is a growing population of developers moving to technologies that eliminate it. https://hypermedia.systems[Hypermedia] frameworks in particular have returned to more innocent times where at most you needed exactly one JavaScript dependency to be productive. ClojureScript now supports hypermedia-centric development approaches where you might have only one dependency and you are using ClojureScript / Google Closure Library primarily to build https://developer.mozilla.org/en-US/docs/Web/API/Web_components[Web Components] and want to sidestep the JavaScript dependency churn and tooling burden. From e940e2b9b7684e8caebe5329c554f4fa54e0a18f Mon Sep 17 00:00:00 2001 From: davidnolen Date: Mon, 24 Nov 2025 09:28:00 -0500 Subject: [PATCH 31/33] change version --- content/guides/quick-start.adoc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/content/guides/quick-start.adoc b/content/guides/quick-start.adoc index 6bc7358f..dbde8124 100644 --- a/content/guides/quick-start.adoc +++ b/content/guides/quick-start.adoc @@ -15,7 +15,7 @@ part of this tutorial are a web browser and an installation of https://clojure.org/guides/getting_started[Clojure]. On Windows you will need https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html[Java 21] and the -https://github.com/clojure/clojurescript/releases/download/r1.12.110/cljs.jar[standalone +https://github.com/clojure/clojurescript/releases/download/r1.12.112/cljs.jar[standalone ClojureScript JAR]. Note that the requirement of a web browser excludes headless environments, and we then recommend skimming to the Node.js portion of the tutorial. @@ -45,7 +45,7 @@ If you are on macOS or Linux your `deps.edn` file should contain the following: [source,clojure] ---- -{:deps {org.clojure/clojurescript {:mvn/version "1.12.110"}}} +{:deps {org.clojure/clojurescript {:mvn/version "1.12.112"}}} ---- In your favorite text editor edit the `src/hello_world/core.cljs` to @@ -308,7 +308,7 @@ Modify your `deps.edn` file: [source,clojure] ---- -{:deps {org.clojure/clojurescript {:mvn/version "1.12.110"} +{:deps {org.clojure/clojurescript {:mvn/version "1.12.112"} cljsjs/react-dom {:mvn/version "16.2.0-3"}}} ---- From 488d15656bb2699a0211d07607a731a2ef90e013 Mon Sep 17 00:00:00 2001 From: davidnolen Date: Mon, 24 Nov 2025 12:17:14 -0500 Subject: [PATCH 32/33] typo --- content/news/2025-11-24-release.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 0dcfb590..1fad8e2c 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -53,7 +53,7 @@ ClojureScript now supports https://clojure.org/reference/java_interop#methodvalu ## `:refer-global` and `:require-global` -`:refer-global` lets a namespace declare what definitions from the global environment should available in the current namespace without `js` prefixing. It can be combined with `:rename`. +`:refer-global` lets a namespace declare what definitions from the global environment should be available in the current namespace without `js` prefixing. It can be combined with `:rename`. [source,clojure] ``` From 0d41dddfab7d314c57bb48faf3df99c335803b3f Mon Sep 17 00:00:00 2001 From: davidnolen Date: Mon, 24 Nov 2025 12:30:46 -0500 Subject: [PATCH 33/33] update for actually released version --- content/guides/quick-start.adoc | 6 +++--- content/news/2025-11-24-release.adoc | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/content/guides/quick-start.adoc b/content/guides/quick-start.adoc index dbde8124..33dffaad 100644 --- a/content/guides/quick-start.adoc +++ b/content/guides/quick-start.adoc @@ -15,7 +15,7 @@ part of this tutorial are a web browser and an installation of https://clojure.org/guides/getting_started[Clojure]. On Windows you will need https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html[Java 21] and the -https://github.com/clojure/clojurescript/releases/download/r1.12.112/cljs.jar[standalone +https://github.com/clojure/clojurescript/releases/download/r1.12.116/cljs.jar[standalone ClojureScript JAR]. Note that the requirement of a web browser excludes headless environments, and we then recommend skimming to the Node.js portion of the tutorial. @@ -45,7 +45,7 @@ If you are on macOS or Linux your `deps.edn` file should contain the following: [source,clojure] ---- -{:deps {org.clojure/clojurescript {:mvn/version "1.12.112"}}} +{:deps {org.clojure/clojurescript {:mvn/version "1.12.116"}}} ---- In your favorite text editor edit the `src/hello_world/core.cljs` to @@ -308,7 +308,7 @@ Modify your `deps.edn` file: [source,clojure] ---- -{:deps {org.clojure/clojurescript {:mvn/version "1.12.112"} +{:deps {org.clojure/clojurescript {:mvn/version "1.12.116"} cljsjs/react-dom {:mvn/version "16.2.0-3"}}} ---- diff --git a/content/news/2025-11-24-release.adoc b/content/news/2025-11-24-release.adoc index 1fad8e2c..1988eb2c 100644 --- a/content/news/2025-11-24-release.adoc +++ b/content/news/2025-11-24-release.adoc @@ -1,6 +1,6 @@ -= 1.12.112 Release += 1.12.116 Release ClojureScript Team -2025-11-25 12:00:00 +2025-11-24 12:00:00 :jbake-type: post ifdef::env-github,env-browser[:outfilesuffix: .adoc] @@ -12,7 +12,7 @@ This a major feature release with a significant number of enhancements. Before d For a complete list of fixes, changes, and enhancements to ClojureScript see -https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.112[here] +https://github.com/clojure/clojurescript/blob/master/changes.md#1.12.116[here] ## ECMAScript 2016 Language Specification @@ -99,7 +99,7 @@ We're excited to hear feedback about all these new features! ## Contributors -Thanks to all of the community members who contributed to ClojureScript 1.12.112 +Thanks to all of the community members who contributed to ClojureScript 1.12.116 * Michel Borkent * Paula Gearon