I have a junk project for every dependency I can think of for that. If something in it pans out I spin it off

But with neil it's so easy to create projects I started deviating from that

I have a clojure-playground deps.edn project with : deps.edn :

{:paths ["resources"]
 :deps {clj-commons/pomegranate                     {:mvn/version "1.2.1"}
        com.github.jpmonettas/flow-storm-inst       {:mvn/version "3.0.236"}
        com.github.jpmonettas/flow-storm-dbg        {:mvn/version "3.0.236"}}}

(ns user
  (:require [cemerick.pomegranate :as deps-pomegranate]
            [flow-storm.api :as fsa]))

(defn add-deps [& lein-style-dependency]
  (deps-pomegranate/add-dependencies
   :coordinates `[~@lein-style-dependency]
   :repositories {"central" ""
                  "clojars" ""}))

(defn start-debugger []
  (fsa/local-connect {:theme :dark}))

(defn stop-debugger []
  (fsa/stop))

(user/add-deps '[hiccup "1.0.5"])

(ns playground.hiccup-test
  (:require [hiccup.core :refer [html]]))

(html [:div 1])

The idea of hot loading dependencies is to keep deps.edn deps small so it starts fast, and then every playground file is self contained

Just one note on using RELEASE version - this fools the classpath caching so once you have that, unless you change the deps.edn or -Sforce, you will never get new versions of those deps

yeah, I had been bitten by that before

edited after Alex comments

Nice, coincidentally I have actually experimented recently with Neil, and, separately, using the add-libs tools.deps branch, both seem really nice for this type of stuff

If you have babashka-compatible code you can also use this:

(require '[babashka.deps :as deps])
(deps/add-deps '{:deps {medley/medley {:mvn/version "1.4.0"}}})

(require '[medley.core :as medley])

(prn (medley/index-by :id [{:id 1} {:id 2}]))

Eric Normand had a good article about running a single .clj file like a .sh by adding some sort of preamble to the top of the file but I can’t find it, will check my files when I get home

This was in the dark ages before Babashka

@U064UGEUQ I found some of these pretty interesting: https://stackoverflow.com/questions/7656523/how-can-i-run-a-clj-clojure-file-i-created

Ok here it is: https://gist.github.com/ericnormand/6bb4562c4bc578ef223182e3bb1e72c5

I’ve started organizing different scratch projects as polylith components. I stole the idea from someone here but don’t remember who. :thinking_face: It’s been working quite well.

https://gist.github.com/ericnormand/6bb4562c4bc578ef223182e3bb1e72c5

#!/usr/bin/env sh
#_(
  #_DEPS is same format as deps.edn. Multiline is okay.
  DEPS='{:deps {seesaw/seesaw {:mvn/version "1.5.0"}}}'

  #_You can put other options here
  OPTS='-J-Xms256m -J-Xmx256m -J-client'

  exec clojure $OPTS -Sdeps "$DEPS" -M "$0" "$@"
)

(use 'seesaw.core)

(native!)

(def f (frame :title "Test"))

(-> f pack! show!)

then you chmod the file and run it from bash

This works because this top segment happens to be both valid bash and valid clojure

I see woodstock already linked this too

If I recall @U04V70XH6 helped me adapt this a little while ago to use the -X parameter so that you can use individual functions from a file but I happen to have that computer in a storage unit

And apparently I don’t know how to back things up to the internets

if you are on linux maybe you can do something like strace -f -e trace=network clj 2>&1 | grep sin_addr to start clojure and see what it is connecting to. And then use wireshark to look at the traffic

im on mac so maybe thats close enough

no idea about macos, but there are probably some gui apps that constantly monitor network activity per app

what about https://www.wireshark.org/?

maybe you can do it just with wireshark, you can capture and filter out all the noise before starting the app, when you run the program you should mostly be seeing what the new process is sending

although tbh, trying to reverse engineer via spying on the network calls rather than reading docs or source seems like the hard way to do it

It’s all just http calls, so an http proxy should be sufficient

I believe it’s requesting the version metadata file from each repository, then doing a local computation

Note that not all repos publish the file so this is a possibly incorrect computation

For HTTP/S traffic something like https://mitmproxy.org/ might be easier to deal with than wireguard

I ended up getting most of what i was looking for with clj -.debug=all src/main.clj 2> out

its doing a strange thing where it tries two urls for the metadata

1. maven2/dev/whatever/maven-metadata.xml fails 2. dev/whatever/maven-metadata.xml succeeds 3. then maven2/dev/whatever/0.0.1/whatever-0.0.1.pom succeeds 4. and it gets the artifact it wants from maven2/dev/whatever/0.0.1/whatever-0.0.1.jar

so...interesting

in the output it doesnt say the domain, but the package im testing is only published to central - so one of those urls. clojars might work differently

I think due to history there are a variety of places that metadata can be?

it would probably be too much to ask from the universe to assume that history is documented, right?

I know from reading coursier that ivy repos are a thing

I don’t know where that’s documented, but would search for “maven repository layout”

Or read the code

> Or read the code Have been - its wierdly brutal

mitmproxy is working great but its not picking up the traffic from clj which is interesting. maybe it doesnt see it as http requests for some reason?

https://cwiki.apache.org/confluence/display/MAVENOLD/IRC+Log+Design+Discussion+26+May+2005