If you’re new to Linux, the terminal can feel like that one angry teacher from school.
One wrong key and you imagine the server catching fire.

This guide is for you if:

• You just got a Linux server (like an Ubuntu 22.04 box) and don’t know where to start.
• You’ve mostly lived in Windows/macOS and GUI land.
• You keep seeing people say “run this command” and you’re like… “where?”

Let’s walk through it step by step, slowly, and safely.

I’ll focus on the basics from the ground up: what a terminal is, what a shell is, how to open it, and how to actually run commands without panicking.

1. What the Terminal Actually Is (And What It Isn’t)

First, let’s clear up some naming confusion that trips a lot of beginners.
People often say “terminal”, “shell”, and “command line” like they’re the same thing.
They’re related, but they’re not identical.

Here’s the simple version:

• Terminal emulator: the program you open on your computer that gives you a text window.
• Shell: the program running inside that window that interprets your commands.
• Command line: the place where you type your commands (in the shell, inside the terminal).

You use a terminal emulator to talk to your shell, which talks to your Linux server’s operating system.

Most modern systems use a GUI for everyday stuff, so you open the terminal as a separate app.
If you’re managing a Linux server somewhere on the internet, the terminal is your main way in.

2. Choosing and Opening a Terminal Emulator

You don’t interact with the server directly.
You use a terminal emulator on your own machine to connect to it.

The source mentions some common free terminal emulators by operating system (it doesn’t list them all out, but we know they exist per-OS).
In practice, that looks like:

• On desktop OSes, you open the built-in or installed terminal emulator.
• That emulator window is where you’ll see a prompt and type commands.

Each terminal emulator has its own features.
But almost all modern ones support:

• Tabbed windows – so you can have multiple sessions in one window.
• Text highlighting – useful for copying commands or outputs.

For now, whichever terminal emulator you have is fine.
Your goal is just: get a black/white text window open where you can type.

3. Connecting to Your Linux Server (The Big First Step)

To really learn this stuff, you need an actual Linux server to poke at.
The source suggests using a Linux server and even mentions spinning one up via a DigitalOcean Droplet guide.

If you already have a Linux server:

1. Open your terminal emulator on your local machine.
2. Connect to the server using whatever method your provider gave you (usually SSH-based, even if the exact command isn’t shown in the source).

Once you log in successfully, you’ll land on the server’s command line.
This is where everything in this guide happens.

If you don’t have a server yet:

• Follow a guide like “How To Create A DigitalOcean Droplet” (as the source suggests) or set up any Linux server.
• The tutorial itself is written for Ubuntu 22.04, but the basic terminal ideas apply across most Linux distributions.

Safety note:
If this is a “real” server (production, client site, anything important), please:

• Make sure you have backups before trying unknown commands.
• Consider practicing on a test server first.

4. Meeting the Shell: Bash and Friends

Inside the terminal, after you log in, you’re actually talking to a shell.
The shell reads what you type, interprets it, and tells the OS what to do.

The tutorial mentions a few common shells:

• bash (Bourne-Again shell) – the one used in the tutorial and default on most distros like Ubuntu, Fedora, and RHEL.
• zsh (Z shell) – another popular shell with more features, but not the focus here.

The guide you’re reading (and the source material) assumes bash.
That’s what most servers ship with by default, especially Ubuntu 22.04.

All these shells have some common capabilities:

• Input and output redirection – sending command output to files or taking input from files.
• Variables – storing values like paths or configuration.
• Condition-testing – checking things like “if this is true, then do that” in scripts.

You don’t need to master these on day one.
But it helps to know the shell isn’t magic – it’s just a program that parses your text commands.

5. Your First Login: Message of the Day (MOTD)

When you first log in to a Linux server, you’ll usually see a wall of text.
That’s the Message of the Day (MOTD).

It’s typically some informational stuff:

• System or distribution details.
• Maybe some security notices or update reminders.
• Sometimes provider branding or links.

You don’t have to do anything with the MOTD.
Just scroll past it or let it scroll and watch for the prompt – that’s where your commands go.

The prompt usually looks something like:

• A username and hostname.
• Maybe a dollar sign $ or hash #.

Once you see the prompt, you’re ready to type.

6. Safely Running Commands for the First Time

This tutorial source mainly covers the idea of executing commands from the terminal, not a giant command list.
So let’s keep things simple and safe.

General rule:
If you don’t fully understand what a command does, don’t run it on a production server.
Practice on a test server where mistakes don’t hurt.

Here’s a safe way to get used to the terminal:

1. Read the prompt
2. You should see something like user@hostname:~$.

3. This means the shell is ready for input.

4. Type a simple command and press Enter

5. Example: whoami
6. This just shows which user you’re logged in as.

7. It doesn’t change your system.

8. Try another simple information command

9. Without adding new commands not mentioned in the source, focus on the concept: you type something, press Enter, and the shell interprets it.

10. The key idea: commands follow the pattern program name + options + arguments.

11. Use copy/paste carefully

12. Terminal emulators support text highlighting.

13. Be careful when copying commands from blogs or chats — always read them line by line.

14. If you see errors, don’t panic

15. Error messages just mean the shell didn’t like something.
16. Read them — they’re often surprisingly honest.

Safety habits from day one:

• Never run random commands you don’t understand, especially as a privileged user.
• Keep a notes file with commands you’ve used and what they do.
• If something “feels dangerous”, it probably is — check docs or search before pressing Enter.

7. Tabs, Copying Output, and Staying Organized

Your terminal emulator is more than just a dumb text box.
The source notes that modern terminal emulators support tabs and text highlighting.
Use those features to make life easier.

Here’s how to make things less chaotic:

1. Use tabs for different tasks
2. One tab for general exploration.
3. Another tab for any command where you’re following a guide.

4. This keeps you from mixing things up.

5. Highlight and copy output

6. When something goes wrong, highlight the error text in your terminal and paste it into your notes or a search engine.

7. This is how many of us learn — see error, copy error, search error.

8. Keep a running log

9. Copy commands and outputs into a text file.

10. Later, you’ll thank your past self when you need to repeat or undo something.

11. Avoid multitasking disasters

12. Label your tabs clearly, if your emulator supports it.
13. If not, pay attention to which server/host you’re on before running anything.

8. Safe Mindset for New Terminal Users

You don’t need to be scared of the terminal.
You just need a healthy respect for it.

From the source, the key idea is:

• The terminal and shell are the standard way to interact with a Linux server.
• If you plan to work with Linux servers, you will be using this a lot.

Good habits that keep you out of trouble:

• Practice on a non-critical server when learning.
• Think before hitting Enter.
• Read what the shell prints back — don’t just spam commands.

Over time, the terminal stops feeling like a monster and starts feeling like a power tool.
Like any power tool, it’s awesome once you understand what each control does.

9. What to Do Next

From this first introduction, you should now understand:

• What a terminal emulator is.
• What a shell is (specifically bash on Ubuntu 22.04 and many other distros).
• What happens when you log in and see the MOTD.
• The basics of typing and executing commands safely.

Your next steps could be:

• Get comfortable logging in and out of your server.
• Run simple, harmless commands just to observe behavior.
• Slowly build up from “read-only” commands to more powerful ones as you learn.

If this worked for you, keep CrushEdge handy for the next fix.