
Photo by Florian Olivo on Unsplash
From “Hello world” to automating your daily chores
Why Bash matters today
If you’ve ever opened a terminal, typed ls, or followed a quick‑start guide that ends with “run this script”, you already know that the command line is more than a nostalgic relic. In 2026 cloud infrastructure, CI/CD pipelines, and even AI workloads run on Linux boxes that expect you to write small pieces of Bash code for everything from backups to log rotation. Bash is the glue language that stitches together commands, tools, and services.
For a newcomer, the idea of scripting can feel intimidating: variables, loops, conditionals—what if I get it wrong? The good news is that Bash is intentionally simple enough that you can write useful scripts in minutes, yet powerful enough to replace manual copy‑paste tasks with reproducible automation. This article walks you through the fundamentals you need to start writing your first scripts and gives practical tips that keep bugs at bay.
1. Setting up a safe playground
Before diving into code, create an isolated environment where experiments won’t break your system.
| Step | What to do | Why it matters |
|---|---|---|
| Use a non‑root user | sudo adduser bashdemo and log in as that user. |
Prevent accidental system changes. |
| Create a dedicated folder | mkdir ~/bash-scripts && cd ~/bash-scripts. |
Keeps scripts organized and easy to clean up. |
| Turn on Bash’s strict mode | Add set -euo pipefail at the top of every script you write. |
Stops execution on errors, enforces variable usage, and catches pipeline failures early. |
2. The building blocks: Variables, strings, and numbers
2.1 Declaring variables
name="Alice"
age=29
- No spaces around the
=sign. - Quoted values preserve whitespace; unquoted values are split on IFS (default: space, tab, newline).
2.2 Referencing variables
echo "Hello, $name!"
printf 'Age: %d\n' "$age"
Use braces {} when concatenating:
greeting="Hi ${name}, you are ${age} years old."
2.3 Arithmetic
Bash supports integer arithmetic with ((…)) or the older $((…)).
num1=5
num2=7
sum=$((num1 + num2))
echo "Sum: $sum"
For floating‑point, you’ll need external tools like bc:
result=$(echo "scale=2; 5 / 3" | bc)
echo "$result" # 1.66
3. Control flow: Conditionals and loops
3.1 If‑then‑else
if [[ $age -ge 18 ]]; then
echo "Adult"
else
echo "Minor"
fi
[[…]]is Bash’s modern test construct; it handles pattern matching, string comparison, and numeric comparison.- Use
==for string equality inside[[…]].
3.2 Case statement
Useful when you have many discrete options:
case "$1" in
start) echo "Starting service";;
stop) echo "Stopping service";;
*) echo "Unknown command: $1";;
esac
3.3 Loops
For loop over a list
for file in *.txt; do
echo "Processing $file"
done
While loop with a counter
counter=0
while [[ $counter -lt 5 ]]; do
echo "$counter"
((counter++))
done
Until loop (runs until condition is true)
until grep -q "needle" file.txt; do
sleep 1
done
echo "Found the needle!"
4. Working with input and output
4.1 Reading user input
read -p "Enter your name: " username
echo "Welcome, $username!"
-pprints a prompt without a newline.read -rprevents backslash interpretation (recommended for scripts that process arbitrary text).
4.2 Command substitution
Capture the output of a command into a variable:
current_user=$(whoami)
echo "Running as $current_user"
For multiline output, use arrays:
mapfile -t files < <(find . -maxdepth 1 -name "*.log")
for f in "${files[@]}"; do echo "$f"; done
4.3 Redirecting output
>– overwrite file>>– append to file<– input redirection2>&1– redirect stderr to stdout
Example: log a command’s output and errors:
./my_script.sh > script.log 2>&1
5. Practical automation patterns
5.1 Backup script
#!/usr/bin/env bash
set -euo pipefail
SRC="/home/user/documents"
DST="/mnt/backup/documents_$(date +%Y%m%d).tar.gz"
echo "Backing up $SRC to $DST"
tar czf "$DST" "$SRC"
tarcreates a compressed archive.- Timestamp ensures unique backup names.
5.2 File watcher with inotifywait
#!/usr/bin/env bash
set -euo pipefail
WATCH_DIR="/tmp/watch"
while inotifywait -e create,modify "$WATCH_DIR"; do
echo "Change detected in $WATCH_DIR"
# trigger your action here
done
inotifywait is part of inotify-tools; it watches for filesystem events without polling.
5.3 Periodic task with cron
Create a cron job that runs every hour:
crontab -e
# Add:
0 * * * * /home/user/bash-scripts/cleanup.sh >> /var/log/cleanup.log 2>&1
0 * * * *means “at minute 0 of every hour”.- Redirect output to a log file for later inspection.
6. Debugging and safety tips
| Tip | How to apply |
|---|---|
| Echo commands | Use set -x at the top or prefix lines with echo. It prints each command before execution. |
| Check exit status | After a critical command, test $? or use || exit 1 to abort on failure. |
| Use functions for reusability | Group related commands into named blocks; call them like regular functions. |
| Avoid hard‑coded paths | Prefer variables and environment checks ($HOME, $PATH). |
| Keep scripts idempotent | Running a script multiple times should not produce different results unless intended. |
7. Learning resources that keep you grounded
- Hands‑on tutorials – Sites like TecMint, TutorialforLinux, and Typecraft provide step‑by‑step guides that treat each lesson as a working script.
- Community forums – The Linux subreddits or Stack Overflow tags for
bashare great for quick questions and real‑world examples. - Books – “Learning the Bash Shell” (O’Reilly) offers depth, while “Bash Cookbook” gives ready‑made snippets you can adapt.
Conclusion
Bash scripting is a skill that grows with practice. Start small: automate a daily task or write a one‑liner wrapper around a command you use often. As you become comfortable with variables, conditionals, and loops, your scripts will evolve into powerful tools that save time, reduce errors, and make your workflow reproducible.
Remember the key principles:
- Write safe scripts – run as a non‑root user, enable strict mode.
- Keep it readable – use meaningful variable names and comments.
- Test incrementally – run parts of the script manually before full execution.
- Leverage community knowledge – don’t reinvent the wheel; adapt proven patterns.
With these habits, you’ll move from “I can’t get this to work” to “This script does exactly what I need”. Happy scripting!
Frequently Asked Questions (FAQ)
1. Why should I enable Bash’s strict mode (set -euo pipefail) in every script?
Strict mode forces the script to exit on any error, prevents accidental use of unset variables, and catches pipeline failures early. It makes scripts more reliable and easier to debug.
2. How do I safely read user input that may contain spaces or backslashes?
Use read -r with a prompt:
read -rp "Enter your name: " username
The -r flag stops Bash from interpreting backslashes, ensuring the raw input is stored.
3. When should I use [[ … ]] instead of [ … ] for tests?
[[ … ]] is a Bash keyword that supports pattern matching, string comparison (==), and safe variable expansion without word splitting or globbing. It’s more robust than the legacy [ … ].
4. How can I capture multi‑line command output into an array?
Use mapfile (or its synonym readarray) with process substitution:
mapfile -t lines < <(command)
for line in "${lines[@]}"; do echo "$line"; done
This preserves each line as a separate array element.


