I used to engaging Node for that. You basically need only Node (which can be installed through nvm at any env via a bare curl call or something). Rich and beautiful NPM ecosystem is at your disposal. Further convenience is the matter of efforts.

But thanks for the V reference, looks interesting.

When I say that bash is bad, I mean shells in general.
They are good for sysadmin tasks, when what I am doing is one program being executed after another.

But I pause and reflect as soon as I find myself using functions / if else / for loops / arguments / ...

language = V

The idea comes from a discussion about V, a modern programming language that on paper seems almost too good to be true.

My obvious counter-argument is : why would I invest my time learning a langauge that just reached version 0.4 ?

But then I saw this

Cross-platform shell scripts in V
V can be used as an alternative to Bash to write deployment scripts, build scripts, etc. The advantage of using V for this is the simplicity and predictability of the language, and cross-platform support. "V scripts" run on Unix-like systems as well as on Windows.
V is 80% go and can be learned in a week-end.

Ok, fair enough, I would rather spend a week-end learning V than fighting to debug a dumb Bash script, that sounds appealing to me.

Yes for simple scripts, it's enough. Although you are comparing apples to orange, because you can call rsync in one line in python code too ;-) (well, with the import, probably 2 or 3 but well).

My problems with bash:

• you cannot really unit test it (and yes, I have tested bats)
• there several ways to do "if", each with their caveats and pitfalls
• there is no real exception handling
• there is no real functions (they are commands) and you cannot really return from them (return statement is for error code, anything other than indicating an error is a hack and will bite you)
• argument parsing is an horror

For these reasons, anything other than trivial is really cumbersome with bash. Especially, as soon as we have arguments to a script, we should just use python and argparse for instance.

I have written installation scripts in Bourne (yeah, that's sh) totally 10s of 1000s of lines of code. (Because across many, varied systems where even bash wasn't a common denominator.) Very excruciating, although this was 20 years ago and there was no debugger. Obviously, I created "libraries" and other helps, but I would have preferred Python.

Powershell is an excellently designed language which did the hard work formalizing lessons learned from bash's awfulness.

But realistically what I see emerging in the next few years, is not yet another command line scripting language. I would be pretty surprised if non-scripted interaction with the CLI in 5 years still requires people manually typing out well formatted commands piping things between utilities. I already ask chatGPT for half of the things I want to do with the CLI, I'm not sure what's to stop that from becoming much more prevalent.

For scripting in the meantime, python or powershell or another omnipresent alternative will be fine

Babashka (github.com/babashka/babashka) allows me to have my cake (write scripts in Clojure) and eat it too (fast! startup). Having a fully powered language to write even simple things in (because they never stay simple) is near ideal.

I honestly believe .*sh are an amazing family of domain-specific scripting languages, and this specialisation also makes them utterly terrible outside their domain.

If what you want consists mainly in 1. running executables 2. managing their I/O then all the best tools for that job will likely be languages you wouldn't want to write an HTTP server in, and that's not a problem.

language = Clojure (with Babashka)

It has a really fast start up due to the GraalVM. 😁

Python is great for some stuff, but to replace lot of the stuff you would use bash for powershell is one of the best scripting languages I have used. Its not perfect but it produces a lot more readable scripts and it is a lot easier to find the utility function you need because of the verb-noun syntax. (Plus it is also cross platform)

One of the problems making bash hard to learn is that some commands consist of special characters, so you can't even google the correct syntax. Its compactness makes it hard to read and easy to get things wrong.

Another thing is that "bash" is not only bash, but bash plus a set of UNIX tools that we will have to use anyway, with or without additional wrapper functions around them.

There are bash built-ins that differ between shells, as many users found out when some sophisticated bash scripts stopped working on Linux machines, after Ubuntu had decided to replace bash with the more minimal dash shell by default.

I used to code Perl for web development long time ago, and maybe Perl is still a valid choice for administrative tools beyond simple bash tasks. But I also see many Python scripts used instead, so maybe we should all learn Python.

