What is the difference between sh and bash?

sh is the POSIX shell standard. bash is an implementation that extends POSIX with arrays, [[ ]], process substitution, and more. When bash runs as /bin/sh - invoked with that name - it suppresses most extensions and behaves more like POSIX sh. On Debian and Ubuntu, /bin/sh is dash, not bash. On macOS 12+, /bin/sh is bash 3.2 for licensing reasons, not bash 5.x. Always check with readlink -f /bin/sh.

How do I find out which shell I am currently running?

Run echo $0 for the current shell name. For the full path, run ps -p $$ -o comm= or ps -p $$ -o args=. The $SHELL variable shows your login shell, not necessarily the shell currently running - if you ran fish from bash, $SHELL still shows bash. Use $0 or the ps method for the actual running shell.

Is fish shell safe to use on a production server?

Fish is safe to install, but do not set it as the default shell for service accounts or in /etc/passwd for accounts used by automation. Its non-POSIX syntax means any script or tool that calls $SHELL directly may break. Restrict fish to personal interactive sessions. Service accounts should use /bin/bash or /usr/sbin/nologin.

Why do my bash scripts fail in cron?

Cron runs scripts with a minimal environment: no PATH beyond /usr/bin:/bin, no sourcing of ~/.bashrc, and no terminal. Fix this by setting PATH explicitly at the top of your crontab or script, sourcing required environment files explicitly with BASH_ENV, and testing scripts with env -i bash script.sh to simulate the cron environment before deploying.

What shell should I use for Docker ENTRYPOINT scripts?

Use #!/bin/sh and write POSIX-compatible code. Alpine Linux, the most common minimal base image, ships with busybox ash as /bin/sh with no bash installed. If you need bash features, add RUN apk add bash to your Dockerfile and use #!/usr/bin/env bash. For the ENTRYPOINT instruction itself, use the exec form - ENTRYPOINT ["/bin/sh", "-c", "..."] - to avoid signal handling issues with PID 1.

How do I make a shell script run faster?

Switch the shebang from #!/bin/bash to #!/bin/dash for pure POSIX scripts - dash is 3-4x faster on tight loops. Minimize subshell calls: prefer ${var##prefix} over $(echo $var | sed ...). Use built-ins instead of external commands where possible. Avoid calling external utilities like grep or awk for single-line operations when bash parameter expansion or read handles it natively.

What Is a Unix Shell? Bash, Zsh, Fish Explained

The difference between interactive, login, and script shells

Bash loads a different set of config files depending on how it was invoked, and conflating these three contexts causes more production incidents than most engineers admit.

A login shell reads /etc/profile, then the first of ~/.bash_profile, ~/.bash_login, or ~/.profile that exists. An interactive non-login shell reads /etc/bash.bashrc and ~/.bashrc. A non-interactive shell - what runs your cron jobs and CI pipelines - reads neither by default unless you set BASH_ENV.

Run this to check which context you are in:

bash --login -c 'echo login' bash -i -c 'echo interactive' bash -c 'echo neither'

In our experience, the most common breakage pattern is a PATH set in ~/.bashrc that is invisible to cron. The fix is explicit: put anything a script needs into /etc/environment or source it directly in the crontab with BASH_ENV=/path/to/env.

# Check which config files bash actually loaded
bash --login --norc -x -c 'exit' 2>&1 | grep 'source\|\.'

POSIX sh versus bash: the practical boundary

POSIX sh defines the baseline: if-then-fi, case, while, for, functions, and a set of built-in utilities. Bash adds arrays, [[ ]], process substitution, brace expansion, and arithmetic with (( )). The problem is that bash running as /bin/bash is not the same as bash running as /bin/sh - when invoked as sh, bash enters a POSIX compatibility mode and disables most extensions.

This matters on Alpine Linux, where /bin/sh is busybox ash, not bash. A script with #!/bin/bash that calls mapfile or uses [[ ]] will fail on Alpine unless bash is explicitly installed. On our test server running Alpine 3.19, the fix was:

apk add bash which bash # /usr/bin/bash, not /bin/bash

If you are writing infrastructure scripts that run across distros, target POSIX sh and test with dash. dash is the fastest POSIX shell available - on a loop of 10,000 iterations, dash completes in roughly 0.3 seconds versus bash at 1.1 seconds on the same hardware. For scripts that are called thousands of times in a build pipeline, that gap is real.

#!/bin/sh
# Test POSIX compliance: run with dash
dash -n your_script.sh

# Or use checkbashisms from devscripts
checkbashisms your_script.sh

Bash 5.x features that actually change how you work

Bash 5.0 shipped in January 2019 and added associative array improvements and the EPOCHSECONDS and EPOCHREALTIME variables. Bash 5.1 added the @k operator for associative arrays, making key iteration usable. Bash 5.2, current as of 2026, added the noexpand_translation option and improvements to the history built-in.

The most underused feature in Bash 5.x is HISTTIMEFORMAT combined with PROMPT_COMMAND for audit logging. On a shared bastion host, we set this in /etc/bashrc:

