Latest response @robert-stuttaford

Because we are migrating to openjdk. We want our libraries and code to run with the latest version of java/openjdk if possible.

This is going to break a LOT of people's experiences with Java-based HomeBrew projects.

If anything is broken for you, please open an issue, we will have a look. But since the migration campaign has started, we did not get that many bug reports.

So I guess you need to report your breakage 🙂

thanks - i'll do so! i doubt they'll do anything with my info though, because the breakage is actually inside cider

Then I have very little sympathy 🙂 Sorry, I shouldn't be mean about CIDER but my life has been calmer since I no longer have to deal with nREPL/CIDER at all.

you're on a pure socket repl, right? i'm just so used to cider + clj-refactor, it'd be a mega yak shaving contest to ween myself off of it!

What do you use in cider/clj-refactor? And, yes, pure socket REPL -- zero dependencies (I don't even bother with Compliment since Atom/Chlorine does auto-complete pretty well on its own -- it will leverage Compliment if it's on the classpath for "better" auto-complete etc)

i lean heavily on cider's print-to-buffer and inline printing stuff, and clj-refactor's clean-namespace and a handful of other code munging tools, like introduce-let, expand-let and friends man, a clean dependency-free repl sounds like it must be fast!

Interesting. I find paredit and parinfer to be sufficient -- I guess I'm not a fan of tools that try to rewrite my code. And, yes, it's fast with no middleware and no dependencies -- and, best of all, it's the same dev/test experience regardless of whether the process is local or remote (I regularly connect my editor to socket REPL processes not running on my machine).

yeah, we basically just put cider and clj-refactor into our production apps 🙈

Huh? That must be new then.

I last checked almost 2 years back when I was using Linux.

Do you need each character in a string? If not, you can do (into [] "abc...zABC...Z").

This will be a vector of java.lang.Characters.

Thanks. I see.

It's not that different from a memoized function with no arguments - you still have to change the calling code.

True. But memoize with a no-arg fn looks a little odd to me. Preference I guess.

also delay lets you use realized? to ask if it's been forced yet, and it lets you use force which is identity on non-delay values, but deref on a delay

I'm a big fan of delay

user=> (def d (delay (doto 42 println)))
#'user/d
user=> (realized? d)
false
user=> (= (force d) (force 42))
42
true

I guess I'm biased because I work with Reagent a lot. I don't like seeing @ where I don't expect an atom, especially when it's in a view. I immediately start thinking that it's a value that may change and that that change might trigger something, like re-rendering.

well, the existence of force helps there too - but @ works on promises too, and futures, and both of those, like delays, only ever have one value (but will block until they have one)

I found a few calls to clojure.core/ints in the Clojure code of the core.rrb-vector library. I do not know if it is needed there when it is used, but it appears to be used there when there really is a Java mutable array of type int for the array elements, and perhaps the cast done by clojure.core/ints is useful in producing better Java byte code then. Not sure.

I am pretty sure that a Java cast operation cannot change a Java array of long into a Java array of int , for example, and assuming that is true, that cannot be what the purpose of clojure.core/ints is.

The only type of argument that I think it makes sense to call clojure.core/ints on is an object that already is a Java array of primitive int elements, but the cast is needed so that the JVM 'knows' it, too.

we have a very tiny library consisting of just a helper for that: https://github.com/nedap/utils.spec/blob/master/src/nedap/utils/spec/api.cljc Usage would be {:pre {(check! :foo fn-argument)]} and it gives you a Expound-backed report (https://github.com/bhb/expound) when the precondition fails You also can build your own check! quite trivially

Yeah, but this requires me to change every single usage..

Can I somehow override valid? globally in my code?

I've tried providing my own:

And while i am able to load this file in REPL, I am not able to build uberjar (seems like original clojure.spec.alpha is not loaded before I start overriding things with my implementation)

Overriding namespaces, or doing monkey-patching is quite frowned upon in the world https://twitter.com/stuarthalloway/status/1229856488560234497

You can use bindings though: https://github.com/bhb/expound/tree/e90a16162e97d16904d2353f46084e139b0e8f37#explain-out

