DEV Community: Beta Shorts

Building a Simple Terminal-Based File Manager in Bash

Beta Shorts — Thu, 13 Mar 2025 13:05:09 +0000

A while ago, I found myself juggling between ls, cd, rm, and mv commands just to move and manage files across different directories. It felt inefficient—why not have a lightweight file manager right inside the terminal?

If you’ve ever wished for a simpler way to navigate and manipulate files without leaving the terminal, this guide will show you how to build a basic file manager in Bash—one that lets you browse, create, delete, and move files interactively.

Understanding the Core of a Terminal File Manager

A terminal-based file manager is essentially a Bash script that allows users to navigate directories and manage files using menus and keyboard inputs.

What It Should Do

✅ Display a list of files and directories

✅ Let users navigate between folders

✅ Provide options to delete, move, or rename files

✅ Offer a simple interface using the terminal

This can be accomplished using a combination of Bash commands like ls, cd, rm, and mv, along with interactive menus using select or read.

Step 1: Listing Files and Directories

The first step is displaying the current directory contents in a structured way. Instead of using a plain ls, let’s format the output to distinguish between files and directories.

for item in *; do
    if [ -d "$item" ]; then
        echo "[DIR]  $item"
    else
        echo "[FILE] $item"
    fi
done

🔹 Why this matters:

Helps differentiate files from directories visually.
Avoids clutter when dealing with large folders.

Step 2: Navigating Between Directories

A simple file manager must allow navigation. Instead of typing cd folder, we can make the script prompt users for input.

echo "Enter a directory name to navigate into:"
read dir
if [ -d "$dir" ]; then
    cd "$dir"
else
    echo "Invalid directory!"
fi

🔹 Why this matters:

Allows movement between folders without retyping commands.
Adds error handling for invalid inputs.

Step 3: Deleting Files Safely

Instead of manually typing rm filename, add a safety confirmation before deleting a file.

echo "Enter the filename to delete:"
read file
if [ -f "$file" ]; then
    echo "Are you sure? (y/n)"
    read confirm
    if [ "$confirm" == "y" ]; then
        rm "$file"
        echo "File deleted."
    fi
else
    echo "File does not exist!"
fi

🔹 Why this matters:

Prevents accidental file deletions.
Adds a confirmation step for safety.

Step 4: Moving and Renaming Files

A file manager should allow renaming and moving files interactively.

echo "Enter the file to rename:"
read oldname
if [ -f "$oldname" ]; then
    echo "Enter new name:"
    read newname
    mv "$oldname" "$newname"
    echo "File renamed successfully."
else
    echo "File does not exist!"
fi

🔹 Why this matters:

Simplifies renaming without manually typing mv old new.
Handles errors gracefully if the file doesn’t exist.

Step 5: Adding a Simple Menu Interface

Instead of running commands manually, let users pick an action.

echo "Select an option:"
echo "1) List files"
echo "2) Change directory"
echo "3) Delete a file"
echo "4) Rename a file"
echo "5) Exit"
read choice

case $choice in
    1) ls ;;
    2) echo "Enter directory:"; read dir; cd "$dir" ;;
    3) echo "Enter filename:"; read file; rm "$file" ;;
    4) echo "Enter old filename:"; read old; echo "Enter new filename:"; read new; mv "$old" "$new" ;;
    5) exit ;;
    *) echo "Invalid choice." ;;
esac

🔹 Why this matters:

Creates an interactive experience instead of manually typing commands.
Makes the script feel like a real file manager.

Enhancing the File Manager

Once you have the basics working, here are ways to improve it:

✅ Color-coded output: Highlight directories and files differently using ANSI colors.

✅ Search functionality: Let users search for files by name.

✅ Bulk operations: Allow multiple files to be selected and moved at once.

✅ Terminal UI libraries: Use dialog or whiptail for a more user-friendly interface.

Final Thoughts: Build Your Own Bash Utility

This project is a great hands-on exercise for improving your Bash scripting skills. By building a basic terminal-based file manager, you get practical experience with:

✅ Handling user input interactively

✅ Working with files and directories efficiently

✅ Creating scripts that automate real-world tasks

If you're new to Bash scripting, this project may feel a bit overwhelming. To get started faster with the basics, check out our Bash Scripting Cheat Book.

Want a Quick Reference for Bash Basics?

📌 If you’re just getting started with Bash and need a beginner-friendly guide, our Bash Scripting Cheat Book is designed to help you learn the fundamentals quickly.

👉 Get the Bash Scripting Cheat Book for just $3.99

📌 This book is NOT for advanced Bash topics like animations or UI enhancements—it’s a quick reference to help you understand Bash basics faster.

Discussion: How Would You Improve This File Manager?

Drop a comment below if you have ideas for additional features, or if you’ve built something similar in Bash!

Building a System Information Fetch Tool in Bash

Beta Shorts — Thu, 13 Mar 2025 10:57:53 +0000

I once needed a quick system overview—CPU load, memory usage, disk space—but opening multiple commands felt inefficient. Instead of running top, df -h, and free -m separately, I decided to automate everything in a single Bash script.

The result? A custom system fetch tool that provides essential system details at a glance. In this guide, you'll learn how to build your own step by step, improving your Bash scripting skills along the way.

Step 1: The Basics (What We’re Fetching)

Before we jump into coding, let’s outline what information we need:

✅ CPU Model & Load (/proc/cpuinfo, top)

✅ Memory Usage (free -m)

✅ Disk Space (df -h)

✅ System Uptime (uptime)

✅ Network Information (ip a, hostname -I)

Step 2: Writing the Script (Fundamentals First)

1️⃣ Shebang & Setup

Start by specifying Bash as the interpreter and clearing the screen:

#!/bin/bash
clear

2️⃣ Fetching CPU Info

Extract the CPU model name using grep on /proc/cpuinfo:

cpu_model=$(grep "model name" /proc/cpuinfo | head -1 | cut -d ':' -f2)

Get the CPU load using top (or uptime for a lightweight alternative):

cpu_load=$(top -bn1 | grep "load average" | awk '{print $10}')

3️⃣ Checking Memory Usage

Use free -m to display RAM usage in MB:

mem_usage=$(free -m | awk 'NR==2{printf "Used: %sMB / Total: %sMB", $3, $2}')

4️⃣ Fetching Disk Space

List available disk space using df -h:

disk_usage=$(df -h | awk '$NF=="/"{printf "Used: %d%%", $5}')

5️⃣ Displaying Network Info

Fetch the current IP address:

ip_address=$(hostname -I | awk '{print $1}')

Step 3: Formatting Output for Readability

Instead of printing raw text, format the output neatly using colors and spacing:

echo -e "\033[32mSystem Information:\033[0m"
echo "-------------------------------"
echo -e "CPU Model: $cpu_model"
echo -e "CPU Load: $cpu_load"
echo -e "Memory: $mem_usage"
echo -e "Disk Space: $disk_usage"
echo -e "IP Address: $ip_address"

🔹 Why it’s useful:

Colors improve readability
Consistent spacing makes it visually appealing

Step 4: Running the Script

Save the script as sysfetch.sh
Make it executable:

   chmod +x sysfetch.sh

Run it:

   ./sysfetch.sh

📌 Expected Output (Example):

System Information:
-------------------------------
CPU Model: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
CPU Load: 0.78
Memory: Used: 3800MB / Total: 16000MB
Disk Space: Used: 42%
IP Address: 192.168.1.10

Step 5: Enhancing the Script

✅ Add Live Updates

Instead of a one-time report, refresh every few seconds:

while true; do
    clear
    ./sysfetch.sh
    sleep 5
done

✅ Save Output to a Log File

Redirect output for future analysis:

./sysfetch.sh | tee system_report.txt

✅ Make It Interactive

Allow users to choose what info to display:

echo "Select an option: [1] CPU [2] Memory [3] Disk [4] All"
read choice

case $choice in
    1) echo "CPU Model: $cpu_model" ;;
    2) echo "Memory: $mem_usage" ;;
    3) echo "Disk Space: $disk_usage" ;;
    4) ./sysfetch.sh ;;
    *) echo "Invalid option" ;;
