Our great sponsors
-
-
InfluxDB
Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
-
-
WorkOS
The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.
-
-
Buck
Discontinued A fast build system that encourages the creation of small, reusable modules over a variety of platforms and languages.
-
-
scripts-to-rule-them-all
Discontinued Set of boilerplate scripts describing the normalized script pattern that GitHub uses in its projects.
-
SaaSHub
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
This is actually very different than `make`, since it will always run the tasks even if their inputs haven't changed[0].
It's a bit bizarre to me that their example involves building code, since this application generally benefits from the "idiosyncratic" behavior of `make`.
In fact, you probably would want the behavior of `make` for the `test` command too, to avoid running potentially time-consuming tests unnecessarily. Bazel caches test results to avoid this, for example.
[0] https://github.com/casey/just#what-are-the-idiosyncrasies-of...
It seems to me much nicer choice is https://taskfile.dev/
Just doesn't seem to even support caching task results (by declaring inputs/outputs)?
A tool that I created in the same category:
RUN : A Task runner that helps you easily manage and invoke small scripts and wrappers
* https://github.com/TekWizely/run
Do you find yourself using tools like make to manage non-build-related scripts?
Build tools are great, but they are not optimized for general script management.
Run aims to be better at managing small scripts and wrappers, while incorporating a familiar make-like syntax.
Some features:
* Auto generates command list
* Auto generates help for commands
* Supports defining command-line arguments, which are presented in help text
* Can be composed via includes
* Each command can define its own shell (or even python, etc)
If you're interested in task runners, I hope you'll take a look!
I've been using this for about six months now and I absolutely love it.
Make never stuck for me - I couldn't quite get it to fit inside my head.
Just has the exact set of features I want.
Here's one example of one of my Justfiles: https://github.com/simonw/sqlite-utils/blob/fc221f9b62ed8624... - documented here: https://sqlite-utils.datasette.io/en/stable/contributing.htm...
I also wrote about using Just with Django in this TIL: https://til.simonwillison.net/django/just-with-django
I use https://github.com/davetron5000/gli for this, since I work in ruby. Adding something like just or gli to your project is a huge win. Every dev can just `just update_db` to refresh their dev db, `just update_secrets` to update dev secrets. Whatever. So much better than putting snippets in a wiki or whatever.
I like gli because it gives you subcommands, like `gli database refresh` etc.
Shameless plug: https://github.com/hbbio/build
This is just a basic prototype but I'm still using it after many years and sits just over a 100 lines of Lua.
The core idea is to embed a way to compile/build files from a single line comment in each file directly.
https://github.com/sagiegurari/cargo-make
I ended up using it over just because it felt easier to use cross platform, and toml seemed like a right choice
Oh excellent, then better (and more portable!) tools are available:
http://pants.build
https://ninja-build.org
https://buck.build
and, if you hate yourself: https://bazel.build
Oh excellent, then better (and more portable!) tools are available:
http://pants.build
https://ninja-build.org
https://buck.build
and, if you hate yourself: https://bazel.build
Oh excellent, then better (and more portable!) tools are available:
http://pants.build
https://ninja-build.org
https://buck.build
and, if you hate yourself: https://bazel.build
There is the "pure bash bible" but it seems less than maintained these days: https://github.com/dylanaraps/pure-sh-bible
Otherwise you're stuck reading the POSIX standard: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V...
I also love just, but I try to restrict my usage to projects that don't have larger communities or user populations, as the getting it installed aspect is nowhere near universal as make. my favorite is mixing scripting languages and shell in the same file, albeit its got some rope.. but its productive and intuitive. https://github.com/kapilt/aws-sdk-api-changes/blob/master/ju...
https://www.shellcheck.net/ and it’s accompanying cmdline tool/ lsp integrations is a lifesaver for preventing that kind of thing. It’ll warn you if you’re doing anything not portable and even smartly changes it’s behavior depending whether your shebang line uses bash or sh (iirc)
You can see that here. You can also see my Make+BASH solution for documenting targets.
https://github.com/lpsantil/oop0/blob/master/Makefile#L87-L1...
I dig the general idea, but question the value add over a directory of `scripts` that follow sane conventions (ie `script/test`, `script/build` etc). Is the main thing that you can do `just -l` to see available commands? I have never really reached for `make` when I've had a choice, as I've done mostly ruby, JS, or java where you have more sane, humane tools (i.e. Rake, Yarn, Maven though that one is never fun).
My general approach is every repo should have something that follows https://github.com/github/scripts-to-rule-them-all, written in sh (maybe bash, its 2023), linted with shellcheck. When you need something fancy Rake is great or grab some nice bash command line helper and source it from all your scripts. Is a command listing really worth another dependency over what you get from `ls script` or `cat script/README` ?
Another simple tool similar to this is makesure[1]. It’s written in shell so the idea is you include makesure itself in your repo, which avoids needing to install another tool to run commands on your project.
It’s very simple so isn’t good for everything, but works well as a simple command runner.
[1] https://github.com/xonixx/makesure
Looks cool! Including the script in the project directory is the way, and I created on makesh[1] with that in mind. Since it's a submodule it can be easily pulled around with a repo and updated.
Glad to see people are finally going back to ahell scripts since they are very ergonomic and with a little portability in mind, they can be cross platform too.
[1] https://github.com/Baldomo/makesh
Related posts
- Cargo make: Rust task runner and build tool
- Makefile equivalent in Rust ecosystem
- Next-Gen Builder: The Go Build Tool with Complete Transparency. From Repo to Shippable – Never Question Your Build Metadata Again.
- Show HN: Builder – Build tool with transparent logs and metadata for every build
- The Open-Source Solution to Every Developer's Build and Compile Nightmare