It was this: https://github.com/seancorfield/next-jdbc/blob/18b09c0bd77cb6850505dcef1ba964a48200ab13/run-tests.sh

Hints and tips on improving my bb usage/idioms welcome since I'm new to it! 🙂

Given the context, a feature that you might like is "babashka tasks" (<https://book.babashka.org/#tasks>). In this case, a lot of the 'post-processing' of the clojure invocation can be handled by tasks 'clojure' function... bb.edn lets you define tasks:

; bb.edn excerpt with a mocked-up task, could be replaced with -X... call
{:tasks {demo-fail
         {:doc  "print something and then fail with exit code 23"
          :task (let [env {"FOO" (first *command-line-args*)}] 
                  (clojure {:extra-env env} 
                           "-M -e '(println (System/getenv \"FOO\"))
                                   (System/exit 23)'"))}}}

$ bb tasks
The following tasks are available:

demo-fail print something and then fail with exit code 23
$ bb demo-fail maria
maria
Error while executing task: demo-fail
$ echo $?
23

@U013JFLRFS8 Yeah, unlikely I'll use that because my scripting outside of work is pretty simple stuff -- and at work we use build.clj and have the Clojure CLI vendored into our repo so that every tier only has to have a JDK and then they all use the same version of the CLI without us needing to so any ops at all to install stuff.

(and my OSS projects also tend that way for anything I might run in CI -- what I showed above was just a convenience script I run locally)

I use tasks more as a way to abstract myself from the CI intricacies too. More often than not i have to hop CIs and have a mix of CIs, hence its nice there but maybe it could me a "me problem" 😅

i do have a fairly complex flow with parallel things, error recovery, cleanup etc in tasks. feels nicer than the YAML for me

@U7ERLH6JX How do you setup bb for CI? (and which CI are you using)

mostly circle. its pretty much uses the linux install script: https://github.com/bob-cd/bob/blob/main/.circleci/config.yml#L22

for actions its https://github.com/turtlequeue/setup-babashka

Ah, OK, so it's installing bb every time for Circle (or, say, BitBucket).

yes

if you have a container based executor, you can use the bb docker image we publish too

https://hub.docker.com/r/babashka/babashka/tags

Good to know re: GH Actions. Thanks.

Also good to know re: Docker image -- does that also have a JDK etc? Or is it barebones with just bb?

we even implement bb's ci logic in bb itself , just saying if you wanna go down that rabbit hole : https://github.com/babashka/babashka/blob/master/.circleci/script/short_ci.clj 😛

> Docker image -- does that also have a JDK etc? Or is it barebones with just bb Its just bb and the only dependency it optionally needs: curl

happy to answer any of bb and bb based ci/orchestration/build questions! most of it i was a part of building 😄

OK, so without Java, that means you can't run clojure in that Docker image:

seanc@Sean-win-11-laptop:~/clojure$ docker run --rm babashka/babashka bb clojure --version
Exception in thread "main" java.lang.Exception: Couldn't find 'java'. Please set JAVA_HOME.
        at borkdude.deps$_main.invokeStatic(deps.clj:439)
        at borkdude.deps$_main.doInvoke(deps.clj:428)
        at clojure.lang.RestFn.applyTo(RestFn.java:137)
        at clojure.core$apply.invokeStatic(core.clj:667)
        at babashka.deps$clojure.invokeStatic(deps.clj:43)
        at babashka.deps$clojure.invoke(deps.clj:7)
        at babashka.deps$clojure.invokeStatic(deps.clj:31)
        at babashka.main$exec.invokeStatic(main.clj:954)

So if you want to use bb with Clojure stuff in a Docker image, you need to start with the clojure images and add bb at startup...

yeah that uses https://github.com/borkdude/deps.clj which would use the JVM clojure to fetch deps and build classpath. the idiom we generally do is in docker we do a multistage build: • get the deps in a java+bb image • use the next stage with a minimal bb image

once the stuff is there on the classpath bb wont need the JVM anymore

Ah, so you generate the classpath from the JDK image and store it (in a file?) and then use that in the bb image in the next stage?

(but you're still limited to whatever bb can actually run with, so you can't run arbitrary Clojure code)

you could copy over the ~/.m2 in the next stage. when loading the deps its the same maven like logic

yes, re what bb can(not) run: https://book.babashka.org/#differences-with-clojure

Right... yeah, I'm used to BitBucket which caches ~/.m2 but only refreshes its caches once every two weeks unless you do it manually!

essentially the way we build bb, after the compilation, we dont have the JVM anymore, specially the JIT infra. so anything that produces bytecode and/or needs compilation to bytecode wont run in bb.

it is an interpreter after all.

Yeah, it's going to take me a bit to wrap my head around what I would actually use bb for... which is why it's taken me so long to actually install it...

Theres this whole thread on "Why bb" but this one kinda sums it up: https://clojurians.slack.com/archives/CLX41ASCS/p1664200068310219?thread_ts=1664199866.573089&amp;cid=CLX41ASCS

At work, we have some shell scripts that may or may not make sense to switch to bb but the tradeoff is that we'd need bb on every server -- or vendored into our repo, like we do for the Clojure CLI -- and once we have the latter, it's somewhat hard to justify the former, just for "shell" scripts, esp. when startup time isn't really an issue for pretty much anything we run...

(and we already run a bunch of stuff in dev/test/CI via build.clj and the full tools.build/`tools.deps.alpha` stack)

in general, if youre already using mostly jvm clojure and arent too sad about the startup time, keep using that. if theres an explosion of "glue" shell stuff and its too hard to understand/you wish you had clojure there, you know where to look 😄

My intention here is to try to "train" myself to turn to bb first and bash second, where I wouldn't instantly just stick something into my build.clj file 🙂

yeah the "batteries included" nature of bb could be another motivation for you too: https://book.babashka.org/#libraries

I see clojure.tools.cli there (which I maintain). I just cut a new minor release of that -- what version does bb use and how could I figure that out? How quickly does bb pick up new versions of those libraries?

https://github.com/babashka/babashka/blob/master/deps.edn#L30

picking up libs are fairly quick. can attribute to borkdude's inhuman efficiency 🙏:skin-tone-3:

Cool. So it's just a matter of getting all those updated before the next bb build/release? Oh... :rolling_on_the_floor_laughing:

yeah bb is produced like any other clojure project. has the jar and everything. just that things change after GraalVM eats that jar 😛

Dang, this needs to be in alphabetical order!!! https://github.com/babashka/babashka/blob/master/doc/projects.md

we could do that i guess! its mostly PR driven now i think

@U04V70XH6 Built-in libs like tools.cli can be overriden, if you add the lib to bb's classpath and use (:require [...] :reload)

$ bb -Sdeps '{:deps {org.clojure/tools.cli {:mvn/version "1.0.214"}}}' -e "(require '[clojure.tools.cli :as cli] :reload) (cli/summarize (cli/compile-option-specs [[\"-b\" \"--boolean\" \"Bla\" :default true]]))"
"  -b, --boolean  true  Bla"

Ah, cool. Good to know @U04V15CAJ Thanks!

We also have this page with supported projects: https://babashka.org/toolbox/

With p/shell it is fine, but should not be necessary to do this: https://github.com/seancorfield/next-jdbc/blob/5557a0e16c0eff1effab79c94a096e8a7992f8e0/run-tests.clj#L13-L14 Since shell (unlike the other functions in process) already automatically checks its exit code and throws if it's non-zero

Awesome first script :)

Since you are using VScode, this might be interesting too: https://marketplace.visualstudio.com/items?itemName=fbeyer.babashka-tasks

Welcome to the wonderful world of cross-platform scripting in Clojure @U04V70XH6! I knew you'd come around eventually!

Did anybody mention the https://github.com/DeLaGuardo/setup-clojure? It can also setup bb.

might i also add cross-platform and truly multithreaded scripting 😄

> Did anybody mention the setup-clojure GitHub Action yet? I mentioned the setup bb one, but yes this is more general and nicer!

My personal pref is to use bb tasks to abstract the tasks for a project. It's nice to go to one of my projects and type bb tasks . And then be able to quickly run a task with very few keystrokes. But I did start with bb scripts only first.

You can start out with just script/foo.clj and then hook up the script in bb.edn using load-file later

Yeah my scripts were easy to hook up to tasks.

@U04V15CAJ Ah, yes, I had been trying various combinations of things, including ProcessBuilder directly, before I ended up there so it's sort of leftover from earlier code. I started with clojure.java.shell, then went to p/process, then ProcessBuilder, then p/shell because it wasn't entirely clear from the book which would better for my use case (specifically: adding environment variables). Also, it took me a while to realize that :env replaces all the environment variables, which I'm pretty sure c.j.s/sh does not?

It does. Compare:

user=> (:out (sh "bash" "-c" "echo $PATH"))

user=> (:out (sh "bash" "-c" "echo $PATH" :env {"FOO" "bar"}))

Ah, interesting. I've never tripped over that before (but tripped over it straight away running tests) so I guess I've just been lucky in the past. Thank you!