Course Content
🗓️ Day 1 – Getting Started with Linux
• Understand what Linux is and why it’s essential for DevOps and AI. • Learn basic terminal commands: pwd, ls, cd. • Explore the filesystem hierarchy and directory structure. • Practice moving around the shell confidently.
0/6
Introduction to Linux
The Terminal & The Shell
Navigating the Filesystem
Absolute vs. Relative Paths
Hands‑On Lab & Challenge
Wrap‑Up & Next Steps
🗓️ Day 2 – Working with Files and Directories
• Create, view, and edit files using touch, cat, nano. • Organize directories with mkdir, rmdir, cp, mv. • Understand absolute vs. relative paths. • Hands‑on: build a mini project folder structure.
0/6
Introduction to Files and Directories
Creating and Viewing Files
Viewing File Contents in Detail
Directory Operations
Hands‑On Lab
Wrap‑Up & Challenge
🗓️ Day 3 – Permissions and Ownership
• Learn how Linux manages read, write, and execute permissions. • Commands: chmod, chown, chgrp. • Understand user roles (root, user, group). • Practice fixing permission errors and securing files.
0/6
Introduction to Permissions
Understanding Users and Groups
Changing Permissions
Changing Ownership
Hands‑On Lab
Wrap‑Up & Challenge
🗓️ Day 4 – Processes and Services
• Understand what processes are and how to monitor them. • Commands: ps, top, kill, systemctl. • Learn how services start, stop, and restart. • Hands‑on: manage a simple service like nginx or ssh.
0/6
Introduction to Processes
Monitoring Processes
Managing Processes
Services and Systemctl
Hands‑On Lab
Wrap‑Up & Challenge
🗓️ Day 5 – Networking and Remote Access
• Basics of IP addresses, ports, and protocols. • Commands: ping, ip, ssh, scp. • Learn secure remote connections and file transfers. • Practice connecting to a remote server.
0/6
Introduction to Networking Basics
Checking Connectivity
Secure Remote Connections
File Transfers with SCP
Hands‑On Lab
Wrap‑Up & Challenge
🗓️ Day 6 – Shell Scripting Essentials
• Introduction to shell scripting and variables. • Write simple scripts using echo, loops, and conditionals. • Learn how to make scripts executable. • Hands‑on: automate a daily task (e.g., backup or log cleanup).
0/6
Introduction to Shell Scripting
Variables and Basic Commands
Conditionals and Loops
Making Scripts Executable
Hands‑On Lab
Wrap‑Up & Challenge
Introduction to the Linux Terminal

Day 1: The Anatomy of the Command Line

Welcome to your first active day of the Linux Prelude. Before we start typing commands into the DigiSpidey Linux Simulator, we need to understand exactly what we are interacting with.

Many beginners use the terms “Terminal” and “Shell” interchangeably, but they are actually two completely different things. Understanding the difference is the first step to mastering the command line.

1. The Terminal vs. The Shell

Think of driving a car. You interact with the steering wheel, the pedals, and the dashboard. But those components don’t actually move the car—they just send your instructions to the engine.

  • The Terminal (The Steering Wheel): The terminal is simply the text-based window you open on your screen. It is an interface. Its only job is to capture the keystrokes you type and display the text that comes back.

  • The Shell (The Engine): The shell is the actual program running behind the scenes (the most common one is called Bash). When you press “Enter” in the terminal, the terminal hands your text to the shell. The shell translates your text into machine instructions, commands the operating system to execute them, and then hands the text output back to the terminal for you to read.

When you use the simulator today, the black box on your screen is the Terminal. The invisible translator processing your commands is the Shell.

2. The Command Structure: The Formula of Linux

Unlike human languages, the Linux shell is incredibly rigid. It expects you to speak to it using a very specific formula. If you memorize this three-part formula, you can learn any command in the world:

Command [Options] [Arguments]

Let’s break down what each piece means using grammatical terms:

  • The Command (The Verb): This is the action you want to perform. It is always the very first word you type. Examples: ls (list), mkdir (make directory), rm (remove).

  • The Options (The Adverbs): These modify how the action is performed. They almost always start with a single hyphen (-) or a double hyphen (--). You can think of them as toggles or switches. You can often combine them (e.g., -l and -a becomes -la).

  • The Arguments (The Nouns): This is the target of your action. It tells the command what to operate on. This is usually a file name, a directory path, or a network address.

3. Example Breakdown: ls -l

Let’s look at one of the most common commands you will use: ls -l /etc

If we apply our formula to this text, here is how the Shell reads it:

  1. ls (Command): The shell reads the verb. It knows you want to “List” the contents of a directory.

  2. -l (Option): The shell sees the hyphen and knows this is a modifier flag. The l stands for “long format.” Instead of just spitting out the names of the files, it knows you want a detailed list showing file sizes, permissions, and creation dates.

  3. /etc (Argument): The shell reads the target. It knows exactly where it should go to generate this detailed list.

Plain English Translation: “List the contents of the /etc directory, and format the output as a long, detailed table.”

Previous
Next