Overcoming the Fear of Linux Link to heading

For many, the first impression of Linux is probably this: a screen full of terminal commands, reminiscent of the Matrix in The Matrix.

While the title suggests overcoming the fear of Linux, it’s really about embracing the convenience of the terminal. I’m not here to debate the pros and cons of operating systems. From a developer’s perspective, Unix-like systems make managing development tools via terminal commands much simpler. This is why many developers prefer Linux or macOS, as both are rooted in Unix-like systems.

What Is a Unix-like OS? Link to heading

We won’t dive deeply into the history of operating systems here. If you’re curious, consider exploring a computer science textbook. To put it simply (and not rigorously), a Unix-like OS is built on a kernel, which manages how the computer processes data—such as scheduling tasks, memory management, etc. Think of it as the software that directs the computer’s internal operations.

On top of the kernel, you’ll find utilities and applications like Google Chrome, Steam, or Firefox. At the outermost layer, there’s the interface, which can be either a Command Line Interface (CLI) or, as we’ll discuss in future posts, a Window Manager.

Getting Started with Linux Link to heading

How can you stop fearing the unknown? By playing with it. For your first experience with Linux, I recommend using a virtual machine (VM). If you mess up, simply create a new virtual space—no need to worry about formatting your computer.

Two beginner-friendly distributions are Ubuntu and Mint, both built on Linux. As a newbie, try experimenting with either of these. Different distributions (or “distros”) have their own strengths and weaknesses, such as performance and stability. Once you’re comfortable with basic commands, you can explore other distros.

Basic Terminal Commands Link to heading

Below are some foundational terminal commands. Should you memorise them? Not necessarily. With regular use, you’ll naturally remember them, as the logic behind the commands is quite intuitive if you’re familiar with English.

Change Directory (cd) Link to heading

The cd command allows you to change the current working directory in the terminal. Since it stands for change directory, it’s abbreviated as cd. In a Linux terminal, the home directory is represented by ~. The following command changes the current working directory to your home directory:

cd ~

In addition to ~, there are two special symbols:

​ 1. . (a single dot) represents the current directory.

​ 2. .. (two dots) represents the parent directory. To move up one level in the directory structure, you can use the following command:

cd ..

If you know the path to a directory, you can navigate to it directly by specifying the path after cd. For example:

cd /path/to/directory

List Files (ls) Link to heading

Once you’ve changed directories, you’ll likely want to see what’s inside. The ls command (short for list) displays the contents of the current directory:

ls

However, this command doesn’t show hidden files—those prefixed with a . (dot). To view all files, including hidden ones, use:

ls -a

Create Files and Directories Link to heading

Creating a Directory Link to heading

To create a directory, use the mkdir command (make directory). For instance, to create a directory called folder:

mkdir folder

Creating a File Link to heading

To create a file, use the touch command. While the connection between “touch” and file creation isn’t obvious, you can think of it as “touching” the filesystem to add a new file. Don’t forget to include a file extension (e.g., .txt). For example, to create a plain text file:

touch pure-text-file.txt

Delete Files and Directories Link to heading

Deleting an Empty Directory Link to heading

To delete an empty directory, use the rmdir command (remove directory). For example, to delete the previously created folder:

rmdir folder

Deleting a File Link to heading

To delete a file, use the rm command (remove), followed by the filename. For example:

rm pure-text-file.txt

Deleting Non-empty Directories Link to heading

To delete a directory and its contents, use the rm -ri command. The r flag enables recursive deletion (deleting all files and subdirectories), while the i flag prompts for confirmation before each deletion:

rm -ri folder/

Force Deletion (⚠️ Dangerous) Link to heading

The -f flag (force) allows deletion without any warnings. This can be extremely dangerous, so use it cautiously:

rm -rf folder/

⚠️ Warning:

Never run the following command, as it will delete the entire filesystem without any prompts:

rm -rf /

Summary Link to heading

This guide introduced basic commands for navigating, creating, and deleting files and directories in Linux. These commands have many additional options, which can be explored in separate articles.

In future posts, we’ll shift our focus to tools that empower developers, as commands are merely a medium for interaction. The true strength of Linux lies in its tools and flexibility.

Remember: The best way to overcome fear is through exploration. Get hands-on with Linux, and you’ll soon discover how powerful and efficient it can be!