After almost 2 months of full remote (even for digits “newbies”) our CEO is convinced that remote is the future. We hired our first fully remote programmer. I’m still working from home :)

(Small company, 15 people total, providing digital services)

I'm going to the office as soon as I can. Mainly because I like going to the city centre, being able to walk to the gym, decide where to eat etc. My office is an empty co-working space though, it could do with more people

This is after having worked remotely for almost 4 years

Anyone have a sizable project sitting around using jetty that would be good for perf benchmarking?

or anything else thread-pool-ey i suppose

(do (in-ns 'ring.adapter.jetty)
    (import org.eclipse.jetty.util.thread.ExecutorThreadPool)
    (import java.util.concurrent.ThreadPoolExecutor)
    (import java.util.concurrent.TimeUnit)

    (defn- ^ThreadPool create-threadpool [options]
      (let [min-threads         (options :min-threads 8)
            max-threads         (options :max-threads 50)
            _ (println (str "Threads: " max-threads))
            thread-idle-timeout (options :thread-idle-timeout 60000)
            queue-capacity      (max min-threads 8)
            queue-max-capacity  (options :max-queued-requests Integer/MAX_VALUE)
            blocking-queue      (BlockingArrayQueue. queue-capacity
                                                     queue-capacity
                                                     queue-max-capacity)
            pool                (doto (ExecutorThreadPool.
                                        (ThreadPoolExecutor. ^Integer min-threads
                                                             ^Integer max-threads
                                                             ^Long thread-idle-timeout
                                                             TimeUnit/SECONDS
                                                             blocking-queue
                                                             (-> (Thread/builder)
                                                                 (.virtual)
                                                                 (.factory)))))]
        (when (:daemon? options false)
          (.setDaemon pool true))
        pool))
    (in-ns 'clojure-getting-started.web))

i'm having trouble thinking of a good way to profile virtual threads

@emccue the default executor for futures uses an unbounded threadpool iirc - so you could spin up futures in a tight loop and profile that?

yeah sure, but thats just profiling how fast and how many threads can be made

i'm more thinking "A to B - this is how a regular server's performance characteristics change"

like how many more concurrent requests can be handled by existing code with the couple line change of the executor

that's super tricky - think doing that in code isn't really going to give you much in the way of real insights. how about using wrk or similar instead?

My company gives me 300 usd for "training" purposes, what would be the best to spend them to improve in clojure?

Is 32GB of RAM (macOS, new Macbook Pro with fast SSD) overkill for development?

does someone has some clojure code to turn html with classes into html with inline styles? I found this: http://www.jonathanpearlin.com/2015/01/06/email_inline_style_jsoup_cssparser.html but maybe there's something else I could also take a look at

i remember seeing Alex Miller discuss the namespace naming decisions of spec/spec.alpha/alpha2 online, with maybe some regret over that decision? I believe this was on reddit. It was in part of a larger discussion about how to structure your namespaces to avoid breakage. Anyone happen to have a link to this thread or remember any search terms to help find it that might be useful?

what's the question?

I'm not sure we have "regret", although maybe in hindsight with better prediction of timelines we would have made other decisions

I think we've decided that have foo.alpha foo.bar.alpha foo.baz.alpha is pretty annoying b/c you have 3 alpha.clj

in tools.deps, we took a second stab at this with foo.alpha, foo.alpha.bar, foo.alpha.baz

in spec 2, we're taking yet a 3rd stab at it with basically alpha.foo, alpha.foo.bar, alpha.foo.baz

so alpha in the segment preceding the root (really clojure.alpha.spec in that case, so there's a prefix)

so far, we like the last one the most

Gotcha, that's pretty much exactly what I wanted to re-read, thanks! Just figuring out my namespaces and remembered that convo might have been useful to go over. Sorry for making you repeat it 🙂

I’ve been using experimental in my projects like helix.experimental.foo and like it a lot

when something gets promoted from experimental to “production” it’s usually just removing the prefix for consumers

yep