Comparing the sh Shell and Bash

The sh shell and Bash are two of the most commonly used shell environments on Linux and other Unix-like operating systems. Though they share some similarities, there are also some key differences that users should be aware of. This in-depth guide will compare and contrast these two popular shells.

What is a Shell?

Before diving into the specifics of sh and Bash, it‘s helpful to understand what exactly a shell is.

A shell is a command-line interface that allows users to interact with the operating system. It processes commands, handles input/output operations, executes programs, and manages processes.

Some key responsibilities of a shell include:

• Providing a prompt for entering commands
• Interpreting commands entered by the user
• Executing other programs based on the entered commands
• Managing environment variables that store information about the shell session
• Handling input/output redirection
• Supporting functionality like pipelines and conditional logic
• Allowing customization via shell scripts and configuration files

The shell is essentially the gateway between the user and the kernel – it takes human-readable commands and communicates them to the operating system. Understanding the basics of how shells operate goes a long way in leveraging them effectively.

The Bourne Shell (sh)

The original Unix shell, developed by Stephen R. Bourne at Bell Labs, is known simply as the Bourne shell or ‘sh‘. First appearing in Version 7 Unix in 1979, it quickly became the standard shell at the time. Due to its specification in the POSIX standard, it remains universally available on Linux and Unix-like systems today as ‘/bin/sh‘.

Being the original shell implementation, sh established much of the fundamental functionality that all later shells would build upon:

• Basic command execution
• Pipelines for chaining commands
• Environment variable management
• Control structures like if/then statements
• Simple scripting to automate tasks

Designed as a lightweight tool focused specifically for scripting, sh eschews more sophisticated features for simplicity and portability. Its syntax is terse, consisting of mostly keywords for logical structures. For interactive use, it includes basic line editing capabilities via the readline library.

The defining characteristics of sh can be summarized as:

• Guaranteed availability on all POSIX-compliant Unix systems
• Excellent portability for shell scripts across different platforms
• Simple, easy to remember scripting syntax
• Quick launch and execution for faster response
• Limited built-in capabilities focused on core functionality

For tasks that don‘t require heavy customization or many features, sh provides a fast, portable interface for executing commands and scripts. Its constraints can also encourage writing cleaner, more maintainable code.

Bash – The Bourne Again Shell

First released in 1989, Bash is an extended version of the original Bourne shell with plenty of new functionality. Officially standing for "Bourne Again SHell", it aimed to continue advancing shell and scripting capabilities. It has since become the default shell on most modern Linux distributions.

The key areas where Bash improves on sh are:

• More advanced scripting syntax inspired by other languages like C
• Additional built-in commands (printf, test, etc)
• Command history and editing for the interactive prompt
• Extended globbing and pattern matching
• Array variables, integer arithmetic, and more data types
• Greater customization via startup scripts and aliases

On the whole, Bash provides a much more "feature complete" shell environment tuned towards improved usability and programmability. The syntax can handle more complex scripting capabilities like functions. With all the extras it adds, Bash does sacrifice some simplicity and portability compared to the original Bourne shell.

To summarize, Bash is distinguished by:

• Sophisticated scripting language with more control structures
• Very customizable prompt with autocomplete and command history
• Many built-ins for text processing, math, file tests, etc
• Advanced features like arrays, regex handling, and subshells
• Larger resource footprint due to increased capabilities

For most interactive usage and advanced scripting tasks, Bash is a superior choice thanks to its more fully-realized feature set. But it comes with additional complexity that isn‘t always necessary.

Key Differences Between the Shells

While sh and Bash share basic handling of commands, pipelines, and control structures, there are some notable differences in their features and functionality:

Syntax

The POSIX-standard sh uses a relatively simple, terse syntax focused specifically on shell scripting structures:

if [ condition ]; then
  commands
fi

Bash employs a more complex syntax inspired by programming languages like C:

if [[ condition ]]; then
  commands  
fi

So Bash allows for more robust conditional tests and control logic, but at the expense of added syntactic complexity.

Built-in Commands

Sh provides only a basic set of built-in commands, mostly focused on flow control and environment handling:

• . (source script)
• : (null command)
• break/continue/return
• cd/pwd (change/print working directory)
• eval (evaluate arguments)
• exec (execute command replacing shell)
• exit (exit shell)
• export/readonly (environment handling)
• set/(un)set (set options/toggle properties)
• shift (adjust arguments)
• trap (handle signals/events)
• wait (wait for process)

