I sometimes even pass a third stop channel as an argument to halt the process

it is almost always useful to at least allow externally created channels (you can default to creating them) as that gives users the opportunity to set channel/buffer properties that reflect their needs, and also makes it easier to test

Makes sense. I realize now that it's easy to start with a function that takes in and out as args, then wrap that function with something else that creates the channels, but not easy to go the other way. So that suggests composability dictates taking them as args.

Hello! I was looking for a type? predicate in Clojure but couldn't find it. Here's two things I tried. • Am I overlooking a function I should be using from core? • Am i missing test cases where my type-2? predicate will not behave as expected? Thanks!

(defn type? [t]
    (contains? (parents t)
               java.lang.Object))

  (type? (type "123"))
  ;; => true

  (type? (type 99))
  ;; => false

  (defn type-2? [t]
    (= java.lang.Class
       (type t)))

  (type-2? (type "123"))
  ;; => true

  (type-2? (type 99))
  ;; => true

What's the proper name given to the practice of allowing a function to use variadic key value pairs? e.g.

(defn foo [& {:keys [a b c]}] ... )
(foo :a 1 :b 2)

hi, I am trying to implement java interface in clojure (based on https://github.com/aws-samples/aws-blog-athena-custom-jdbc-credentials/blob/master/src/main/java/com/amazonaws/custom/athena/jdbc/CustomIAMRoleAssumptionSAMLCredentialsProvider.java)

(def provider
    (reify AWSCredentialsProvider
      (getCredentials [_]
        (BasicSessionCredentials. ak sk token))
      (refresh [_])))

BuiltinClassLoader.java:  581  jdk.internal.loader.BuiltinClassLoader/loadClass
         ClassLoaders.java:  178  jdk.internal.loader.ClassLoaders$AppClassLoader/loadClass
          ClassLoader.java:  521  java.lang.ClassLoader/loadClass
                Class.java:   -2  java.lang.Class/forName0
                Class.java:  315  java.lang.Class/forName
                       nil:   -1  com.simba.athena.athena.utilities.AJUtilities/createAwsCredentialsProvider

How to debug this? => #error{:cause nil, :via [{:type java.lang.ClassCastException, :message nil}], :trace []}

Hello dear Clojurians, I have a problem dealing with Leiningen and “Multi-Release JARs” (MRJARs). Specifically, I work with Java 11 and Log4J2, but get the following warning upon running or uberjaring:

WARNING: sun.reflect.Reflection.getCallerClass is not supported. This will impact performance.

depstar from @seancorfield deals with this: https://github.com/seancorfield/depstar/issues/22

Oh wait, I am deeply embaressed – I found it: https://github.com/technomancy/leiningen/blob/master/sample.project.clj#L445-L457

Trying with :manifest {"Multi-Release" "true"}…

… and it works! Sorry!

Note that depstar figures this out for you automatically based on what's in the libraries on your classpath.

what is the idiomatic way to 'amend' an exception thrown using ex-info with additional data ? ideally i want to do something like (try ... (catch Exception e (throw (merge e {:foo :bar})))

i would have no problems using a library like slingshot for this if it supports it, but i was hoping for a way to do this in vanilla clojure

a common thing to do is to chain an exception cause:

(throw (ex-info "uh-oh" {:more :context} original-exception))

there was also something to indicate this exception is thrown because of other exception which you can include, but I don’t remember details to give you an example

maybe you need this instead of merge

merge sounds a little risky

Someone on my team has defined a ^:private ^:const vector in one of our namespaces, and I changed the values in it from standard Strings to Jackson’s SerializedString , and now I’m getting an odd compiler error when building the project -

Error:clojure: Syntax error compiling fn* at (a/name/space/a_file.clj:30:21).
java.lang.RuntimeException: Can't embed object in code, maybe print-dup not defined: next
 at clojure.lang.Util.runtimeException (Util.java:221)
    clojure.lang.Compiler$ObjExpr.emitValue (Compiler.java:4893)
    clojure.lang.Compiler$ObjExpr.emitListAsObjectArray (Compiler.java:4704)
    clojure.lang.Compiler$ObjExpr.emitValue (Compiler.java:4851)
    clojure.lang.Compiler$ObjExpr.emitConstants (Compiler.java:4934)
    clojure.lang.Compiler$ObjExpr.compile (Compiler.java:4612)
    clojure.lang.Compiler$FnExpr.parse (Compiler.java:4106)
    clojure.lang.Compiler.analyzeSeq (Compiler.java:7105)
    clojure.lang.Compiler.analyze (Compiler.java:6789)
    clojure.lang.Compiler.analyzeSeq (Compiler.java:7095)

take out the ^:const

Removing the ^:const on this vector fixes the issue, but I’m just trying to understand what’s going on there

presumably only things like Strings / ints / etc should be marked ^:const?

yeah things that can be emitted as values in the bytecode

Just interesting that it was fine when it was a vector of Strings

vec of constants can be, but the compiler only understands certain constants natively. For others, it attempts some trickery

look at emitValue() in the compiler

Yeah i was digging around in there

It hits this call - `

cs = RT.printString(value);

Which throws the exception

@souenzzo JVM elides stacktraces in certain cases tldr: run with -XX:-OmitStackTraceInFastThrow

Mmm presumably this case actually throws the error -

else if(x instanceof IPersistentVector) {
			IPersistentVector a = (IPersistentVector) x;
			w.write('[');
			for(int i = 0; i < a.count(); i++) {
				print(a.nth(i), w);
				if(i < a.count() - 1)
					w.write(' ');
			}
			w.write(']');
		}

@gseyffert ^:const is overused..

Ahaha yeah, agreed…

I wouldn't say it is overused, I would say people have no idea what it actually does and treat it like some kind of incantation

That’s probably more accurate

That’s how people on my team use it

yeah... I find that if you see it once in a codebase, it will appear a dozen more times within a month when people use it without understanding what it does

^:const can lead to embedding arbitrary objects (like your SerializedString thing) into code. And it can! but the objects have to have accessible constructors

Are there any official docs on what ^:constactually does?

Or is it better considered an implementation detail that no one wants to promise what it does?

https://github.com/clojure/clojure/blob/master/changes.md#215-const-defs is the most official thing I've seen

I am having trouble even finding it mentioned anywhere outside of RT.java in the Clojure/JVM implementation.

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Compiler.java#L7325-L7326 is the implementation, you use a name that refers to a var tagged with const, instead of compiling to a deref of the var the compiler compiles the compile time contents of the var as a quoted literal in place of the name

and the quoted literal goes through that emitValue path we saw earlier. (You run into the same code path when trying to embed objects into macro templates, too)

yeah, the effect is something like turning

(def ^:const foo 1)

(defn bar [] (+ foo 10))

(def foo 1)

(defmacro foo* [] (list 'quote foo))

(defn bar [] (+ (foo*) 10))

that is all clj specific, it would not surprise me at all if ^:const behaved differently in cljs (because why not)

I’m writing a macro in which I want to create a local dynamic var in the ns in which the macro is evaluated. When I do this, the macro appears to drop the ^:dynamic declaration but the var can still be treated dynamically. Any idea how to keep the dynamic declaration? Here’s a complete example:

(defmacro create-foo []
  `(def ^:dynamic ~'*foo* nil))
;=> #'user/create-foo
(macroexpand '(create-foo))
;=> (def *foo* nil)
(create-foo)
;Warning: *foo* not declared dynamic and thus is not dynamically rebindable, but its ;name suggests otherwise. Please either indicate ^:dynamic *foo* or change the name. 
;=> #'user/*foo*
(println *foo*)
;nil
;=> nil
(alter-var-root #'*foo* (constantly 42))
;=> 42
(println *foo*)
;42

you to do

(defmacro create-foo []
  `(def ~(with-meta '*foo* {:dynamic true}) nil))

if you quote your syntax quoted expression you can see what the reader produces for it

user=> '`(def ^:dynamic ~'*foo* nil)
(clojure.core/seq (clojure.core/concat (clojure.core/list (quote def)) (clojure.core/list (quote *foo*)) (clojure.core/list (quote nil))))
user=>

which is the expression that is actually evaluated to create the syntax quoted form, which is rather complicated, and I forget how it is actually built in read, which you would need to know to figure out where your dynamic metadata is ending up

however, you also don't need a macro to create a var

intern

I was hoping to use intern, but don’t I need to know the ns for which I am interning a var?

ugh

yes

and if you don't know that, then something is being done in poor taste

like, if your create-foo macro is being called at the top level, the value of *ns* will be the current namespace

if your create-foo is not being called at the top level, you are using def not at the toplevel which is gross

Well, I should clarify… I would, of course, know the ns I am in, but it seems odd to have to declare it as part of the macro. Let me give a complete explanation. I would welcome your comments. A common pattern I’ve seen used (and have used) with integrant is some boilerplate in one ns along the lines of:

(defonce ^:dynamic *system* nil)

(defn system [] *system*)

(defn start
  ([system] (alter-var-root system (fn [s] (if-not s (ig/init config) s))))
  ([] (start #'*system*)))

(defn stop
  ([s] (alter-var-root s (fn [s] (when s (do (ig/halt! s) nil)))))
  ([] (stop #'*system*)))

(defn restart
  ([s] (do (stop s) (start s)))
  ([] (restart #'*system*)))

(defmacro create-system
  "Create a ns-global system. Takes code that evaluates to a system configuration.
  The following items will be created:
    * *system* dynamic variable to hold the system.
    * 'system' function for viewing the current value of the system.
    * Functions start, stop, and restart which will do those actions on the system."
  [config]
  `(do
    (defonce ^:dynamic ~'*system* nil)

    (defn ~'system [] ~'*system*)

    (defn ~'start
      ([~'system]
       (alter-var-root
         ~'system
         (fn [~'s] (if-not ~'s (ig/init ~config) ~'s))))
      ([] (~'start ~'#'*system*)))

    (defn ~'stop
      ([~'system]
       (alter-var-root
         ~'system
         (fn [~'s] (when ~'s (do (ig/halt! ~'s) nil)))))
      ([] (~'stop ~'#'*system*)))

    (defn ~'restart
      ([~'system] (do (~'stop ~'system) (~'start ~'system)))
      ([] (~'restart ~'#'*system*)))))

(defn config []
  {::web/server {:custom-key "This is a custom key"
                 :host    "0.0.0.0"
                 :port    3000
                 :handler #'handler}})

(create-system (config))

my initial though is: this is horrible, use component

and create-system can't do what you want

because it is a macro

and at macro expand time (config) is not the result of calling the config function, it is a list containing the symbol config

I prefer integrant to component - individual components are very OOish. However, I think at the top level, a component-like approach can be good. Kind of a hybrid solution.

It actually does work.

it happens to work

Why does everyone say "component is OO" when all of the alternatives seem to just swap global state for maps/records?

I think someone said it once and it has become standard FUD

My experience with component was that I was writing a lot of records and it did, indeed, feel very much like I was writing a lot of OOish boilerplate. This isn’t meant in any way to be an insult towards component, it’s just what my experience was. I found integrant to be much more straighforward.

but there is no accepted definition OOP (Kay's or Stroustrup's) that component is like

especially that now you don't have to create records if you don't want to

you didn't have to create records before either, but people are so lazy about understanding the capabilities of their tools

ah well ,yes - anything can be a component.

I was referring to the extend-via-metadata bit

“feels OO” is not the same as “is OO” and I’ll just say that’s how it felt. A prime example is when I needed a db component. Component creates records. Some libraries, e.g. monger, take a bare db connection in the first position. I ended up writing wrappers for a ton of libraries to accommodate them.

I would just like for people to say "it felt very boilerplate heavy to me" instead of repeating the oo nonsense

true, although having worked on a pretty big application which used atoms/defonce etc for holding connections and such, I'm not sure if less boilerplate is worth the problems it brings

What would you consider the best environment for Clojure dev? Tried VSCode with Calva and spacemacs with Cider both seem decent?

if you are creating your own system framework you should identify strengths and weaknesses in existing frameworks and try to deal with the weaknesses

you have thrown out component's strengths (proper scoping, explicit dependencies, systems as a first class manipulatable object) and seem to have introduced your own boiler plate problems you are trying to solve by layering on macros

I suspect the “feels OO” has a lot to do with the fact that you are creating records which implement a declared protocol. Feels like creating a class that implements a declared interface.

you can use component as is without using records

you can pass in your own functions that do whatever you want for starting and stoping

you can use components dependency system without using the Lifecycle protocol at all

writing a stripped down version of component that just uses maps is super simple https://gist.github.com/hiredman/075b45eaeb01e4b526ce6f8854685487

looks like component and integrant are fundamentally the same but one uses maps/records, the other EDN

Ok. I apologize if I offended you regarding Component. I just said I like integrant more. Never said I didn’t like Component. I’ve used mount, component, and integrant and I like integrant best. The only issue I’ve had with integrant is the small amount of boilerplate I add to a project to contain my single application map. I know weavejester has written https://github.com/weavejester/integrant-repl and I was just thinking of other ways of doing it. It really isn’t that big of a deal.

Integrant uses a map with multimethods where Component uses records and protocols.

I've not used integrant, I am just tired of garbage takes on component

I've used maps with multimethods with component

it works ok

I don't like it has much because it limits your ability to on the fly replace things in tests because defmethods have global effects (the mutate the multimethod)

@markbastian Here is another one, seems slightly smarter than integrant, but I have not tried it yet: https://github.com/juxt/clip#defining-a-system-configuration

at what point do you feel to add componet to a project? for ex: as soon as you have a DB and server?

It avoids the multimethod problem @hiredman mentioned above

Yeah, I know there’s also duct, which has multiple stages of configuration. I haven’t run across a need for it. Integrant is currently at the sweet spot for me. Thanks for the info on clip, I’ll check it out.

the critique of these data driven approaches to system building (like clip or integrant) is the same as for xml files for java. application booting can be complicated, so eventually your dsl for describing building a system becomes a programming language

That critique would apply if you are using pure EDN, but that is not needed for either - you can use clojure to define the system map

My experience (and it seems to mirror many other devs) is that the more data-driven the solution, the simpler it is. For me I see it in Component -> Integrant and Compojure -> Reitit as examples. Again, not saying the former are bad, but I personally like the data driven solutions a lot more.

What do you all leverage them for? I've really never felt the need to use any of them

No idea about Integrant, since I use Mount as Component-replacement. But Reitit is sweeeeet.

for component it holds state

and it holds the entire system state as a single object

and has a clear why to starting up and tear everything down

which makes it super useful for tests

because the state is mostly all encapsulated in a system object, I can have multiple systems in the same jvm and have tests that check all kinds of distributed system properties

because the system is described as a map I can manipulate the map, like swapping out a redis pubsub component for a core.async channel, so I can have some tests run without hitting redis

because the runtime state isn't held in globals (like mount) I can run the same code configured slightly differently

we had a whole thing at work where we are using braintree for payments processing, and it turned out for some business reason we couldn't use the braintree account we use for credit cards for paypal, and my boss came to me and was like "how long is going to take to add some new paypal support"

and it was almost like flicking a switch, just add another braintree component configured differently to the system

(mount is totally gross)

Any time I need a system with state I use one of the mentioned frameworks (Integrant nowadays). As hiredman has said, it encapsulates yours state so testing, etc. are much easier. Component and Integrant make it easy to have as many systems as you want in your project, so it’s easy to (for example) have a single application system and also have smaller instances that you spin up and tear down as needed for testing. A long time ago we’d do something along the lines of dynamic vars for each stateful item (e.g. a db connection) and it made a lot of things hard.

Ya, never had any of these issues

The main issue I had with Mount (and why our team tried Component after that) was that it felt kind of fragmented. You initialized different items in different nses vs. having a single system that encapsulated all your state. Integrant and Component both do that.

Doesn't seem useful to me sorry

It seems it's only relevant for tests, but in my tests I either don't mock and do a full integration test, or I mock my side effecting fns

Again, if you like mount or none of the above I don’t think you should feel bad. Clojure is made for making things that work however you want them to.

Ya for sure. Its just I hear everyone using them and people asking when should you start using them and all. And I've never felt I needing anything else then what Core Clojure offers. So I'm curious what kind of use case others have that these solve more simply

there is a repl benefit too

Like if I have a client for some rest API I just (def cool-client (delay (CoolRestClient.)))

ugh

all the code that uses cool-client referring to it via a global var

so suddenly when you get a requirements change like "we need to interact with this other cool client" that all gets rewritten

No none of the code will. All the code is written as (defn foo [client ...] ...)

Only the top level orchestrator function that manages the workflow of the request does

Yea right now I e.g. use Mount so the webserver gets restarted when I reload the code

As an example of something that works well for me with integrant is that I can have a config map for each system I am dealing with. Say I’m working in dev and someone walks into my room and says “We have a production issue.” I can just restart my system with the prod config or launch a second system in the repl with the prod config. As long as my functions take my system components as an argument, I’m off to the races. It’s a very nice, consolidated way to work. If I were using dynamic vars in different nses I might need to go to each and relaunch them or restart my repl.

Hum... Oh so you use it for configuration as well ?

Do you mean do I use integrant for configuration?

What I do is I'd have a make-client fn for each client. And a global client def that uses that make-client wrapped in a delay. The delay would pull environment specific config from our config and use the info there to figure out how to call the make-client for the current environment. In a repl, if I want to switch to the prod environment, I can just change the "environment" property to prod and reload the def so it'll now constructs a client using the prod config

Something like:

(def config
  {:test {:cool-endpoint "http.x.u.x"}
   :prod {:cool-endpoint "some.prod.comx}}

(defn make-cool-client [endpoint]
  ;; returns a constructed client for given endpoint
)

(def environment :test)

(def cool-client (delay (make-cool-client (:cool-endpoint (get config environment))))

(defn handle-some-request [request]
  (-> (do-a cool-client request)
    (do-b cool-client)
    (etc cool-client)))

Slow to type on mobile phone :p

Interesting. The way I use Integrant all configuration is pushed to the config map. This gives you a lot of flexibility to do things like restart your singleton system with a different config map, launch additional systems with different maps, merge configs (you can use derived keys to prevent collisions) to have multiple environments’ parts in your system, etc. It’s pretty flexible. It’s also super easy to synthesize what you need for tests.

I see. The big difference between what you are doing and what Integrant does is that in integrant centralizes the entire config along these lines:

(def dev
  {::web/server   {:host    "0.0.0.0"
                   :port    3000
                   :handler #'handler
                   :datomic (ig/ref ::datomic/conn)
                   :sql     (ig/ref ::sql/conn)}
   ::datomic/conn {:connection-stuff "dev-config"}
   ::sql/conn     {:jdbc-config "dev jdbc string"}})

(def prod
  {::web/server   {:host    "0.0.0.0"
                   :port    3001
                   :handler #'handler
                   :datomic (ig/ref ::datomic/conn)
                   :sql     (ig/ref ::sql/conn)}
   ::datomic/conn {:connection-stuff "prod-config"}
   ::sql/conn     {:jdbc-config "prod jdbc string"}})

Ya, I should check out integrant. If in a way it just can replace my config and give me a few extra bells and whistles that could be worth it.

When I played with component, I wasn't a fan of how it made everything more complex, reminded me too much of Spring and Guice

Mount I actually liked a bit better, since it's more lightweight, but even then, I didn't really see what more it gave compared to what I just manually was doing.

I get that component gives you the same promise that Spring does, but I find in practice I don't care. Like I never need to swap one DB for another except maybe once every 5 year when you choose to migrate from say SQL to Mongo, or Oracle to Postgress. And generally that sort of migration involves more changes anyways, it's not just swapping one client for another, since they rarely have absolutely equal interface and semantics

All I need is to swap from connecting from my prod DB, to my local, to my test, etc.

Similarly, in tests, I mean sometimes I do maybe use an in-memory variant. Like DynamoDB has an in-memory one. But since all my business code takes a client as argument, it's not an issue as well. I just create wtv client the test need and tests the functions that use it.

And for testing an end-to-end request, I generally go the extra mile and use a real DB. And sometimes I'll just use with-redefs if I really wanted to say swap it for a mock or a in-memory one. At the cost of not having parallel tests

Also, I keep all business logic pure

So my requests are like:

(-> (gather-data-from client)
  (transform-data)
  (figure-out-what-to-do-next)
  (case :do-x (perform-x-io client)
          :do-y (perform-x-io client)
  ...)

Something like that