The Bourne Shell is a command-line interface and scripting language for Unix and Linux systems. It allows users to run programs and create scripts to process data. It was created by Stephen Bourne and was the first shell to implement signal handling and file descriptor checking. While lacking some features, it paved the way for descendants like Bash.
The Bourne Shell is a small program that runs on Unix® and LINUX® operating systems and provides an interface for running programs on the system. It is often referred to as a command-line interface or command interpreter, as it does not provide the user with a graphical user interface (GUI). The commands and all necessary parameters to execute are typed in the shell. The Bourne Shell is also a scripting language, which allows users to create and run script files that can process data across multiple programs via a single command. On Unix®-like systems, the program is simply known as “sh”.
The first such shells for Unix® systems were known as the Thompson shell, created by Ken Thompson, one of the original creators of the Unix® operating system. The Thompson shell was limited to command interpretation, and a number of additional functions had to be performed as external operations. Subsequently, Stephen Bourne created the Bourne shell to replace the Thompson shell, adding a number of new features in the shell itself, as well as the shell scripting language.
In fact, the Bourne Shell was designed as a scripting language from the very beginning. While it was still the command-line interface for Unix® version seven, it also opened up the ability for users to develop shell scripts that linked commands together to process data. Through the use of this programming, the user could establish variables to capture known or unknown data from inputs or outputs and manipulate the processing of that data through the use of conditional statements in the script via a technique called control flow.
This was also the first shell to implement a feature known as signal handling. Through the Bourne Shell, a user can send a specific type of signal to a process already running on the computer, instructing that process to do something else. Many of these are ways to interrupt a running process and produce some sort of output that can be used for debugging, although there are others to temporarily stop a process, resume it, and so on.
The ability to directly check file descriptors was also first for the Bourne shell. On a Unix®-like system, every running program has a table listing the file descriptors for any open files. This can include anything from a simple text file to a directory or even the communication sockets that processes use to share data with each other. For a user having control over file descriptors on a system allowed unprecedented control over input and output for virtually everything on the computer.
Of course, while the Bourne shell offered users that additional functionality, it lacked features such as the ability to interactively control processes, establish command aliases, and keep a history. Later, however, a number of descendants began to emerge that took the most useful shell features that had been conceived over the years and rolled them up into new shells. A common example is the Bourne-again shell, or Bash, common on many LINUX® systems. As a result, many of these descendants are fully capable of running normal Bourne shell scripts, giving any Unix®-like system an implementation of the original Bourne shell in one way or another. On many LINUX® systems, this is simply a link from “sh” to “bash” or some other capable descendant.
Protect your devices with Threat Protection by NordVPN
