Cloistered JVM dev here: On the non-JVM hosts of Clojure, are there concepts parallel to system properties? Is there a platform-agnostic alternative to System/getProperty? EDIT: Fell prey to the X Y problem. What I really want to know is: Is there a runtime-agnostic way to get the name of the logged in (OS) user?

Hi folks. I'm trying to include an external jar dependency via lein uberjar, so I can run with java -jar, and it does not seem to work despite it working fine with lein repl. Am including via:

:resource-paths ["resources/openrq-3.3.2.jar"]

❯ unzip -l standalone.jar|grep openrq
   283205  2021-12-08 06:32   openrq-3.3.2.jar

Caused by: java.lang.ClassNotFoundException: net.fec.openrq.OpenRQ

apparently I misunderstand refs and STM. I have two streams of key/value records that are being processed by separate threads, and each thread has a simple cache (ref {}) associated with it. if a thread reads a record that isn't in the other thread's cache, it stores the key/value pair in its cache and returns []. if the key is found in the other thread's cache, that entry is removed and [v v2] is returned, where v is this thread's value and v2 is the value from the other cache. (the idea is to process two potentially unordered streams in parallel to determine where they match/don't match.) the test code I hacked up is, as usually happens when writing async code, inconsistent: sometimes one thread returns both values, other times a value ends up in one cache. here's the code:

(let [k :k
        v "value"]
    (defn check
      [cache k v other-cache]
      (dosync
       (if (contains? @other-cache k)
         (let [v2 (get @other-cache k)]
           (alter other-cache dissoc k)
           [v v2])
         (do
           (alter cache assoc k v)
           []))))
    (let [cache1 (ref {})
          ch1 (chan)
          cache2 (ref {})
          ch2 (chan)]
      (go (>! ch1 (check cache1 k v cache2)))
      (go (>! ch2 (check cache2 k v cache1)))
      {:cache1 @cache1 :result1 (<!! ch1) :cache2 @cache2 :result2 (<!! ch2)}))

you need to use ensure instead of deref

I don't use the stm much, but if I recall deref in a transaction is stable, in that multiple derefs of the same ref in a transaction will always return the in transaction value of the ref, but at the point the transaction commits, a deref that would have gotten a different value at that point in time will not cause the transaction to retry

this can cause one of the skews, maybe read skew?

https://github.com/fmi/clojure-examples/blob/master/2013/07-concurrency/04-write-skew.clj nope write skew

I suspected there might be something up with the STM machinery not correctly recognizing the @cache read or something similar.

for what it is worth, I would use a single atom for this

(which is why I don't end up using the stm much)

I thought about atoms, but stm/refs seemed like a better fit with two threads banging on two separate data structures. if ensure works, then all is cool, otherwise atoms are an option -- this isn't long-term production code, just a hack to monitor streams during system migration to a new data center. thanks --

if your transaction always includes the refs "from" both threads, then you've gone from 2 threads banging on one atom, to two threads banging on two refs