Introduction to Linux Shell and Shell Scripting

In Linux systems, users communicate with the operating system through a shell, which interprets and executes commands entered in a terminal. The shell acts as an intermediary between the user and the kernel, ensuring that instructions are processed correctly. Building on this interaction model, shell scripting allows users to combine multiple commands into a single file and execute them as a program, enabling structured task automation and system control.

• Forms the foundation of command-line interaction in Unix/Linux systems
• Enables automation of repetitive administrative tasks
• Supports batch execution of multiple commands
• Widely used in system administration and DevOps environments

Core Components of the Linux Environment

Before starting with shell scripting, it is important to understand the main components of a Linux system. These components work together in layers, where user input passes through multiple stages before reaching the hardware.

• Terminal: Interface used to access the shell
• Shell: Command interpreter that processes user input
• Kernel: Core of the operating system that manages hardware and system resources
• GNU Utilities & Libraries: Provide essential commands and system functions

Terminal

The terminal is a program that provides a text-based interface for users to interact with the system. It allows users to enter commands and displays the output generated by those commands. The terminal itself does not interpret commands, it simply provides an environment in which the shell runs.

• To access the terminal, simply search in search box "terminal" and double-click it.

• Here you can see how the terminal looks of Red Hat Linux.

Shell

The shell is a command-line interpreter that acts as a bridge between the user and the kernel. It receives commands from the terminal, interprets them, and translates them into instructions that the operating system can execute. Without the shell, the system cannot understand human-readable commands.

• Interprets and validates user commands
• Converts commands into system calls
• Executes built-in and external programs
• Displays output or error messages
• Provides scripting capabilities

Shell is broadly classified into two categories:

• Command Line Shell
• Graphical shell

Command Line Shell (CLI-Based Shell)

Shell can be accessed by users using a command line interface. A special program called Terminal in Linux/macOS, or Command Prompt in Windows OS is provided to type in the human-readable commands such as "cat", "ls" etc. and then it is being executed. The result is then displayed on the terminal to the user. A terminal in Ubuntu system looks like this:

• In the above screenshot, the ls -l command is executed. This command lists all files and directories in the current working directory in a long listing format, displaying detailed information such as permissions, ownership, file size, and modification date.
• Working with the command-line interface (CLI) can be challenging for beginners since it requires memorizing numerous commands. However, it is an incredibly powerful tool — it allows users to store multiple commands in a file and execute them together, enabling automation of repetitive tasks. These files are known as batch files in Windows and shell scripts in Linux and macOS systems

Graphical Shells

A Graphical Shell allows users to interact with the system through a Graphical User Interface (GUI). Instead of typing commands, users perform actions by clicking icons, opening windows, and using menus.

• Window-based program management
• Drag-and-drop file handling
• Mouse-driven navigation
• Visual system settings configuration

A typical GUI in the Ubuntu system:

Common Shell Programs in Linux

Linux supports multiple shell programs. Each shell performs the same core task but differs in syntax, features, and built-in functionality.

• Bash (Bourne Again Shell): Most widely used Linux shell. It is used as default login shell in Linux systems and in macOS.
• Csh (C Shell): The C shell's syntax and its usage are very similar to the C programming language.
• Ksh (Korn Shell): The Korn Shell was also the base for the POSIX Shell standard specifications.

Kernel

The kernel is the core component of the operating system. It directly interacts with the computer hardware and manages all critical system resources. While the shell interprets user commands, the kernel is responsible for actually executing them at the hardware level.

• Process Management
• Memory Management
• File System Management
• Device Management
• Input/Output (I/O) Management

Complete Linux system = Kernel + GNU system utilities and libraries + other management scripts + installation scripts.

Getting Started with Shell Scripting

Shell scripting allows users to automate repetitive tasks by combining multiple commands into a single file. Instead of typing each command manually, a shell script executes a sequence of commands automatically, saving time and reducing errors. This is particularly useful in system administration, DevOps, and repetitive workflow management.

Shell Script

A shell script is essentially a text file containing a series of commands that the shell can interpret and execute. These files typically have a .sh extension, such as:

myscript.sh

Uses and Advantages of Shell Scripts

