I'm going to give a (remote) introduction of clojure for some coworkers. I'll check the popular plugins for their editors (mostly vscode I think), but some of them are non-programmers. For them, I'm looking into the easiest to setup clojure ide. Maybe even something on cloud. I looked into http://repl.it but it doesn't allow to eval a single expression, only the whole file, and that seems so limiting when it comes to lisps.

Java interrop question.. How can I call .drainTo in Clojure on a BlockingQueue? Attempt below:

(import '[java.util.concurrent LinkedBlockingQueue BlockingQueue]
          '[java.util ArrayList])

  (let [^BlockingQueue q (doto (LinkedBlockingQueue.)
                           (.put [:command 1])
                           (.put [:command 2])
                           (.put [:command 3]))
        coll (ArrayList.)]


    ;; 
    ;; drainTo(Collection<? super E> c)
    ;; Removes all available elements from this queue and adds them to the given collection.


    (.drainTo coll)
    ;; FAIL
    ;; Unhandled java.lang.IllegalArgumentException
    ;; No matching field found: drainTo for class java.util.ArrayList

    ;; FAIL
    ;; (.drainTo (make-array (type []) 3))
    ;; Unhandled java.lang.IllegalArgumentException
    ;; No matching field found: drainTo for class [Lclojure.lang.PersistentVector;

    coll)

This might be an unimportant performance thing, but why isn't destructure using find + val here: https://github.com/clojure/clojure/blob/7baa5b2f79f05c56a04e1d5c90129972cd962df3/src/clj/clojure/core.clj#L4465-L4466

user=> (let [defaults {:a 1}] (time (dotimes [i 100000000] (val (find defaults :a)))))
"Elapsed time: 379.921527 msecs"
nil
user=> (let [defaults {:a 1}] (time (dotimes [i 100000000] (contains? defaults :a) (defaults :a))))
"Elapsed time: 759.108181 msecs"

wow. crazy how different the speeds of (defaults :a) (:a defaults) and (get defaults :a) are

Actually the or defaults are usually symbols:

user=> (let [defaults '{a 1}] (time (dotimes [i 100000000] (contains? defaults 'a) (defaults 'a))))
"Elapsed time: 1583.053364 msecs"
nil
user=> (let [defaults '{a 1}] (time (dotimes [i 100000000] (second (find defaults 'a)))))
"Elapsed time: 6325.311779 msecs"

they are always symbols

yeah, and in the case of symbols the current implementation is way faster. hmm!

enforced by the spec

nope, sorry, I was using second which causes the slowness:

user=> (let [defaults '{a 1}] (time (dotimes [i 100000000] (val (find defaults 'a)))))
"Elapsed time: 697.04199 msecs"
nil
user=> (let [defaults '{a 1}] (time (dotimes [i 100000000] (contains? defaults 'a) (defaults 'a))))
"Elapsed time: 1593.39499 msecs"
nil

so yeah, I'll file a JIRA. yay!

I mean those numbers make sense to me based on what they're doing

the first is one lookup, the second is two

yes, that's why I wondered. so JIRA good?

yeah

Issue + patch: https://clojure.atlassian.net/browse/CLJ-2586

could you try to make a perf test that actually uses destructure ?

is this causing an issue in real world code?

it's not, but why not take the perf if it doesn't make the code any less readable

because it's not costless to accept changes

this is only called at macroexpansion time, right?

> This might be an unimportant performance thing Alex responded: feel free to file a jira. He also could have responded with: not important, bye.

mostly yes

in sci I do call it at runtime

but I'll make a perf test with destructure itself and I'll let it sit there until it's closed in 2028 ;)

please don't be sarcastic

core team works hard to manage issues

again, I asked the core team (Alex) if this was unimportant and the reaction was: feel free to file a JIRA. That's what I did, ok?

there is a non-issue, imho -- lots of macrotime things use the not most performant code

I would also have accepted: no

(like last)

macroexpansion has impact on startup time which is not unimportant I would say

I think it's worth doing - we have chased micro gains in this area in the past given how common destructuring is

you are misreading the ticket @alexmiller

it's not the code emitted by destructuring that is being optimized (which would be worthwhile)

it's the destructuring macro helper itself

I'm ok with bringing it to rich, he can decide

I'm accepting any outcome, I just found this while fixing a bug in sci. I appreciate the hard work the core team is doing. In the grand scheme of things this may not matter very much and that's ok. I don't find a noticable difference with:

(time (dotimes [i 10000000] (destructure '[{:keys [a] :or {a 1}} {:b 1}])))
(time (dotimes [i 10000000] (destructure2 '[{:keys [a] :or {a 1}} {:b 1}])))

I'll add this to the ticket.

I do see potential speedups in the generated code, e.g. replacing get with a keyword lookup when :keys is used, etc, but I haven't considered this longer than core probably has. So I'll leave it at this for now

I am wanting to replace an old Java service (slow and somewhat buggy) with Clojure. The interface to this system inputs/writes out several XML files marshallled and unmarshalled by JAXB-annotated code. I have the .xsd files defining the 250 or so classes that can be in-/output by this service (and of course, the generated Java classes). Does Clojure have any tools to make this replacement simpler or am I stuck updating the old Java code? So far, I've run across libraries like clj-xsd, which parses .xsd files, but gives no help as to reading/writing the XML data files that might be marshalled/unmarshalled by JAXB. And, although there are one-or-two libraries that mention JAXB, they seem to be moribund/aborted. Has anyone even attempted something like this in the past, or is this a data format that Clojure doesn't have a very good answer for?

clojure.data/diff-associative is implemented as:

(defn- diff-associative
  "Diff associative things a and b, comparing only keys in ks (if supplied)."
  ([a b]
     (diff-associative a b (set/union (keys a) (keys b))))
  ([a b ks]
     ...))

(clojure.set/union (keys {1 1}) (keys {1 1}))
=> (1 1)

TIL:

user=> (defn foo:bar [])
#'user/foo:bar

It wouldn't surprise me if this was an edge case in the reader

per the reader docs, it seems like it's supported: > Symbols beginning or ending with ':' are reserved by Clojure. A symbol can contain one or more non-repeating ':'s. > https://clojure.org/reference/reader#_symbols