Is it safe to use Bash 4 features in new scripts? - bash

Bash 4 offers some nice features like globstar, associative arrays, the mapfile builtin etc.
Will it greatly decrease the portability of my scripts if I make use of these features? Is it safer to stick to Bash 3?

Depends on how portable you want to be.
Apple does not ship Bash 4 on Mac OS X since Bash 4 uses the GPLv3. Of course, users can install it themselves if they want, but most users won't have it.
If you want to be portable to OS X, you probably shouldn't rely on Bash 4 features. However, if you don't mind just being portable to modern GNU/Linux distros, then pretty much all of them include Bash 4, so you might as well rely on them.
Also, do recall that not all OS's even ship bash by default. For instance, OpenBSD ships pdksh by default, and you need to explicitly install Bash. Debian ships bash, but /bin/sh is Dash, so you need to explicitly use #!/bin/bash if you want to opt in to Bash specific features.
If you really want portability, you should stick to POSIX/Single-Unix-Specification features. However if all you need is to run on the latest GNU/Linux distros (and even ones a few years old), using /bin/bash and assuming it's Bash 4 should be fine.

Related

Find out what version of BASH a script needs

I wrote a shell script that uses a few BASH specific commands, such as [[ ... ]]. I know that some BASH features are only available in BASH 4 or newer. How can I find out what version of BASH I need for this script without trying numerous different versions?
Is there some kind of tool that can check the needed minimum version?
The source code is available on GitHub at https://github.com/JEFF-Media-GbR/RandomRound/blob/master/randomround
There are a bunch of resources to check for a) introduction of a specific Bash feature and b) Bashisms in general:
BashFAQ/061 ("Is there a list of which features were added to specific releases (versions) of Bash?")
Bash changes on Bash Hackers
Bash release notes
These can all be used to figure out when a feature was introduced.
For a list of Bashisms, the Bash manual describes differences to the Bourne Shell in Appendix B ("Major differences from the Bourne Shell"), and there is the article How to make bash scripts work in dash on the Wooledge wiki.
I don't know what the distribution of versions "in the wild" is, but if your user base includes macOS users, be aware that they use Bash 3.2 unless they have upgraded using Homebrew or similar.
As for programmatically determining what version of Bash is required to run a specific script, I'm not aware of any tool that does that. Shellcheck comes somewhat close in that it can warn about Bashisms when your script starts with #!/bin/sh.
What you are asking can not be done. This is one of the programming problems which are principally impossible to solve. One (but not the only) reason is that a script may at run time construct a string and evaluate it, and there is no way that you can by automatic means analyze for an arbitrary program, what data it will produce.

How portable is the `ps` command?

I'm making a bash script and I'd like to make sure it's portable. For context, the command will be the part of tmux-resurrect plugin.
I want to use this command: ps -eo ppid,command. Is that command portable?
I'd also be glad to hear how to check that myself. For example: maybe there's a service that can test commands on the large number of operating systems etc?
The POSIX Standard is publicly available on the web. Yes, ps is one of the standardized utilities. If you stick to the standard options, you should be pretty portable.
Note however, that forcing some utilities to behave posixly correct, setting certain environment variables might be necessary. In particular, systems using the GNU utilities may need POSIXLY_CORRECT=yes or similar being set.

Emulate OSX Terminal to test Portability