Shell scripts are widely used in Linux and Unix-based systems because they provide a simple yet powerful way to automate tasks and manage systems efficiently. Their flexibility makes them essential for IT professionals, system administrators, and DevOps engineers.

1. Automate Repetitive Tasks

Shell scripts turn routine jobs like file cleanup, backups, or server updates into one-click actions, saving time and reducing manual effort

2. Reliable and Consistent

Shell scripts run the exact same steps every time, without mistakes. Once you write and test a script, you can count on it to perform tasks consistently whether it's setting up servers, cleaning up files, or running a deployment. This removes human error and ensures predictable results.

3. Native Support on Unix/Linux Systems

Shell scripting is natively supported on Unix-based systems, requiring no additional installations. The shell environment (like Bash or Zsh) is pre-installed, allowing scripts to run seamlessly across most Linux distributions and Unix-like operating systems.

4. Great for Linking Commands to Work Together

Shell scripts make it easy to link different commands together. You can pass the output of one command into another, filter data, or run tasks step by step all in one script. This helps automate complex jobs using simple building blocks.

5. Ideal for IT, DevOps & Monitoring

Shell scripts help automate important tasks like checking system health, setting up servers, and scheduling jobs to run at specific times (using tools like cron). In DevOps, they are widely used to speed up deployments and manage infrastructure without doing everything manually.

6. Lightweight and Easy to Write

They are interpreted, so there is no compile step. You can write a useful script in minutes, and test it instantly perfect for quick fixes and small tasks.

Shell Script Structure, Syntax

A shell script is essentially a sequence of commands stored in a text file, which the shell executes in order. Understanding the structure and syntax of shell scripts is essential to write efficient and error-free scripts.

Shebang (#!):

• The first line in a shell script typically starts with #!/bin/bash
• Specifies which shell should interpret the script

Comments:

• Lines starting with # are comments and are ignored during execution
• Useful for documenting the script

Commands:

• Shell commands like ls, cd, echo, pwd are executed sequentially

Variables:

• Used to store values or user input for reuse in commands
• Example: MYDIR="/home/user/projects"

Control Structures:

• Conditional statements: if...then...else, case
• Loops: for, while, until

Functions:

• Reusable blocks of code that can be called multiple times within a script

Example: A simple shell script to displays the current directory and lists all files

#!/bin/bash
# This script displays the current directory and lists all files

echo "Current Directory:"
pwd

echo "Files in Directory:"
ls -l

• #!/bin/bash: Uses Bash shell to run the script
• echo: Prints text to the terminal
• pwd: Prints the current working directory
• ls -l: Lists files in long format, showing permissions, size, and modification date

Output:

Practical Shell Script Example: Directory Jump Script

When working deep inside nested directories, repeatedly typing cd ../ to move up can be time-consuming. A shell script can automate this process, allowing you to jump directly to a desired directory level.

Script: jump.sh

# !/bin/bash

# A simple bash script to move up to desired directory level directly

function jump()
{
    # original value of Internal Field Separator
    OLDIFS=$IFS

    # setting field separator to "/"
    IFS=/

    # converting working path into array of directories in path
    # eg. /my/path/is/like/this
    # into [, my, path, is, like, this]
    path_arr=($PWD)

    # setting IFS to original value
    IFS=$OLDIFS

    local pos=-1

    # ${path_arr[@]} gives all the values in path_arr
    for dir in "${path_arr[@]}"
    do
        # find the number of directories to move up to
        # reach at target directory
        pos=$[$pos+1]
        if [ "$1" = "$dir" ];then

            # length of the path_arr
            dir_in_path=${#path_arr[@]}

            #current working directory
            cwd=$PWD
            limit=$[$dir_in_path-$pos-1]
            for ((i=0; i<limit; i++))
            do
                cwd=$cwd/..
            done
            cd $cwd
            break
        fi
    done
}

Making the Script Executable

By default, scripts do not have execution permissions. To make it executable:

Command:

chmod +x path/to/our/file/jump.sh

Integrating with .bashrc for Persistent Availability

To make the jump function available in every terminal session:

Command:

echo "source ~/path/to/jump.sh" >> ~/.bashrc

• After restarting the terminal, you can use the script

Command:

jump directory_name

Output:

• This command will move directly to the specified directory from any location within your filesystem.