Haven't checked myself but I'm 80% certain that this library either has that kind of functionality or has all the necessary building blocks to implement it on your own: https://github.com/clojure/core.cache

Looking at it

Stumbled on this while searching to learn what you mean by "TTL" (time to live). https://github.com/clojure/core.memoize/blob/master/docs/TTL.md

didn't know about core.memoize, been using core.cache all this time

Clojure does not have any dependencies on other libs

deps-deploy depends on some Java libraries which aren't available in bb. But I think clojars / maven also support REST apis that support releasing artifacts which you could use, if you want to do it all in bb - I've never tried

Great idea, thanks for suggesting! I'll see if I can publish over HTTP > From first glance looks like Clojars doesn't have (publicly documented) endpoint for uploading JAR-s > https://github.com/clojars/clojars-web/wiki/Data In case I go with publishing over HTTP, do you recommend babashka.curl or babashka/clj-http-lite or some other library for it? If I had to guess, one POST request should do it

It doesn't really matter which one you use I think. Both should work

Thanks borkdude, you're awesome. I hope your YouTube channel gets more views. Viewed bunch of your demos there!

Thanks :) Maybe I should do another video some time :)

@U6P6QJTUZ if you find the api for clojars publishing can you doodle it down?

Perhaps someone in #C0H28NMAS can also help, but I also wanna know :)

I never found what it was for maven central either ^

i found that zip upload route but i don't get the sense that its really the intended path

> like have a future running in parallel updating values Why not just make that future call that function periodically?

could work, but... What if you are trying to avoid unwanted latency, so your cache is sort of: gimmie the best value for this at this time, doesnt have to be exact as it changes slightly. However during the cache window I want to run at least one update on the data. So for processing the cache is needed in order to provide latency. However the mechanics of the cache are not really required - well at least as long as there is backdoor to cached values.

Sounds like https://github.com/clojure/core.memoize should have what you need.

Specifically its memo-swap! function.

async/alts! sounds nearly perfect for what you want, unsure if it will serially take from a if you had each worker using async/alts! on the same source channels/queues

each queue gets a go-loop taking from it and submitting to any number of executors would do it. You can balance the number of executors as you like and reports that it is done. The executors just get jobs submitted to them, they don’t care. And the many go loops just wait for the previous work to be done before adding the next elements in

Okay, I have a rough idea. Thanks team!

that isn't a thing

:default isn't some kind of wildcard in the dispatch

Hmm. Can I achieve that result, without the ‘implement this manually’ solution in the docs?

https://clojuredocs.org/clojure.core/defmulti#example-57558046e4b0bafd3e2a0474

it depends, people often forget that multimethods dispatch using isa? not =, which means you can do stuff with dispatch hierarchies

like (isa? [String String] [Object Object]) is true

but basically no

I’ve done very little with the hierarchies, but I had my heart set on a simple decision matrix with a vector of 2 elements…

Which just led me to a better, simpler way. 👍:skin-tone-2:

Looks like https://github.com/camsaul/methodical#advanced-customization can do what you originally wanted.

:thinking_face:

I’ll check it out

> because zip archives include timestamp related information. it can mean many things, show the code or cmd line output what you mean

clojure builds aren't really reproducible even without the timestamps

assuming you are aot compiling, there are a number of things that cause the compiler to generate slightly different bytecode every time it runs

I think the last thing I saw was the compiler has a map in it somewhere that uses object identity for keys, and then iterates over the map, so the order things come out of the map depends on System/identityHashCode, which is basically a pointer

there are people interested in this, I think also for things like nix packaging, but I am not sure if there is like a channel or something devoted to it

https://clojurians.slack.com/archives/C6QH853H8/p1665004046619029

https://clojurians.slack.com/archives/C03S1KBA2/p1598642136361500

I see, at least with the last point, it's would be reproducible on my machine but I understand the issue here

nah

System/identityHashCode is basically a pointer, so the order certain things are emitted in the bytecode will depend on where the memory allocator puts them

oh ok, if the address itself matters…

https://ask.clojure.org/index.php/12249/bytecode-not-100-deterministic-given-identical-inputs is the discussion of the hashcode issue