I am writing several shell scripts using Ubuntu/bash and I would like to ensure that they are portable to OSX.
I have previously had trouble when I tried to use non-portable behavior of certain commands. Is there anything like an emulator for another shell environment?
I'm looking for an option besides just researching the portability of each command that I use.
Terminal.app is just a GUI, like xterm. It doesn't execute scripts. OS X uses bash, just like Ubuntu. It may, however, use a different version. For instance, OS X 10.9 uses bash version 3.2.51.
What you're describing is not Terminal and probably isn't bash. It's probably "the entirety of the command line tools that are installed by default." Things like grep, sed, and cut, and in practice you mean "the entire OS." There is no environment other than the OS that is going to capture all of those. Even if they did, you'd still need to worry about numerous other portability concerns like whether there is /proc filesystem (there isn't one on OS X).
Do you really mean to suggest that it only has to run on Ubuntu and OS X? FreeBSD is quite different. And there are many platforms that don't include all the GNU extensions that are common on Linux. In principle you could write to the POSIX standard, which they are all supposed to follow, but that won't really take you that far. In practice, the only way to know that you're portable to a platform is to test it on that platform.
But short version: no. You have to research first. And then you have to actually test it on each version of each platform you support.
There is another option though: don't use bash and don't use the low-level command line tools like grep. Use a higher-level language that you know will be on the target platform like Python, Perl, or Ruby. Then you just have to work to an old enough version of these languages and stay within the standard library. That's typically much easier to keep portable than bash scripts.

Portability between Unix shells - am I thinking about the issue correctly?

Whenever I write shell scripts (mostly software development utilities or build tools) I've generally tried to avoid using bash in favor of using plain old sh for portability. However lately I've been running into more and more issues where useful features are not available, or behavior is actually less consistent across systems using sh then it is using bash, since sh is aliased to different shells...
As I understand it, sh is the oldest Unix shell and carefully written sh scripts should in theory run on pretty much any system out there... but it also seems there are about 9000 different variants of every major shell, too. Doesn't using bash as your script interpreter effectively limit your script's portability? Sure, no problems on OS X or pretty much any Linux out there, but what about the BSDs? Solaris, AIX, HP-UX? What do you do if you really want to run on everything?
I know bash can be installed on virtually any OS but it is really a first class citizen on all relevant modern systems? Does it come pre-installed? I'm just not really sure whether it's best to avoid or embrace bash with the intent of having the most consistent and portable overall experience.
What do you do if you really want to run on everything?
You follow the POSIX standard for sh (and the tools you're calling) and hope that the target OS does so too. Any modern product called "UNIX" must follow this standard, and customarily (though not universally), the standard shell will be called /bin/sh. The BSDs and Linux distros tend to aim at POSIX compatibility as well.
Doesn't using bash as your script interpreter effectively limit your script's portability?
Yes, but it depends on your target audience as you noted. If it's a short script, it's worth testing under dash (Ubuntu and Debian's default shell) for POSIX compatibility.
Whenever I start thinking about portability issues in my shell script, I switch to another language. Perl is widely available and generally a good choice for scripts, but if your tools are to be consumed by Python, Ruby, $lang developers, use $lang to its full potential.
bash itself is just a plain C program, does not need special authority to run, can be put in any location. You can easily build it from source. Basically, you can run bash if you need to and doesn't need the administrator of the system to install it.
As long as it is in your path, you can always code your script with the line.
#!/usr/bin/env bash

What is the best (portable and maintanable) Shell Scripting language today?

I know this question has kind-a started "religious" wars in past and there might not be one correct answer. But after working with ksh and csh for last 3-4 years and going through the pain of porting from one to another or applying a common piece of logic to multiple versions (read as legacy code), if I am writing a new script, I would go for ksh, but out of compulsion rather than choice. Is there a better option other than ksh/csh? Also something that is portable across Unixes (Solaris/HP/IBM/FreeBSD) and Linux (and if I am not asking too much or it if does make sense all Linux flavors)
Waiting for suggestions ...
Peace :)
Devang Kamdar
I would suggest plain old sh, which is available everywhere.
Also, it is worth noting that portability involves not only shell but also other commands used in a script such as awk, grep, ps or echo.
If you really want it to be portable (I don't know that any shell-script is maintainable), I would specify #!/bin/sh and test with dash and if possible other shells.
I would expect BASH to be the widest spread shell at the moment since it is the default for many Linux distributions (it can even run on Windows with cygwin, but that's probably true for the other shells, too).
An alternative might be to not use the shell itself for scripting but one of the scriping languages out there like perl, python, ruby, ...
I usually use ksh. I find that it's a good compromise between features and portability. It's there (or a compatible version is available) on most Linux boxes and Solaris. It's a while since I used HP-UX (thankfully) but I'm pretty sure it was available there too.
If all the machines you need to support are modern, bash might be an option. Solaris 10 comes with a copy. It's the default on most Linux machines.
Your lowest common denominator is going to be Bourne (sh), so that's worth considering if portability is your main concern. It's missing some of the more friendly features of ksh and bash though.
It's still worth steering clear of csh/tcsh for scripting. Csh Programming Considered Harmful is an oldie but still largely relevant.
My answer would be perl.
Does everything 'sh' 'bash' etc can do in a nicer more elegant manner.
Also it is actually more portable. A given version perl is very consistant accross all platforms. There are no significant differences between the Linux, Solaris and AIX distributions whereas porting shell scripts between these platforms is a real pain.
And it works on all windows paltforms! Provided you avoid backticks and "system()" your script has a good chance of running.
Python! Check out iPython, which is an enhanced Python interpreter. Also: Python for Unix and Linux System Adminitration.
You can write great portable scripts, and it's fun.

Resources