Yeah I think that’s your expectations. Clojure doesn’t treat the JVM as an implementation detail, but as a very important part that you’ll want to use and interact with directly. It wouldn’t make any sense for clojure to not show you the JVM details, because for all it knows, those are the parts that you really care about and you just use clojure to glue it all together

Does clojure not have a destructuring match in it's standard library?

Yes it does:

    (def my-vector [:mary :had :a :little :lamb])
    (let [[_ _ _ _ lamb] my-vector]
      (print lamb))

    (def person {:name "Bob Dylan" :age 77})
    (let [{person-name :name
           person-age :age} person]
      (print person-name)
      (print person-age))

For fun, I just made a macro to support it in def as well:

    (defmacro ^:private def-locals
      []
      `(do ~@(for [local (keys &env)]
               `(def ~local ~local))))

    (defmacro ddef
      [destructuring value]
      `(let [~destructuring ~value]
         (def-locals)))

    (ddef [_ _ _ _ lamb] my-vector)
    (print lamb)

    (ddef {person-name :name
           person-age :age} person)
    (print person-name)
    (print person-age)

Ya, Clojure JVM is not ideal for small CLIs, because it has a slow startup. Though you can now compile a Clojure JVM program into a self-contained statically compiled native executable, it requires understanding a fair amount of GraalVM native-image, and Clojure infrastructure and all that to do so, actually Babashka itself is such a program. But that's also where Babashka comes in, because now all your effort learning Clojure also means you can reuse those learning for scripting and babashka driven CLIs, where as before you needed to rely on some other language for those, which meant having to learn something else for those use cases. You can also use ClojureScript to write Node.JS driven CLIs and scripts if you want, though I'd say Babashka is much nicer, unless you cared for some Node.JS library.

And when I last tried to do web apps with Clojure, it seemed like everything relied on a lot of self-assembly, and didn't map cleanly to ways I knew how to web apps at the time from Go, C#,or Erlang. I dunno what the situation is there these day

It hasn't changed, familiarity is Clojure's enemy, that holds for frameworks as well. This is another learning curve.

For Janet, I did lean into the more imperative constructs early on.

Ya, that will be another big learning curve then.

Oh nice, I did not know that, I've been wanting to try Racket for a while, maybe trying my hand at a desktop GUI will be it. Thanks.