esac

Final Thoughts

Creating a custom system fetch tool is a great way to:

✅ Improve your Bash scripting skills

✅ Understand Linux system commands

✅ Make system monitoring more efficient

If you're a beginner, this project gives you real-world Bash experience. If you're advanced, you can customize it further with more data points.

Want a Quick Reference for Bash Basics?

If you're just getting started with Bash and need a beginner-friendly guide, check out my Bash Scripting Cheat Book:

📌 A quick reference for beginners to understand Bash scripting faster

📌 Covers fundamental concepts like variables, loops, conditionals, and functions

📌 Designed for absolute beginners—no advanced topics covered

👉 Get the Bash Scripting Cheat Book for just $3.99

Discussion: What System Info Do You Track in Your Bash Scripts?

Drop a comment below and share what extra system details you’d add to this script!

Create a Matrix Digital Rain Effect in Your Terminal with Bash

Beta Shorts — Thu, 13 Mar 2025 10:36:48 +0000

A while ago, I came across a Matrix-inspired Bash script and thought, this would be a cool project to build from scratch! The result? A lightweight, terminal-based Matrix digital rain effect that you can run instantly on any Linux system.

Whether you’re a Bash beginner looking for a fun scripting challenge or an experienced user interested in terminal animations, this guide will walk you through every step.

What We’re Building (Live Preview)

Before jumping into the code, here’s what the final effect looks like:

If you want to understand how it works and tweak it yourself, keep reading.

How the Matrix Effect Works in the Terminal

At its core, the Matrix rain effect is a combination of:

✅ Randomly generated characters (Katakana, alphanumeric, or symbols)

✅ A vertical falling effect using Bash’s tput command to control the cursor

✅ Color manipulation to add a cyberpunk aesthetic

We’ll be using Bash’s ANSI escape codes to control text placement, color, and movement.

Step 1: Setting Up the Script

Create a new Bash script and open it in your favorite editor:

nano matrix.sh

At the top of the file, add:

#!/bin/bash
clear  # Clears the terminal at the start
tput civis  # Hides the cursor for a cleaner effect

Step 2: Generate Falling Characters

Let’s define the characters that will fall down the screen:

chars=("ｱ" "ｲ" "ｳ" "ｴ" "ｵ" "ｶ" "ｷ" "ｸ" "ｹ" "ｺ" "ｻ" "ｼ" "ｽ" "ｾ" "ｿ" "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z")

To get the terminal dimensions dynamically, use:

rows=$(tput lines)
cols=$(tput cols)

🔹 Why this matters: The script should adapt to different screen sizes dynamically.

Step 3: Make It Rain

Now, let’s animate the falling characters using an infinite loop:

