BTW I hink you can replace (remove nil? (map ...) with keep Also take a look at transducers. You can put together all the mapping functions by calling them without the collection argument, then you can use that xf with into instead of doall, because it is eager when used with a transducer. It may give you some performance gain.

#datomic is the place for this

But you can decant the database into a new one

If you're planning on putting that much data into datomic, you might struggle. There's a soft limit on the data you can put in, and you'll need to speak with cognitect for capacity planning.

thank you!

I would first look at Maven for that.

Also consider Leiningen, in particular in combination with https://github.com/ztellman/virgil

clojure itself and older clojure contrib libs are built with Maven: https://github.com/clojure/clojure/blob/master/pom.xml and https://clojure.org/community/contrib_libs

Thanks for the replies. I actually didn't know about java-source-paths in leiningen

Yeah. If you're already using leiningen, I'd just go that route ^^^

https://fabianlee.org/2018/01/19/java-determining-the-java-version-used-to-compile-a-class-class-file-has-the-wrong-version/

https://en.wikipedia.org/wiki/Java_class_file#General_layout

Whether a .class file works on certain JDK version depends on the bytecode version that .class files have. https://clojure.org/community/devchangelog says that clojure 1.10 generates Java 8 bytecode.

ah, so if I don't use any fancy java 11 features, chances are it still works?

It won’t work if you used parts of JDK libraries that are in JDK 9 or later. Otherwise it could work.

thank you

If you have class files, javap can tell you which version they are

thank you

I don't think special forms can be shadowed

right

Or it seems they can, but not if they're the first element of a form

I had a similar issue recently

I don't know if that's correct or not, but I like to think of them as read time macros

Like they get evaluated at read time, even before macro-expansion

Hum... well ya that doesn't seem to be the case. But oh well. I'm not too sure what the semantics are for special forms and when they are processed exactly. But I'd avoid shadowing them 😝

It seems like a thing a linter one might want to warn about 🙂

I don't think Eastwood does so.

hm yeah.. 🙂

I think they're processed directly by the compiler. And depending which special form it is, they'll have the compiler do something different. But in the context where you shadowed a special form. I guess you could consider it a bug that the compiler misidentifies the code as a special form when it isn't referring to one. At the same time, I don't know if it's possible (or just way too hard) to detect the difference.

I have this inside a clojure interpreter:

;; derived from (keys (. clojure.lang.Compiler specials))
;; (& monitor-exit case* try reify* finally loop* do letfn* if clojure.core/import* new deftype* let* fn* recur set! . var quote catch throw monitor-enter def)
(def special-syms '#{try finally do if new recur quote catch throw def . var set!})

I mean, just imagine the confusion that one could create by trying to name a function .

so I guess the same will happen when you call a function throw

I had fun debugging Eastwood running on a Clojure library that defined, I believe, a macro named catch

(def def (fn [] "lol"))

which I believe worked as the authors intended it to.

lol

user=> (def throw [])
#'user/throw
user=> (throw)
Syntax error compiling throw at (REPL:1:1).
Too few arguments to throw, throw expects a single Throwable instance

Actually

I think it does work

user=> (defn catch [])
#'user/catch
user=> (catch)
nil

Just need to fully qualify your fn name namespace/var

catch probably works because that symbol only has a special meaning inside throw

something like that, yeah.

@U0K064KQV it could work with a namespace prefix, but what if the function is recursive like in my original post?

aaaanyway, good to lint

`(def def (fn [] "lol"))
(def) ; too few args to def
(def a 10) ; #'a
a ; 10
(user/def) ; lol`

It does not come up very often in live code examples, but there might be something out there.

oh yes, this works:

user=> (defn var ([x] (user/var x nil)) ([x y] [x y]))
#'user/var
user=> (user/var 1)
[1 nil]

still probably good to avoid. I bet I will trip some edge case in CLJS or something when I go ahead with this

Ya. I also don't really understand the underlying mechanism. I guess the compiler probably just first checks if the symbol in first position is a special form, if so treats it as one. If not, performs var resolution in the given namespace. And when the symbol is fully qualified, it does not equal any special form so that probably works.

Seems to work in CLJS as well. But ya, who knows what other edge case it could have.

i don't know if the details are still accurate but there is a bit in the "clojure for java programmers" (part 1) rich hickey talk that mentions about the order -- around 1:03:00 or so (the op slide)

Yes, although that might be a somewhat simplified explanation vs. what the compiler actually does, even at the time that talk was given.

The details of name conflicts can get pretty finicky here, I suspect.

i hope to some day understand it well :)

Eh, if you get insanely curious, I would recommend adding several System.out.println calls into likely-looking places in the Clojure compiler implementation, then come up with several example forms to compile and evaluate that should exhibit different behaviors in that area. It can be time consuming, but on the order of hours, not weeks.

well, perhaps hours stretching into days 🙂

thanks for the tips -- may be my curiosity level will reach that point before long

Not sure what you mean by "that's out of scope" there. Do you have an example of what you mean?

I mean, how can you shadow something unless it is visible in the scope of where the let expression is?

for example, I often use key destructuring, but if I need to process a key before passing it thoruhg, I often shadow

(let [{:keys [a b c]} some-obj
      a (if (= b 2) a 0)],,,)

sorry, you're right, not out of scope

In a small enough let, I would think the meaning is pretty clear to all all slightly experienced Clojure developers.

The larger the let gets, the harder everything is to follow, not just shadowing.

I often do a' or something, but evil-cleverparens has some annoyances with stray single-quotes

I am not familiar with evil-cleverparens, but if that is intended to be a Clojure or Lisp-specific mode, it might be advisable to report that and see if they can improve on it.

i wouldn’t read into that too much. may just mean many clojurians are happily employed, effective in small numbers, and anti-hype 😛

Don't know what to say... Clojure is amazing, but the battle for mindshare is tough, and Clojure puts little focus on it and doesn't really care. Or should I say, wouldn't compromise its goals to make itself more attractive, for good reasons.

Those are based on very small percentage differences at one online job site

My impression is that there are more companies hiring more people now than ever

Was just at Clojure Conj, full of people at companies hiring Clojure devs

That's good to hear.

I wonder what's the threshold for being included on that list. I can imagine the job postings mentioning clojure went from 5 to 1, just by chance of the measuring date.

It's kind of weird to see Clojure (a relatively new and popular technology) among other dinosaurs like jsp, solaris (!), vba, flash, windows XP (!!) ...

I don't necessarily pay too much attention to such reports but I still find it peculiar that among all possibile niche technologies that exist and are declining it's Clojure has the taken first position.

Compared to flash it was particularly surprising for me as well. That suggests, according to the worlds largest jobhunting site, that more people are interested in sticking with flash for their work than clojure?

Maybe that's because there are few corporate jobs and companies are simply no longer posting their positions on that website anymore. Maybe most recruitment these days happens in other forms (other hiring platforms, this slack's channels, conferences ect).

But it could be as well just an anomaly in the way they processed their data. I doubt that people are sticking more with Flash than with Clojure.

Also I remember that in the past many backend -positions would list Clojure as a "nice-to-have" technology in their description. Maybe it's no longer the case nowadays and this highly influenced the final result.

list of companies hiring at #reclojure (London) from today ... https://clojurians.slack.com/archives/CQ4R1R96V/p1575294494200600