DEV Community: Kengah Ireneaus

A Month With Bash — Part 3: Building Projects

Kengah Ireneaus — Tue, 04 Aug 2026 00:36:48 +0000

A Month With Bash — Part 3: Building Projects

After all the expansions and syntax, I moved on to regex in bash. It wasn't too hard since I'd already worked with regex in Python, but alongside it I learned grep, sed, and awk — tools that turned out to be extremely useful for automation.

I built a few mini projects and started automating some of my small day-to-day tasks. I won't go too deep into that here, but you can check out my learning-bash GitHub repo, which has all my learning scripts.

From there I covered conditionals, loops, and repetitive tasks.

Finally

I learned about array variables in bash and shell options,
went even further testing different ways of looping, and that's when I started actual project building(I am still building )

#!/usr/bin/env bash

## looping with range functions -- somehow

# python style looping {start..end}
for i in {1..10}; do    # this uses brace expansion so using vars wont work becase of execution sequencing
    echo $i
done

clear

## c - slyle looping 
for (( i = 0; i < 10; i++ )); do # variables works here well
    echo "hello $i"
done

## using variables to loop

clear
start=1
stop=10
step=2

for i in $(seq $start $stop); do # this uses the seq command
    echo "hello world"
done

Conclusion

Spending so much time on bash wasn't a waste. Not only did it force me to learn a huge number of commands, it changed how I think about my own machine — most of what I used to do manually, I can now automate. That shift alone made the month worth it.
i am still learning and trying to get the best practices and things not to do

THANK YOU FOR READING THIS FAR. That is a rough summary of me writing bash for a month there is really a lot left unsaid here but still building and learning. If you are just starting out with bash or if you haven't tried it hope this helps
feel free to drop questions advice and corrections

A Month With Bash — Part 2: Expansions

Kengah Ireneaus — Tue, 04 Aug 2026 00:26:00 +0000

A Month With Bash — Part 2: Expansions

Continuing from where I left off, the next thing I learned was special parameters in bash:

"$*"
$#
$?
$@
$N
$-
$0

Another important concept I picked up is how bash executes shell scripts. Bash is one of those languages that interprets each line as it goes — but it doesn't stop if a line fails. It continues on unless you explicitly set set -o pipefail (or -e, depending on what you want it to catch).

Generally, the procedure looks like this:

Tokenizing: splitting the line into tokens, usually split using the IFS value.

Brace expansion: a mechanism by which arbitrary strings can be generated.

echo file{1,2,3}.txt
## output: file1.txt file2.txt file3.txt

Bash preserves the order from left to right.

Tilde expansion: this is where expansion of special symbols takes place.

~ represents the HOME built-in variable
~+ represents PWD, the current working directory
and others

DIR=~/Desktop # this is $HOME/Desktop
echo "$DIR"

Parameter expansion: introduced with the $ symbol.

# ${} — the braces can be omitted for normal variables but not for array-type variables

Command substitution: very important — it lets you assign the output of a command to a variable, and use commands inside if and for statements. Done with $(command to execute).

week_name="$(date +%A)" # gets the current day of the week
echo "$week_name"

Generally, $() spawns a new shell instance, so it's advisable to avoid it where possible, for latency reasons.

Arithmetic expansion: just from the name, this allows evaluation of arithmetic expressions and substitution of the result. It starts with $(( expression )). There are some rules — bash doesn't support floating point arithmetic natively, so you'd reach for bc if you need it. I won't go deep into that here since this isn't a full bash tutorial.

Here's a simple BMI calculator I wrote while practicing this:

#!/usr/bin/env bash

# script calculates user's BMI and gives a recommendation

set -euo pipefail

# ---------------- read parameters ----------------
weight="$1"
height="$2"

bmi=$(bc -q <<< "scale=2; $weight / ($height^2)")

# ---------------- test ----------------
if (( $(bc -q <<< "$bmi < 18.5") )); then
    echo "UNDERWEIGHT"
elif (( $(bc -q <<< "$bmi < 25") )); then
    echo "normal weight"
elif (( $(bc -q <<< "$bmi < 30") )); then
    echo "overweight"
else
    echo "obese"
fi

Process substitution: this saves the output of a process into a temporary file-like descriptor under /dev/fd/N. It lets you feed command output into programs that expect a file as input. Done with >(command) and <(command).

#!/usr/bin/env bash

# script demonstrates process substitution
# process substitution is when you want to use the output of a command
# as the input to a command that needs files as parameters

set -euo pipefail

# gets the difference between two texts without making temp files
echo "$(diff -p <(echo "hello mr beast") <(echo "hello mr beast."))"

# note: <(cmd) uses the output of a command as a file
# >(cmd) takes input from a program and feeds it to the command as a file

Word splitting and globbing: occurs after expansion, only on unquoted values.

Next up: regex, grep/sed/awk, and moving into building actual projects.

A month with bash

Kengah Ireneaus — Mon, 03 Aug 2026 14:20:00 +0000

A Month With Bash

*this began as one long write-up but i decided to split it into three parts

A month ago I decided to learn bash so I could use my Fedora machine more effectively. My original plan was to just learn some commands and get over with it, but as I began reading resources and books, I quickly noticed how important it is for Linux users, automation experts, and system admins. The thing that amazed me most is that I could literally automate almost every repetitive process I do on my PC.

Getting Started

Starting off with bash wasn't really bad or difficult, maybe because I already had experience programming in C and Python. Learning the basic syntax of bash wasn't much of a problem — things like variables and printing to the terminal were quite easy to grasp. I also learned some theory on shell types and their differences, which wasn't too hard either.

# create, assign, and print a variable
my_var="declared"
echo "$my_var"

Moving Deeper Into Bash

After the basics, where bash just seemed like a small programming language, things changed once I started learning about the bash environment. This is what began to show me what makes it special and unique. I learned about:

Shell initialization scripts
- System-wide
- Individual user scripts
- How to configure them

Honestly, these files affect system behavior, so it's better to avoid touching them unless you know what you're doing. This part was quite confusing at first, but with practice it became clearer. I still don't fully understand every use case of these initialization scripts off-hand, and explaining them isn't the goal of this post.

After that I took some time to learn about reserved variables — just a curated table of them. They're very useful because they enable some handy functionality, and they're good to use when making a script portable. Some important ones:

HOME
IFS
PWD
PATH
DIRSTACK

location="$HOME" # this stores the location of the home directory
echo "$location"

Next up: special parameters, expansions, and how bash actually executes a script line by line.