Find out what version of BASH a script needs - bash

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.

Related

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

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.

Ant task vs Shell script

I see a lot of places in my office where ant tasks are used to move files from one place to another and also do some tasks on these files.However all this can be done with shell scripts.
My question is ,
In what cases is ant preferred over shell scripts ?
What are the benefits of using ant over a shell scripts for doing same set of tasks.
One advantage ant has is that it works on all platforms,other than that are there any performance related advantages ?
Your question as to why ANT should be preferred to shell scripts is two-fold:
ANT is a tool that has achieved widespread adoption and is likely to
be already installed on a developer's workstation. Compared to one
of it's main predecessors, make, ANT is a lot more standardized and
cross-platform.
ANT is a tool familiar to developers. Used to build their code so they will often extend the ANT script to deploy their application as
well. Indeed many vendors offer ANT tasks for this purpose.
There are no performance benefits, really. Java is slow for command-line usage.
But..... I would advise against playing the "performance" card. Let's pretend that your application does not support windows (Which is odd considering a Java application should support all plaforms...): I have seen shell script driven deployments decend into chaos attempting to reconcile the various ways different unix operating system commands work. Commands like "tar", "awk", etc can be subtly different which leads to additional platform support logic in your script.
In conclusion I would use neither. I choose a hybrid approach of using groovy for general scripting. It is a java based scripting language and embeds the full power of ANT. Being a java based scripting language means it will work on all platforms. In the interest of fairness it should also be noted that there are other language options. Ruby is certainly worthy of mention since it has spawned a set of configuration management technologies that are well worth evaluation. (See Chef and Puppet)
In practice, it boils down to Windows support. If you're in a Unix shop and don't want to introduce new stuff to devs, there are two alternatives i've used with success:
Plain old shell script with Git Bash. Git Bash comes with the Git windows distribution (http://git-scm.com/). If you're doing automation, you can launch shell scripts like so: "C:\Program Files (x86)\Git\bin\sh.exe" --login -i -- ./BUILD
Node script. Again it's one easy installer, it's javascript, and you can use something like ShellJS (https://github.com/arturadib/shelljs) to get very close to Unix shell script / Makefiles.

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

Bash script interpreter that runs in JVM (Jbash?)

I'm wondering if there exists a bash shell script interpreter that runs solely in the JVM (i.e., does not rely on "shelling out" to a system bash.) A "Jbash" if you will.
Such interpreters exist for many other languages (JRuby, Jython, etc.) I'd have thought there'd be one for bash scripts as well but I haven't found one yet.
Any recommendations?
There is one in google code http://code.google.com/p/jbash/
There is a new project : https://github.com/crashub/bash but too young at the moment:
Very early prototype built on top of the libbash ANTLR grammar, aims
to implement basic stuff. The grammar provides an AST.

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