But as ECMAScript/JavaScript/TypeScript already seems to run 90% of everything that I use as a web developer, why not use node/deno for local administration as well?

language = Kotlin

Two options :

1. Lightweights Kotlin scripts are a thing
2. A full Kotlin project compiled to a binary executable with Kotlin native

I liked the idea of it, but right now Kotlin scripts are very niche and not quite supported.
The native toolchain is quite heavy, the compiler is slow.
Packaging is not really ready.

So right now it's better in theory than in practice, probably use something else.

Agree with this completely. I genuinely think PowerShell is an overall improvement but there's still so much that annoys me about it.

Whenever people offer things like zsh, fish, etc that's like putting a sticky plaster on a broken arm. It might be a bit better but it's still building on something fundamentally broken.

I also think that bash has a lot of people stuck in Stockholm syndrome, because it's great at some things people love everything it does, but everything you say is true.

I big time think there's a market for a modern decent shell but also appreciate this is genuinely hard.

Great article 👏

Totally agree. Shell scripting is deceptively difficult. The syntax is arcane and handling of error conditions complex. One of its only positive is being nearly ubiquitous, but so much functionality is left to other programs you still don't have a very consistent runtime environment.

Bash is a terrible language, I won't argue with you about that. However I don't think it's the worst. Batch files on Windows are much, much worse.
I tend to use Powershell now, both on Windows and Linux. It's not perfect, but it's okayish.

vlang.io might be interesting as a replacement - small, simple, ships as a single executable, has most of the things you need from bash, and is much easier to learn.

I kind of agree, in that I think if there's anything you need to code more than a very simple for loop then you would be better off using any available scripting language.

Having said that, I write a lot of shell scripts. I try to make them POSIX if at all possible, and that's kind of my cut-off point for choosing a different language. If you need to use a bash extension for arithmetic then either fall back on bc or make the jump to Python or whatever.

... but there's no point in using Python if the majority of what you're doing could be accomplished by calling grep in a subshell.

If you know some JavaScript, maybe try github.com/google/zx

I'm disagree with all of you who thinks bash is bad or hard to learn. I am using both, Bash and Python, for over 3 years and maybe more and in some cases I prefer Bash over Python because would easier to write it in Bash and the performance would be slight better than Python. Try comparing Vim or Lua scripting to Bash and you'll realise how easy to learn is Bash.

Every Bash bashing post has one thing in common; they ignore the fact that the Bash programming language features are meant to facilitate its purpose as a command interpreter, rather than as a general-purpose, interpreted programming language.

As per the Bash Info manual:

As a command interpreter, the shell provides the user interface to the rich set of GNU utilities. The programming language features allow these utilities to be combined.

If you don't spend a lot of time on the command line using Bash as a command interpreter for other programs/utilities while using anonymous pipes (or any other Unix IPC) for message passing, then maybe you don't need its programming language features anyways. Most people can get by with the built-in facilities Bash provides, along with simple sed, grep, awk, or perl one-liners without having to delve too deep.

Bash, like all shells, is largely misunderstood by those who complain that the programming features are bad, or don't work as expected, or are inefficient as compared to general-purpose, interpreted programming languages, while completely missing the point.

If you work on a Unix -like system to get real work done, properly knowing Bash, or any other shell, along with the built-in Unix IPC mechanisms and all the *utils suits (coreutils, binutils, util-linux, etc...) is almost a panacea. But, but, but...Bash doesn't have any data-structures and Bash arrays suck! Have you tried recutils?

Bash on its own isn't a panacea. Its the collection of tools that make Unix-like systems so powerful. If you want to take advantage of full power of Bash, you have to learn all the other parts that go with it. Only then will you understand the foolishness of comparing Bash to any general purpose, interpreted programming languages. They are not the same thing at all.

Claiming a language is bad because you can't remember the syntax is a skill issue.

Bash has a dependency management through brew or apt or whatever other stores you use.

