What I found is that writing a CLI in Rust is a absolute breeze, in part due to excellent documentation and the tooling, and also thanks to various well-maintained crates, such as StructOpt [1] to parse command line arguments of any complexity, or indicatif [2] to show animated progress.
[1] https://github.com/akeru-inc/xcnotary/blob/11649e49892d81754...
[2] https://github.com/akeru-inc/xcnotary/blob/11649e49892d81754...
Do you happen to have a link with more details about how that's done?
Did you link against TBD files?
fish shell's notarization script: https://github.com/fish-shell/fish-shell/blob/master/build_t...
I will need to add support for .pkg to cover more use cases. (Right now the tool specifically checks the input to be an .app bundle and zips it up for submission.)
Does it support other platforms? Will it run on Linux?
We used the MacOSX SDK from Xcode, packaged up into our internal file store for build machines to use and passed a bunch of compiler options that clang sets by default when you're compiling on macOS: https://searchfox.org/mozilla-central/rev/72e3388f74458d369a...
Getting DMG creation working was a bit of a hassle but we managed to get it done with some dmg/hfsplus tools from the iPhone jailbreak scene.
https://github.com/asciinema/asciinema
https://github.com/marionebl/svg-term-cli
(I ended up moving the SVG assets to GitHub Pages which hopefully fixes the issue others were seeing.)
You also mostly don't hit into the tricky ownership issues that can make Rust less ergonomic in CLI apps. Because the code flow is usually quite linear, so you don't have multiple bits of code trying to access the same variables at once.
Note: Although Rust has static types, it has very good type inference such that you don't often have to explicitly state the types. IMO this brings Rust pretty close to dynamic language ergonomics for simple things like this.
For most CLI tools you do not even need third-party packages in Python to begin with. You cannot beat that. And if you do, you don't need virtualenvs, because your system package manager can do the job just fine for most cases, or you can use pip or you can locally deploy.
Python has no ownership issues to think about. You cannot beat that either.
Type inference is nowhere close to dynamic typing.
Then there are other things like no compile-edit cycle in Python. No binary distribution. No shenanigans like issues with missing libraries and dynamic linking.
So you may disagree, but your points are not valid. The actual advantage for going for a compiled low-level language is performance, so unless you need that, there is no point on using Rust or any other compiled language for the majority of the boilerplate code for small scripts and CLI tools.