Bash incorporates all these along with many more for various purposes:

• Text manipulation: echo/printf, test operators []/[[]]
• Math: let, random numbers, integer handling
• Arrays: indexed, associative, and nested arrays
• External processes: kill, pwd, time
• Programming constructs: function, brace expansion, eval
• Customization: alias, bind, history

So Bash reduces reliance on external utilities for many common tasks, but at the cost of a larger memory footprint.

Portability

The POSIX sh specification guarantees basic shell functionality across all standards-compliant Unix-derived systems. This ensures maximum portability:

• Scripts using only POSIX sh features will run on any sh-compatible shell
• Helps avoid compatibility issues caused by shell deviations
• Encourages simple, clean, portable coding habits

Meanwhile, Bash allows extensions beyond the POSIX standard in pursuit of greater functionality and ease-of-use:

• Adds many useful features not present in standard sh
• Scripts may depend on Bash-specific extensions
• Reduces portability – requires Bash to work properly

So there‘s a tradeoff between simplicity/compatibility and advanced capabilities.

Customization

For interactive usage, Bash offers much more customization and flexibility:

• Startup scripts like .bashrc execute on new shells
• Configure keybindings with bind, prompt with PS1
• Create aliases for commands or use shell functions
• Set shell options via set +/-option
• Store often-used commands in history for quick access
• Choose from many prompt themes with added info like current path

Sh provides only minimal tools for customization like aliases and environment variables. It sticks closer to guaranteeing base shell functionality.

Performance

The simpler Bourne shell generally has a faster launch time and lower memory utilization than Bash. Reasons include:

• Quick loading of the smaller base feature set
• Less overhead for tracking additional shell state
• Avoids Bash initialization scripts and add-ons

However Bash has made great improvements in performance over earlier versions. The differences may be negligible for most typical daily usage.

But for very repetitive tasks across many processes, sh may retain something of an edge in raw speed and efficiency.

Quick Comparison Chart

	Bourne Shell (sh)	Bash (Bourne Again Shell)
First released	1979	1989
Creator	Steve Bourne	Brian Fox
License	Open source	GNU GPL
Written in	C	C
Default on most Linux distros?	No	Yes
Syntax	Simple, POSIX-standard	More complex, C-inspired
Built-in functionality	Basic	Extensive
Portability	Excellent	Reduced
Customization	Minimal	Extensive
Speed	Faster launch time	Slightly slower

When to Use Each Shell

Based on their respective strengths and limitations, here is guidance on when each shell may be more appropriate:

The Bourne shell (sh) is ideal for:

• Scripts requiring maximum portability across Unix platforms
• Resource-constrained situations like embedded systems or rescue environments
• Boot scripts and other init processes that must launch quickly
• Simple scripts with mostly flow control and command execution
• Legacy system maintenance where change needs to be minimized

Bash provides advantages for:

• Interactive non-script use with emphasis on usability
• Customizing your shell environment to suit personal workflow
• Scripting needing advanced programming capabilities
• Situations where memory/disk use isn‘t as critical
• Utilizing Linux-specific features beyond POSIX standards

So in essence:

• Use sh when you want simplicity, speed and compatibility
• Use Bash when you want advanced features and customization

Conclusion

While the Bourne shell laid the foundation for user shells on Unix-like systems, Bash built upon that to become the standard interactive shell on modern Linux. Bash is recommended now for most general purpose use thanks to its robust feature set and customizability to improve productivity. But the simplicity, portability and speed of sh still give it a place for basic scripting tasks.

Both shells have their advantages depending on whether raw efficiency or richer capabilities are more important for the task at hand. Understanding those tradeoffs allows matching the right shell to the job. With Bash supporting a POSIX-compatible mode, it can stand in for sh when needed – but the additional overheard and complexity may not always be justified.

Knowing how to leverage both shells provides flexibility in approaching administration, automation and configuration tasks on Linux and Unix-like systems. And beyond just these two, exploring more recent alternatives like Zsh offers even more diversity in UI and functionality.

With its long history and specification in standards, the foundation ‘sh‘ provides ensures it will continue having relevance even along newer and trendier offerings. But for most daily shell use, Bash represents the current pinnacle of capability and convenience.