Opened Blog

Scripting: A guide

scripting

Scripting isn't just for sysadmins or legacy systems—it's an essential tool in any developer's toolkit. Whether you're looking to automate repetitive tasks, streamline your workflow, or connect different parts of your development environment, a well-crafted script can save you significant time. In this post, we'll cover the fundamentals and dive into practical scripts you can implement immediately.

Table of Contents

Why Scripting Still Matters

Think of scripting as your personal automation layer. It's not about building full-scale apps — it's about solving small, annoying problems efficiently. Need to batch rename files? Clean up your downloads folder? Auto-deploy something on save? A simple script can handle it. You write a few lines, run it in the terminal, and save yourself a repetitive headache. Over time, these little helpers add up to a faster, smoother workflow.

Practical scripts that you will actually use

  • Bulk File Operations: Like renaming hundreds of vacation photos from "IMG_001.jpg" to "Paris_2024_day1.jpg" in a flash using regular expressions.
  • Automated Backups: Set up a script to automatically copy your important files to a cloud service or external drive every night without you even lifting a finger.
  • System Monitoring: Create a script that keeps an eye on your computer's resources (CPU, memory) and sends you an alert if something goes haywire.
  • Web Data Extraction (Scraping): Need to grab daily stock prices or the latest headlines? Scripts can automate fetching this data and even organize it into a spreadsheet or database.

Going Deeper

✅ 1. Environment Variables & Configuration Files

Hardcoding sensitive information like API keys or passwords directly into your scripts is dangerous. Instead, use environment variables (settings defined outside your script) or configuration files (like.ini or .yaml) to keep your secrets safe and make your scripts more flexible.

# .env (example)
API_KEY=your_super_secret_key
DATABASE_URL=your_database_connection_string
# Python: using dotenv
from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("API_KEY")
database_url = os.getenv("DATABASE_URL")
print(f"Your API Key is: {api_key}")

✅ 2. Robust Logging & Debugging

Implementing a proper logging system is crucial for understanding what your script is doing, especially for long-running or automated tasks. Libraries like Python's logging module allow you to record events, errors, and warnings to a file or console, making debugging a whole lot easier.

import logging

# Configure basic logging
logging.basicConfig(filename='my_script.log', level=logging.INFO,
                    format='%(asctime)s - %(levelname)s - %(message)s')

logging.info("Script execution started.")

try:
    result = 10 / 0
except ZeroDivisionError:
    logging.error("Oops! Division by zero occurred.")

logging.info("Script execution finished.")

✅ 3. Smart Error Handling

Things don't always go according to plan. Using try...exceptblocks allows your script to gracefully handle unexpected errors without crashing. You can catch specific types of errors and define how your script should respond, like logging the error and continuing with other tasks.

try:
    data = fetch_data_from_api()
    process_data(data)
except requests.exceptions.RequestException as e:
    logging.error(f"Network error occurred: {e}")
    # Maybe try again or exit gracefully
except ValueError as e:
    logging.error(f"Data processing error: {e}")
except Exception as e:
    logging.error(f"An unexpected error occurred: {e}")

✅ 4. Building Interactive CLI Tools

Want to create scripts that can take input from the command line? Libraries like Python's argparse and click make it a breeze to define arguments and options that users can pass when running your script. This turns your scripts into more versatile and user-friendly tools.

# Python with argparse
import argparse

parser = argparse.ArgumentParser(description="Process some data.")
parser.add_argument("input_file", help="Path to the input file")
parser.add_argument("-o", "--output_file", help="Path to the output file")
parser.add_argument("--verbose", action="store_true", help="Enable verbose output")

args = parser.parse_args()

print(f"Input file: {args.input_file}")
if args.output_file:
    print(f"Output file: {args.output_file}")
if args.verbose:
    print("Verbose mode is enabled.")

# Your script logic here using args.input_file, args.output_file, etc.

✅ 5. The Power of APIs in Scripting

Many web services and applications expose APIs (Application Programming Interfaces) that allow you to interact with them programmatically. Using libraries like Python's requests, you can write scripts to automate tasks like fetching data, posting updates, or triggering actions on these services. The possibilities are endless!

import requests
import json

# Replace with a public API endpoint
api_url = "https://jsonplaceholder.typicode.com/todos/1"

try:
    response = requests.get(api_url)
    response.raise_for_status() # Raise an exception for bad status codes
    data = response.json()
    print(json.dumps(data, indent=4))
except requests.exceptions.RequestException as e:
    logging.error(f"API request failed: {e}")

✅ 6. Scheduled Scripts with Cron

Use cron jobs to schedule your scripts to run hourly, daily, etc.