the thread I linked to above links to it, and apparently the person who opened that ask did some patching of clojure and claims to have reproducible builds

thank you, I'm digging into this!

while we are in the topic here is my trick for cache to not repeat downloading dependencies after each commit:

# environment + clojure dependencies
FROM env as env-with-clj-deps
COPY deps.edn .
RUN clojure -A:uberjar:tests-deps:check-syntax-and-reflections:run-tests -Stree

# full image ready to compile and tests
FROM env-with-clj-deps as deps-with-code
COPY . .

so the first step is COPY . . when the cache doesn’t match

unless you changed deps.edn

I feel like I’m missing something very basic 😢

the infra (ns, vars, classes) created by your example.oesa namespace need to be loaded (unless you're doing something like AOT compiling your clojure, which I'm going to assume you're not doing if you are new)

so to trigger ns loading from Java, you need to call require:

IFn REQUIRE = Clojure.var("clojure.core", "require");
REQUIRE.invoke(Clojure.read("example.oesa"));  // this creates a clojure symbol from inside Java

then call your app stuff.

ohhh … there is something in the clojurephant gradle docs that I added, related to AOT - but I just copy/pasted it, I’m not sure what it does or what else I need to do

I’ll try this, thank you!

that totally worked, I wish I had asked sooner

the snippet of java code I pasted is exactly equivalent to calling this from clojure: (require 'example.oesa)

I guess I didn’t understand what this part in the linked docs actually meant, 😂 > Functions in clojure.core are automatically loaded. Other namespaces can be loaded via require

the docs for as-> do say it binds the name to the result, not that it replaces the name

so x is bound to nil after (prn x)

I am learning that yes

Years after using it

When unsure on what threading macros will do, I always call macroexpand-1. I rarely use as-> so I sometimes have to pause and think about what's going on

I paused and thought about what was going on

Then I came here to chat about it

it may depend on if you know the context about how as-> was added

I've seen the swiss arrows library before, and I want to say as-> feels a lot like -<> from swiss arrows, but this is just my best guess on where it could've come from 😄

rich had some personal project somwhere that he ended up doing a lot of repeated let bindings in (let [a (f) a (g a) a (h a)] (i a))

as-> is that pattern as a macro

I played with swiss arrows right around 1.7 when I started with Clojure, and noticed as-> a bit later.

so if you read it as a let binding like that, what it does is pretty clear (and in fact that is how it macroexpands)

I use as-> infrequently when most of the forms need ->> but there is an outlier or two

It's also worth mentioning that as-> is designed to be used inside a -> pipeline:

(-> expression
    (f)
    (as-> x (g 1 x 2))
    (h))

as-> was even originally named let->

Is there a known and perhaps well-discussed rationale for not having a corresponding as->> macro?

What would that even mean @U0E2268BY? as-> uses a named symbol -- it's not "first" or "last" in anything.

Well, if as-> is only for use inside -> (I don't agree with that) then as->> would only be for use in ->>, would take the initial value last

(->> ... (as->> name ...))

Exactly

I didn't say "only for use inside" -- I only needed that part of its design is for that use case and that's why the arguments are expr, sym in that order.

The swiss-arrows -<>> isn't exactly what I had in mind, but is very promising for handling the situation I find myself in occasionally.. contrived example:

(let [h [:a :b :c :d :e :f :g]]
        (-<>> [1 2 3 4 5 6 7]
              (map inc)
              (zipmap h)
              (select-keys <> [:a :b :c])
              prn
              with-out-str))

"{:a 2, :b 3, :c 4}\n"

I'll just leave this here: https://stuartsierra.com/2018/07/06/threading-with-style 🙂

And https://stuartsierra.com/2018/07/15/clojure-donts-thread-as which specifically talks about "Don’t use as-> by itself"

Oh not that cringe-worthy article again 😁

Stuart was a policeman in a former life

Sometimes there doesn't need to be a rule

Interesting how that article never mentions the context in which the macro appeared, one that hiredman mentioned. I wonder if Stuart knew it at the time of writing.