We use Component, but I've heard good things about Integrant would love to check it out sometime

@caleb.macdonaldblack atoms work well for simple applications. they also have a great property of being built in to the language, hence no additional deps or ways that lock you in someone else's app design approach. in case you need lifecycle management: i.e. restart stateful components inside repl, depending on number of these stateful components, you could choose to go with a library of framework that does it for you. I use mount (when I need it) and it works great for me. But do start with a few atoms, they are great.

Are you guys using these libraries mainly for dependency injection or lifecycle management? In terms of dependencies and decoupling it seems to be overkill in clojure to manage it this way if we have no need of hots wapping services like a database. A well structured app using namespaces to separate concerns seems to be sufficient to me even if they functions are directly calling implementation. It feels like more work to manage dependencies using these libraries than it would be in the rare chance we swap out an entire service that is tightly coupled. I can definitely see value in managing lifecycle though. Perhaps I’m misunderstanding were the value is in these libraries

Lifecycle management. DI isn't really a thing in Clojure: you pass the arguments a function needs.

DIME is about the closest I've seen to actual DI in Clojure and... well... it's very clever...

https://github.com/kumarshantanu/dime

Component lets you define start/`stop` lifecycle for services and specify an implicit graph of what must be started before each service.

(Mount and Integrant basically do the same in different ways)

To me, DI really implies automated injection of dependencies which Component et al only do on a very small scale (and rightly so).

The main thing that Component (and Integrant) help with is avoid global (mutable) state for services that you use -- database connections, web servers, etc.

Yes, they also let you swap out services but that's really much less of a concern (except perhaps for integration testing?). The big benefit is no global mutable state and automated start/`stop` of service to assist with resource management (which is really beneficial when you're working in the REPL @caleb.macdonaldblack).

@caleb.macdonaldblack it usually comes down to solving this or similar class of problems: > if a database connection needs config, and it often does, config should be created first before a database connection gets created if a function, that creates a database connection takes config as an argument then there should be a "power that be" that makes sure this config is created and injected, passed, into that create-database-connection function. this can be done manually of course, but with a high number of such "dependencies" it could become hard to maintain: hence you could choose to use a library or a framework to help you out with that. mount lets you to still have create-database-connection function that takes the config, but to reference the need for this config in a :start function:

(:require [app.env :as env]
          ...)
...
(defstate database-connection :start (create-database-connection env/config)
                              :stop (disconnect database-connection))

(mount/start)

(mount/start #'app/database-connection #'app/another-component ...)

@seancorfield @tolitius Thank you. This definitely cleared everything up for me. I was getting too hung up on the DI side of things coming from OOPS languages. As I now understand it, DI is not really an issue in clojure and these libraries are more for life cycle management which is absolutely a problem area for me when managing state for services and the REPL.

When is the connection actually opened?

@scott.archer I can't speak for Mount, but in Component-based systems, it would happen when you call start on your overall system component.

Thanks, I was following a conversation in beginners on jdbc and saw this one so I thought I'd ask.

So your -main function would look like

(let [running-system (component/start (app/build-system args))]
  (-> running-system :done deref))

@scott.archer connection is opened whenever create-database-connection function is called. and it is called whenever (mount/start) is called, which usually happens at either -main or REPL time

Looks like when using clojure.walk/keywordize-keys any reader tags are stripped off.

https://gist.github.com/dnaeon/9b5702968714549421853bbb6c39f233

Is this a known thing/issue?

So this is possibly a stupid question, but when basing a project on a lein/boot template, does this necessitate the resulting project be licensed under the same license as the parent template? I'm pretty sure the answer is yes in as much as there is an answer, but I'm curious

Surely not. The files are generated by the lein new command like JPEG files are generated by Photoshop or TXT files by Emacs, but you don't have to license your art under Adobe's license, nor your novel under GNU's

One might think, but also there's a considerable amount of actual original source code being copied when using a template. It's not like when Photoshop generates an image it's including huge chunks of some Adobe-made image in every output file

@seancorfield thanks for the Selmer recommendation, i really like it!

Hi there, what are going to be the main features of Clojure 1.10?

the ability to conquer the world in 4 lines of code

That sounds very promising @jgh 😎

https://clojureverse.org/t/roadmap-to-1-10/1581/7?u=alexmiller

for my comments there

thanks @alexmiller

Anyone know how to set up lighttable to not compile a new connection for each file in the project? but rather to create one connection per project?

@cgrand Hey I'm using enlive for some html parsing, have a few questions. Please let me know if you have some time to discuss

@josh_tackett I don't know how many people still use LightTable these days but there's a #lighttable channel, if that helps? (it looks pretty quiet/small)

I’m writing a macro that looks at the signature of a protocol, then generates a record that implements that protocol. This works as intended when I :refer the protocol: (protocol/spy BasicProtocol) but when I attempt to use a protocol with an ns prefix: (protocol/spy my-protocol/MyProtocolInADifferentNs) then I get a CompilerException:

CompilerException java.lang.RuntimeException: Can't refer to qualified var that doesn't exist

you are passing a namespace qualified symbol in to gensym, so you get a namespace qualified symbol out, namespace qualified symbols are pretty much cannot be used as names in def (defn, def, defrecord, etc) or local binding forms (let, fn, etc)

defprotocol methods will accept namespaced method names if they point to the right namespace at least, it simplifies writing macros

I mean, I don't know if that is the source of your error (I would need to see the full stacktrace) but it is definitely an error

so your macro will end up generating something like (defrecord foo/Whatever [...] ...)

@alexanderjamesking backing up for a moment - it would be easier to use a reify here instead of defrecord, is there a reason you can't use reify or maybe proxy?

reify and proxy are designed for making one-off anonymous implementations of things

I’m using defrecord as I’m passing in a map of functions that I need to be able to access again - so I can verify those functions were called, and for functions not passed in I generate a default (that I also want to be able verify against). The calls are stored on the functions as metadata hence the reason I need access to them.

you can store a reify for later as easily as a record instance

I mean, for workflow you might need to have a map or var that holds both your reify and the functions, instead of a record that could directly hold the functions, but that's still simpler than anonymous defrecords with automatically generated global names

thanks @hiredman and @noisesmith, that makes sense. I think I’ll take a different approach rather than using defrecord.

is there a predicate in Clojure against a namespace object returned by find-ns?

apart from (instance? clojure.lang.Namespace n)?

None that I can find.