_bsless

5 ms·

1.
by _bsless 5y ago
Modest proposal - The real problem I see with JSON is it's not rich enough. Not a problem if you're using EDN https://github.com/edn-format/edn
2.
by _bsless 5y ago
*Unless you're paying for the commercial version Worth noting, GraalVM's JVM implementation has a different JIT compiler which seems to give better performance for highly dynamic and polymorphic languages like Clojure and Scala
3.
by _bsless 5y ago
Up to 4 threads I usually see linear scaling as well, but it begins to drop off afterwards, although I don't have a representative example at hand. I'd like to see a good example if you have one available, most of my performance w
4.
by _bsless 5y ago
I don't think there's an immediately available answer here. The wide branch factor in Clojure's implementation is very iteration-friendly, less so for updates. Worth checking out are BTrees and Hitchhiker trees, but I think a
5.
by _bsless 5y ago
You could start with these: https://clojureverse.org/t/parallel-transducing-context-figh... https://www.reddit.com/r/Clojure/comments/emylbs/any_idea_wh... https://clojur
6.
by _bsless 5y ago
Take that with a grain of salt, from experiments run by myself and others I can share this does not scale linearly. Hope some performance experts can chime in but this might be related to data structure sharing between caches or allocation
7.
by _bsless 5y ago
That's a fair criticism, but indulge this hypothetical, if you will: - assume the sliding window transducer existed in the standard library (there's an open jira for it) - assume the programmer is not an expert, but is familiar wi
8.
by _bsless 5y ago
> although he doesn't really explain why HAMTs specifically are slow Hello, author here :) HAMTs are certainly slower, for "churning" operations, i.e., lots of updates, which is where Clojure exposes the transient API, whi
9.
by _bsless 5y ago
Others have made similar comments on comparing apples to oranges when comparing optimized CL to idiomatic Clojure, but what they didn't address was "idiomatic Clojure". Threading a sequence through a bunch of lazy operations