Is there a way to get clj to print out the actually-resolved deps it's using? (I'm trying to override a dependency but it doesn't appear to working -- maybe :override-deps is an alias-only thing)

don't know if it will help but within the .cpcache dir there are files with details about deps and versions iiuc

@lvh Yes, :override-deps is an alias-only thing, and -Stree should show you the final, selected versions of everything.

nice

So my colleague and I head-scratched our way through fixing a situation, and we want to give back a document, or some code, or a plug-in, or what have you, and we aren't sure where'd be best.

We're delivering a skinny jar as a "free" version of a bigger SaaS product, and so as not to give away everything we AOT'd our clojure code into a jar. First we were using straight-up compile and the jar command, and now we're using badigeon. We hit https://clojure.atlassian.net/browse/CLJ-1544 where we have to figure out which protocols to also AOT.

(We went with skinny and a pom.xml for the rest of the deps to keep the initial download small, and to play it paranoid-safe on bundling/licensing/etc.)

anyway, it seems like quite a rough edge and we'd like other people to benefit from it, and so I'm asking advice on what'd be the best way to get this out there ... blog post? Plug-in of some sort? Contribution to the AOT guide?

if it's possible to introspect a set of namespaces to extract a set of references to protocols (so we know which ones to include in the jar) I can see us making up a library or helper too.

I suppose another idea would be to implement the proposed fix in CLJ-1544 but as a lib or contribution to badigeon.

@rgm AOT is a thorny problem and the general advice is to only AOT whole applications, as the last step before deploying them, and to avoid AOT'ing libraries at all costs. At work we don't even AOT our applications -- it's just not worth the hassle.

If your product is SaaS then maybe making a full JAR and AOT'ing all of it, so it could be run directly (but could also still be used like a library, much like REBL from Cognitect), would be a safer approach?

Writing it up on http://ClojureVerse.org might be a nice way to put the information/process out there for the community, as well as generate some follow-up discussion -- or on your own/your company's blog and then posting a link and summary to ClojureVerse?

yeah, maybe our own blog is the way to go, if only so we actually lock down our own understanding.

as far as I can tell we successfully managed a thin AOT'd jar, and it was certainly educational, but yeah, not sure I'd try that again.

The problem with AOT'd libraries is that you often end up tied into specific versions of your dependencies (including Clojure itself) so the library can be very brittle -- and may break with any change in the dependencies used by clients of your library.

I'll be interested to read your blog post @rgm and to hear any experience reports from folks who try to use your "thin AOT'd jar" but I expect pain 🙂

well, I expect some travails but fortunately it's an application and not a lib.

Then I'm confused about why you refer to it as a "thin JAR" -- applications are "uber JAR" by definition @rgm and AOT'ing those, AOT'ing all namespaces, is fine (like I say, like Cognitect's REBL).

What's the best way to convert unix epoch to date time?

It's giving me bad result

@seancorfield?

@sandae.macalalag What "date time" type are you trying to produce?

Correct value like in here - https://www.epochconverter.com/

