Class 25 of 55 • Linux Shells & Terminal

Bourne Shell (sh) Architecture & Scripting Masterclass

 1. What is the Bourne Shell (sh)?

 The Bourne Shell (binary command name sh) is the historic, foundational command-line interpreter and script execution environment designed for the Unix operating system. Developed by computer scientist Stephen Bourne at AT&T Bell Laboratories in Murray Hill, New Jersey, it was officially released in 1979 with Version 7 Unix (V7).

 Before the Bourne Shell, early Unix systems used Ken Thompson's rudimentary "Thompson Shell" (1971), which had no programmatic control flow (loops or conditionals) and required external utility calls for almost every logical operation. Stephen Bourne revolutionized systems programming by creating a shell that was simultaneously a responsive interactive command interpreter and a full-fledged, structured, algorithmic scripting language.

 2. The Architectural Role of a Shell in Linux

 In Linux architecture, the Kernel sits at the core managing CPU scheduling, RAM allocation, hardware drivers, and raw filesystem access. The user never communicates directly with the kernel; instead, the Shell acts as an outer protective layer (hence the name "shell") wrapping around the kernel:

 3. Groundbreaking Inventions of the Bourne Shell

 Stephen Bourne introduced syntax rules that became the universal standard codified in the POSIX (Portable Operating System Interface) specification:

 4. The Modern Linux Reality: /bin/sh vs. Bash & Dash

 On modern Linux computers, the original proprietary Bell Labs Bourne Shell is rarely installed. Instead, /bin/sh is a standardized symbolic link pointing to a modern, open-source POSIX-compliant implementation:

• On Ubuntu & Debian: /bin/sh points to Dash (Debian Almquist Shell). Dash is a tiny, blazing-fast POSIX shell (~150 KB) that boots the operating system and runs system scripts with minimal RAM and CPU overhead.
• On RHEL, Fedora & Rocky Linux: /bin/sh points directly to Bash (GNU Bourne Again Shell). When invoked as sh, Bash automatically turns on its strict POSIX-compliance compatibility mode.

 5. Practical Lab: Writing a Portable POSIX Bourne Script

 Let us create, inspect, and execute a 100% portable Bourne shell script:

Step 1: Inspecting Your Active /bin/sh

# Check where /bin/sh points on your system:
ls -l /bin/sh
# On Ubuntu/Debian: /bin/sh -> dash
# On Fedora/RHEL:    /bin/sh -> bash

# Check your current login shell:
echo $SHELL

Step 2: Writing a Portable Script

Create a file named backup_check.sh using your text editor:

#!/bin/sh
# Portable Bourne / POSIX Shell Script

# 1. Variables (No spaces around '=')
BACKUP_DIR="/tmp/student_backup"
TARGET_FILE="/etc/hosts"

# 2. Conditionals using standard test '[' operator
if [ ! -d "$BACKUP_DIR" ]; then
    echo "Creating backup directory: $BACKUP_DIR"
    mkdir -p "$BACKUP_DIR"
fi

# 3. Copying and logging
echo "Backing up $TARGET_FILE..."
cp "$TARGET_FILE" "$BACKUP_DIR/"

# 4. Check Exit Status ($?)
if [ $? -eq 0 ]; then
    echo "Backup completed successfully!"
    ls -l "$BACKUP_DIR"
else
    echo "Error: Backup failed!" 1>&2
    exit 1
fi

Step 3: Making Executable & Debugging

# Grant execute permissions:
chmod +x backup_check.sh

# Run the script normally:
./backup_check.sh

# Run the script in trace debugging mode (prints each command executed):
sh -x ./backup_check.sh

 6. Essential Positional Parameters Reference

 7. Student Q&A and Viva Preparation

 8. Summary & Next Steps

 The Bourne Shell established the syntax and execution model upon which modern cloud automation and DevOps scripts rely. In the next tutorial, we examine the shell created for C programmers at UC Berkeley: Class 26: The C Shell (csh / tcsh).