What Is a Shell?

A shell is a command-line interpreter written primarily in C that serves as an interface between users and the operating system kernel. It functions both as an interactive command language and as a scripting language for automating tasks.

Historically, Ken Thompson’s sh (Bourne Shell) was the first widely adopted Unix shell. Modern systems support multiple shells — for example, bash, zsh, dash, and ksh — each offering distinct features and syntax. Graphical environments like GNOME or KDE also implement shell-like interfaces, though they operate at a higher abstraction layer.

Compiled vs. Interpreted Languages

Programming languages fall into two broad categories based on how source code is executed:

• Compiled languages (e.g., C, C++, Rust): Source files are translated entirely into machine code before execution via a compiler. The resulting binary runs directly on the hardware, yielding high performance and portability across similar architectures.

• Interpreted languages (e.g., Python, Perl, Awk, and shell): Source code is processed line-by-line at runtime by an interpreter. No standalone binary is produced; instead, the interpreter reads, parses, and executes instructions dynamically. This simplifeis development and portability but typically incurs runtime overhead.

Common Shell Interpreters

Linux distributions ship with several shell interpreters. Their paths are listed in /etc/shells. To inspect available shells:

cat /etc/shells

Key interpreters include:

• bash (Bourne-Again Shell): The default interactive shell on most GNU/Linux systems. Developed as a free replacement for sh, it extends functionality with job control, command history, and advanced scripting constructs.

• sh: The original Bourne Shell, standardized by POSIX. Minimalist and highly portable; often symlinked to dash on Debian-based systems for faster script execution.

• Others: zsh (feature-rich alternative), ksh (Korn Shell), fish (user-friend with smart defaults), and dash (lightweight, POSIX-compliant).

Writing and Executing Your First Script

Create a minimal script named greet.sh:

#!/usr/bin/env bash
printf "Greetings from the shell!\n"

The shebang (#!) line specifies the interpreter. Using /usr/bin/env bash improves portability over hardcoded paths like /bin/bash.

Method 1: Direct Execution

Make the file executable and run it explicitly:

cd /path/to/script
chmod u+x greet.sh
./greet.sh

The ./ prefix ensures the shell searches the current directory — unlike built-in commands or binaries in $PATH, local scripts aren’t auto-resolved without it.

Method 2: Interpreter Invocation

Alternatively, invoke the interpreter directly and pass the script as an argument:

bash greet.sh

In this mode, the shebang is ignored; the specified interpreter handles execution regardless of the first line’s content.