Shell Scripting

What it does

Explains how to write shell scripts with explicit failure on errors, clarity, portability to POSIX sh, defensive safety for empty variables and missing files, and predictable behavior with clear exit codes. It targets maturities up to and beyond defensive levels, and requires using functions, help text, argument parsing, cleanup traps, and structured error handling. It prescribes a comprehensive script structure, including shebang, set -euo pipefail, logging helpers, and modular functions for validation, building, and deployment. It also covers portability differences between Bash and POSIX sh, recommended quoting habits, and robust error and exit code conventions.

How it works

• It instructs start with a shebang and set of safety flags (set -euo pipefail).
• Organize logic into reusable, named functions with a naming convention (validate_, build_, deploy_, cleanup_).
• Implement a main() function with argument parsing and a guarded entry point so the script can be sourced for testing.
• Provide example implementations for logging (log_info, log_warn, log_error) and core operations (validate_environment, build_application, deploy_application).
• Emphasize exit codes and a standardized mapping for common conditions, including 0 for success and 1 for general error, with additional codes for specific situations.
• Establish an Error Handling framework: fatal, warn, assert, and trap-based cleanup to guarantee resource cleanup on exit.
• Include a thorough Portability section detailing Bash vs POSIX sh considerations, OS differences, and ensuring portability with POSIX behavior when possible.
• Describe best practices for quoting, using [[ ]] over [ ], safe temporary file handling with mktemp, and robust argument parsing via getopts or manual parsing.
• Provide concrete code blocks demonstrating patterns for logging, error handling, cleanup, and argument parsing.

When to use it

• Use when building automation scripts that must be reliable across environments and shells.
• Apply to scripts intended to run unattended, where predictable exit behavior and robust error handling are required.
• Follow when aiming for mature scripting levels (Defensive, Robust, Production) per the Script Structure and Scripting Maturity Model sections.

What it can touch

• The skill recommends using functions, environment setup, and argument parsing logic within shell scripts. It discusses using POSIX-compatible constructs and Bash-specific features only when documented as acceptable for portability.

Caveats

• The material emphasizes defensive coding and explicit exit behavior but also notes edge cases (e.g., set -e limitations inside conditionals).
• It requires adherence to prescribed exit codes and structured cleanup via traps, which may require careful implementation to avoid unintended exits in complex scripts.