I had no luck with bind:

=> 
(set! spec/valid? valid?)
Execution error (IllegalStateException) at hermes.debug/eval29194 (form-init4832872063532060265.clj:1).
Can't change/establish root binding of: valid? with set
class java.lang.IllegalStateException

that's a setting not a binding :) It's certainly possible to perform the binding in dev and prod alike

OK, I might had a success here..

I expect this could be the Nth issue related to those changes that they have heard about, and their answers haven't changed on how to handle it -- use JAVA_HOME

basically I need to do this request in clojure:

curl -X POST "" -H  "accept: application/json" -H  "Content-Type: audio/wav" -d {}

oh, it looks like @U08JQ8RD0 maintains it! 🙂 wdyt about a PR that takes a bit more of an https://github.com/vic/asdf-clojure/blob/master/bin/list-all approach so other versions are available?

I think this would work: https://github.com/ztellman/virgil

> Now, as if by magic, every time the .java files on your :java-source-paths change, they will be recompiled within your REPL and all the namespaces that rely on those files will be reloaded.

Thanks. I may use that, though right now I'm using clj not lein. Maybe I'll look inside virgil and unwrap the magic.

Yeah, I started doing that some time ago (before I realized I didn't really need Java for my task), and it seemed that hooking it up to whatever you use should be pretty straightforward.

Yeah, it's doing (refresh-all) at the core. I don't really want to reload all of the clojure namespaces, just get the new java class defs correctly loaded and bound.

I know you said that you are not talking about calling some existing Java code somewhere else, but I believe that the minimum fuss way is to create the Java code you want to call as separate files, compile them to JVM byte code, and then use Java interop calls from Clojure.

I'd be interested to see the java code you want to inline. I think a lot of the time people just aren't aware of the clojure interop version. but yeah as andy said for the few instances where you can't use interop the minimum fuss way is to write a java class

I don't have a very specific thing in mind, but as a hobbyist I do problems from Project Euler and the thumb rule is the solution should run within a second. I can rarely clear the bar if ever. I want to basically right the hottest part in pure mutable Java.

there are things that are faster in java land than any equivalent in clojure land, but it's unlikely that that is what you're encountering. most likely you can get as fast as you need to writing optimised clojure

If you are looking to leverage mutability for performance, take a look at transients: https://clojure.org/reference/transients

@UG00LE5TN Yeah, tried that. Not fast enough. The only way it is fast enough is when I can do pure primitive math with absolutely no (un)boxing. There are basically two ways. Use the Java array types or restructure code to be loop/recur with primitives.

Have spent quite a bit of time on this, so I know this much.

@U050MP39D Sometimes I can reach as close as 4x to let's say the Java version. But that's a lot of fuss. At that point I wish I can simply use some Java. But that is also a lot of fuss, 🙂

fair enough, loop/recur with primitives was the kind of thing I was referring to so if you're down that low it probably is worth dropping to java. I would love to see an example though

On my phone but I will post back later. But I have recently started fiddling with clj-java-decompiler and that's a lot fun too. I am not an expert yet. Maybe I will uncover a few new ways of optimizing the Clojure versions.

That seems unlikely to be a 'minimum fuss' approach 🙂

but I've never tried it myself. Had never seen it before. Thx for the link.

That's hilarious, I think (glanced over the code and just read function names) that it's actually compiled the java as text 😀

And the project is named javastar because java*, 👌

That is just creating a symbol, not defining the thing

oh - that's not a namespace intern, just a symbol intern?

It is just an old method

Symbols aren't interned

oh, so it's just a symbol constructor, got it https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Symbol.java#L54

thanks for the clarification

Thanks. As a side note, how did you find that? Github search-foo has eluded me...

Find the import* ...

I used $ ag 'import\*' in the cloned repo locally

Ahh, that's my fallback too.

I was surprised not to establish it was special via special-symbol? as mentioned further down in the main topic

user=> (->> Compiler/specials keys (filter qualified-symbol?))
(clojure.core/import*)

Does refresh-all, which I'd like to avoid because it triggers side-effects.

if refresh-all triggers side effects you should fix your namespaces so it doesn't :D

It's just useful for dev. I have a dev namespace I'm working in for triggering various effects that rely on the Java. Not something to be used in production code.

you can blacklist a namespace from refresh-all

I'm going to have to hack virgil then, since I don't see that it exposes that. Also using not using lein. Forking...

I thought this was exposed via clojure.tools.namespace itself

this is all you need https://github.com/clojure/tools.namespace#disabling-refresh-in-a-namespace

Yup, that did it. So the trick was in my dev namespace, first call disable-reload! on that namespace, then virgil-watch. Thanks, I think that's going to be a big efficiency boost.

Given that (+) is 0 already...

That’s not the point of the example. The point is that you can extend protocols to functions this way. It’s not about the details in the example. I just choose the monoid example cause it was easy.

It’s just something fun to play around with and I wanted to share it. 😄

I think the word monad took the focus the wrong direction.

I think putting "fun" and "monoid" in the same sentence was the problem :rolling_on_the_floor_laughing:

In spite of the fact that we take advantage of monoids in everyday programming all the time?

Who would have thought the associative and identity properties could be such a lightening rod under the word “monoid”?

I’d be down for a better example that doesn’t provoke eye rolling at algebra.

You missed the point.

Here’s some more point.

user=> (defprotocol IInverse (-inverse [this]))
IInverse
user=> (extend-type (class inc) IInverse (-inverse [this] dec))
nil
user=> (defn inverse? [f g]
         (= (-inverse f) g)) 
#'user/inverse?
user=> (inverse? inc dec)
true

I think it's getting too late for me to get any points 😉

Ha!

The point is you can extend protocols to function classes. 🙂

For fun and profit!

ah right, hack Friday 🙂

I often do this move for singletons like

(def Thing (reify))
(extend-type (class Thing) ,,,)

reminds me a bit of this code where the function name is recovered from the class name: https://github.com/borkdude/spartan.spec/blob/ff7317d67ec15f188afb856d37090e5c9509374e/src/spartan/spec.clj#L118

for the same thing from the opposite direction, you can also extend a deftype / defrecord to IFn so it can be called like a function

just implement applyTo for arglist and invoke for each arity

Yeah, familiar with that (been doing this for a long time).

But you could imagine tagging functions as Associative or Commutative in this way and win with algebra.

or SideEffecting 😛

Yeah, why not? THIS. IS. SPAHTAH!

What would you do with functions tagged Associative or Commutative , out of curiosity? Some kind of run-time checks when those functions are passed as parameters into other reduce-like functions?

Same question (and maybe answer) for SideEffecting ?

I probably wouldn’t do this in serious practice but if I’m experimenting I’d use it to explore a space where those properties are of interest.

something like a reducer could automatically decide how to build a pipeline based on those tags

it's the sort of auto-optimization of steps that RH explicitly talks about disliking (eg. that talk where he discusses a query planner in the context of justifying how little optimization clojure attempts)

Algebra is useful. 🤷

Optimizations and/or designs which leverage algebraic properties can be useful too. But most of this discussion is OT. I only wanted to share this one neat trick cause I thought it was just that. 😄

I am afraid to type that, even if you explained what it did 🙂

try and implement assoc with update-in

(hint)

another constraint: the function to update-in must be a resolvable symbol in clojure.core

koan: (-> {:pedantic? :warn} (update-in :pedantic? _ _) (update-in :pedantic? _)) must equal {:pedantic :abort}

It seems like a usage of lein that deserves a longer comment than the plugin one would write to make it clear what was happening 🙂

Andy it's been a long week I'll leave it at that.

I wish you a shorter next week!

appreciated!

The obvious answer is that you should make a profile

I don't understand why lein calls it update-in, but doesn't take a vector.

That doesn't seem too bad

Who said I was looking for an answer.

Sorry for the snark, I'm only showing the tip of the iceberg of more of a social/human situation. I got a bit frustrated that I can't really communicate where I'm coming from.

No offence taken :). The social stuff is often the hardest :(. Been there a number of times.