I'm not sure what that question means in the context of Clojure @deleted-user

When you ask for a dependency, it is fetched and cached into the local Maven repository cache in your home directory. After that, any process you run under your account can reuse that dependency without fetching it again.

You can use an environment variable or command-line option I think to specify a different location for that cache... so I guess you could use a shared location across multiple accounts -- if that's what you mean by "global"?

If you have a dependency cached, you can use it from any project.

you mean like installing leiningen globally

The JVM doesn't have "executables" -- it has class files on the classpath which java "executes".

That's just a matter of having lein on your PATH tho'...

And that's nothing to do with Clojure/JVM's view of the world.

lein (and boot and clojure/`clj`) are shell scripts/executables that are outside the Clojure/JVM ecosystem.

Maven Central and Clojars are those "shared package repo"s.

But there are no "executables", just libraries that the JVM can use.

i don't know of a way to install clojure "apps" that way from maven, but if you have a need for it

The JVM -- the java command -- is the executable.

then hacktoberfest is the perfect time

When you do gem install rake, is rake a native machine binary, or is it a file containing Ruby source code with a #! as the first line?

So it requires the ruby executable already installed

So if that command after the #! doesn't exist on your system, then it can't run.

Just like Clojure requires the java executable already installed

You can write similar things with Clojure source code if you want, using a first line like #! /usr/bin/env clj ...

Those will work anywhere on your path, as long as clj and a JVM are also on your path.

And here is another variation of that: https://github.com/jafingerhut/dotfiles/blob/master/bin/clj-check-added-metadata

The syntax gets a bit weird for that one.

@deleted-user but clj-kondo is an executable

Like I said: lein and other things are not Clojure

I believe @borkdude creates native executables from Clojure source using GraalVM, or some such wizardry I haven't looked into

package.json files can have a "bin" bit that defines how to run it huh

So, yeah, you can use homebrew or similar to install scripts and executables... but that's completely independent of Clojure.

you'll need to come up with some way to define that for lein/boot if you were to do it

or just use the target/xxx.jar as the default

I mean, there is brew install clojure, so presumably one could create Homebrew things that depend upon the Homebrew thing named clojure also being installed.

Sorry, I'm new to Homebrew, and don't know the lingo there yet.

@deleted-user what does "for clojure" mean in your sentence above?

