Shell Scripting (Bash)

Practice Tasks

1. Create a script: Write hello.sh with at least one echo line.
2. Make it executable: Run chmod u+x hello.sh.
3. Simulated run: Execute ./hello.sh (simulated) or bash hello.sh.
4. Args: Create args.sh and print all args one per line (hint: loop over "$@").

Shell Execution Model

Understanding how the shell processes and executes scripts is crucial for writing robust code:

• Process Creation: Each script execution creates a new process via fork() and exec() system calls
• Environment Inheritance: Child processes inherit environment variables but cannot modify parent's environment
• Exit Codes: Processes communicate success/failure through integer return values (0 = success, 1-255 = various errors)
• Signal Handling: Scripts can intercept and respond to system signals using trap

Security & Safety Principles

Shell scripting presents unique security challenges due to its text-processing nature:

• Input Validation: Always validate and sanitize user input to prevent injection attacks
• Privilege Principle: Run scripts with minimal necessary permissions
• Word Splitting: Unquoted variables can lead to unintended command execution
• Path Safety: Use absolute paths or validate PATH to prevent command hijacking

Safety Header & Defensive Programming

# Near top of most scripts
set -euo pipefail
IFS=$'\n\t'

Theory: Implements fail-fast principle from software engineering. -e ensures error propagation, -u catches undefined variable bugs (similar to strict mode in modern languages), -o pipefail ensures pipeline failures aren't masked.

IFS Reset: Prevents field splitting vulnerabilities by explicitly setting Internal Field Separator.

Variables & Lexical Scoping

name="Alice"
echo "Hello, $name"    # Variable expansion
echo 'Literal $name'   # No expansion
readonly CONFIG_FILE="/etc/app.conf"

Theory: Bash uses dynamic scoping by default. local keyword in functions creates lexical scope. Quoting rules follow formal language theory—double quotes allow expansion, single quotes create string literals.

Finite State Automaton: getopts

while getopts ":i:o:n" opt; do
  case $opt in
    i) infile=$OPTARG ;;
    o) outfile=$OPTARG ;;
    n) dryrun=1 ;;
    :) echo "Missing arg for -$OPTARG" >&2; exit 2 ;;
    \?) echo "Unknown -$OPTARG" >&2; exit 2 ;;
  esac
done
shift $((OPTIND-1))

Theory: Implements a finite state machine for parsing command-line options. Each state transition is deterministic, following formal language parsing principles.

Control Flow & Computational Thinking

# Iteration with safe variable handling
for arg in "$@"; do 
  echo "Processing: $arg"; 
done

# Pattern matching (similar to switch statements)
case "$extension" in
  csv|tsv) echo "Tabular data" ;;
  json|xml) echo "Structured data" ;;
  *) echo "Unknown format" ;;
esac

Theory: Demonstrates algorithmic thinking patterns. The quoted "$@" preserves argument boundaries, preventing inadvertent data corruption.

Debugging Techniques

# Enable debugging
bash -x script.sh

# Or within script
set -x    # Enable trace
command1
command2
set +x    # Disable trace

# Check file readability
[[ -r "$input_file" ]] || {
  echo "Error: Cannot read $input_file" >&2
  exit 1
}

# Validate numeric input
if ! [[ "$count" =~ ^[0-9]+$ ]]; then
  echo "Error: Invalid number '$count'" >&2
  exit 2
fi

Error Recovery & Cleanup

# Setup cleanup on script exit
tmp_file="/tmp/script_$$"
trap 'rm -f "$tmp_file"' EXIT

# Handle interruption gracefully  
trap 'echo "Script interrupted" >&2; exit 130' INT TERM

# Standard exit codes
exit 0   # Success
exit 1   # General error
exit 2   # Misuse (bad arguments)
exit 126 # Command not executable
exit 127 # Command not found
exit 130 # Script terminated by Ctrl+C

Requirements Analysis

Algorithm Design

Pipeline Architecture:

1. Input Validation: File existence and readability
2. Pattern Matching: Extract failed login attempts
3. Data Extraction: Parse usernames from log entries
4. Aggregation: Count failures per user
5. Sorting: Rank by failure frequency
6. Output Formatting: Display or export results

Time Complexity: O(n log n) due to sorting step

Space Complexity: O(k) where k = unique usernames

Real-World Applications

• DevOps Automation: CI/CD pipelines, deployment scripts, and infrastructure management
• System Administration: Server maintenance, user management, and system monitoring
• Data Processing: ETL workflows, log parsing, and batch data transformation
• Security Operations: Log analysis, incident response, and security monitoring

Advanced Applications & Research Directions

• Systems Administration: Infrastructure as Code (IaC) with configuration management
• DevOps Integration: CI/CD pipelines and automated deployment scripts
• Data Engineering: ETL processing for large-scale data transformation
• Security Research: Log analysis and intrusion detection systems
• Performance Analysis: System monitoring and resource optimization

Career Connections

• Site Reliability Engineer: Automation, monitoring, and incident response
• Cloud Infrastructure Engineer: Infrastructure as Code and deployment automation
• Data Engineer: ETL pipelines and data processing workflows
• Cybersecurity Analyst: Log analysis and security automation

Extension Challenges

Key Takeaways & Theory Connections

• Process Model: Shebang + execute bit demonstrate Unix process creation via exec() family
• Formal Languages: Variable quoting implements lexical scoping and prevents injection vulnerabilities
• State Machines: getopts implements finite automaton for command-line parsing
• Functional Programming: Unix pipelines demonstrate function composition and data flow
• Software Engineering: trap & cleanup patterns implement resource management and exception safety
• Algorithm Design: Text processing demonstrates ETL patterns and data transformation

Cross-Curricular Connections