Optimizing Bash Scripts

Bash Script Optimizer

Analyze and optimize bash scripts according to strict standards: performance, modern tooling, consolidation patterns.

Quick Start

Analyze a script:

python3 scripts/analyze.py path/to/script.sh

Optimize workflow:

1. Run analyzer on target script(s)
2. Review issues by priority: critical → performance → optimization → standards
3. Apply fixes systematically
4. Validate with shellcheck
5. Test functionality
6. Measure improvement

Core Standards

Scripts must include:

#!/usr/bin/env bash
set -euo pipefail
shopt -s nullglob globstar
IFS=$'\n\t' LC_ALL=C

Style: 2-space indent, minimal blank lines, short CLI args, quoted variables

Native bash: arrays, [[ ]] tests, parameter expansion, process substitution

Modern tools (prefer → fallback):

• fd/fdfind → find
• rg → grep
• sd → sed
• fzf for interactive
• jaq → jq
• choose → cut/awk
• parallel → xargs -P
• gh → git
• aria2/axel → curl → wget

See references/standards.md for complete specification.

Analysis Categories

Critical: Must fix (security, correctness)

• Parsing ls output
• Unquoted variables
• eval usage
• Wrong shebang

Performance: Significant impact

• Unnecessary cat pipes
• Excessive subshells/forks
• Sequential vs parallel opportunities
• Uncached expensive operations

Optimization: Modern alternatives

• find → fd (3-5x faster)
• grep → rg (10x+ faster)
• sed → sd (cleaner syntax)
• Legacy tool replacement opportunities

Standards: Code quality

• vs [[ ]]
• echo vs printf
• Indentation (2-space)
• function syntax (prefer fn(){})

Consolidation Patterns

When to consolidate multiple scripts:

• Shared validation/setup logic
• Common function libraries
• Similar workflows with parameter variations
• Reduce maintenance burden

Unified entry point pattern:

mode=${1:-}
case $mode in
  action1) shift; action1_fn "$@";;
  action2) shift; action2_fn "$@";;
  *) die "Usage: $0 {action1|action2}";;
esac

Shared library extraction: Extract common functions to lib/common.sh, source in scripts.

Configuration-driven logic: Replace script proliferation with data structures (assoc arrays).

See references/patterns.md for detailed consolidation strategies.

Optimization Workflow

1. Baseline Analysis

Run analyzer on all target scripts. Prioritize by issue count/severity.

2. Quick Wins

• Replace cat pipes: cat f | grep → grep < f
• Convert tests: [ ] → [[ ]]
• Quote variables: $var → "$var"
• Add missing options: set -euo pipefail

3. Tool Modernization

Replace legacy tools where available:

# Check availability
command -v fd &>/dev/null && use_fd=1

# Fallback pattern
if [[ $use_fd ]]; then
  fd -tf '\.sh$'
else
  find . -type f -name '*.sh'
fi

4. Performance Optimization

• Batch operations: Collect items, process in parallel
• Cache results: Avoid repeated expensive calls
• Reduce forks: Use bash builtins vs external commands
• Process substitution: < <(cmd) vs cmd |

5. Consolidation

If analyzing multiple related scripts:

• Extract shared functions
• Unify entry points
• Create configuration-driven logic
• Document migration

6. Validation

• Shellcheck clean
• Bash execution test
• Functionality verification
• Performance measurement (time, profiling)

Common Refactorings

Remove unnecessary subshells:

# Before: count=$(cat file | wc -l)
# After: count=$(wc -l < file)
# Better: mapfile -t lines < file; count=${#lines[@]}

Parallel processing:

# Before: for f in *.txt; do process "$f"; done
# After: printf '%s\n' *.txt | rust-parallel -j"$(nproc)" process

Parameter expansion over sed:

# Before: echo "$file" | sed 's/\.txt$//'
# After: printf '%s\n' "${file%.txt}"

Batch I/O:

# Before: while read line; do echo "prefix $line" >> out; done < in
# After:
output=()
while read -r line; do output+=("prefix $line"); done < in
printf '%s\n' "${output[@]}" > out

Token Efficiency

Compress documentation:

• Cause → effect: ⇒ notation
• Lists: ≤7 items
• Minimize whitespace: Prefer compact over verbose

Example:

# Verbose (44 tokens)
# This function checks if the required tools are available
# in the system PATH and exits with an error if any are missing.
# It takes a list of tool names as arguments.

# Compact (16 tokens)
# Verify required tools exist ⇒ exit if missing

Tips

• Analyze before bulk edits
• Test incrementally, not all at once
• Keep shellcheck clean at each step
• Measure performance impact when optimizing
• Document consolidation rationale
• Maintain fallback chains for tools

Resources

• scripts/analyze.py - Automated script analyzer
• references/standards.md - Complete coding standards
• references/patterns.md - Optimization patterns and consolidation strategies