Force yourself to solve problems with it and you will see immediately there is some value.

Every language has its quirks.

I've seen just as many criticisms of JavaScript or PHP. All programming languages have trade offs.

Why hate on bash. I can do 95% of all my work in bash. Sometimes you need a little go, erlang or python. Maybe you're just overthinking and engineering the solutions? 5 liners sounds like bad scripts. Even the small simple ones I write are around 100 lines. With individual "functions", error message, usage and argparsing. I've written scripts a decade ago that are still running just fine. And, honestly, I'm not a very clever programmer, just mind my T's and I's.

KISS!

Am I missing something here or are you referring to something other than the UNIX SHELL?

I have to laugh at you modern-day warriors whining about something that's probably older than most of you. Personally, I've always used C shell but that's just 1 old man's opinion. Until you've debugged memory allocation issues with DBX, please with your outrage! It's petty!

Your answer might be PERL. It's your basic C or PHP syntax and is powerful enough to 86 SED and AWK via a single command. If you're complaining about the limited time when you use BASH with your repo check-ins, please write a COBOL program to calculate the compound interest of a 30-year mortgage. No, please do .. your head will explode!

This.
I have a Java project and I needed some scripts to update and process some resources. Since I wanted them to be executable on any OS I made these choices:
1) the tools responsible for the update/processing come from npm and they are cli tools
2) the scripts had to be written in bash because it was the only one language I could execute on any OS (given than on Windows I need the Git shell anyway)

It was a nightmare. Loops and conditions are so counterintuitive sometimes, and let's not talk about variables...
I ended up rewriting them in Groovy, while still using npm cli tools though

I totally agree, I have read once that if your bash script is 100+ lines then it should be python.
However under 100 lines, Bash feels like a linux super power. To be able to use the linux commands like this, and yeah and I definitely won't try to use it as general purpose programming language.

Most regular programming languages provide an option to execute shell commands, so, why don´t you not use any of them to do the things you regularly woud do with a shell script? As long as you do not need an UI or complex interactions, things are not much different from writing scripts.

I use Ruby. Very funny language, full object, near human language.

As someone who has written an entire CMS in bash for kicks I disagree, the simplicity and power of native C applications make bash a great easy grab tool for prototyping. With zsh coproc it borders on useful, and in many cases is faster than python. But if I'm serious I'll reach for golang

While aliases are probably more common, Bash does have functions, but maybe not what you consider a "real function"? Also variable substrings being built in, as well as index and associative arrays. However, I also like the 5 line rule, although I'll admit my limit is probably closer to 15, +/-5.

That said I also try to avoid Bash scripting even before that limit. While I dable in JavaScript, Typescript, Node and Rust, I actually try to use Python as soon as possible. I find it elegant and simple compared to most languages. Even though it's dynamic, Typing can be achieved in a number of ways. Unit tests are pretty simple to achieve as well. As for package management I use pipenv when I want a unique venv which doesn't taint my git repo or require .gitignore or .git/info/exclude entries, plus it provides a nice way to lock versions as well as define actual requirements separate than those just for development (unit testing etc.) and then generate a requirements.txt file to be included in the repository.

When it comes to something where performance is a concern I see if compiling my Python script via codon into native machine code is viable. When it works it can beat the pants off C++ and many other languages. This is also becoming simpler to do with Codon creating native versions (ports?) of modules as well as supporting imports for many of the native Python modules too. I only hope they keep picking up speed on creating new releases to continually make it easier to compile and reduce the performance gap between Python and most other languages.

Bash is not a programming language as such. It has a context, it has a purpose, it is specific and useful within that. Like each and every other tool. Use the right tool for the right job. Bash mainly operates on the file system and programs level: it typically starts programs to run operations on files, and it can facilitate the data flow between these programs. It's job is not: doing the tasks those specific programs do.

If you need to do some complex text parsing, process large amounts of data quickly, or other specific tasks, you don't choose Bash for that. If you do, that's on you ;)

