Linux Bash Shell — Tutorials

239Total chapters

35Modules

239Chapters live

35 / 35Active modules

Sequenced, not collected

Every concept arrives after its prerequisites. Streams before pipes, exit status before conditionals, variables before quoting, quoting and expansion before any script. A learner never meets a pipe without stdin and stdout, or a loop without knowing what expansion produced the list.

Two parts, one dependency chain

Part I is a complete Linux and Bash education that stands on its own for any learner — the shell's model, the filesystem, processes, expansion, scripting. Part II is the engineering continuation: it builds on Part I and deliberately never re-teaches it, applying the same quoting, status and process rules to RTL trees, EDA tools and regressions.

Automation that stays trustworthy

Defensive scripting is taught as a module, not a footnote — where set -euo pipefail helps and where it does not, cleanup that survives an interrupt, and the real behaviour of EDA tools that truncate logs, hang, lose licences and exit zero after a fatal error.

Linux & Bash Complete Curriculum

Your Learning Roadmap

239 chapters · 35 modules — two parts — Linux and Bash taught from zero, then the Linux and Bash a semiconductor engineer needs for repositories, EDA tools, logs and regressions.

239of 239 chapters live

100% complete

Part I — Linux & Bash Fundamentals

Linux and Bash taught from zero, with no semiconductor prerequisite: the shell's mental model, the filesystem and paths, files and directories, reading file contents, permissions and ownership, links, processes, jobs and signals, variables and command substitution, quoting and shell expansion, the environment and PATH, exit status and chaining, streams, redirection and pipes, text processing, searching by name and content, and Bash scripting through conditionals, loops, functions, arrays, defensive error handling and reusable tools.

Module 1

Linux, the Shell and the Command Line

1.1What Linux Is: Kernel, Userland and Distributions 1.2What a Shell Is, and Why Bash 1.3Terminal, Shell and Program: Three Things People Call the Terminal 1.4Your First Session: Where You Are, Who You Are, Which Machine 1.5Anatomy of a Command: Words, Options and Arguments 1.6Getting Help: man, help and --help 1.7Builtins, External Programs, and How Bash Decides 1.8History and Editing the Line You Are On

Module 2

The Filesystem and Paths

2.1One Tree: The Filesystem Hierarchy 2.2Absolute and Relative Paths 2.3The Working Directory, and the Shorthands . .. and ~2.4Moving Around: cd, pwd and ls 2.5Reading ls -l: What the Long Listing Tells You 2.6Hidden Files and the Meaning of the Dot

Module 3

Creating and Changing Files and Directories

3.1Creating Files and Directories 3.2Copying and Moving: cp, mv and What They Overwrite 3.3Deleting Things, and Why There Is No Undo 3.4File Names, Spaces and Characters That Need Care 3.5Wildcards: How the Shell Expands Names Before a Command Runs 3.6Archiving and Compressing: tar and gzip

Module 4

Reading and Inspecting File Contents

4.1cat, and When Not to Use It 4.2Paging Through a Large File with less 4.3The Beginning and End of a File: head and tail 4.4Following a File While It Is Still Being Written 4.5Counting Lines, Words and Bytes 4.6Comparing Two Files: diff and cmp 4.7What Kind of File Is This? Text, Binary and Line Endings

Module 5

Permissions, Ownership and Execution

5.1Users, Groups and Why Permissions Exist 5.2Reading and Writing a Permission String 5.3Changing Permissions with chmod 5.4Ownership and Shared Directories 5.5Making a Script Executable: the Execute Bit and the Shebang 5.6Default Permissions and umask

Module 6

Links and File Identity

6.1Names, Inodes and What a Directory Really Contains 6.2Hard Links 6.3Symbolic Links and the Ways They Break 6.4Following Links Deliberately: realpath, readlink, -L and -P

Module 7

Processes, Jobs and Signals

7.1What a Process Is 7.2Seeing What Is Running: ps and pgrep 7.3Live Load: Reading CPU and Memory 7.4Parent, Child and Inheritance 7.5Foreground, Background and Job Control 7.6Signals, and What Ctrl-C Actually Sends 7.7Ending a Process Properly: kill, and Why -9 Comes Last 7.8Work That Outlives the Terminal: nohup, setsid and tmux

Module 8

Variables, Command Substitution and Arithmetic

8.1Creating and Using a Shell Variable 8.2Expansion Forms: ${name}, Defaults and Length 8.3Trimming and Replacing Inside a Value 8.4Command Substitution: a Command's Output as a Value 8.5Arithmetic in Bash 8.6read: Taking a Value from Input

Module 9

Quoting and Shell Expansion

9.1The Expansion Pipeline: What Bash Does Before Running Anything 9.2Word Splitting, and Why an Unquoted Variable Is a Bug 9.3Double Quotes, Single Quotes and the Backslash 9.4Quoting Inside Quoting 9.5Brace and Tilde Expansion 9.6When Expansion Produces Nothing, or Too Much

Module 10

The Environment, PATH and Shell Startup

