First Contact: The Shell & Moving Around

If you've only ever used a computer by clicking, a screen of text with a blinking cursor can feel intimidating. It shouldn't — by the end of this paragraph you'll know exactly what you're looking at.

Two words, often used loosely, mean two different things:

• The terminal is the window — the frame that shows text and takes your keystrokes. (You'll also hear "console" or "command line" — same idea.)
• The shell is the program running inside that window. It reads the line you type, figures out what you meant, runs it, and shows you the result.

Think of it as a conversation. You say something (type a command and press Enter), the machine does it and replies, and then it shows a prompt — that little $-or-#-ended line that means "your turn." Say something, get a reply, repeat.

That loop — type → Enter → read — is the entire interaction model. It never gets more complicated than that. Starting a web server, hunting down an intruder, deploying an app to a thousand machines: all of it is this same small conversation, just with different sentences.

So why do professionals live here instead of clicking through menus? Three real reasons, not snobbery:

• It's everywhere. Most servers have no desktop at all — the shell is the only way in. Learn it once, use it on every Linux machine on Earth.
• It's automatable. Anything you can type, you can save into a script and have the machine do a thousand times, perfectly, while you sleep. You can't automate a mouse click nearly as well.
• It's faster. Once the basics are in your fingers, a three-word command beats a dozen clicks.

Here's a small idea that pays off forever: every command line you will ever type has the same three-part shape.

`

command -options arguments

`

• The command is the verb — the thing to do: ls (list), cd (change directory), cat (show a file).
• Options (also called flags) change how the verb behaves. They start with a dash: ls -l lists in a long, detailed form. You can think of them as settings on the verb.
• Arguments are what the verb acts on: ls /home lists a specific place.

Two rules the shell never bends. Spaces separate the parts — ls-l is a mystery word, ls -l is a command with an option. And capitalisation matters everywhere: ls is a command, LS is "command not found."

Here's the mental shift that makes the filesystem click: you are always standing somewhere in it. That spot is your working directory — in plain English, the folder you're currently "in." Commands act relative to where you're standing unless you tell them otherwise, so step one of not getting lost is always knowing your two basics:

• pwd — print working directory: where am I?
• ls — list: what's here?

ls on its own is useful; ls with a flag or two is where it earns its keep. These are the ones you'll reach for daily:

• ls -l — long detail (sizes, dates, owners)
• ls -a — all files, including hidden ones (names starting with .)
• ls -lh — long + human-readable sizes (4.0K instead of 4096)
• ls -lt — newest first (time-sorted) — perfect for "what changed most recently?"
• ls -S — biggest first (Size-sorted) — perfect for "what's eating the space?" (add -r to reverse either sort: ls -Sr is smallest first)
• ls -R — Recursive: this folder and everything inside it

Every file on a Linux machine lives in one single tree. Not "the C: drive and the D: drive" — one tree, and it starts at /, called the root of the filesystem. Everything branches out from there:

A path is simply directions to one spot in that tree. Read /var/log as "start at the root, into var, into log."

There are two ways to give directions, and you'll use both constantly:

• Absolute paths start at / and work from anywhere, because they always describe the full route from the top: /root/practice/attic.
• Relative paths start from wherever you're standing, so they're shorter but depend on your current location: practice/attic (from inside /root).

And four shorthands that appear everywhere — memorise these four and half of navigation is free:

| Symbol | Means |

|---|---|

| / | the very top of the tree (and the separator between path parts) |

| ~ | your home directory (/root for the root user) |

| . | the directory you're standing in right now |

| .. | the directory one level up (the parent) |

cd (change directory) is how you walk the tree. Every move you'll ever need is one of these:

• cd practice — step into a folder that's here (relative)
• cd /var/log — jump anywhere in one hop (absolute)
• cd .. — step one level up
• cd ~ — or just cd on its own — go home from anywhere
• cd - — bounce back to wherever you just were (brilliant for hopping between two spots)

Notice there's a rhythm to exploring any machine, and it's always the same loop: pwd (where am I?) → ls (what's here?) → cd somewhere → and repeat. When a lab says "go to X and do Y," that loop is literally how you get to X.

Four readers, four jobs — and picking the right one is the whole skill:

• cat file — pour the whole file onto the screen at once. Perfect for short files; chaos for a 50,000-line log.
• less file — page through a long file calmly: arrows or space to scroll, /word to search, q to quit. (You already know its controls — the man help pages open in less.)
• head -n 5 file — just the first 5 lines. Great for "what kind of file is this?"
• tail -n 5 file — just the last 5 lines. Great for "what happened most recently?" (Later you'll love tail -f, which follows a growing log live, line by line as it's written.)

And two small friends that round out the set: echo prints text back at you (echo hello → hello) — the backbone of scripting — and clear wipes a cluttered screen (nothing is lost; scroll up and it's all still there).

1. `Ctrl-C` cancels. Command stuck? Output flooding the screen? Press Ctrl-C — it interrupts whatever's running and hands the prompt back to you. It isn't rude or dangerous; it's how everyone stops a runaway command. (One exception: if you're trapped inside a pager like less or man, the key to escape is q, not Ctrl-C.)

2. `rm` is forever. There is no recycle bin in the terminal. rm file deletes it — permanently, silently, no "are you sure?". Until careful deletion is second nature, look before you delete: ls the target first so you know exactly what you're about to remove. The full deletion toolkit, including safety nets like rm -i (interactive, asks first), comes in the next module.

3. Your sandbox resets. Every Signal9 lab is a throwaway machine. Delete the wrong thing? Break the box beyond repair? Reset the lab and it comes back pristine. Mistakes here cost you nothing — that is the entire point of a sandbox. So explore hard, try the scary command, and learn by doing.

You have a real shell to the right — and a real sandbox that resets, so nothing you type here can do harm. Run this short tour end to end and watch how each command answers a question. This is the loop every lab expects of you, so a minute here pays off immediately.