ClojureScript News

ClojureScript which targets JavaScript as the host language (https://clojurescript.org/) is a good option on the Clojure side. ClojureScript is great if you're drawn towards the "production use" side as pixelmonkey said and already have knowledge of the Javascript / Node ecosystem.

My biggest pointer would be to remember that Java & JavaScript aren't named that way by coincidence. They're two different approaches to a similar problem. Java suffers from Enterprise Development (eg: Enterprise FizzBuzz[0]), JavaScript suffers from Ultimate Accessibility (eg: how many questions on Stack Overflow conflated jQuery and JS?). > How should exceptions be managed? [...] Has there been a debate about best practice? Where can I find it? I suggest you handle the errors you can and otherwise let it crash.[1][2] Debates in NodeJS-land have steered towards more monadic/Result-like structures and working synchronous-looking try/catch onto async/await. NodeJS and its various components are open source, you'll have a lot of luck looking around on GH for issues & PRs related to a feature -- same for the language, ECMAScript[3] officially.[4] Since you mentioned Clojure, have you looked at ClojureScript?[5] That may be a good entry to JS authors & articles you'd enjoy. > I have the impression that NodeJS is a bit more magical than the JVM [...] Is that correct? Where are good resources on this subject? As other replies have mentioned, you're really talking about V8[6] for the "JSVM" executing that code. A thing I've seen throw some people for a loop is how minimalist the specification actually is.[7] The magic in NodeJS is certainly from V8 and the rate of optimizations there but also libuv,[8] what actually powers the infamous event loop. Hope that helps! [0]:…

I'm surprised by how often questions like this come up, but I always find the responses interesting and educational. * What I Want * Non-negotiable items include: - Low Friction: A little initial setup is ok, but just taking a note should require no more than a click or two (whether clicking a mouse or a pen). - Open source. - Aesthetically Pleasing: I'm tired of looking at ugly stuff. - Has to handle LaTex. - Has to handle syntax highlighted code listings. - Notes are in an easily portable format. - Organization Tools: Some sort of organizational ability. I have thousands of notes that I use and need to refer back to all the time. - Privacy: No sending my personal information to someone else's server. Negotiable: - Mobile Friendly: My eyesight isn't good enough to use a phone for note-taking or reading. Tablets are Ok. Desktop is best for me. - Implementation Language: Since I'm looking for an open source solution, I'd like it to be in a language that I like. In my case, Clojure/ClojureScript, Lisp, Scheme (Racket) would be optimal. JavaScript is least desired. - Minimal dependencies: I'd prefer that it not be based on Node, NPM, Electron, Atom, or any other huge ecosystem that would have to be installed on my system. (Java is Ok with me, obviously.) Scriptability: It would be nice if it could help automate my workflow. * What I Have Tried * - Long ago (2005) I started a job at which the company provided me with a stylus-based, Windows tablet PC. Included was a copy…

LISP in the browser! You end up having to ship a large runtime with your app but it all transpiles to vanilla JS. https://clojurescript.org/

That’s Google Closure [1] with an ‘s’, not ClojureScript [2] with a ‘j’. ClojureScript uses the Closure Compiler to optimise its JS output, but that’s the only relationship, and the name is a coincidence. [1] https://developers.google.com/closure [2] https://clojurescript.org

I don’t think it’s that $ npx nbb -e (println "Hello, world") Need to install the following packages: nbb Ok to proceed? (y) Hello, world Or more comprehensively: https://clojurescript.org/guides/quick-start

> ClojureScript is a compiler for Clojure that targets JavaScript. [1] If ClojureScript is compiled, why can't WASM be the same? [1] https://clojurescript.org/

I found Clojurescript https://clojurescript.org/ to have a better ecosystem than parenscript.

> To be perfectly honest, Clojure's biggest mistake, from my point of view, was to be so heavily JVM-dependent. With Clojure being a hosted language, there's nothing stopping it from adopting a new platform or expanding to other platforms or languages. It has actually already done this with Clojurescript (run in the browser or Node.js)[1] and Clojure CLR (run on Microsoft's .NET)[2]. [1] https://clojurescript.org/ [2] https://clojure.org/about/clojureclr

Fantastic tooling The official guide recommends using webpack, the irony. https://clojurescript.org/guides/webpack

I would. Web dev is (for better or worse :) one of the main applications of Clojure. See further at https://clojurescript.org/ and https://pragprog.com/book/dswdcloj2/web-development-with-clojure-secon…

That's no longer true. ClojureScript can now be self-hosted. https://clojurescript.org/guides/self-hosting [Edit to correct: the following is no longer entirely valid: see downthread.] That said, if you want to benefit from the Google Closure optimizations, you currently do need to use the JVM toolchain. IIRC, there's been work on the Google Closure side to run without a JVM, and if that's the case, there may be opportunities in the future to take advantage of this in the ClojureScript toolchain.

Perhaps not directly related to 'Concurrency' but iirc ClojureScript got released in 2011 https://clojurescript.org https://www.youtube.com/watch?v=tVooR-dF_Ag (ClojureScript Release)

Have you looked at Clojure? It's a modern Lisp that feels designed to be simple, yet powerful. It works on the JVM/.NET/JavaScript platforms, so it's reach is almost universal. https://clojure.org/ https://clojurescript.org/

confusingly, ClojureScript compiles to JavaScript which is compatible with Google Closure -- thereby coming full circle. http://clojurescript.org/

Similar experience here. My first Clojure(script) projects used leiningen, now everything is deps.edn and the clojure CLI. Cool, changes happen. But editor integration, REPL tooling, even which compiler to use, etc are not consistent either. The tooling is changing everywhere and bit rot has claimed almost all of my past projects. The code is still 100% compatible but the build system is just broken. I've given up trying to port any projects over - it's easier to generate scaffolding for a new project in the tool-du-jour and move the actual code into that structure. Since there is no obvious right way, there's little consistency between projects - which means you're likely to follow the wrong path if you follow the wrong README or pick an outdated starter template. This forces developers to make a ton of orthogonal choices up front before they even begin coding. Case in point: https://clojurescript.org/tools/tools lists 4 different build tools without any explanation as to how they relate or why you might pick one over the other. But don't worry, you'll find out after days of tedious research! If Clojure had a consistent out-of-the-box experience like Go or Rust, I think it could rule the world. It's a great language but the developer experience is a serious impediment to that.

Some technical points about Krell. It leverages the ClojureScript `:bundle` target which was released last year https://clojurescript.org/news/2020-04-24-bundle-target. By simply producing output that is JS bundler friendly we can just piggieback on Facebook's Metro just like we piggieback on Webpack etc. when targeting the web. We simply reuse the debug loader provided by Google Closure and load ClojureScript and Google Closure JavaScript files through the Metro server. But this is the core of ClojureScript's hot-reloading capabilities without caveats. In Google Closure namespaces can be represented as nested JavaScript objects which delivers pervasive late-binding - which simply cannot be done with ES6 modules because imports will be captured (early bound). The REPL bit (which is an independent piece from the hot-reloader) just runs on top of react-native-tcp-socket. The only tricky part is that we need to be able to require Node libraries and assets into ClojureScript during development. This is done by a compiler pass - first we start at the entry point of the ClojureScript React Native project and follow the dep graph collecting all libraries required from `node_modules`. This is dumped to a file that is required transitively by `index.js`. Asset handling is done as a simple compiler pass over every AST node searching for JavaScript `require` statements in the ClojureScript. The end result is that we have an extremely rapid development workflow that simply is not…

Anyone tried ClojureScript ? https://clojurescript.org/

> If anyone has advice on how someone who prefers rigour, simplicity, elegance, and decent PL design over the latest trend should approach web dev that would be massively helpful Sounds like Elm [0] (pure, functional, very very easy to start with but lacks abstractions), Purescript [1] (pure, functional, powerful, the best language for the web right now, imo) or ReasonML [2] (functional but impure, familiar syntax, focused on pragmatism) would be right up your alley. If you're ok with a dynamic language (i.e. strike rigour), then look no further than Clojurescript [3], Clojure's [4] little web brother. An elegant and simple Lisp, it makes almost all other dynamic languages completely obsolete. There most definitely are sane options for developing for the web if one is willing to use a compile-to-js language. [0] http://elm-lang.org [1] http://www.purescript.org [2] https://reasonml.github.io [3] https://clojurescript.org [4] https://clojure.org

There is a significant amount of divergence in semantics. I’m not sure why you would try to convince anyone otherwise...the clojurescript developers acknowledge this completely upfront. https://clojurescript.org/about/differences In my experience, all of the stated benefits of clojurescript become more and more tenuous as your intensity of use increases. Hello world seems fantastic, todomvc still seems pretty cool, but by the time you’re doing full size apps of meaningful complexity, you really start to see the limitations. In order to get any meaningful performance out of it, I ended up having to rewrite and experiment like crazy...the code looked like nothing I would have written in Clojure, using completely different idioms and data structures. And while the prototyping was fast, in the end it took me far longer to write and then iteratively optimize than it would have to write an equivalently fast version in scalajs or typescript. Maybe your experience is different, but my experience is my experience, and it most definitely is not baseless.

Short answer - yes. https://clojurescript.org/

You're still able to do so, as we've been able to in ClojureScript land for many years already, since ultimately they're just Promises! I don't think that's going away with this new function hints. https://clojurescript.org/guides/promise-interop#using-promises-with-c…

yup, correct https://clojurescript.org/news/2024-01-24-release#_google_closure_libr…

Clojure(Script) apps and systems exist at a bunch of household name places. - Clojure: https://clojure.org/community/companies - ClojureScript: https://clojurescript.org/community/companies Also, a few case studies may interest you: https://clojure.org/community/success_stories and community stories: https://clojure.org/community/community_stories

It's optionally self-hosted, without support for Closure's full suite of optimizations (https://clojurescript.org/guides/self-hosting).

For those who are interested, here is the official statement from the ClojureScript team regarding Google Closure Library going into “maintenance mode” and its impact on ClojureScript: https://clojurescript.org/news/2024-01-24-release

Note that this doesn't include the Closure Compiler[0], and doesn't affect Clojurescript[1], which has traditionally used the compiler and related bits of the Google Closure library. [0] https://github.com/google/closure-library/issues/1214 [1] https://clojurescript.org/news/2024-01-24-release

JS isn't perfect, but it's good enough. And there is ongoing effort to make it even better. Also, many other languages compile to JS (without WASM). Notably: - https://www.typescriptlang.org/ - https://coffeescript.org/ - https://clojurescript.org/ - https://www.transcrypt.org/ I wrote https://multi-launch.leftium.com, which is only 6% JS. The majority is Svelte (65%) + TypeScript (27%). (https://github.com/Leftium/multi-launch)

> Is that still tied to that google closure abomination ? I've not been in CLJ ecosystem for >5 years now but last time I used CLJS I remember they went all in on google Closure and it was a major PITA to use the rest of JS ecosystem because of it. This has been solved now--there's a blessed CLJS solution[1][2] as well as a third-party compiler with NPM support[3] which many prefer. [1]: https://clojurescript.org/news/2017-07-12-clojurescript-is-not-an-isla… [2]: https://cljs.github.io/api/compiler-options/npm-deps [3]: https://shadow-cljs.github.io/docs/UsersGuide.html#npm