# Edit your crontab file
crontab -e

# Example: Run a backup script daily at 3:00 AM
0 3 * * * /path/to/your/backup_script.sh

# Example: Run a cleanup script every Monday at 5:00 PM
0 17 * * 1 /path/to/your/cleanup_script.sh

Bash Automation: Get More Done with Less Typing

For those on macOS or Linux, Bash scripting is your trusty sidekick for automating system-level tasks. It lets you chain together commands, manipulate files, and even make decisions based on conditions. Let's see some cool things we can achieve with bash:

Let’s start simple. A Bash script is just a series of commands written in a text file. You can use it to automate anything you normally do in the terminal.

#!/bin/bash

echo "Hello, $USER!"
echo "Today is $(date)"
echo "Your current directory is: $(pwd)"

Save this to a file, for example hello.sh, and make it executable:

chmod +x hello.sh
./hello.sh

That’s it—you’ve written a working Bash script. From here, you can add logic, loops, and conditionals to build more powerful tools.

Automating Scripts with Cron Jobs

Cron is a time-based job scheduler in Unix-like operating systems. You can use it to schedule your Bash scripts (or any other scripts) to run automatically at specific times or intervals. Imagine automatically backing up your important documents every night at midnight!

# Edit your crontab file
crontab -e

# Example: Run a backup script daily at 3:00 AM
0 3 * * * /path/to/your/backup_script.sh

# Example: Run a cleanup script every Monday at 5:00 PM
0 17 * * 1 /path/to/your/cleanup_script.sh

Making Scripts Interactive with dialog

Sometimes you need to get input from the user when running a script in the terminal. The dialog utility allows you to create simple text-based dialog boxes for things like displaying menus, asking for input, or showing messages.

#!/bin/bash

# Present a menu
choice=$(dialog --menu "Choose an option:" 10 30 3         1 "Backup files"         2 "Check disk space"         3 "Exit" --stdout)

case "$choice" in
    1)
        echo "Starting backup..."
        # Your backup command here
        ;;
    2)
        echo "Checking disk space..."
        df -h
        ;;
    3)
        echo "Exiting."
        ;;
    *)
        echo "Invalid choice."
        ;;
esac

Enhanced User Interfaces with gum

For a more modern and visually appealing way to create interactive terminal scripts, check out gum. It provides commands for creating things like colorful menus, progress bars, input prompts, and more, making your command-line tools much more user-friendly. You'll likely need to install it separately (e.g., via Homebrew on macOS or apt on Debian/Ubuntu).

#!/bin/bash

# Present a colorful menu
choice=$(gum choose "Backup files" "Check disk space" "Exit")

if [[ "$choice" == "Backup files" ]]; then
    echo "Starting backup..."
    # Your backup command here
elif [[ "$choice" == "Check disk space" ]]; then
    echo "Checking disk space..."
    df -h
elif [[ "$choice" == "Exit" ]]; then
    echo "Exiting."
fi

# Get user input with a prompt
name=$(gum input --prompt "Enter your name:")
echo "Hello, $name!"

# Display a progress bar
gum progress --title "Processing..." -- bash -c 'for i in {1..100}; do sleep 0.05; echo "$i"; done'

Real-World Example: YouTube Music on the Command Line

Here's a Bash script that combines yt-dlp (to fetch YouTube audio), ffmpeg (to convert it), and mpg321 (to play it). It grabs audio from a YouTube URL and plays it directly from your terminal. Make sure you’ve got these installed: yt-dlp, ffmpeg, and mpg321. On Ubuntu/Debian:

sudo apt install yt-dlp ffmpeg mpg321
#!/bin/bash

read -p "Enter YouTube URL: " url

echo "Downloading best audio..."
yt-dlp -f bestaudio --extract-audio --audio-format mp3 -o "temp_audio.%(ext)s" "$url"

echo "Playing music..."
mpg321 temp_audio.mp3

echo "Cleaning up..."
rm -f temp_audio.mp3

This script:

  • Prompts you for a YouTube URL
  • Downloads and converts the best audio stream using yt-dlp and ffmpeg
  • Plays the audio with mpg321
  • Removes the temporary MP3 after playback
Quick, clean, and actually useful.

Wrapping Up

Scripting truly unlocks a world of automation possibilities. Whether you're starting with simple file renaming scripts or diving into more advanced techniques like API interactions, scheduled tasks with cron, or creating interactive command-line tools with dialog or the more modern gum, you're empowering yourself to work smarter, not harder.

✨ Your Next Mission: Identify just one repetitive task you do regularly and try to automate it with a simple script today. That first step is often the most rewarding on your journey into the exciting world of scripting!