if peeps are feeling it, i'd like any feedback you have on that one-paragraph spiel, btw

Have you actually found object pooling to be a win perf wise? I feel like every time I try it the caching and/or concurrency aspects end up making it slower than not pooling

My main use cases are pooling connections / clients to external resources (APIs / databases). So it's been useful in those situations (especially if I need to limit the total number of concurrent connections). I'm curious though. In what situations have you tried object pooling and found that it made performance worse?

Been a while, don’t remember. Always seems like the complexity of it is not worth the trouble

No worries. If you remember, let me know. FWIW, simplicity was a goal of mine with this library. You just need a 0-arg generator function and a maximum size for the pool, and then you can pass functions to with-object to have them execute in the context of an object from the pool. Everything else is handled for you. There's extra parameters you can pass in for things like timeouts and health checks if that's required for your situation.

;;construct a pool that always generates 5 as the object and has a max size of 10
(def pool-ref (pool-party/build-pool (constantly 5) 10))

;;Run a function in the context of an object from the pool
(pool-party/with-object pool-ref
  (fn [obj]
    (println "borrowing obj:" obj)))

Hi Stephen! I was actually looking for an object pool library a few days ago, will give it a try.

I haven't tried, and maybe my reasoning is wrong, but let's say you are processing real time frames coming from opencv, if you grab the frame objects from a pool and just replace the pixel array content instead of creating new frame objects every time, shouldn't this improve processors cache usage, since the frames memory are always the same and stay in L1 or something?

this is neat @U0M7A18V6 I'm going to start trying it for my use case: a remote service which only allows sessions for auth, has a very low limit on total sessions, doesn't have a way to check if a session is still alive (apart from: make request, does it succeed/fail?) so object pooling seems like a pretty good fit