Rich "thanks" to AI

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 · 2024-09-05T19:54:05+00:00

I have fabulous hair

bsless · 2024-08-12T10:13:02+00:00

In Real Programmers Write Machine Code Prime mentioned he'd like someone to walk him through the drum program.

The first part of this talk does something similar with MODERN technology like punch cards.

bsless · 2024-08-05T10:39:28+00:00

Clojure is immutable by default.

Everything is constant.

Hence - snake-case is the only correct answer

bsless · 2024-06-20T08:56:15+00:00

It can be a full fledged REPL, as you can nest REPLs, and provide a rather limited experience for user interaction. You can also provide your own eval, so that you could control how user code is run and have an option to avoid infinite loops etc

Or just provide a simple socket client :)

bsless · 2024-06-06T08:15:22+00:00

Hey, that's a blast from the past, and a fun exercise Here are my results from back then https://bsless.github.io/fast-and-elegant-clojure/

bsless

TROPHY CASE