(and I don't see what "bad result" you are getting from that screen shot -- please post actual code and results as text)

Oh, the return date is "1970"...

(require '[clj-time.core :as t])
(require '[clj-time.coerce :as c])
(c/from-long 1573788135)
#clj-time/date-time "1970-01-19T05:09:48.135Z"

If I convert it from the epochconverter it's giving me November 15, 2019

user=> (java.time.Instant/ofEpochSecond 1573804980)
#inst "2019-11-15T08:03:00Z"
user=> 

Don't use clj-time. Joda Time is deprecated. You should use Java Time instead -- as it says on the readme of clj-time.

Ah! Thank you sir! and for your awesome tools.

Also, per the docstring for clj-time.coerce/from-long it expects milliseconds since the epoch, now seconds.

(! 836)-> clj -Sdeps '{:deps {clj-time {:mvn/version "RELEASE"}}}'
Downloading: clj-time/clj-time/maven-metadata.xml from 
Clojure 1.10.1
user=> (require '[clj-time.coerce :as c])
nil
user=> (c/from-long (* 1000 1573804980))
#clj-time/date-time "2019-11-15T08:03:00.000Z"
user=> 

I guess, I'm going to say it now from my current perspective. JavaScript has huge adoption because there are a lot of tools and blog posts around where you can find what you're looking for... Clojure's future seems bleak because there aren't a lot of code/tools and blogs in the wild. It's really hard for beginners to traverse. Clojure does it's job very well though. I hope more and more people will use it and showcase what they do. I will add my fair share as well. Writing posts about my journey.

Clojure isn't trying to be "popular". Just "really good". But it is definitely a language that is geared more to experienced developers who are tired of the problems that other "popular" languages bring to the table and want something better.

And, yes, it is hard for beginners to learn, especially if they're coming from a world of OOP and/or mutable state and assignments etc. The same is true of Elm and Haskell and PureScript and several other (mostly) pure functional languages. Because it requires a different way of thinking. Complete beginners -- who've never programmed before -- often pick up FP a lot more easily than junior devs who know Java/JavaScript.

And about the future looking bleak, Elisp appeared in 1985 and whilst perhaps your common dev won't know it, Emacs plugins are written in it 🙂 ... I agree that it's not one of those languages that will (probably ever) be mainstream, and that's fine.

being forced to write some java currently at work, I'd say clojure feels more beginner-friendly

(my opinions on Java are not very charitable so I will refrain from sharing them here)

(my opinions on JavaScript are even less charitable 🙂 )

I would like to hear that!

"Clojure and its communication forums are run by, and for, people who make things." -- https://www.clojure.org/community/etiquette

Oh. Thanks for the link.

fast feedback loop with REPL + autocompletion/static analysis from Cursive is better than slow feed back loop with compile/run/reach state you are interested in + autocompletion/static analysis by IDEA java plugin

https://corfield.org/blog/2014/06/20/some-thoughts-on-java-8/ -- note the date!

It is a pity that this isn't bridged to Matrix

Anyway, I have a problem in that clojure.core/compile is not working for me. What I get is `Syntax error (IOException) compiling fn* at (compiletestfile.clj:1:1). Datei oder Verzeichnis nicht gefunden`

does "classes" directory exists and on a classpath?

Ah, no, it does not. I assumed the compile would create that as needed

how do java devs find libraries these days?

google/github/mvn search?

they copy the pom.xml of the last project

but seriously, those would be my guess

I learn about some stuff in some companies' technology radars

other stuff in hacker news

other stuff in techempower's benchmarks

and so on

I’m trying to see if anyone has implemented a java.nio.file.FileSystem Provider that is backed by a local directory… this is my most promising find so far: https://github.com/peter-mount/filesystem

And TIL about java.nio.file.FileSystem, neat.

@rickmoynihan what's the use case?

for that class or backing by a local directory?

Main use case is abstraction… I’d like the code I write to work with a zipfile or a local directory or potentially an s3 bucket.

Update: The problem has been fixed, having `Clojure.read("'minbedrift.auth")` was wrong. The code was updated as suggested. Hi! What are best practices for exposing Clojure functions to Java? I have created a Java class Auth with a static method calling clojure like this (notice the require):

public class Auth {
    private static final IFn authTokenFn;
    static {
        Clojure.var("clojure.core/require").invoke(Clojure.read("minbedrift.auth"));
        authTokenFn = Clojure.var("minbedrift.auth/auth-token");
    }
    public static String getAuthToken() { return (String) authTokenFn.invoke(); }
}

$ unzip -l build/libs/clj-common-0.1.0-SNAPSHOT-all.jar | egrep 'minbedrift/(Auth|auth)' 
     1299  11-15-2019 15:26   minbedrift/Auth.class
     2196  11-15-2019 15:26   minbedrift/auth.clj

whats the static initialization order? first the static block?

can you run line by line to know whats the line thats throwing?

you don't need to ' in that code

you should do the authTokenFn init in the static {} block after you require

I don't think either of those correspond to the error though

require should be fine here

I guess I would check in your Auth initializer whether you can do Clojure.class.getClassLoader().getResource("minbedrift/auth.clj")

Thanks! I have updated my post to indicate that the problem is fixed and the cause.

(do 
  ;; random spec that exists
  (s/def ::unrelated string?)
  
  ;; spec for a map that I don't care about the contents
  (s/def ::map-of-who-cares (s/keys))
  
  ;; this returns false, is this expected? Seems like a bug to me
  (s/valid? ::map-of-who-cares {::unrelated 1}))

spec'ed attributes are always checked @dstephens

https://clojure.org/guides/spec#_entity_maps

If I would users give access to a limited set of classes, say String in an interpreter, can they, via chained method calls, do harmful things, like (System/exit 0)?

I could build in an extra check if the method call still happens on the "allowed" classes, but I want to know if this is necessary

What’s the easiest way to write an anaphoric macro that creates a resource binds it a symbol/name of the users choice, and releases it afterwards? e.g. from the user perspective I’d like:

(with-temp-file temp-file
    (println temp-file))

@rickmoynihan something like this? https://gist.github.com/lukaszkorecki/888cf7413057d5fb532262ff3f0aaac5 I might be missing some details of course

and error handling

hmm that was essentially the first thing I wrote; but it was failing at the time because the symbol in the let expansion wasn’t a simple-symbol?

though now it seems to be working — must’ve missed something… 👀

ok weird, I’m not seeing the same error now

thanks @lukaszkorecki I clearly did something stupid and didn’t notice

hmmm looking at this further it is weird that

(macroexpand-1 `(with-temp-file foo (println foo))) ;; =>

(clojure.core/let
                              [my.ns/foo (my.ns/create-tempfile)]
                            (clojure.core/println my.ns/foo)
                            (my.ns/delete my.ns/foo))

Syntax error macroexpanding clojure.core/let at (*cider-repl repos/muttnik:localhost:51301(clj)*:850:43).
my.ns/foo - failed: simple-symbol? at: [:bindings :form :local-symbol] spec: :clojure.core.specs.alpha/local-name
my.ns/foo - failed: vector? at: [:bindings :form :seq-destructure] spec: :clojure.core.specs.alpha/seq-binding-form
my.ns/foo - failed: map? at: [:bindings :form :map-destructure] spec: :clojure.core.specs.alpha/map-bindings
my.ns/foo - failed: map? at: [:bindings :form :map-destructure] spec: :clojure.core.specs.alpha/map-special-binding

use ' not ` for macroexpand

doh! Thanks. It’s been a while.

Would it be "okay" to have something with interior mutability inside an agent

With the assumption that actions never fail

And is it safe to do arbitrary side effects inside some action put upon an agent

(for the longest time I've just been okay using atoms so agents and refs still elude me a bit)

The documentation page on agents I link says this: "The state of an Agent should be itself immutable (preferably an instance of one of Clojure’s persistent collections), and the state of an Agent is always immediately available for reading by any thread (using the deref function or reader macro @) without any messages, i.e. observation does not require cooperation or coordination." https://clojure.org/reference/agents

I would say it's ok, but it's a bad habit. You'll miss some logs and debugging is going to be hard.

Not sure if that addresses your question about "interior mutability inside an agent".

I'm making a gen-class, and it seems to me that the reflector isn't finding the overridden method of superclass I have :exposes-methods {"getCurrentContext" "getCurrentContextSuper"} and I call (.getCurrentContextSuper this), and the reflector refuses to recognize getCurrentContextSuper in this.

I don't see anything in the docs that say whether all actions for the same agent can be executed in different threads, or are guaranteed to be executed in the same thread. I would assume different send action functions might be executed in different threads, so if any of the internal state of the agent is mutable, you would be reponsible for ensuring that the mutable state was properly synchronized between the threads.

and you'd be doing so explicitly against the recommendations in the documentation, so not on terribly solid ground in doing so.

I wrote atoms once inside an agent, because I used the agent as a thread and used the atom to signal the state. It was bad in every way, it didn't crash and everything worked fine. But the value of the atom was a complete black box.

But at least changes to an atom are safely published to all threads that try to deref them, so you were probably on reasonably safe ground in terms of the Java memory model, at least, avoiding data races.

You can do side effecting things in agent actions and in fact because the stm is agent-aware (agent sends in a txn are held till the transaction completes), this is a pretty useful hook

I would heed the warning to use immutable data as agent state but you could have nil as the state and (safely) update other state, either by using a state construct, locking, etc

Does the implementation guarantee safe publishing of data mutated in an execution of an action function to all other threads somehow?

Explicitly, no, I don’t think so

Practically, maybe, but just don’t do that

So swap! on an atom is safe, as are many other kinds of mutations, by their implementations, but a lot of arbitrary mutations of Java objects would be unsafe, I think.

Right

I've started playing with macros. Oh. My. God. This changes everything :shocked_face_with_exploding_head:

Just to make sure, is reduce-kv single-threaded or can it use multiple threads ?

single

clojure.core.reducers/fold is really the only parallel reduction in Clojure

I've got a weird issue here:

(defn normalize-classes [classes]
  (let [sym->class (transient {})
        class->opts (transient {})]
    (reduce-kv (fn [_ sym class-opts]
                 (let [[class class-opts] (if (map? class-opts)
                                            [(:class class-opts) class-opts]
                                            [class-opts {}])]
                   (prn "SYM" sym (type sym) class (type class)) ;; outputs: "SYM" java.lang.ArithmeticException clojure.lang.Symbol java.lang.ArithmeticException java.lang.Class
                   (assoc! sym->class sym class)
                   ;; storing the physical class as key didn't work well with
                   ;; GraalVM
                   (assoc! class->opts sym class-opts)))
               nil
               classes)
    (let [sym->class (persistent! sym->class)]
      (prn (contains? sym->class 'java.lang.ArithmeticException)) ;; false, huh?
      {:sym->class sym->class
       :class->opts (persistent! class->opts)})))

assoc! on a transient map can return a new map — it doesn’t necessarily update it in place

ah, that was my assumption. thanks

sometimes transients do mutate the Java object given, in place, so people easily make the wrong inference from small experiments in the REPL.

now it works, phew... thanks @csm301

yeah they're not meant to be used like variables. they're meant to be used like normal data but with a big loud asterisk that they're not always (or even usually) persistent

hence with assoc! returns a new transient

this has bitten me a few times — I think transient vectors and sets don’t have this behavior

they do

If we had a Rust borrow checker, it could catch this mistake, but that is asking a lot.

the transient docs say something to the effect of "don't bash in place"

https://clojure.org/reference/transients

I'm not seriously suggesting trying to change Clojure in any way like this 🙂

actually @borkdude you've discovered a great lint check here. any time someone doesn't use the return value of conj! pop! assoc! dissoc! disj! it's probably an error

(cough -- eastwood does -- cough :-)

at least I am pretty sure it does, among warnings that other functions that should always have their return value used, not ignored.

cool! I'll also consider it for clj-kondo then

It uses that big map of data you borrowed and enhanced, @borkdude, IIRC

https://github.com/borkdude/clj-kondo/issues/611

Is there a good way to select keys in a map based on a namespace? E.g. you can specify #:foo{:bar 1 :x/y 2 :baz 3} and then use (select-keys my-map [:foo/bar :foo/baz]) to get those keys. Any way to use (select-keys my-map [#:foo]) to select all keys undernead the namespace :foo ?

group-by namespace

which is to say, you will need to write it yourself, and group-by namespace is likely a quick start to that

Hmm.. yeah I see that

cljs.user=> ((group-by #(namespace (key %)) {:foo/bar 1 :foo/baz 2 :baz/bar 9}) "foo")
[[:foo/bar 1] [:foo/baz 2]]