is there official documentation about AOT besides https://clojure.org/reference/compilation

does it recompile automatically if files changes?

it seems to only compile once and never recompile even when a file changes?

Re docs, that's it

Re recompile, no - what would "it" be here?

(clojure.core/compile 'my.app)

if I change my.app it appears to recompile but not whenever any dependencies change

(which is ok, only want to confirm)

I haven’t totally deciphered the load process when it comes to AOT

it's exactly the same as with require

RT.load is simple enough but do classes still call that or do they directly refer to classes?

it will load (and compile) namespaces that have not already been loaded

transitively

if a namespace has already been loaded it won't reload it

its a fresh JVM so nothing is loaded

I basically call clojure.main -e "(compile 'my.thing)" -m my.thing

except it will recompile a namespace if the clj file is newer than the classfile

so that I have AOT compiled code on the next run

but only for the root namespace you pass through to compile

yeah that was my quesion

if (ns my.thing (:require [foo])) and foo changes

the (compile 'my.thing) won’t recompile foo

yeah well, the transitive namespaces are laoded via require not compile

so they behave as per require

meaning they don't get re-loaded (and re-compiled) automatically

hmm but (compile 'my.thing) compiles everything (transitively)

not just my.thing

compile sets up a compilation context, every namespace loaded within that compile call will get compiled

now I’m confused …

the point I’m confused about is whether or not it still recompiles once it has loaded a class (and didn’t reocmpile it)

I don’t know how classes load dependencies

so, having (ns foo (:require bar)) (ns bar)

if you (compile 'foo) and bar isn't loaded yet, bar will get AOT compiled

if bar is loaded already, it won't

yes that is clear

as I said NOTHING is loaded

its a fresh JVM

so it doesn’t matter

clojure.main -e "(compile 'my.thing)" -m my.thing

if you change foo and recompile foo, only foo will get AOT compiled

if you change bar and recompile foo, nothing will get recompiled

ok thx. I was unsure about that

unless your requires have a :reload clause

in that case they might get re-compiled transitively

so if I know that bar changed I need to delete the .class file for foo

compile has :reload?

no, require does

if you (ns foo (:require bar :reload)), change bar and foo and recompile foo, bar will get recompiled too

or whatever the syntax for reload is

I’ll just reset the .class files whenever I know that something may have changed

is proxy-super thread safe?

(defn proxy-call-with-super [call this meth]
 (let [m (proxy-mappings this)]
    (update-proxy this (assoc m meth nil))
    (try
      (call)
      (finally (update-proxy this m)))))

(defmacro proxy-super 
  "Use to call a superclass method in the body of a proxy method. 
  Note, expansion captures 'this"
  {:added "1.0"}
  [meth & args]
 `(proxy-call-with-super (fn [] (. ~'this ~meth ~@args))  ~'this ~(name meth)))

that doesn't look thread safe, but I must be missing something

I’ve never looked at it. what looks unsafe?

it mutates the method map for the proxy, and for the duration of (call) it seems like any callers of that method on the proxy, would get the superclass's method instead

(is how I read i t, but I haven't looked in the guts of proxy in a while, and it seems crazy that it wouldn't be threadsafe, so I must be missing something)

well, I didn’t exhaustively through all the code, but at a glance, that seems correct

I mean your analysis seems correct that is

although I’m not sure it’s possible for that method to be in the proxy in first place as you can’t proxy super methods

I don't entirely follow that last bit, I have a (not very small) test case https://gist.github.com/hiredman/a42f83c2708bf6291a75c9372ad26525 that seems to demonstrate the thread unsafe behavior