a tool that produces an "executable" (from the user's point of view) from clojure source code

even if said executable is just an alias for java -jar target/app.jar

e.g. creates an Uberjar with a one-line shell script that runs java with that uberjar named?

i think it shouldn't be hard with a lein plugin

chances are there's already one (last commit 2009)

If you don't mind the Clojure source code being in the "executable", that seems to achieve the effect, one one way (there are others)

just as rake includes all or most of its source code in its executable.

clj / clojure just do the late binding one more step -- they find the deps over the network after you invoke the command?

Bear in mind that you already have clojure -Sdeps '{:deps {somegroup/someartifact {:mvn/version "RELEASE"}}}' -m some.thing which will fetch that library (if not already cached) and then run it's some.thing/main function.

What I mean by "outside the Clojure ecosystem" is that what you need/what is to be able to install a shell script that runs clojure with specific arguments.

I have about 3 tiny shell scripts in my path that do nothing but run a clojure command with long args I don't want to type twice.

We already have plenty of package managers (outside Clojure) that can find and install shell scripts -- just like brew install lein or brew install clojure -- and all you need to write are the shell scripts to invoke libraries.

But we already have such tools.

They're just "outside the Clojure ecosystem".

Homebrew, Scoop, Chocolatey, etc.

Are you trying to make something where you can guarantee that after step X, you can disconnect from the Internet and the program is all local?

something like homebrew specifically for clojure libs

Because if working after disconnecting from the Internet is not a requirement for you, I don't see why shell scripts a handful of lines long that invoke long clojure commands don't do what you want.

i'd lein uberjar standalone it then make a shell script that does java -jar uberjar and puts it somewhere on the PATH

And even if working after disconnecting is a requirement, you could say "run the program once and let it download the rest of itself before disconnecting from the network"

i guess it could be very useful for making trivial little tools in clojure

considering the startup time of clojure, preferably non-trivial ones actually haha

g'nite

Given clojure's user-level deps.edn and "global" aliases in that, I can't say I find the need for what Nate is talking about...

It would only automate such a tiny step in the process (basically adding a new alias to deps.edn and perhaps a shell script that invokes clojure with that new alias).

At least from one perspective, mvn/lein/boot/clj are Clojure package managers, if you consider JAR files in your $HOME/.m2 directory as installed packages.

They just don't have "uninstall" or "list installed packages" commands

"list installed packages" = ls -d ~/.m2/repository/*/* 🙂

ls -d ~/.m2/repository/*/*/[0-9]* if you want all the installed versions 🙂

For years I resisted installing homebrew on my Mac -- too much "magic"... And for years I installed stuff manually because that's what I'd been used to for decades of using computers.

Yeah, I got tired of that some time around 2000 🙂

Loved MacPorts

Partly because I figured out that if things got weird or seemed broken, and I had a couple hours to kill, I could rm -fr /opt/local and start over from scratch.

Hi everyone, do you have some tips how to make uberjar small as it can be? Is there some Lein plugin that will tell that this required namespace is not used etc? Thank you

Morning all, I remember once encountering a convention when writing Clojure... something along the lines of when should not be the final form in a function, it should be substituted with a single branch if...but I don't remember the reasoning for this. Does anyone recall this or what on Earth I'm talking about?

FWIW: I understand @deleted-user’s desire, to essentially package tooling with a project. Though we just use aliases in our deps.edn that specify a :main-opts and :extra-deps for pulling in java/clojure tools and services. And this works really well. However it doesn’t work for stuff that is compiled with graalvm, e.g. clj-kondo… I’d also like to package, compile with graalvm and ship as downstream executables some of our custom tooling in a similar way. I did notice that mvn repos can in principle store arbitrary artifacts (not just jars) — so that might be one such mechanism.

@rickmoynihan you can also put your binaries in a Github release and use bash. this is what I do for several projects, next to brew. if you want to keep those binaries private, you could store them in s3 behind some credentials and use bash.

fwiw brew also works for linux nowadays

@borkdude indeed. It’s simple enough in principle it’s just a lot of of extra setup you need to do… each package manager etc requires its own installation in CI or locally in dev. They each need different keys / auth methods etc, on both the production and consumption side, and this needs to be repeated in each downstream project. It’d be nice if you only had to do that for one of them, and then everything could be resolved. i.e. leveraging maven/tools.deps for other artifacts.

Though I also understand the desire to keep things simple. i.e. I’m not requesting this as tools.deps feature… it’d just be nice to leverage the same auth paths / transport mechanisms it uses.

@rickmoynihan this is what my brew repo looks like: https://github.com/borkdude/homebrew-brew I host several binaries there now

each binary is installable by just doing brew install borkdude/brew/clj-kondo etc

I don't need to push anything into the "main" brew package system, it's just a git repo

Thanks. I’ll take a look.

I got this idea from @roman.bataev, so credits go to him 🙂

Don’t get me wrong I think your setup is great… it’d just be nice if it were easier though; without having to involve external tooling.

Understood, don't have the answer to that 🙂

I was just wondering if it would possible to essentially just put a tar ball in a maven repo; and unpack it out of the repo into a local ./bin directory. Then you could manage it with tools deps, and the addition of a single -A:install-executables alias… in theory.

I don't see why not. You can upload basically anything into a jar.

it doesn’t even need to be a jar.

You could put the statically linked binaries in their directly if you wanted.

and perhaps have a separete repo for each platform you need to support.

or use classifiers

yeah, that's what brew is also doing for mac and linux. so I'm just going for that right now

which totally makes sense btw! I’m just thinking outloud about tooling I wish we had 🙂

and how it might work.

it reminds me of https://github.com/magnars/optimus which bundles clj-v8 to run JavaScript

https://github.com/circleci/clj-v8/tree/master/clj-v8-native/build/native

interesting… though I guess that’s using v8 as a native lib rather than an executable

true

Does anyone know if it’s possible to make a phraser for a spec, which has set as a predicate? Eg.

(s/def ::operator #{"a" "b"})

what's a phraser?

https://github.com/alexanderkiel/phrase

maybe not the best place to ask

@dmytro.bunin in this area there's also https://github.com/bhb/expound

Re: phrase & expound. The key difference is that phrase is specifically intended to enable the construction of 'end user' level error messages while expound is specifically targeting developers. In it's niche/space, phrase is impressive.

Howdy y'all I am having trouble to troubleshoot a NullPointerException that is caused when a Clara Rule is fired on a Record. The record contains no null values, but it tells me it has null values

I don't want to post the whole long exception trace. I posted my issue in clara-rules github, https://github.com/cerner/clara-rules/issues/437

record lookup can return null for a key that doesn't exist

Can you elaborate more?

I can't help right now with the clara specific stuff - I know nothing about their DSL, but clojure lets you look up any key on a record, with a null value if the key isn't present

also, as a nitpick, idiomatically _ means "a value that must be assigned but isn't used", so intentionally using it as a binding in as-> is confusing

(update _ :volume #(/ v 42)) - I would expect an arity exception here - this function doesn't accept any args

My bad yes, I saw the typo

fixed

what guarantee do you have that both rate and volume will be present and non-nil?

100% guarantee every entity passing through that rule will have rate and volume. They are added before even going through the rate

I would start by looking to see what is returned by (get @evnts "733B772B94101049D1C8520FF8A9FB109CBC66BDB6A577E8A0E6311698837E12")

my guess is it returns nil

the confusing thing the exception shows an event with a volume and rate, but your rule ignores that event and uses its id to look up another value in @evnts and actually uses that

so likely that value doesn't have a volume or rate

so like, the some? condition on the rule means nothing

also to get knit picky, Event is a record, not a protocol

#clara isn't super busy but usually pretty helpful. I have only played with clara a little, so don't have too much experience, but I think you are asking for a bad time if you pass in an immutable collection of events, and then sort of ignore that and fiddle around with your atom of events

that sounds right - also the fact this happens under load means this could be one of those "don't deref inside the thing already using the atom" situations - it could be a condition that happens when something failed a swap! and retried for example

it sounds like you are trying to multithread the thing too, which likely means you are running multiple independent clara rules engines all banging on the atom, and likely doing it in a none safe way

I suspect the best thing to do is to restructure your rules to not do anything, but generate some kind of job specifications of what is to be done, run the rules single threaded, and then take the job specs and do whatever parallel stuff you want to do

user=> (apply distinct? [1])
true
user=> (apply distinct? [])
Execution error (ArityException) at user/eval7 (REPL:1).

seems like that's what you should expect from the docstring

sure, but who reads docstrings... oh right, read the docs 😉

but it's kinda inconvenient that you should check for non-empty when using this with apply

I am using (json/read-str "{\":id\" : \"ebc7b483-1558-4b9c-8f8c-c9af3d1d37eb\"}") which returns a map that looks like {":id" "ebc7b483-1558-4b9c-8f8c-c9af3d1d37eb"}. How can I get that to be :id instead of ":id"? Should I manually (keyword ":id") afterwords? (I'd just pass in "id" instead of ":id" if I keyworded it manually)

@brian.rogers Which library are you using for json? Most of them have an option to "keywordize" keys.

Clojure.data.json

that would give you ::id as a key

Oh, no. I see what you mean. Well, ":id" is a string containing : already

So, whatever produced that string is doing the wrong thing.

you can use a custom key generating function

you might want that string to be coerced to uuid as well

I would expect you to start with "{\"id\" : \"...\"}" instead.

Yes @seancorfield I think you've given me the solution. I will pass in "id" and then use (`clojure.walk.keywordize-keys ...)`

Thank you!

And I'll coerce that uuid after that =]

there's an optional arg, you don't need to walk afterward https://github.com/clojure/data.json#converting-keyvalue-types

(json/read-str "{\"a\":1,\"b\":2}"
               :key-fn keyword)
;;=> {:a 1, :b 2}

and your :value-fn could check for uuids :D

Oh wow! That's even more perfect thank you @noisesmith!