I've finally had a chance to play with RDF/SPARQL again (dbpedia and wikidata) and I imagine there's all sorts of cool Clojure projects that could make this more pleasant than this in-browser editor. Anything I should look at?

I need a util to find a file on a classpath, something like URLClassLoader or URLClassPath that doesn't rely on these classes directly on any of the internal sun.misc or jdk.internal packages (separate from the running JVM's classpath). So a kind of simplified re-implementation. Does this exist already? It has to work with both JDK8 and JDK11. I can roll my own, but chances are there's already a Clojure lib for this.

reify documentation states:

Methods should be supplied for all methods of the desired
protocol(s) and interface(s).

You can rely on it

Based on some simple benchmarking using criterium it seems that clojure.data.int-map is performing about the same as a hash-map. Does anyone have any insight on whether there are still performance benefits to using int-map? The test:

(def mm (map #(assoc {} :a % :b (- 0 %)) (range 0 10000)))

(quick-bench (into {} (map (juxt :a :b) mm)))
;; Execution time mean : 2.863400 ms
;; Execution time std-deviation : 408.476661 µs
;; Execution time lower quantile : 2.610338 ms ( 2.5%)
;; Execution time upper quantile : 3.520416 ms (97.5%)

(quick-bench (into (i/int-map) (map (juxt :a :b) mm)))
;; Execution time mean : 2.796002 ms
;; Execution time std-deviation : 180.611581 µs
;; Execution time lower quantile : 2.678685 ms ( 2.5%)
;; Execution time upper quantile : 3.102775 ms (97.5%)

(quick-bench (r/fold i/merge conj (map (juxt :a :b) mm)))
;; Execution time mean : 3.031864 ms
;; Execution time std-deviation : 150.951817 µs
;; Execution time lower quantile : 2.894153 ms ( 2.5%)
;; Execution time upper quantile : 3.249662 ms (97.5%)

I believe one of the motivations for creating it was reducing memory usage.

That is mentioned in the README, with measurements.

Yes, it just also mentioned in the README performance benefits especially when using r/fold for map insertion (which I added to my test above). The memory benefits are probably still worth it though.

I may have missed corresponding measurements of r/fold on your environment for the built-in Clojure maps? Comparing your measurements to those in the README isn't a useful exercise.

Unless you happen to have matched the author's hardware, OS, JDK version, etc.

I'm looking for the fastest way to get the current year in CLJ without including any libraries. Anyone?

(+ 1900 (.getYear (java.util.Date.)))

Thanks! I wasn't sure if java.util.Date was the new or old Java date thing

oldest

friends don't let friends use java.util.Date

(.getYear (java.time.LocalDate/now))

that's the new thing

ah hah

^^ prob better

(they're obviously equivalent in this use-case, but we can't migrate to the better java.time package unless we have ubiquitous examples)

@ghadi i was watching: https://www.youtube.com/watch?v=-zszF8bbXM0&t=20m23s the other day and wondered if you had anything in text form somewhere

for java time @sogaiu?

yes, sorry

the highest quality reference I know of for java.time is https://docs.oracle.com/javase/tutorial/datetime/TOC.html

thanks

When writing a new piece of functionality, I write many small functions, trying to isolate the ones doing transformation from the ones doing side effects, and it all feels nice. At some point though, it all has to be tied together in a long-ish let binding that orchestrates all the small functions and has all the “defensive” code inside. Example:

(let [msg (decode arg)
      _   (when-not (valid? msg) (throw (ex-info ...)))
      record (lookup db msg)
      _      (when-not record (throw (ex-info "Can't find record"...)))
      ;; and so on
]
  (do-work! record ,, ,,))

I wonder if this is considered “idiomatic” or there are different ways of doing this?

I can think of putting the exception throwing inside the decode , lookup etc — but I’d prefer them returning nil or some explicit invalid value instead.

one idiom is (let [msg (doto (decode arg) (assert "some message"))] ....) - as long as the error state is nil or false this works

since doto will provide the value to assert, and return it

I guess I could have my own little assert-like validation functions (I like my errors to be specific and have data, since then I can see what’s going in post-mortem)

@orestis i think using the -> macro is more idiomatic for cases where you want this logical order. Certainly makes the code look neater too.

(-> {:foo 1 :bar 2}
      :bar
      (doto (when-not (throw (ex-info "not found" {})))))

Combining the two seems… off 🙂

Too tired to figure out a better way…

(defmacro guard->
  [init pred error & forms]
  `(if (~pred ~init)
     ~error
     ~(condp = (count forms)
        0 init
        1 `(-> ~init ~(first forms))
        2 (let [[pred error] forms]
            `(guard-> ~init pred error))
        (let [[f pred error & forms] forms]
          `(guard-> (-> ~init ~f) ~pred ~error ~@forms)))))

(only because I’m otherwise bored, I don’t know if this works well or not…)

I see a lot of threading macros around here, are they considered substantially better than using line breaks and indentation to format code?

“it depends”

the alignment will keep indenting if you just use linebreaks

Here's my solution: https://github.com/pastafari/adventofcode/blob/master/advent-2019/src/advent_2019/sunny_with_a_chance_of_asteroids.clj

Ok, so I would reach for -> to keep runaway indentation under control.

what indentation problem are we talking about here?

Some people like -> and ->> because it puts the function calls in the order that they occur in time, from beginning of text to end of text, instead of the opposite order.

Lol, I'm used to the nested style (came here from common lisp) but I can see that would be clearer in a lot of cases. I'll try using it. Thanks!

was reminded of this section of stuart sierra's talk "thinking in data": https://www.youtube.com/watch?v=kuNxVXnmjHA&t=28m40s

i was mentioning indentation since it was suggested you could use newlines to replace threading

(->> x
     foo
     bar
     baz)
(foo
  (bar
    (baz x)))

so that isn't equivalent

the forms are in the same order

which makes the function applications in the reverse order

my heuristics for using threading macros are generally more conservative than what I see "in the wild"

I don't like using them when the threaded calls or threaded datastructures change dramatically

starting with ->> then having a bare keyword used a function gives me pause

it's certainly valid usage

which is another way of saying I have a lower threshold for migrating parts into a let binding

which of course gives you the burden of naming

yes. sorry. just wanted a quick example while working

When using specs with generators, is it possible to provide it with some kind of seed value? Given my-spec, generate an example where :some-key = "Some given string". The rest of the keys might be dependent upon :some-key, for example if there's a multi-spec dispatching on it.

Ah! It might be the overrides argument in the clojure.spec.alpha/gen function.

Overrides are for alternate generators

You can of course provide an alternate generator that creates values from an expected form or subset