New content added weeklyLive

Master Bash Scripting with Adaptive AI.

Master Bash Scripting across 18 topics - Foundations, Intermediate, and Advanced - guided by Leyaa's adaptive intelligence.

3Parts

18Topics

147Patterns

35hEst. duration

Start Learning Free

Bash Scripting Course

3 - part learning journey

Foundations

6 topics · 52 patterns

Beginner

Intermediate

6 topics · 49 patterns

Intermediate

Advanced

6 topics · 46 patterns

Advanced

Begin Part 1: Foundations

✦ Course Structure

Your Bash Scripting Journey in 3 Parts

Each part builds on the last - a deliberate progression from beginner to advanced.

Beginner

Part 1: Foundations

Covers Bash Scripting Basics, Variables, User Input and 3 more topics.

6Topics

52Patterns

View topics

Intermediate

Part 2: Intermediate

Covers Functions, String Operations, Arrays and 3 more topics.

6Topics

49Patterns

View topics

Advanced

Part 3: Advanced

Covers Process and Job Control, Regular Expressions in Bash, Advanced Scripting Patterns and 3 more topics.

6Topics

46Patterns

View topics

Curriculum

Everything You'll Learn

Explore every topic and pattern in the course.

Bash Scripting

3 parts · 18 topics · 147 patterns

Part 1: Foundations6 topics · 52 patterns

Beginner

Bash Scripting Basics

8 patterns

Why Bash scripting automates Linux tasks

What a shell script is

Bash vs other shells (Zsh, Fish, sh)

Creating a script file (.sh)

Shebang line (#!/bin/bash)

Making scripts executable (chmod +x)

Running scripts

First Bash script

Variables

9 patterns

Why variables store and reuse data

Variable assignment (no spaces around =)

Accessing variables ($var and ${var})

String variables

Integer variables

Read-only variables (readonly)

Unsetting variables (unset)

Environment variables vs local variables

Special variables ($0, $1, $#, $@, $?, $$)

User Input

8 patterns

Why input makes scripts interactive

read command

Prompting with read -p

Silent input with read -s (passwords)

Reading into multiple variables

Default values for input

Command-line arguments ($1, $2, ...)

Shifting arguments (shift)

Quoting and Expansion

8 patterns

Why quoting rules prevent errors

Single quotes (literal strings)

Double quotes (variable expansion)

Backticks and $() for command substitution

Arithmetic expansion $(( ))

Brace expansion ({1..10})

Tilde expansion (~)

Escape characters (\)

Conditionals

10 patterns

Why conditionals branch script logic

if-then-fi structure

if-then-else

if-elif-else

test command and [ ] syntax

[[ ]] extended test

String comparisons (=, !=, -z, -n)

Integer comparisons (-eq, -ne, -gt, -lt, -ge, -le)

File test operators (-f, -d, -e, -r, -w, -x)

Logical operators (-a, -o, !)

Loops

9 patterns

Why loops repeat tasks efficiently

for loop (list-based)

for loop with range ({1..10})

Looping over files and directories

Infinite loops

Part 2: Intermediate6 topics · 49 patterns

Intermediate

Functions

8 patterns

Why functions organize reusable code

Function definition

Calling functions

Function arguments ($1, $2 inside function)

Return values (return and echo)

Local variables (local keyword)

Function libraries (sourcing scripts)

Recursive functions

String Operations

8 patterns

Why string manipulation is frequent

String length (${#var})

Substring extraction (${var:offset:length})

String replacement (${var/old/new})

String prefix removal (${var#pattern})

String suffix removal (${var%pattern})

Default values (${var:-default})

Uppercase and lowercase conversion

Arrays

8 patterns

Why arrays handle lists of data

Indexed array declaration

Accessing array elements

Array length

Iterating over arrays

Adding and removing elements

Associative arrays (declare -A)

Array slicing

Text Processing in Scripts

9 patterns

Why scripts often process text

grep in scripts

sed for substitution in scripts

awk field extraction in scripts

cut and paste

sort and uniq in pipelines

tr for character transformation

Here documents (<<EOF)

Here strings (<<<)

File Operations in Scripts

8 patterns

Why file I/O is core to scripting

Reading files line by line (while read)

Writing to files (echo, printf)

Appending to files (>>)

File existence checks

Temporary files (mktemp)

File descriptors and redirection

Processing CSV files

Error Handling

8 patterns

Why error handling prevents silent failures

Exit codes ($?)

Custom exit codes (exit N)

set -e for exit on error

set -u for undefined variable errors

set -o pipefail

trap for cleanup on exit

Error logging patterns

Part 3: Advanced6 topics · 46 patterns

Advanced

Process and Job Control

7 patterns

Why process control manages execution

Running commands in background (&)

wait for background processes

Process substitution (<() and >())

Subshells (command grouping)

Parallel execution patterns

Signal handling with trap

Regular Expressions in Bash

8 patterns

Why regex enables pattern matching

Basic regex in grep

Extended regex (grep -E)

Character classes ([a-z], [0-9])

Quantifiers (*, +, ?)

Anchors (^, $)

Regex in [[ ]] with =~

Capture groups in Bash

Advanced Scripting Patterns

8 patterns

Why patterns solve common automation needs

Option parsing with getopts

Long option parsing

Configuration file reading

Lock files for single instance

Logging framework

Color output (ANSI escape codes)

Progress indicators

System Administration Scripts

7 patterns

Why sysadmin scripts automate operations

Log rotation script

Backup automation script

Disk space monitoring script

Service health check script

User account management script

Report generation script

Networking Scripts

7 patterns

Why network scripts automate connectivity tasks

HTTP requests with curl in scripts

API interaction scripts

SSH automation

Port scanning basics

File download automation

Network monitoring script

Debugging and Best Practices

9 patterns

Why debugging saves hours

set -x for trace mode

Debugging with PS4

ShellCheck for static analysis

Script testing strategies

Portable scripting (POSIX compliance)

Style guide and conventions

Documentation with comments

Script security best practices

Why Leyaa

Not just a course. A learning intelligence.

Leyaa doesn't just deliver content - it understands where you are, what you need, and how to get you there fastest.

Adaptive Diagnostics

Leyaa identifies which of the 147 patterns you've mastered and which need work - before you waste time on what you already know.

Pattern-Level Precision

Every pattern gets a verdict - Learn, Practice, or Skip - so your study time goes exactly where it counts.

Intelligent Pacing

Leyaa reads your velocity across the whole course and adapts your focus list dynamically, keeping you in the optimal learning zone.

Before & After Visibility

Every assessment creates a snapshot. Retake anytime to see exactly how much you've grown - topic by topic, pattern by pattern.

Learner Autonomy

Leyaa recommends, never restricts. Override any suggestion and explore at your own pace - the system tracks everything regardless.

Clear Learning Path

Foundations → Intermediate → Advanced - a structured journey where each part sets you up perfectly for the next.

Bash Scripting

Ready to master Bash Scripting?
Start your journey today

Start your diagnostic now. Build mastery across all 18 topics in under 15 minutes.

18 Topics

147 Patterns

Personalized roadmap

Master Bash Scripting with Adaptive AI.

Your Bash Scripting Journey in 3 Parts

Everything You'll Learn

Bash Scripting

Not just a course. A learning intelligence.

Ready to master Bash Scripting?Start your journey today

Ready to master Bash Scripting?
Start your journey today