Don't use def inside defn.

If you really want a global Var (which I think is a bad idea), you can do this without the weird def-in`-defn` thing:

(def pool nil)

(defn start []
  (alter-var-root #'pool (constantly (connection/->pool ..)))
  (.close (next-jdbc/get-connection pool)))

(and the fact that the idiomatic way to modify pool's value is so ugly should be a hint that global Vars are intentionally unpleasant to work with)

Gotcha, thanks Sean! Would you use something like an atom for this?

My pattern is to pass stuff like this through the call chain, to be honest.

And then I have a global Var just for use with the REPL (and never reference it anywhere else).

That’s fair! Also one more curious question: Why did you use constantly?

Either like this https://github.com/seancorfield/usermanager-example/blob/develop/src/usermanager/main.clj#L227 or as a plain Var with alter-var-root (per above).

alter-var-root takes a function to apply. So constantly makes this like "assignment" rather than an update.

(and signals that we're doing something "ugly")

For pretty much everything I write, I have more than just a "thing" that needs initializing (e.g., connection pool, web server, caching), so I use Component pretty much from the get-go.

This makes a lot of sense! Thanks Sean — learned a bunch.

So I have an app Component, that contains the db connection pool, the server, caches, etc, and I pass app through the call chain (or just parts of it as needed).

Then my -main builds the "production" Component and starts it and uses alter-var-root to put it in the REPL global Var (in case I need to REPL into the process while it is running on QA/production). And I have RCFs as needed that have code to build, start, and stop the "dev" Component, that deliberately does not update the global Var so I avoid the temptation to write code that depends on the global while working in dev mode.

Okay, noting to play with component and take a longer gander at usermanager-example. You rock Sean!

Example from work:

(comment
  (def app "Admin App" (component/start (build-system 8081)))

  (require '[next.jdbc :as jdbc])
  (def ds (-> app :database :pooled-db :datasource))
  (jdbc/execute! ds ["select * from user where siteid = 45"])
  (jdbc/execute! ds ["select * from skywriting_admin"])
  (jdbc/execute! ds ["show index from loguserphoto"])
  (jdbc/execute! ds ["describe loguseragent"])
  (component/stop app))

And the -main for that app looks like this:

(defn -main
  "Start Jetty and run the Admin Server app."
  [& [port]]
  (let [port (or port (get (System/getenv) "PORT" 8081))
        port (cond-> port (string? port) Integer/parseInt)
        running-system (component/start (build-system port))]
    (alter-var-root #'admin-app/sys (constantly running-system))
    (alter-var-root #'admin-app/metrics-request-name
                    (constantly "Admin Requests"))
    (start-telemetry (-> running-system :application :worldsingles-application)
                     "admin" "Admin Server"
                     `admin-web/probe)
    ;; wait for web server to shutdown
    (-> running-system :web-server :shutdown deref)))

(I edited the RCF a bit so the -> is a little different than it actually is in the -main but in reality they are the same)

Our Application Component contains a Database Component that holds multiple connection pools as c.j.j-compatible db-specs -- hence the :datasource selection to get a next.jdbc-compatible datasource.

(since our app uses both libraries -- c.j.j in old code and next.jdbc in new code)

And build-system includes the actual "web application" function that runs everything.