Honestly not sure, I'm not a Webpack expert and have no wish to be :) But again, as I've said elsewhere, there is no specific integration with Webpack. The bundle feature makes no choices so it's easier for users to fully control the integration with any JS build tool.
Yep. But having this feature only in shadow-cljs doesn't do much for the ecosystem as a whole since non-portable. With this change, many tools, cljsbuild, Figwheel, etc. have the same capabilities. It also opens the door for creating ClojureScript libraries that depend on node_modules and these can again be consumed with any tool.
1. NPM is analogous to Maven for Java. Yes the ClojureScript bundler target lets you use anything you've installed from NPM into your project's `node_modules` directory. Not many limitations because we wash our hands of dealing with this stuff - use whatever popular bundler solution you prefer.
2. Not for creating NPM packages, just consuming them. Webpack lets you use dependencies from NPM and package them up into a single JS (or code-split) asset to be used on a webpage. Note, we have no integration to any particular bundler. You could just as easily run Metro for React Native on the output and build a mobile app.
We don't really compete with PureScript, BuckleScript, ReasonML or even Elm and this is heavily reflected in our surveys. The only real competition at this point is Scala/Scala.js or full stack JavaScript.
New users (and experts as well) do not find Leinginen and templates easy to use. The response to the Quick Start has been overwhelmingly positive from new and experienced users.
The whole point of passing everything through Closure is to avoid needing externs. However there are caveats, see me comment above about building React.js directly from sources.
Using NPM for client libraries required using Webpack to bundle those things. If you were targeting Node.js then we just didn't support idiomatic usage of those libraries (users could just call require themselves directly).
Nothing has changed about ClojureScript interop in 6 years so I don't really know what you're getting at. We believe ClojureScript interop is pretty good and our users pretty consistently agree.
I fail to see how Closure Complier is any more complicated, more painful, and has any more caveats than Babel/Webpack. With Closure Compiler at 8 years old and building some of the most sophisticated JS properties on the web (GDocs anyone?) it seems pretty "solid" to me. Perhaps it not clear from the post but that's a big part of why this works, we're not doing the heavy lifting.
I would say you are in a distinct minority here with that viewpoint :) I've been using / working on ClojureScript since the very beginning and the halfway integration with Node and NPM never seemed particularly desirable to me.
There's no extern inference required here as all the original sources are passed directly through Google Closure Compiler. As a benchmark for feasibility when we started we chose React.js as it's non-trivial and heavily depended upon in the ClojureScript ecosystem. We discovered that over all of React's sources we only need 4 extern definitions for 4 generated names in EventsPlugin. So as long as the JS library in question isn't relying on string-based meta programming everything should work.
Granted this rules out some libraries, there are plenty of libraries written in a simple straightforward style that will work just fine. In particular I am bullish about fantastic results with ES6+ libraries written with ES6 classes with static import/export. Closure will eat that stuff up.
That's exactly what I'm saying. You don't choose ClojureScript or Scala.js haphazardly, you're already using Clojure or Scala. Thus it doesn't make sense to lump them into choices that are primarily client-centric like Elm or PureScript.
I use Datomic everyday. While it's certainly a stunning piece of technology and you could pry it from my cold dead hands, I don't think it has that much bearing on the growth of the Clojure community.
I don't really have anything to say about your other points, but the only comparable compile-to-JS tech in your list to ClojureScript is Scala.js. The other options assume you don't see significant value in using the same programming idioms across client and server.
If I'm on an engineering team that's using Dart or TypeScript I'm not going to lean on functional programming patterns the way I would if I was on a team using ClojureScript. Idioms matter when you're working on production stuff with other people.
But sure, TypeScript appears to dwarf all other compile-to-JS languages in terms of actual usage.
Thanks for the kind words but I do think ClojureScript is much, much bigger than Om Next :) People are succeeding with many different approaches - Reagent, Rum, Hoplon, etc. all have enthusiastic, active user bases and for good reason. While I'm happy too see Om Next gain traction, in the end I'm much more excited to hear about someone adopting ClojureScript regardless of what other technology choices they might make.
No, ClojureScript has been bootstrappable since late summer 2015. Everything already runs in JavaScript. It's just that now the final optional optimization pass can also run in JavaScript.
Comparing C and Makefiles and `npm init` just doesn't make any sense to me. For something in style of the former (i.e. no real dependency management) you have the ClojureScript Quick Start - download a JAR & make a build script, done. For the later I just don't see how `npm init` is any easier / different than `lein new mies easy`? And doing anything serious with Node requires reading up on a far more dizzying array of choices than the Clojure(Script) ecosystem offers.