As the famous quote goes: if you judge a fish by its ability to climb a tree ...

The fact that you have to refer to the documentation, every time you want to write a simple statement, says more about you than the language. That being said, if you want something that is easy to distribute and a "proper programming language" look no further than Perl - the runtime is available on most systems out of the box. Alternatively, you can do python, is very easy to setup and a lot of software already depends on the runtime so telling someone "you need to install python to run this script" sounds less weird than "you need to install node" 😉.

I use nushell for my shell and scripting at this point (aside from scripts I make for work with the intent of others using or seeing and whatnot). After more than a decade of refusing to use anything that wasn't bash because it's omnipresent, I finally caved and regret not doing so sooner.

I agree with everything you said here. Another thing I hate about Bash is that it lacks even basic string manipulation features.

It depends on external programs like sed, grep, AWK, to do even simple things. Not only the output of such programs is hard to parse, but the cost associated with creating each process.

I use Lua and a module that I developed to handle any process execution (and interaction with the os): luarocks.org/modules/johannesblasc...

Why Lua? It's small enough to install anywhere, and sufficiently feature rich to do everything that you'd use bash for (automating system administration mainly).

Just to be clear, and I think others have mentioned this, but bash isn't a programming language...it's a scripting language. Two vastly different domains...Python kinda straddles that but usually it's a clear deviation between the two. You wouldn't use bash to provide a complex gui, and you wouldn't use C to copy some files...You can, but that's on you then ;)

Couldn't agree more bash has its place and it's extremely good in that place. It's easy to pick up and useful for specific jobs.

bash has been around +20y for a reason.

Bash is an alternative way to push and pull to GitHub. Git was invented before GitHub. It’s not a programming language it’s Shell Scripting. We learn about the Linux Kernel and the Shell. This is basic knowledge if we respect Linus Torvalds as the father of the Linux kernel.

Yes, bash has poor syntax, semantics and the uncontrollable multi-layer evaluation/expansion scheme makes quoting & analyzing scripts a nightmare. But suggesting 'use Python' is a non-starter as it fails to address the intent of a shell.

The purpose of a shell is to allow a user to 'exec' processes with set of arguments, and to 'connect' that process to others so that interaction is possible. For convenience bash performs wildcard expansions of file names, allows various redirections of stdin/out/err (and more), some basic signal handling, performs a little math (awkwardly). Can do a little boolean logic based on things like return codes and file features. It can iterate over numerical indices or string tokens (inflexibly).

Any programming language that intends to replace bash must include this sort functionality; hopefully with much cleaner syntax & semantics.

You need a language that every decent Linux administrator knows in order to have continuously.
That is bash.
Use perl, python or another language and almost no administrator can read it.
Even the bash scripts shouldn't be too complicated.

Bash is not terrible in itself. It might not be good outside the core linux.

Fish shell, otherwise Scala script

I think you are stuck in your developer bubble, bash was never meant to be a programming language, it is meant to be a lean scripting language inspired ny C to do day to day admin task.

Bash is not a programming language, it is an ops scripting language. All you devs go write code and let the ops folks get on with making a secure resilient place to host your work properly.

This Oz the same problem JS/Ecma has. There is no valid replacement for the role or fills. Not worth the install base now, now or ever.

Zsh

Xonsh

What about github.com/risor-io/risor or github.com/abs-lang/abs ?

I agree that bash and shell are languages ​​with a steep learning curve, but they are widely supported, and despite not having OOP, they do support functions, streams, etc.

Bash leans more towards scripting and heavy overkill if you program. You can script with most languages but bash is less intensive and has gentle learning curve for uber *NIXers.

My choice is pwsh: learn.microsoft.com/en-us/powershell/

What about fish ? fishshell.com/

I guess I'm confused, I thought bash was a scripting language..

Disagree. rsync binary does the glob'ing *& looping, not the shell. Bashmerely collects the two string arguments and performs a fork/exec of rsync.

I think the best alternative is to script using yaml files 🤓