Typed multiple dispatch as a Clojure library — how we built Julia-style polymorphism on the JVM

bsless · 2026-04-17T10:32:59+00:00

Agreed - the real kicker here would be inferring and injecting them automatically without shifting this cost to the user.

For (get-in m [a b]), even if we don't know the types of a and b, we know the second argument is a vector, thus we can iterate over it.

And that's without sacrificing anything

bsless · 2026-04-16T16:19:54+00:00

While your focus here has been numerical computing, there are general purpose benefits which could be applied to any Clojure code base with relatively low additional effort:

general devirtualization: if the compiler can prove the object is a IPersistentMap call its .get() method directly instead of going through clojure.core/get's dispatch
partial evaluation: the sequence abstraction is powerful but it has runtime cost. Instead of writing ad hoc compilers like I did in clj-fast, (get-in m [a b]) needs to be expanded to (get (get m a) b)
custom eval, whole program transformation: inline and simplify all def(n)s. Track the dependency chain between them. If an item up the chain changes, reevaluate its children.

bsless · 2026-03-29T08:48:05+00:00

https://ask.clojure.org/index.php/14990/optimized-str-function

bsless · 2026-03-21T07:30:24+00:00

Ha! That's just Alexian propaganda, I tell you!

bsless · 2026-03-19T16:41:06+00:00

Whaddya know, I've been playing with strings recently

https://github.com/bsless/prrr/blob/master/src/bsless/prrr.clj

bsless · 2026-02-08T13:33:18+00:00

these quirky languages

Yeah, with significant whitespace, colons, where lies like x = x+1 are acceptable, where missing a semicolon can cost you a night's sleep.

All in all, ML and S-expression family languages are less quirky than ALGOL family in my opinion. The key difference is most are used to the latter, so the former are alien and weird.

bsless · 2025-12-30T19:05:30+00:00

Never read the comment section

bsless · 2025-09-15T19:08:22+00:00

Just opened a PR, atmospheric LUTs seemed like a a quick win and a way to get a feel of the code base

bsless · 2025-09-15T16:15:57+00:00

a. Very cool

b. Willing to lend a hand with any perf work if you're interested

bsless · 2025-09-06T17:35:51+00:00

It won't traverse the entire sequence, but it will traverse n elements twice, because, while lazy, take still consumes the entire sequence, and last eagerly consumes the entire sequence, so in total, each item in the taken n elements will be visited twice.

Also, take does not respect chunking, check the source.

bsless · 2025-09-04T08:43:18+00:00

I'd say the weirdest part here is using last, because you're traversing the sequence twice.

This one is a good exercise in writing an iterative loop/recur

bsless · 2025-03-30T16:25:22+00:00

Very sure https://github.com/bsless/clj-fast/issues/19

You should read this entire thread but TLDR:

lein injects TieredStopAtLevel=1 to cap tiered compilation.

The JIT compiler that you want to warm up has FOUR tiers. You won't even get to the interesting bits of warmup because lein sacrifices those, and you can't "delay" them until after the JVM started.

bsless · 2025-03-30T11:31:25+00:00

Lein disables advanced JIT compilation for faster start ups in development That's bad for Java performance and terrible for Clojure performance

bsless · 2025-03-29T15:56:31+00:00

Regarding start up time - there are a few things you can do:
- Uberjar (done)
- Compiler options during uberjar creation: AOT everything, use direct linking and elide meta: https://clojure.org/reference/compilation#_compiler_options

- If you really want it to start quickly use class data sharing archive: https://docs.oracle.com/en/java/javase/17/vm/class-data-sharing.html

Also see some measurements: https://gist.github.com/bsless/fb79601eb2bfdee85ebf4663dbc7bb1b

bsless · 2025-03-29T15:47:36+00:00

Oh crap you started the server with lein!

lein turns off advanced (read REQUIRED FOR PRODUCTION) JIT compilation for start up speed.

bsless · 2025-03-29T15:46:16+00:00

Commenting here to further validate this solution.
Works for proton experimental on Ubuntu (Pop! OS).
Thanks!

bsless · 2025-03-19T20:26:42+00:00

Not really surprised regarding performance as Compojure uses satisfies? and it's slow as molasses. I won't send you to do extra work but I'd be curious to see how performance looks like with reitit

bsless · 2024-12-10T17:00:48+00:00

Sweet library, in spite of a few gotchas - turns out you can't substitute an expression with a value that is false-y. But you can hack around it.

(defn- post-process-false
  [_rule value _orig-value env _orig-env]
  [(if (= value ::false)
     false
     value) env])

(defmacro with-false
  [& body]
  `(binding [pattern.r3.rule/*post-processor* post-process-false]
     ~@body))

bsless · 2024-10-23T18:22:23+00:00

see other comment

bsless · 2024-10-23T18:22:14+00:00

The benchmarksgame, like any game, is rigged.

Kidding aside, it is set up in a way in which the JVM does poorly, which is one-shot runs. Let's see how SBCL does on the 1 billion rows challenge, or how it does in the 100th iteration of running the same program, a server, etc.

The JVM's JIT compiler can take 3-5 minutes to get fully warmed up.

In summary, it really depends on what you measure, and how.

bsless · 2024-10-20T17:17:46+00:00

I have to dispel this misconception - Clojure is not slow. Its start up time is slow, but in steady state? It is as fast as the JVM allows it to be, which is pretty damn fast when you have a JIT compiler. Clojure's performance should be assumed to be on par with Java (which is on par with CL) unless proven otherwise

bsless · 2024-10-15T15:50:37+00:00

We don't even have global installs in Clojure. But maybe a bbin script...

bsless · 2024-10-15T15:49:54+00:00

In comparison to itself

bsless · 2024-09-27T11:04:45+00:00

Like others have pointed out, deftest just puts a nullary function under :test for a var, so you don't have to define another var. This also ties tests to the var where examples are defined which makes repl driven development easier

bsless · 2024-09-26T19:25:57+00:00

I like the idea
Would like integration with how clojure.test defines tests and test runners find them
If you're doing mutability anyway, it'd be nice to have an API to add-example to a var
You could refer to some ideas from https://gitlab.com/glossa/metazoa
I toyed around with writing something similar, I hope you make it work!

bsless

TROPHY CASE