while true; do
    col=$((RANDOM % cols))  # Pick a random column
    char=${chars[$((RANDOM % ${#chars[@]}))]}  # Pick a random character
    tput cup 0 $col  # Move cursor to the top of the column
    echo -ne "\033[32m$char\033[0m"  # Print the character in green

    for ((i=1; i<rows; i++)); do
        tput cup $i $col
        echo -ne "\033[32m$char\033[0m"
        sleep 0.1
    done
done

🔹 Breakdown of what’s happening:

The script randomly selects a column and places a random character at the top.
It moves down the screen, refreshing each position with the next character.
tput cup is used to position the cursor dynamically.

Step 4: Restore the Cursor on Exit

When you interrupt the script (Ctrl + C), the cursor might remain hidden. Let’s ensure it restores properly:

trap "tput cnorm; exit" SIGINT

🔹 Why this matters: Prevents terminal glitches when exiting the script.

Step 5: Running the Script

Save the script (Ctrl + X, then Y, then Enter) and make it executable:

chmod +x matrix.sh
./matrix.sh

🎉 Your terminal should now be streaming Matrix-style digital rain!

Tweaks & Customization

Once you’ve got the effect running, try modifying the script to customize the rain effect:

1️⃣ Change the Color (Replace \033[32m with other ANSI color codes):

   echo -ne "\033[36m$char\033[0m"  # Cyan rain

2️⃣ Speed Up or Slow Down the Effect (Modify sleep 0.1):

   sleep 0.05  # Faster rain
   sleep 0.2   # Slower rain

3️⃣ Add More Variability (Introduce randomness in delay time):

   sleep $(awk -v min=0.05 -v max=0.2 'BEGIN{srand(); print min+rand()*(max-min)}')

Next Steps: Expanding the Project

If you enjoyed this project, you might like:

✅ Exploring Matrix scripts like for more optimized versions

✅ Adding interactivity (like pausing or changing colors dynamically)

✅ Converting this into a system screensaver

Let me know in the comments what improvements you’d like to see!

Final Thoughts

Building the Matrix rain effect in Bash is a fun way to explore terminal animations while improving your scripting skills. This project introduced you to:

✅ Cursor manipulation with tput

✅ Generating random characters dynamically

✅ Controlling terminal colors and output positioning

✅ Creating looping animations in Bash

Want a Structured Bash Reference?

If you need a Beginner Friendly Bash guide with easy to follow tips and explanations, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Sheet for just $3.99

Discussion: What’s Your Favorite Bash Animation Trick?

Drop a comment below if you have ideas for improving this script or other cool terminal animations you’ve built!

How to Build a Snake Game in Bash (Yes, Really!)

Beta Shorts — Fri, 07 Mar 2025 09:12:17 +0000

Most people use Bash for automation, scripting, and server management—but have you ever thought about using it to build a game?

At first, it sounds impossible. Bash lacks graphics support and isn't designed for real-time interactivity. But with clever workarounds, you can create a fully playable Snake game right in your terminal.

Let's break down the core logic behind a Bash-based Snake game and how you can start building it yourself.

Can You Really Code a Game in Bash?

✅ Yes, but it’s a challenge.

Unlike Python or C, Bash has no built-in game libraries. You need to manually control input, timing, and rendering using simple shell commands.

Here’s what makes it work:

Real-time input handling (using read in raw mode)
Game loop simulation (using while true; do ...; sleep x; done)
Terminal-based rendering (using tput and printf)

Step 1: Setting Up the Game Grid

Bash doesn’t have a GUI, so the game board is represented using characters.

Basic Board Representation

Imagine a 10x10 grid in the terminal:

##########
#        #
#        #
#   @    #
#        #
##########

Here’s a basic script to draw a static grid:

clear
for i in {1..10}; do
    for j in {1..10}; do
        if [[ $i -eq 1 || $i -eq 10 || $j -eq 1 || $j -eq 10 ]]; then
            echo -n "#"
        else
            echo -n " "
        fi
    done
    echo
done

🔹 What’s happening?

Loops create rows and columns
Borders (#) are drawn at the edges
Spaces (" ") are the playable area

Step 2: Moving the Snake

Handling real-time input is tricky in Bash. You can’t just use read because it waits for input. Instead, we use:

stty -echo -icanon time 0 min 0

This puts the terminal in raw mode, letting us read one key at a time.

Now, we can move the snake using key presses:

while true; do
    read -n 1 input
    case "$input" in
        w) direction="UP" ;;
        s) direction="DOWN" ;;
        a) direction="LEFT" ;;
        d) direction="RIGHT" ;;
    esac
done

🔹 Why it works:

read -n 1 reads one character at a time
case changes the direction variable based on input

Step 3: Making the Snake Grow

Each time the snake eats food, we increase its length. Instead of storing a graphical representation, we store coordinates:

snake=("3 5" "3 6" "3 7")  # List of x,y positions

Every time it moves:

Add a new head
Remove the tail (unless it eats food)

Here’s an example update logic:

new_head="$((x+dx)) $((y+dy))"
snake=("$new_head" "${snake[@]:0:${#snake[@]}-1}")

🔹 Why it works:

Moves head forward by modifying coordinates
Removes the last piece (tail) to keep the length constant

Step 4: Collision Detection (Don’t Crash!)

The game ends if the snake crashes into itself or the wall.

To check for self-collision:

if [[ " ${snake[@]} " =~ " $new_head " ]]; then
    echo "Game Over!"
    exit 0
fi

🔹 Why it works:

Converts snake[@] to a string and checks if new_head exists inside it.

For wall collision, add a check:

if [[ $x -le 1 || $x -ge 10 || $y -le 1 || $y -ge 10 ]]; then
    echo "Crashed into the wall!"
    exit 0
fi

🔹 Why it works:

If x or y reaches the grid boundary, the game ends.

Step 5: Adding Food and Score

A random food spawn looks like this:

food_x=$(( RANDOM % 8 + 2 ))
food_y=$(( RANDOM % 8 + 2 ))

When the snake’s head reaches the food:

Increase the length
Generate new food

if [[ "$new_head" == "$food_x $food_y" ]]; then
    snake+=("$new_head")  # Grow the snake
    food_x=$(( RANDOM % 8 + 2 ))
    food_y=$(( RANDOM % 8 + 2 ))
fi

🔹 Why it works:

Food respawns in a random location
Snake grows by adding a new segment

Challenges and Enhancements

If you’ve followed along, you have the logic for a simple Bash Snake game. But here are some challenges to improve it:

✅ Add a scoring system

✅ Make the snake move continuously

✅ Increase speed as the game progresses

✅ Store high scores in a file

Is Bash the Best Choice for a Snake Game?

🚀 Yes, for a challenge.

Bash wasn’t designed for games, but it’s a great way to learn scripting logic.

🛑 No, for complex games.

Bash struggles with real-time interaction. Python or C is better for performance.

Final Thoughts: Can You Build Games in Bash?

Bash isn’t made for game development, but that’s what makes it fun.

If you love problem-solving, this is a great exercise.
If you want high-performance, Bash isn’t the best option.

🎯 Challenge: Try building your own Snake game in Bash! Drop a comment if you get it working!

🚀 Master Bash Faster with This Cheat Book!

Want to boost your productivity and avoid Googling the same Bash commands over and over? My Bash Scripting Cheat Book is the ultimate quick-reference guide for everyday tasks like:

File handling, process management, and networking
Regex, text manipulation, and troubleshooting techniques
Essential Bash utilities (jq, find, grep, awk) explained concisely

👉 Get the Bash Cheat Sheet for just $3.99

What’s Inside?

✔️ Structured reference of 100+ essential Bash commands

✔️ Clear explanations with practical use cases

✔️ Formatted PDF for easy offline use

Is Bash Scripting Essential for Bioinformatics? Practical Use Cases and Common Pitfalls

Beta Shorts — Fri, 07 Mar 2025 06:42:18 +0000

When I started working with bioinformatics data, I was manually renaming hundreds of FASTQ files. It was tedious, slow, and prone to mistakes.

Then, I learned a simple Bash loop that did it in seconds.

If you're working in bioinformatics, you’ve probably encountered large datasets, repetitive tasks, and Linux-based systems. Bash scripting is a key skill, but how essential is it? And when should you use something else—like Python, Snakemake, or Nextflow?

This guide goes beyond discussion to show you real-world Bash examples used in bioinformatics and the common mistakes that waste time.

Why Bash Matters in Bioinformatics

Skill Level	What to Learn in Bash	When to Use It
Beginner	`ls`, `cd`, `grep`, `awk`, `sed`	Daily file operations, log parsing
Intermediate	Loops (`for`, `while`), automation scripts	Data preprocessing, renaming files
Advanced	`xargs`, `parallel`, workflow automation	Large-scale batch processing

Why It’s Useful

🔹 Most bioinformatics work happens on Linux servers, where Bash is the default shell.

🔹 Data preprocessing (renaming, filtering, merging files) is often easier in Bash than Python.

🔹 Automating workflows (running BLAST searches, QC checks) can save hours.

Real-World Bash Use Cases in Bioinformatics

1. Renaming Multiple FASTQ Files in Seconds

Instead of renaming files manually:

mv sample1_R1.fastq sample1_001_R1.fastq
mv sample1_R2.fastq sample1_001_R2.fastq

Use a Bash loop to automate renaming:

for file in *.fastq; do  
    mv "$file" "${file/_R/_001_R}"
done

🔹 Why it matters: Saves hours of manual renaming, reduces human error.

2. Filtering and Extracting Data from Large Files

Bioinformatics files are massive. Instead of manually searching for key data in a .vcf or .fastq file, use grep and awk:

grep -v '^#' variants.vcf | awk '$6 > 50' > high_quality_variants.vcf

🔹 Why it matters: Filters out low-quality variants in seconds instead of manually parsing data.

3. Running the Same Command Across Multiple Samples

Instead of running fastqc manually for each sample:

fastqc sample1.fastq
fastqc sample2.fastq
fastqc sample3.fastq

Use Bash to automate:

for file in *.fastq; do  
    fastqc "$file"  
done

🔹 Why it matters: This batch process scales across hundreds of samples without extra effort.

4. Submitting Batch Jobs to HPC Clusters

Most bioinformatics workflows run on high-performance computing (HPC) clusters. Bash makes it easy to submit jobs:

for sample in *.fastq; do  
    sbatch run_alignment.sh "$sample"
done

🔹 Why it matters: Automates sequencing alignment across multiple samples in an HPC environment.

5. Avoiding Common Bash Pitfalls in Bioinformatics

Even experienced users make mistakes when scripting. Here are some common pitfalls:

❌ Mistake #1: Forgetting to Quote Variables

mv $file renamed_$file  # ❌ Breaks if $file has spaces

✅ Fix:

mv "$file" "renamed_$file"

🔹 Why it matters: Unquoted variables break loops and cause unintended file deletions.

❌ Mistake #2: Using `ls` in a Loop (Bad Practice)

for file in $(ls *.fastq); do  # ❌ Breaks with spaces in filenames
    fastqc "$file"
done

✅ Fix: Use proper globbing:

for file in *.fastq; do  
    fastqc "$file"
done

🔹 Why it matters: ls mangles filenames with spaces or special characters.

❌ Mistake #3: Running Heavy Workloads Without Parallelization

for sample in *.fastq; do  
    aligner "$sample"  
done

✅ Fix: Use parallel for faster processing:

ls *.fastq | parallel aligner {}

🔹 Why it matters: Using parallel runs jobs in parallel, reducing execution time on multi-core machines.

When to Use Bash vs. Python in Bioinformatics

Bash is great for file manipulation, job automation, and quick tasks, but Python excels at data analysis and complex workflows.

Task	Best Tool	Why?
Renaming files, moving data	✅ Bash	Simple and fast
Parsing and transforming sequences	✅ Python	Handles complex data structures better
Running batch jobs on HPC clusters	✅ Bash	Integrates well with SLURM and PBS
Statistical analysis, machine learning	✅ Python	Libraries like NumPy, Pandas, SciPy

Final Thoughts: Is Bash Essential for Bioinformatics?

Bash isn’t required for everything, but learning it makes life easier in bioinformatics.

✅ Use Bash for automation, batch processing, and file manipulation.

✅ Use Python for complex data analysis, plotting, and statistics.

✅ If you work with an HPC cluster, Bash is almost unavoidable.

🚀 Master Bash Faster with This Cheat Book!

Want to boost your productivity and avoid Googling the same Bash commands over and over? My Bash Scripting Cheat Book is the ultimate quick-reference guide for everyday tasks like:

File handling, process management, and networking
Regex, text manipulation, and troubleshooting techniques
Essential Bash utilities (jq, find, grep, awk) explained concisely

👉 Get the Bash Cheat Sheet for just $3.99

Discussion: How Do You Use Bash in Your Bioinformatics Work?

Drop a comment below and share your most-used Bash scripts or automation tricks!

Top 5 Bash Pitfalls That Newbies Keep Getting Wrong

Beta Shorts — Fri, 07 Mar 2025 06:32:30 +0000

A few years ago, I ran a simple script to delete old log files.

At least, that’s what I thought I was doing.

In reality, a tiny mistake wiped an entire directory, causing hours of recovery work. If you've ever seen a Bash command go horribly wrong, you're not alone.

New Bash users often fall into avoidable traps—from missing quotes to unexpected variable expansions. Some mistakes cause silent failures, while others can delete important files in seconds.

Here are five common Bash mistakes, how they break scripts, and the right way to fix them.

1. Forgetting to Quote Variables (Breaks Scripts in Unexpected Ways)

Skill Level: Beginner 🔹

The Problem

Leaving variables unquoted leads to word splitting and glob expansion, causing unpredictable results.

What Can Go Wrong?

filename="my file.txt"
rm $filename  # ❌ Breaks if filename contains spaces

If filename="my file.txt", Bash interprets this as:

rm my file.txt  # ❌ Tries to delete "my" and "file.txt" separately

The Fix

Always quote variables to prevent unwanted splitting:

rm "$filename"  # ✅ Safe, deletes "my file.txt" as expected

💡 Real-World Debugging Example:

A friend once wrote a backup script that copied files based on a user-provided variable:

cp $source_dir /backup/

It worked fine—until someone entered a directory name with spaces, and nothing got copied.

**2. Using `rm -rf *` Without Thinking (A Disaster Waiting to Happen)**

Skill Level: Beginner 🔹

The Problem

New Bash users sometimes run dangerous commands without safeguards.

What Can Go Wrong?

cd /var/www
rm -rf *  # ❌ Destroys everything in the directory, no confirmation

Accidentally running this in the wrong directory can delete critical files.

The Fix

Use rm -i for an interactive prompt:

  rm -i *

Prevent accidental deletions by enabling noclobber mode:

  set -o noclobber

Instead of deleting files permanently, use a trash command:

  sudo apt install trash-cli  # Install trash-cli
  trash-put important_file.txt

💡 Real-World Debugging Example:

An engineer at a startup once ran:

rm -rf / var/log

The space between / and var/log was missed, resulting in a full system wipe instead of just clearing logs.

3. Looping Over `ls` Output (Why This Breaks Scripts)

Skill Level: Intermediate 🔹🔹

The Problem

Parsing ls output in a loop causes unexpected failures, especially with filenames that contain spaces or special characters.

What Can Go Wrong?

for file in $(ls *.txt); do
    echo "Processing $file"
done

Why This Fails:

ls doesn’t handle filenames with spaces properly.
Newline-separated filenames break the loop.

The Fix

Use find or globbing instead:

for file in *.txt; do
    echo "Processing $file"
done

Or, using find:

find . -name "*.txt" -print0 | while IFS= read -r -d '' file; do
    echo "Processing $file"
done

💡 Real-World Debugging Example:

A DevOps engineer once wrote a script to bulk rename logs but found that files with spaces were being mangled in the process. Switching to find -print0 solved it.

4. Assuming `[` and `[[` Work the Same Way (They Don’t)

Skill Level: Intermediate 🔹🔹

The Problem

Many beginners assume [ and [[ are identical—but they have critical differences.

What Can Go Wrong?

file="myfile.txt"
if [ -f $file ]; then  # ❌ Breaks if $file is empty or contains spaces
    echo "File exists"
fi

The Fix

Use [[ ... ]] instead of [ ... ] whenever possible:

if [[ -f "$file" ]]; then  # ✅ Safe, avoids expansion issues
    echo "File exists"
fi

💡 Real-World Debugging Example:

A bug in a backup script resulted in deleting the wrong files because a test failed silently due to [ ... ] behaving unexpectedly.

5. Not Handling Errors Properly (`set -e` Can Save You Hours of Debugging)

Skill Level: Advanced 🔹🔹🔹

The Problem

By default, Bash scripts keep running even if a command fails, leading to unexpected behavior.

What Can Go Wrong?

#!/bin/bash
mkdir /backup
cp important_file.txt /backup
echo "Backup complete!"

If cp fails, the script still prints "Backup complete!", misleading the user.

The Fix

Use set -e to exit on errors:

#!/bin/bash
set -e
mkdir /backup
cp important_file.txt /backup
echo "Backup complete!"

💡 Real-World Debugging Example:

A CI/CD pipeline once deployed broken code because a failed command was ignored, causing a major production outage.

Final Thoughts: Avoid These Bash Pitfalls and Write Better Scripts

These mistakes waste hours of debugging time, but once you learn to avoid them, your scripts will be more reliable and secure.

Quick Recap:

✅ Quote variables to prevent unexpected splitting

✅ Use [[ ... ]] instead of [ ... ] for safer conditionals

✅ Avoid rm -rf * without safeguards

✅ Use set -e to catch errors early

✅ Never loop over ls output—use find or globbing instead

🚀 Master Bash Faster with This Cheat Book!

Want to boost your productivity and avoid Googling the same Bash commands over and over? My Bash Scripting Cheat Book is the ultimate quick-reference guide for everyday tasks like:

File handling, process management, and networking
Regex, text manipulation, and troubleshooting techniques
Essential Bash utilities (jq, find, grep, awk) explained concisely

👉 Get the Bash Cheat Sheet for just $3.99

Discussion: What’s the Worst Bash Mistake You’ve Ever Made?

Drop a comment below and share your biggest Bash scripting fail—so others can learn from it!

How to Automate Everything With Bash: Beginner to Advanced Guide

Beta Shorts — Thu, 06 Mar 2025 17:38:38 +0000

A few years ago, I spent 30 minutes every morning manually checking system logs, copying backups, and cleaning up temporary files. It was tedious and unnecessary.

Then I wrote a 10-line Bash script that did everything in seconds.

If you’re still manually performing repetitive tasks, it’s time to start automating everything with Bash. This guide will take you from basic scripts to fully automated workflows, with real-world examples instead of generic tutorials.

If you need a Beginner Friendly Bash guide, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Sheet for just $3.99

1. Stop Running the Same Commands Every Day (Beginner)

❌ The Problem: Manually Running Tasks

If you find yourself typing the same command every day, you need to automate it.

✅ The Fix: Write a Simple Bash Script

Instead of typing commands repeatedly, create a script:

#!/bin/bash
echo "Backing up logs..."
cp /var/log/syslog /backup/logs/syslog_$(date +%F).log
echo "Backup complete."

Run Your Script Automatically

chmod +x backup.sh
./backup.sh

🔹 Why it's better: No need to remember commands—one script does it all.

2. Schedule Scripts to Run Automatically (Beginner)

Once you have a script, why run it manually? Let Linux do it for you.

Use `cron` to Schedule Your Scripts

Edit your crontab:

crontab -e

Run a script every day at 2 AM:

0 2 * * * /home/user/backup.sh

🔹 Why it's useful: Automates backups, cleanup, and system monitoring.

3. Automate File Organization (Intermediate)

❌ The Problem: Sorting Files Manually

Are you constantly renaming files, moving downloads, or organizing logs?

✅ The Fix: Automate It

Move all .jpg files from Downloads to Pictures:

#!/bin/bash
mv ~/Downloads/*.jpg ~/Pictures/
echo "Moved all images to Pictures."

Automatically rename files with timestamps:

#!/bin/bash
for file in ~/Documents/*.txt; do
    mv "$file" "${file%.txt}_$(date +%F).txt"
done

🔹 Why it's useful: Saves hours of manual sorting.

4. Automate System Monitoring and Alerts (Advanced)

❌ The Problem: Checking System Health Manually

You don’t need to run htop or df -h manually—let Bash monitor everything for you.

✅ The Fix: A Monitoring Script

Check Disk Space and Send Alerts

#!/bin/bash
THRESHOLD=80
usage=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')

if [ "$usage" -ge "$THRESHOLD" ]; then
    echo "Warning: Disk usage is at ${usage}%!" | mail -s "Disk Alert" admin@example.com
fi

🔹 Why it's useful: Prevents unexpected storage failures.

5. Automate Backups and Cleanup (Advanced)

❌ The Problem: Forgetting to Back Up and Delete Old Files

Stop manually copying files or cleaning up old data.

✅ The Fix: Automate It with `find`

Automatically Delete Files Older Than 30 Days

find /var/log -type f -mtime +30 -delete

Backup Important Files Every Week

tar -czf /backup/home_$(date +%F).tar.gz /home/user

🔹 Why it's useful: Runs silently in the background with cron.

6. Automate User Management (Advanced)

Create Users in Bulk from a File

#!/bin/bash
while IFS=, read -r username password; do
    useradd -m "$username"
    echo "$username:$password" | chpasswd
done < users.csv

🔹 Why it's useful: Automates onboarding multiple users instantly.

7. Automate API Calls and Web Scraping (Advanced)

Use `curl` to Automate API Calls

curl -s "https://api.github.com/users/octocat" | jq '.name'

Automate Web Scraping with `wget`

wget -r -np -A pdf https://example.com/reports/

🔹 Why it's useful: Fetches real-time data automatically.

8. Automate SSH Commands for Remote Servers

Run Commands on Multiple Servers via SSH

#!/bin/bash
servers=("server1" "server2" "server3")

for server in "${servers[@]}"; do
    ssh user@$server "uptime"
done

🔹 Why it's useful: Runs commands across all servers at once.

9. Automate Everything with One Script

If you need to fully automate your workflow, create a master script.

Example: One Script to Manage Everything

#!/bin/bash
echo "Starting system maintenance..."
echo "Updating system..."
apt update && apt upgrade -y

echo "Cleaning up old logs..."
find /var/log -type f -mtime +30 -delete

echo "Backing up home directory..."
tar -czf /backup/home_$(date +%F).tar.gz /home/user

echo "Checking disk space..."
df -h

🔹 Why it's useful: Automates multiple system tasks in one go.

Final Thoughts: Automate and Save Hours

Bash automation can eliminate manual tasks, prevent errors, and speed up workflows.

Quick Recap:

✅ Schedule tasks with cron

✅ Automate file organization and cleanup

✅ Set up system monitoring and alerts

✅ Run SSH commands on multiple servers

✅ Make API calls and scrape websites

Want a Structured Bash Reference?

If you need a Beginner Friendly Bash guide, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Sheet for just $3.99

Discussion: What’s the Best Bash Automation You’ve Created?

Drop a comment below and share how you use Bash to automate tasks!

Why Every Dev Should Know These 20 Bash Keyboard Shortcuts

Beta Shorts — Wed, 05 Mar 2025 11:55:40 +0000

A few years ago, I wasted hours scrolling through command history, retyping long file paths, and fixing typos the slow way. Then I discovered Bash keyboard shortcuts.

After incorporating just a handful of these, my terminal speed doubled.

If you're still using Bash inefficiently, this guide will show you the shortcuts that experienced Linux users rely on daily—from basic navigation to power-user tricks.

1. Rerun the Last Command Instantly (`!!`)

Skill Level: Beginner

Instead of retyping a failed command with sudo, just use:

sudo !!

🔹 Real-World Use Case: Quickly retry failed commands without retyping everything.

2. Edit and Reuse the Last Argument (`!$`)

Skill Level: Intermediate

Instead of manually copying the last argument:

mv file1.txt /backup/
ls -l !$

This expands to:

ls -l /backup/file1.txt

🔹 Real-World Use Case: Saves keystrokes when working with long filenames.

3. Search Command History Like a Pro (`Ctrl + R`)

Skill Level: Intermediate

Stop pressing Up Arrow 20 times—use reverse search:

Press Ctrl + R
Start typing a previous command
Press Enter to run it instantly

🔹 Real-World Use Case: Instantly finds a complex command without scrolling through history.

4. Move to the Beginning or End of a Command (`Ctrl + A / Ctrl + E`)

Skill Level: Beginner

Stop holding Left Arrow to edit a command. Use:

Ctrl + A → Jump to the start
Ctrl + E → Jump to the end

🔹 Real-World Use Case: Makes editing long commands much faster.

5. Delete a Whole Line (`Ctrl + U`)

Skill Level: Intermediate

Instead of holding Backspace, erase everything before the cursor instantly:

Ctrl + U

🔹 Real-World Use Case: Quickly clear mistakes without retyping everything.

6. Delete Everything After the Cursor (`Ctrl + K`)

Skill Level: Intermediate

echo "This is a test sentence"

If the cursor is after "test", pressing Ctrl + K results in:

echo "This is a test"

🔹 Real-World Use Case: Remove unnecessary text without deleting the whole command.

7. Swap Two Characters (`Ctrl + T`)

Skill Level: Advanced

Instead of manually fixing typos:

grpe file.txt  # Typo

Press Ctrl + T:

grep file.txt  # Fixed

🔹 Real-World Use Case: Quick typo correction without retyping.

8. Cancel a Running Command (`Ctrl + C`)

Skill Level: Beginner

Stops a command immediately.

ping google.com
# Press Ctrl + C to stop

🔹 Real-World Use Case: Kills unresponsive processes instantly.

9. Suspend a Process (`Ctrl + Z`)

Skill Level: Advanced

Pause a running task instead of quitting it:

vim file.txt  # Press Ctrl + Z

Resume later with:

fg

🔹 Real-World Use Case: Temporarily switch tasks without losing progress.

10. Run a Process in the Background (`&`)

Skill Level: Intermediate

long-running-task.sh &

🔹 Real-World Use Case: Keeps the terminal free while running background tasks.

11. Kill a Background Process (`jobs` + `kill %`)

Skill Level: Advanced

List background jobs:

jobs

Kill job #2:

kill %2

🔹 Real-World Use Case: Manages multiple background tasks efficiently.

12. Clear the Terminal (`Ctrl + L`)

Skill Level: Beginner

Same as clear, but faster.

Ctrl + L

🔹 Real-World Use Case: Keeps your workspace clean.

13. Copy the Previous Command Without Running It (`!:`)

Skill Level: Advanced

Instead of retyping a long command, use !:p to print the last command without running it.

!:

🔹 Real-World Use Case: Preview a command before executing it again.

14. Replace Text in the Last Command (`^old^new`)

Skill Level: Intermediate

Instead of retyping a command to fix a mistake:

ls /ect
^ect^etc

🔹 Real-World Use Case: Fixes typos without manually editing the command.

15. Scroll Through Past Commands (`Up` and `Down`)

Skill Level: Beginner

Navigate command history without retyping.

Up Arrow  → Previous command
Down Arrow → Next command

🔹 Real-World Use Case: Quickly re-execute previous commands.

16. Autocomplete File and Command Names (`Tab`)

Skill Level: Beginner

Type part of a filename or command, then press Tab to autocomplete.

ls /var/lo<Tab>  # Expands to /var/log

🔹 Real-World Use Case: Reduces typing mistakes.

17. Ignore Duplicate Commands in History (`HISTCONTROL`)

Skill Level: Advanced

Add this to your .bashrc to prevent duplicate history entries:

export HISTCONTROL=ignoredups

🔹 Real-World Use Case: Keeps history cleaner.

18. Repeat the First Argument of the Last Command (`!^`)

Skill Level: Advanced

cp myfile.txt backup/
mv !^ newlocation/

🔹 Real-World Use Case: Saves keystrokes and reduces mistakes.

Final Thoughts: Save Hours with Bash Shortcuts

Mastering these shortcuts will speed up your workflow, reduce errors, and make you more efficient in the terminal.

Want a Structured Bash Reference?

If you need a Beginner Friendly Bash guide with easy to follow tips and explanations, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Sheet for just $3.99

Discussion: What’s Your Favorite Bash Shortcut?

Drop a comment below and share your most-used Bash keyboard shortcut!

How to Automate Everything With Bash: Beginner to Advanced Guide

Beta Shorts — Wed, 05 Mar 2025 11:53:43 +0000

A few years ago, I spent 30 minutes every morning manually checking system logs, copying backups, and cleaning up temporary files. It was tedious and unnecessary.

Then I wrote a 10-line Bash script that did everything in seconds.

Need a structured Bash reference for automation?

👉 Get the Bash Cheat Sheet for $3.99

1. Stop Running the Same Commands Every Day (Beginner)

❌ The Problem: Manually Running Tasks

If you find yourself typing the same command every day, you need to automate it.

✅ The Fix: Write a Simple Bash Script

Instead of typing commands repeatedly, create a script:

#!/bin/bash
echo "Backing up logs..."
cp /var/log/syslog /backup/logs/syslog_$(date +%F).log
echo "Backup complete."

Run Your Script Automatically

chmod +x backup.sh
./backup.sh

🔹 Why it's better: No need to remember commands—one script does it all.

2. Schedule Scripts to Run Automatically (Beginner)

Once you have a script, why run it manually? Let Linux do it for you.

Use `cron` to Schedule Your Scripts

Edit your crontab:

crontab -e

Run a script every day at 2 AM:

0 2 * * * /home/user/backup.sh

🔹 Why it's useful: Automates backups, cleanup, and system monitoring.

3. Automate File Organization (Intermediate)

❌ The Problem: Sorting Files Manually

Are you constantly renaming files, moving downloads, or organizing logs?

✅ The Fix: Automate It

Move all .jpg files from Downloads to Pictures:

#!/bin/bash
mv ~/Downloads/*.jpg ~/Pictures/
echo "Moved all images to Pictures."

Automatically rename files with timestamps:

#!/bin/bash
for file in ~/Documents/*.txt; do
    mv "$file" "${file%.txt}_$(date +%F).txt"
done

🔹 Why it's useful: Saves hours of manual sorting.

4. Automate System Monitoring and Alerts (Advanced)

❌ The Problem: Checking System Health Manually

You don’t need to run htop or df -h manually—let Bash monitor everything for you.

✅ The Fix: A Monitoring Script

Check Disk Space and Send Alerts

#!/bin/bash
THRESHOLD=80
usage=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')

if [ "$usage" -ge "$THRESHOLD" ]; then
    echo "Warning: Disk usage is at ${usage}%!" | mail -s "Disk Alert" admin@example.com
fi

🔹 Why it's useful: Prevents unexpected storage failures.

5. Automate Backups and Cleanup (Advanced)

❌ The Problem: Forgetting to Back Up and Delete Old Files

Stop manually copying files or cleaning up old data.

✅ The Fix: Automate It with `find`

Automatically Delete Files Older Than 30 Days

find /var/log -type f -mtime +30 -delete

Backup Important Files Every Week

tar -czf /backup/home_$(date +%F).tar.gz /home/user

🔹 Why it's useful: Runs silently in the background with cron.

6. Automate User Management (Advanced)

Create Users in Bulk from a File

#!/bin/bash
while IFS=, read -r username password; do
    useradd -m "$username"
    echo "$username:$password" | chpasswd
done < users.csv

🔹 Why it's useful: Automates onboarding multiple users instantly.

7. Automate API Calls and Web Scraping (Advanced)

Use `curl` to Automate API Calls

curl -s "https://api.github.com/users/octocat" | jq '.name'

Automate Web Scraping with `wget`

wget -r -np -A pdf https://example.com/reports/

🔹 Why it's useful: Fetches real-time data automatically.

8. Automate SSH Commands for Remote Servers

Run Commands on Multiple Servers via SSH

#!/bin/bash
servers=("server1" "server2" "server3")

for server in "${servers[@]}"; do
    ssh user@$server "uptime"
done

🔹 Why it's useful: Runs commands across all servers at once.

9. Automate Everything with One Script

If you need to fully automate your workflow, create a master script.

Example: One Script to Manage Everything

#!/bin/bash
echo "Starting system maintenance..."
echo "Updating system..."
apt update && apt upgrade -y

echo "Cleaning up old logs..."
find /var/log -type f -mtime +30 -delete

echo "Backing up home directory..."
tar -czf /backup/home_$(date +%F).tar.gz /home/user

echo "Checking disk space..."
df -h

🔹 Why it's useful: Automates multiple system tasks in one go.

Final Thoughts: Automate and Save Hours

Bash automation can eliminate manual tasks, prevent errors, and speed up workflows.

Quick Recap:

Want a Structured Bash Reference?

If you need a Beginner FriendlyBash guide with easy to follow explanations and tips, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Sheet for just $3.99

Discussion: What’s the Best Bash Automation You’ve Created?

Drop a comment below and share how you use Bash to automate tasks!

The Hidden Superpowers of Bash Pipes and Redirection

Beta Shorts — Wed, 05 Mar 2025 11:52:03 +0000

I once wrote a script that processed thousands of log files but ended up with dozens of unnecessary temporary files. It worked, but it was slow and messy.

Then I realized I could eliminate every temp file just by using pipes (|) and redirection (>, >>, <) properly. The result? The same task ran 50% faster, with zero clutter.

If you are still writing to temp files for processing, it's time to unlock the full power of Bash pipes and redirection.

Need a structured Bash reference for automation?

👉 Get the Bash Cheat Sheet for $3.99

1. Stop Using Temporary Files: Process Data on the Fly

Many scripts use unnecessary temp files, slowing down execution and cluttering directories.

❌ The Wrong Way: Using Temp Files

cat access.log | grep "404" > errors.txt
sort errors.txt | uniq -c > count.txt
cat count.txt

✅ The Right Way: Using Pipes

grep "404" access.log | sort | uniq -c

🔹 Why it's better:

Eliminates unnecessary files (errors.txt, count.txt)
Faster execution (data flows between commands without writing to disk)

2. Redirecting Output: Save, Append, and Merge Streams

Save Output to a File (`>` and `>>`)

ls -lh > file_list.txt  # Overwrites file
ls -lh >> file_list.txt # Appends to file

Capture Both `stdout` and `stderr`

command > output.log 2>&1

Or shorter:

command &> output.log

🔹 Why it's useful: Logs both normal output and errors into a single file.

3. Filter and Transform Data in Real-Time

Pipes let you chain commands together, making complex data processing effortless.

Find Top 10 Most Visited Pages

cat access.log | awk '{print $7}' | sort | uniq -c | sort -nr | head -10

🔹 What’s happening here?

awk '{print $7}' extracts the URL path from each log entry
sort | uniq -c counts occurrences of each unique path
sort -nr | head -10 displays the most visited pages

4. Redirecting Input: Feed Data from a File or Another Command

Use a File as Input (`<`)

sort < unsorted_list.txt

Use a Command’s Output as Input (`|`)

ps aux | grep nginx

🔹 Why it's useful: Avoids needing intermediate files when processing data.

5. Merging and Splitting Streams: `/dev/null`, `tee`, and More

Suppress Output (`/dev/null`)

command > /dev/null 2>&1

🔹 Why? Runs the command silently, ignoring both stdout and stderr.

Save Output While Still Showing It (`tee`)

command | tee output.log

🔹 Why? Useful for logging while monitoring.

6. Combining Multiple Commands with `xargs`

Find and Delete Large Files

find /home -type f -size +100M | xargs rm -v

🔹 Why it's better: xargs processes multiple files in one command, unlike find -exec rm {} \;.

7. Using `yes` to Automate Interactive Commands

Force Overwrite Without Prompting

yes | cp -i file.txt /backup/

🔹 Why? Avoids manually confirming every file overwrite.

8. Process Substitution: Pass Command Output as a File

Compare Two Command Outputs

diff <(ls /dir1) <(ls /dir2)

🔹 Why it's useful: No need to create temporary files just to compare results.

9. Real-Time Log Monitoring with `tail -f` and `grep`

Monitor Logs for Errors in Real-Time

tail -f /var/log/syslog | grep "ERROR"

🔹 Why? Instantly filters live logs instead of manually scrolling.

10. Nested Pipes: When One Isn’t Enough

Find the Most Common IPs Making Requests

cat access.log | awk '{print $1}' | sort | uniq -c | sort -nr | head -10

🔹 Why? Finds high-traffic IPs without needing a database.

Final Thoughts: Level Up Your Bash Game

Mastering pipes and redirection will make every Linux task faster and more efficient.

Quick Recap:

✅ Use pipes (|) to eliminate temporary files

✅ Redirect output (>, >>) for logging

✅ Merge and split streams (/dev/null, tee)

✅ Use xargs for batch processing

✅ Leverage process substitution (<()) for comparisons

Want a Structured Bash Reference?

If you need a Beginner Friendly Bash guide with easy to follow tips and explanations, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Sheet for just $3.99

Discussion: What’s Your Favorite Bash Piping Trick?

Drop a comment below and share how you use pipes and redirection to automate tasks!

Master the Find Command: Stop Searching Manually in Linux

Beta Shorts — Tue, 04 Mar 2025 11:43:14 +0000

A few years ago, I wasted 30 minutes looking for a misplaced log file—scrolling through directories, opening files manually, and running random ls commands.

Then, I learned how to use find properly—and found the file in 5 seconds.

If you are still clicking through directories or using slow GUI searches, it’s time to master the find command. This guide will eliminate manual searching forever with real-world examples, not just a list of flags.

Need a quick-reference guide for Bash scripting?

👉 Get the Bash Cheat Book for $3.99

1. Stop Searching by Hand: Find Any File Instantly

Most Common Manual Search Mistake:

Manually navigating directories or using ls to search for a file:

ls -lR /home/user | grep "report.pdf"  # ❌ Slow and inefficient

✅ The Fix: Use `find` for Instant Search

find /home/user -name "report.pdf"

🔹 Why it's better: Works even if you don’t remember the exact location.

🔹 Bonus: Make it case-insensitive:

find /home/user -iname "report.pdf"

2. Searching by File Type: Don't Get Unnecessary Results

Instead of listing everything, filter results by type.

Find Only Directories

find /home/user -type d -name "projects"

Find Only Files

find /var/log -type f -name "*.log"

🔹 Why it's useful: Stops wasting time sifting through irrelevant results.

3. Finding Large Files Eating Up Space

Instead of guessing which files are wasting disk space, use find to locate big offenders instantly.

Find Files Larger Than 500MB

find /home -type f -size +500M

Find Files Between 50MB and 100MB

find /home -type f -size +50M -size -100M

🔹 Why it’s useful: Helps free up storage without digging through directories manually.

4. Find Recently Modified Files for Debugging

Finding recently edited files helps track down issues fast.

Find Files Modified in the Last 7 Days

find /var/log -type f -mtime -7

Find Files Modified More Than 30 Days Ago

find /var/log -type f -mtime +30

Find Files Modified in the Last 10 Minutes

find /var/log -type f -mmin -10

🔹 Why it's useful: Essential for debugging recent system changes.

5. Cleaning Up: Find and Delete Files in One Command

Stop manually deleting files one by one.

Delete All `.tmp` Files in `/tmp`

find /tmp -type f -name "*.tmp" -delete

🚨 Test first before deleting:

find /tmp -type f -name "*.tmp" -print

🔹 Why it’s useful: Automates temporary file cleanup.

6. Batch Processing: Running Commands on Found Files

You can use find to automate tasks across multiple files.

Change Ownership of All `.log` Files

find /var/log -type f -name "*.log" -exec chown user:user {} \;

Move All `.jpg` Files to Another Directory

find /home/user/Pictures -type f -name "*.jpg" -exec mv {} /backup/images/ \;

🚀 Pro Tip: If your command needs multiple files, use + instead of \; for better performance:

find /home/user/Pictures -type f -name "*.jpg" -exec mv {} /backup/images/ +

🔹 Why it's useful: Great for bulk renaming, moving, or modifying files.

7. Searching With Logical Operators: Combine Multiple Criteria

Find `.log` OR `.txt` Files

find /var/log -type f \( -name "*.log" -o -name "*.txt" \)

Find Files Modified in the Last 7 Days AND Larger Than 1MB

find /home -type f -mtime -7 -a -size +1M

🔹 Why it's useful: Refines searches to only return exactly what you need.

**8. Finding Hidden Files (`.*` Dotfiles)**

List All Hidden Files in a Directory

find /home/user -type f -name ".*"

🔹 Why it’s useful: Quickly find dotfiles like .bashrc, .gitconfig, etc.

9. Searching for Files by Permission Settings

Find Files That Are World-Readable (`644`)

find /home -type f -perm 644

Find Files That Are Executable (`755`)

find /usr/bin -type f -perm 755

🔹 Why it's useful: Helps detect misconfigured permissions that could be security risks.

10. Finding Files Without a Certain Extension

Find All Files Except `.log`

find /var/log -type f -not -name "*.log"

🔹 Why it's useful: When you need to exclude certain file types from your search.

Final Thoughts: Stop Searching Manually

Mastering just a few find tricks will eliminate wasted time spent manually looking for files.

Quick Recap:

✅ Find files by name, type, and size

✅ Search by modification time to track changes

✅ Use -exec and -delete for batch processing

Want a Structured Bash Reference?

If you need a Easy to Read Bash guide with real-world scripts, check out my Bash Cheat Sheet:

👉 Download the Bash Cheat Book for just $3.99

What’s Inside?

✔️ Essential Bash commands for automation

✔️ File handling, process management, and troubleshooting tips

✔️ Formatted PDF for offline use

Discussion: What’s the Most Useful `find` Trick You Use?

Drop a comment below and share your best find command use case!

10 Bash Traps That Are Costing You Hours (And How to Fix Them)

Beta Shorts — Tue, 04 Mar 2025 11:27:14 +0000

A single missing space in a Bash script once cost me three hours of debugging. The worst part? The script looked fine at first glance.

Bash scripting is deceptively simple, but one small mistake can break everything. Worse, some of these issues fail silently, causing data loss, broken automation, or security risks.

This guide covers 10 Bash traps that cost people hours of frustration—and how to fix them instantly.

Need a quick-reference guide for Bash scripting?

👉 Get the Bash Cheat Book for $3.99

1. Not Quoting Variables (Silent Failures & Data Loss)

❌ The Problem

Leaving variables unquoted leads to unexpected word splitting, which can break commands without warning.

🚨 Example of a Bug

filename="my file.txt"
rm $filename  # ❌ Tries to delete 'my' and 'file.txt' separately

✅ The Fix

rm "$filename"  # ✅ Always quote variables

🔹 Why it matters: A missing quote in a rm command can delete the wrong files—or worse, everything in a directory.

2. Using `[` Instead of `[[` in Conditionals

❌ The Problem

Bash has two ways to write conditionals:

[ ... ] (old, POSIX-compliant but error-prone)
[[ ... ]] (newer, safer)

Using [ ... ] can cause unexpected bugs with spaces, regex, and logical operators.

🚨 Example of a Bug

file="myfile.txt"
if [ -f $file ]; then  # ❌ Breaks if $file is empty or contains spaces
    echo "File exists"
fi

✅ The Fix

if [[ -f "$file" ]]; then  # ✅ Safe syntax
    echo "File exists"
fi

🔹 Why it matters: [[ ... ]] prevents syntax errors and unexpected expansions.

3. Ignoring Exit Codes (`$?`) and Assuming Success

❌ The Problem

Bash does not stop execution on errors unless explicitly told to.

🚨 Example of a Bug

cp important_file /backup
echo "Backup complete"  # ❌ This prints even if `cp` fails

✅ The Fix

Use set -e to exit immediately on failure:

set -e
cp important_file /backup
echo "Backup complete"  # ✅ Runs only if `cp` succeeds

🔹 Alternative Fix: Manually check exit codes:

if cp important_file /backup; then
    echo "Backup successful"
else
    echo "Backup failed"
fi

🔹 Why it matters: Prevents silent failures that corrupt automation workflows.

4. Hardcoding `/bin/bash` Instead of `#!/usr/bin/env bash`

❌ The Problem

Not all systems have Bash at /bin/bash, leading to "command not found" errors.

🚨 Example of a Bug

#!/bin/bash
echo "Hello"

Fails if Bash is in /usr/local/bin/bash.

✅ The Fix

#!/usr/bin/env bash
echo "Hello"

🔹 Why it matters: This finds Bash dynamically, ensuring compatibility across Linux distros.

5. Using `cat file | grep` Instead of Just `grep`

❌ The Problem

Useless use of cat slows down processing.

🚨 Example of a Bug

cat file.txt | grep "error"  # ❌ Unnecessary `cat`

✅ The Fix

grep "error" file.txt  # ✅ More efficient

🔹 Why it matters: Speeds up command execution, especially in loops.

6. Running Scripts Without `chmod +x`

❌ The Problem

If a script lacks execute permissions, running ./script.sh fails.

✅ The Fix

chmod +x script.sh

Or run explicitly with Bash:

bash script.sh

🔹 Why it matters: Prevents "Permission denied" errors when running scripts.

7. Using `find -exec` Instead of `xargs` (Performance Issue)

❌ The Problem

Using find -exec spawns a new process for every file, slowing down execution.

🚨 Example of a Bug

find . -name "*.log" -exec rm {} \;  # ❌ Runs `rm` separately for each file

✅ The Fix

find . -name "*.log" | xargs rm  # ✅ Much faster

🔹 Alternative: Use -exec ... + (if supported):

find . -name "*.log" -exec rm {} +

🔹 Why it matters: Massively improves script performance.

8. Overwriting Files Without Warning (`>` Instead of `>>`)

❌ The Problem

Using > overwrites files without a prompt.

🚨 Example of a Bug

echo "New data" > important.txt  # ❌ Overwrites existing content

✅ The Fix

Use append (>>) or safe redirection (>|):

echo "New data" >> important.txt  # ✅ Appends instead of overwriting

🔹 Extra Safety: Enable no-clobber mode:

set -o noclobber

🔹 Why it matters: Prevents accidental data loss.

9. Using `echo` for Command Output Instead of `printf`

❌ The Problem

echo does not always handle special characters and escape sequences correctly.

🚨 Example of a Bug

echo "Column1\tColumn2"

This may not print a tab correctly in some shells.

✅ The Fix

printf "Column1\tColumn2\n"

🔹 Why it matters: printf ensures consistent output formatting.

10. Using `==` Instead of `=` in `sh` Scripts

❌ The Problem

Bash supports ==, but POSIX sh only supports =.

🚨 Example of a Bug

#!/bin/sh
if [ "$var" == "hello" ]; then  # ❌ Works in Bash, fails in POSIX sh
    echo "Match"
fi

✅ The Fix

if [ "$var" = "hello" ]; then  # ✅ Compatible with both Bash and sh
    echo "Match"
fi

🔹 Why it matters: Ensures portability across different shells.

Final Thoughts: Debug Bash Like a Pro

Fixing these 10 common Bash mistakes will save hours of debugging.

Want a Structured Bash Reference?

If you need a quick reference Bash cheat sheet with real-world scripts, check out my Bash Cheat Book:

👉 Download the Bash Cheat Book for just $3.99

What’s the worst Bash mistake you’ve ever made? Drop a comment below!

DEV Community: Beta Shorts

Building a Simple Terminal-Based File Manager in Bash

Understanding the Core of a Terminal File Manager

What It Should Do

Step 1: Listing Files and Directories

Step 2: Navigating Between Directories

Step 3: Deleting Files Safely

Step 4: Moving and Renaming Files

Step 5: Adding a Simple Menu Interface

Enhancing the File Manager

Final Thoughts: Build Your Own Bash Utility

Want a Quick Reference for Bash Basics?

Discussion: How Would You Improve This File Manager?

Building a System Information Fetch Tool in Bash

Step 1: The Basics (What We’re Fetching)

Step 2: Writing the Script (Fundamentals First)

Step 3: Formatting Output for Readability

Step 4: Running the Script

Step 5: Enhancing the Script

Final Thoughts

Want a Quick Reference for Bash Basics?

Discussion: What System Info Do You Track in Your Bash Scripts?

Create a Matrix Digital Rain Effect in Your Terminal with Bash

What We’re Building (Live Preview)

How the Matrix Effect Works in the Terminal

Step 1: Setting Up the Script

Step 2: Generate Falling Characters

Step 3: Make It Rain

Step 4: Restore the Cursor on Exit

Step 5: Running the Script

Tweaks & Customization

Next Steps: Expanding the Project

Final Thoughts

Want a Structured Bash Reference?

Discussion: What’s Your Favorite Bash Animation Trick?

How to Build a Snake Game in Bash (Yes, Really!)

Can You Really Code a Game in Bash?

Step 1: Setting Up the Game Grid

Basic Board Representation

Step 2: Moving the Snake

Step 3: Making the Snake Grow

Step 4: Collision Detection (Don’t Crash!)

Step 5: Adding Food and Score

Challenges and Enhancements

Is Bash the Best Choice for a Snake Game?

Final Thoughts: Can You Build Games in Bash?

What’s Inside?

Is Bash Scripting Essential for Bioinformatics? Practical Use Cases and Common Pitfalls

Why Bash Matters in Bioinformatics

Why It’s Useful

Real-World Bash Use Cases in Bioinformatics

1. Renaming Multiple FASTQ Files in Seconds

2. Filtering and Extracting Data from Large Files

3. Running the Same Command Across Multiple Samples

4. Submitting Batch Jobs to HPC Clusters

5. Avoiding Common Bash Pitfalls in Bioinformatics

❌ Mistake #1: Forgetting to Quote Variables

❌ Mistake #2: Using ls in a Loop (Bad Practice)

❌ Mistake #3: Running Heavy Workloads Without Parallelization

When to Use Bash vs. Python in Bioinformatics

Final Thoughts: Is Bash Essential for Bioinformatics?

Discussion: How Do You Use Bash in Your Bioinformatics Work?

Top 5 Bash Pitfalls That Newbies Keep Getting Wrong

1. Forgetting to Quote Variables (Breaks Scripts in Unexpected Ways)

The Problem

What Can Go Wrong?

The Fix

2. Using rm -rf * Without Thinking (A Disaster Waiting to Happen)

The Problem

What Can Go Wrong?

The Fix

3. Looping Over ls Output (Why This Breaks Scripts)

The Problem

What Can Go Wrong?

The Fix

4. Assuming [ and [[ Work the Same Way (They Don’t)

The Problem

What Can Go Wrong?

The Fix

5. Not Handling Errors Properly (set -e Can Save You Hours of Debugging)

❌ Mistake #2: Using `ls` in a Loop (Bad Practice)

**2. Using `rm -rf *` Without Thinking (A Disaster Waiting to Happen)**

3. Looping Over `ls` Output (Why This Breaks Scripts)

4. Assuming `[` and `[[` Work the Same Way (They Don’t)

5. Not Handling Errors Properly (`set -e` Can Save You Hours of Debugging)

Use `cron` to Schedule Your Scripts

✅ The Fix: Automate It with `find`

Use `curl` to Automate API Calls

Automate Web Scraping with `wget`

1. Rerun the Last Command Instantly (`!!`)

2. Edit and Reuse the Last Argument (`!$`)

3. Search Command History Like a Pro (`Ctrl + R`)

4. Move to the Beginning or End of a Command (`Ctrl + A / Ctrl + E`)

5. Delete a Whole Line (`Ctrl + U`)

6. Delete Everything After the Cursor (`Ctrl + K`)

7. Swap Two Characters (`Ctrl + T`)

8. Cancel a Running Command (`Ctrl + C`)

9. Suspend a Process (`Ctrl + Z`)

10. Run a Process in the Background (`&`)

11. Kill a Background Process (`jobs` + `kill %`)

12. Clear the Terminal (`Ctrl + L`)

13. Copy the Previous Command Without Running It (`!:`)

14. Replace Text in the Last Command (`^old^new`)

15. Scroll Through Past Commands (`Up` and `Down`)

16. Autocomplete File and Command Names (`Tab`)

17. Ignore Duplicate Commands in History (`HISTCONTROL`)

18. Repeat the First Argument of the Last Command (`!^`)

Use `cron` to Schedule Your Scripts