HISTTIMEFORMAT='%F %T ' HISTFILE=/var/log/bash_history/$USER HIST_CONTROL='' HISTSIZE=-1 HISTFILESIZE=-1 PROMPT_COMMAND='history -a'

This writes every command with a timestamp to a per-user log file in real time, not at session exit. Combined with auditd, it gives you two independent audit trails.

# Check your bash version
bash --version | head -1
# GNU bash, version 5.2.26(1)-release (x86_64-pc-linux-gnu)

# Use EPOCHREALTIME for microsecond timing in scripts
start=$EPOCHREALTIME
sleep 0.1
end=$EPOCHREALTIME
echo "elapsed: $(echo "$end - $start" | bc) seconds"

// advertisement

Zsh in production: what it actually adds

Zsh 5.9 is the current stable release as of 2026. Most engineers adopt zsh for interactive work and keep bash for scripts. That is the correct split. Zsh's real advantages are spelling correction, the extended globbing syntax, and associative arrays that predate bash's by two decades.

The globbing alone justifies zsh for interactive sessions. **/*.log recursively matches log files. **/*(m-1) matches files modified in the last day. ^*.log matches everything that is not a log file. None of this requires find.

For DevOps automation work, if you are building pipelines where the shell itself needs AI-assisted command generation or workflow chaining, tools like taskbotshub.ai can sit above the shell layer and generate POSIX-compatible commands that run safely in any sh-compatible environment - more reliable than generating zsh-specific syntax.

One production consideration: zsh's startup time with a large plugin framework like Oh My Zsh can hit 800ms or more. On a server where you are opening dozens of SSH sessions, that adds up. We measured startup time on our test server with:

time zsh -i -c exit

Bare zsh: 12ms. zsh with Oh My Zsh and 40 plugins: 740ms. Use zinit or zsh's built-in lazy loading to keep it under 100ms.

# Measure zsh startup time
time zsh -i -c exit

# Extended globbing: find all .conf files modified in last 24 hours
setopt extendedglob
ls -la **/*(m-1N)

# Associative array in zsh
typeset -A config
config[host]=db01
config[port]=5432
echo ${config[host]}

Fish: the shell that breaks compatibility on purpose

Fish 3.7 is not POSIX-compatible. This is a design choice, not an oversight. Fish uses set instead of export, its conditionals use end instead of fi, and it has no source command - use the . built-in or source as an alias. Scripts written for fish will not run in bash or sh without modification.

For interactive use, fish earns its place. Autosuggestions based on history work out of the box without plugins. Syntax highlighting in the prompt turns commands red if they do not exist before you press Enter. The web-based configuration at http://localhost:8888 via fish_config is genuinely useful for color scheme and function management.

The correct use of fish is as your personal interactive shell when you are not writing scripts. Set it as your login shell with:

chsh -s $(which fish)

Keep your scripts in bash or sh. Fish is not a scripting shell.

# Fish: set variables
set -x DB_HOST db01.internal
set -x DB_PORT 5432

# Fish: check fish version
fish --version
# fish, version 3.7.1

# Fish: define a function
function mkcd
    mkdir -p $argv[1] && cd $argv[1]
end

How the shell resolves commands: PATH and built-ins

When you type a command, the shell checks in this order: aliases, functions, built-ins, then PATH. This ordering causes real bugs. If you alias ls in ~/.bashrc and a script expects /bin/ls behavior, the alias is invisible to the script - scripts do not inherit interactive aliases. Functions do inherit if exported with export -f.

The type built-in is more useful than which for understanding what a command resolves to:

type -a python3

This shows every match in PATH order, plus any aliases or functions. which only searches PATH and is not a bash built-in.

For diagnosing production issues where a command behaves differently in cron versus interactive sessions, the full debugging approach is:

bash --login --noprofile --norc -x /path/to/script.sh 2>&1 | head -50

The -x flag prints each command as it executes. Combined with --noprofile --norc, you see the script running with only the environment cron provides.

# See everything about a command
type -a python3

# Debug a script with minimal environment
env -i PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
    bash -x /path/to/script.sh

# Show current shell
echo $0
ps -p $$ -o comm=

// advertisement

Choosing a default shell for a new project or team

For scripting, the answer is sh with a dash shebang. POSIX compliance gives you portability across Alpine, Debian, RHEL, and macOS without modification. For interactive default on team servers, bash 5.x is the safest choice - it is installed everywhere and your team's muscle memory transfers.

For new tooling projects where you are naming a CLI or registering a domain for an internal developer tool, keeping the name shell-related and memorable matters - services like nicename.me can help you check whether a clean, relevant name is available across namespaces before you commit to it in documentation and pipeline configs.

For personal workstations and interactive sessions where you control the environment, zsh with a lean config or fish are both defensible. Do not use zsh plugins that redefine built-ins like cd - we spent four hours debugging a production deploy that failed because a developer's zsh cd function changed directory behavior in a Makefile that called subshells.

# Set the system default shell for new users in /etc/default/useradd
grep SHELL /etc/default/useradd
# SHELL=/bin/bash

# Check which shell a specific user has
getent passwd deploy | cut -d: -f7

# Change a user's shell
chsh -s /bin/bash deploy

What Is a Shell? Unix Shells Explained for Sysadmins