What's the state of the art in http server libraries atm? I'm using reitit for routing, I'll probably be using sieppari for interceptors, and I'm curious what the modern recommendation is for servers. Ring is the old stand-by, but it focuses mostly on middleware and while that can be adapted for interceptors that's still stuff I'd have to do for it and it wouldn't likely connect well with the existing ring libraries for auth, sessions, and other stuff. There's http-kit which is pretty cool but the site and docs are unmaintained for the most part (despite the actual lib still seeing updates) and has some interesting features about which I know very little, like websocket promotion.

ring isn't an http server, it is an interface that defines http request responses in terms of clojure function calls. Often when people speak about ring in terms of http servers they are refering to ring-jetty-adapter, but there are are adapters for a number of http servers

right, I suppose I haven't dived into that ecosystem enough to remember that off the top of my head. Thanks for the clarification!

jetty can also be used via the java servlet api, or directly via its api

and supports things not readily exposed via ring (like websockets)

right, and so does http-kit, with a similar api to ring

as to state of the art, interceptors are maybe still that, but they have been around a while and haven't really unseated ring as the go to

at work we are still mostly ring, compojure, and jetty

we have two services that use bidi for routing (which predates reitit, but provides some features I really like over compojure like reverse routing), and one service that uses a netty based http server

we've experimented with using http-kit over jetty, but didn't get as good newlic metrics reporting

I have seen reverse routing as a feature, but I'll admit I have yet to get when it would be useful.

avoids having to hard code paths for links, form actions, etc

so if I change the path for a handler, all the links to it still work

which I think is great, but yeah, a lot of people are not blown away by

reverse-routing++ ❤️

the bidi stuff does bite us from time to time because everything else is ring/compojure so sometimes things need to be worked around for one reason or another

(reitit has the same thing and will build the url for you from params)

we use interceptors at nubank for not only web servers, but Kafka message consumption and production

I find an assembly line / bulletin board style of work separation easier to deal with than function composition (ring)

that seems pretty cool

interceptors handle request coercion, serialization, validation, auth, signing/validation, all sorts of things

via pedestal?

yeah, the interceptor machinery is separated from the web stuff

I’m struggling to get the -P switch to work (to cache dependencies in CI) My makefile contains:

deps:
	clojure -P -J-Xmx1024m -X:jar :jar target/app.jar
jar:
	clojure -J-Xmx1024m -X:jar :jar target/app.jar

FROM openjdk:12-jdk-alpine AS build
RUN apk add bash curl build-base
RUN curl -O 
RUN chmod +x linux-install-1.10.1.478.sh
RUN ./linux-install-1.10.1.478.sh
RUN apk add bash \
    gcompat \
    libsass
RUN adduser -S app app

WORKDIR /app
COPY Makefile deps.edn ./
RUN chown -R app /app
USER app
RUN make deps
USER root
COPY entrypoint.sh /app/
COPY resources /app/resources/
COPY dev /app/dev/
COPY src /app/src/
RUN chown -R app /app
RUN chmod +x /app/entrypoint.sh
RUN make jar
USER app

EXPOSE 3000
CMD ["/app/entrypoint.sh"]

different users have different ~/.m2 directories

oh dear you’re right, i’m running one as root and the other as app that’s not it, even if I put them right next to each other, make jar will re-download the deps

USER app
RUN make deps #bump
RUN make jar

EXPOSE 3000
CMD ["/app/entrypoint.sh"]

I would replace the calls to make file with the direct calls to the clojure cli for debugging purposes

if it is actually downloading the same stuff again that is very odd, I would start using ls to see if after make deps runs app has an ~/.m2 and it has things in it, is there a .cpcache directory, etc

HI. I wonder why we have a puts queue for async channel? https://github.com/clojure/core.async/blob/6ac8ed2a26c67bbc3cc43e4e650f97c984666b0c/src/main/clojure/clojure/core/async/impl/channels.clj#L158. Why don’t we directly rely on the channel buffer?

Hello ! is there a "better" way to check if a namespaced keyword is from a specific namespace other than (= (namespace said-keyword) "namespace-name") ? Thanks in advance !

I am using a library that returns values in clj but in cljs it returns a chan that will eventually have that value. This presents a problem that processing of that value must now have split logic for channel vs non-channel value. Is there some sort of small utility library that would smooth over that?

I want to put into spec that something is a core.async channel, but I cannot find a predicate for that… am I missing something?

spec does not have a function for that, and indeed core.async itself doesn't have a predicate for channels

the best you can get from what I've seen is satisfies? with ReadPort and WritePort

For some reason, the following compiles and runs fine:

(let [{:keys [a b c] 
       :or {a 1 b 2 
            c (for [i (range a)
                    j (range b)]
                [i j])}} nil]
   [a b c])
;;=> [1 2 ([0 0] [0 1])]

(defn transform2 
  [{:keys [algo opts] frame :hydrated fill :compressed}]
  (let [{:keys [rcs rsiz csiz] 
         :or {rsiz (count frame)
              csiz (-> frame first count)
              rcs (for [i (range rsiz)
                        j (range csiz)] [i j])}} opts]))
;;=> ... Unable to resolve symbol: csiz in this context

What am I missing? Thanks for any comment..

can i rely on the observation that (into [] (apply sorted-set (reverse (range 10000))) produces a sorted vector?

here, yes

Generic Q as somebody who doesn't always follow the Clojure world closely: have there been any announcements/roadmaps about where Clojure is headed now w/ NuBank in play? How has the strategy/roadmap changed? That kind of thing. Thanks.

This statement from Ed when Cognitect joined Nubank is a great overview of intent and (18 months later) continues to be pretty close match https://building.nubank.com.br/welcoming-cognitect-nubank/

(except all the Nubank numbers there seem small now :)