10.1The Environment: Variables a Program Inherits 10.2PATH: How the Shell Finds a Program 10.3Startup Files: Which One Actually Runs 10.4Sourcing vs Executing: Why ./setup.sh Does Nothing 10.5Aliases, Functions and Lookup Order 10.6Shell Options: set and shopt

Module 11

Exit Status and Command Chaining

11.1Every Command Returns a Number 11.2Running Commands in Sequence 11.3Conditional Chaining with && and ||11.4Grouping, Subshells and What Survives

Module 12

Streams, Redirection and Pipes

12.1Three Streams: stdin, stdout and stderr 12.2Redirecting Output to a File: > and >>12.3Redirecting Errors, and Combining Streams 12.4Redirecting Input, and Here Documents 12.5Pipes: One Program's Output as Another's Input 12.6tee: Saving a Stream While Still Watching It 12.7Discarding Output, and /dev/null 12.8The Exit Status of a Pipeline

Module 13

Text Processing on the Command Line

13.1Thinking in Lines and Fields 13.2Selecting Columns: cut and the Field Separator 13.3Sorting: Keys, Numeric Order and Stability 13.4Finding and Counting Duplicates: uniq 13.5Replacing and Squeezing Characters: tr 13.6Stream Editing with sed, One Substitution at a Time 13.7Field-Aware Processing with awk 13.8Joining and Reshaping: paste and join 13.9Building a Pipeline Incrementally

Module 14

Finding Files and Searching Their Contents

14.1grep: Searching Text for a Pattern 14.2Regular Expressions, from Literal to Pattern 14.3Basic vs Extended Regex, and grep -E 14.4Searching Recursively, and Excluding What You Did Not Mean 14.5Context, File Lists and Counts 14.6find: Locating Files by Name, Type, Time and Size 14.7Acting on What find Found: -exec, xargs and NUL Safety 14.8Choosing Between grep, find, sed and awk

Module 15

Writing and Running Bash Scripts

15.1From Command Line to Script 15.2The Shebang, and Which Interpreter Runs Your Script 15.3What a Script Inherits, and What It Cannot Change 15.4Positional Parameters: $1, $@, $# and shift 15.5Structure, Comments and a Script Someone Else Can Read 15.6What a Script Returns: exit and the Caller's Contract

Module 16

Conditionals and Pattern Branches

16.1if, elif, else, and What Bash Is Actually Testing 16.2test, [ and [[: Three Spellings, Different Rules 16.3String and Numeric Comparisons 16.4File Tests: Existence, Type, Readability and Age 16.5Combining Conditions, and Negation 16.6case: Branching on a Pattern 16.7Testing a Command Instead of a Value

Module 17

Loops and Iteration

17.1for: Iterating Over a List of Words 17.2Looping Over Files Safely 17.3C-Style for and Counting Loops 17.4while and until 17.5Reading a File Line by Line 17.6break, continue and Leaving a Loop Early 17.7The Subshell Trap: Why a Loop in a Pipeline Loses Its Variables

Module 18

Functions and Script Decomposition

18.1Defining and Calling a Function 18.2Arguments, and Why a Function Has Its Own $1 18.3return vs exit, and a Function's Status 18.4Getting a Value Out: Output vs Status 18.5local, Scope and Accidental Globals 18.6Splitting a Script, and Function Libraries You Source

Module 19

Arrays and Lists of Values

19.1Why a String Is Not a List 19.2Indexed Arrays: Creating, Reading, Appending 19.3"${array[@]}" vs "${array[*]}"19.4Building an Array from Command Output 19.5Arrays as Command Arguments 19.6Associative Arrays: Keys and Values

Module 20

Defensive Scripting: Failing Loudly and Cleaning Up

20.1Why Scripts Fail Silently 20.2set -e, set -u, set -o pipefail — and Their Limits 20.3Validating Inputs and Required Variables 20.4Guarding Destructive Commands 20.5trap: Cleanup That Runs Even on Failure 20.6Temporary Files Done Right: mktemp 20.7Messages, Logging and Which Stream They Belong On 20.8Debugging a Script: set -x, bash -n and PS4

Module 21

From Script to Reusable Tool

21.1Interface First: Arguments, Options and a Usage Message 21.2Option Parsing with getopts 21.3Configuration: Defaults, Environment and Flags 21.4Exit Codes as a Contract 21.5Idempotence and Dry Runs 21.6Portability: bash vs sh, GNU vs BSD 21.7shellcheck, and Reviewing Shell Code 21.8Testing a Shell Script

Part II — Linux & Bash for VLSI Engineering

The same Linux and Bash applied to semiconductor engineering work, building on Part I and never repeating it: the shared-compute environment, navigating RTL and verification repositories, searching design and log text, EDA environment and tool access, compile file lists, invoking simulators, run directories and artifacts, log and report investigation, running work on shared machines and schedulers, batch execution and seeds, regression automation end to end, debugging failed jobs, defensive automation around tools that fail quietly, and reusable flow tooling you can hand to someone else.

Module 22

The Engineering Linux Environment