(For more resources related to this topic, see here.)
Why should we use the terminal?
With Mint containing a complete suite of graphical tools, one may wonder why it is useful to learn and use the terminal at all. Depending on the type of user, learning how to execute commands in a terminal may or may not be beneficial. If you are a user who intends to use Linux only for basic purposes such as browsing the Internet, checking e-mails, playing games, editing documents, printing, watching videos, listening to music, and so on, terminal commands may not be a useful skill to learn as all of these activities (as well as others) are best handled by a graphical desktop environment.
However, the real value of the terminal in Linux comes with advanced administration. Some administrative activities are faster using shell commands than using the GUI. For example, if you wanted to edit the /etc/fstab file, it would take fewer steps to type sudo nano /etc/fstab than it would to open a file manager with root permissions, navigate to the /etc directory, find the fstab file, and click on it to open it. This is especially true if all you want to do is make a quick change. Similarly, typing sudo apt-get install geany may be faster if you already know the name of the package you want, compared to opening up Mint Software Manager, waiting for it to load, finding the geany package, and installing it. On older and slower systems, the overhead caused by graphical programs may delay execution time.
Another value in the Linux Shell is scripting. With a script, you can create a text file with a list of commands and instructions and execute all of the commands contained within a single execution. For example, you can create a list of packages that you would prefer to install on your system, type them out in a text file, and add your distribution package’s installation command at the beginning of the list. Now, you can install all of your favorite programs with a single command. If you save this script for later, you can execute it any time you reinstall Linux Mint so that you can immediately have access to all your favorite programs. If you are administering a server, you can create a script to check the overall health of the system at various times, check for security intrusions, or even configure servers to send you weekly reports on just about anything you’d like to keep yourself updated on. There are entire books dedicated to scripting, so we won’t go in detail about it in this article. However, by the end of the article, we will create a script to demonstrate how to do so.
Accessing the shell
When it comes to Linux, there is very rarely (if ever) a single way to do anything. Just like you have your pick between desktop environments, text editors, browsers, and just about anything else, you also have a choice when it comes to accessing a Linux terminal to execute shell commands. As a matter of fact, you even have a choice on which terminal emulator to use in order to interpret your commands.
Linux Mint comes bundled with an application called the GNOME Terminal. This application is actually developed for a completely different desktop environment (GNOME) but is included in Mint because the Mint developers did not create their own terminal emulator for Cinnamon. The GNOME Terminal did the job very well, so there was no need to reinvent the wheel. Once you open the GNOME Terminal, it is ready to do your bidding right away. The following screenshot shows the GNOME terminal, ready for action:
As mentioned earlier, there are other terminal emulators that are available. One of the popular terminal emulators is Konsole. It typically comes bundled with Linux distributions, which feature the KDE environment (such as Mint’s own KDE edition). In addition, there is also the xfce4-terminal, which comes bundled with the Xfce environment. Although each terminal emulator is generally geared toward the desktop environment that features it, there’s nothing stopping you from installing them if you find that GNOME Terminal doesn’t suit your needs. However, each of the terminal emulators generally function in much the same way, and you may not notice much of a difference, especially when you’re starting out.
You may be wondering what exactly a terminal emulator is. A terminal emulator is a windowed application that runs in a graphical environment (such as Cinnamon in Mint) that provides you with a terminal window through which you can execute shell commands to interact with the system. In essence, a terminal emulator is emulating what a full-screen terminal may look like, but in an application window. Each terminal emulator in Linux gives you the ability to interact with that distribution’s chosen shell, and as each of the various terminal emulators interact with the same shell, you won’t notice anything unique about them regarding how commands are run. The differences between one terminal emulator and another are usually in the form of features in the graphical user interface, which surround the terminal window, such as being able to open new terminal windows in tabs instead of separate instances and even open transparent windows so that you can see what is behind your terminal window as you type.
While learning about Linux, you’ll often hear the term Bash when referring to the shell. Bash is a type of command interpreter that Linux uses; however, there are several others, including (but not limited to) the C shell, the Dash shell, and the Korn shell. When you interact with your Linux distribution through a terminal emulator, you are actually interacting with its shell. Bash itself is a successor to Bourne shell (originally created by Stephen Bourne) and is an acronym for “Bourne Again Shell.” All distributions virtually include Bash as their default shell; it’s the closest shell to a standard one in terms of shells that Linux has. As you start out on your Linux journey, Bash is the only shell you should concern yourself with and the only shell that will be covered in this article.
Scripts are generally written against the shell environment in which they are intended to run. This is why when you read about writing scripts in Linux, you’ll see them referred to as Bash Scripts as Bash is the target shell and pretty much the standard Linux shell.
In addition, terminal emulators aren’t the only way to access the Linux shell for entering commands. In fact, you don’t even need to install a terminal emulator. You can use TTY (Teletype) terminals, which are full-screen terminals available for your use, by simply pressing a combination of keys on your keyboard. When you switch to a TTY terminal, you are switching away from your desktop environment to a dedicated text-mode console. You can access a TTY terminal by pressing Alt + Ctrl and one of the function keys (F1 through F6) at the same time. To switch back to Cinnamon, press Alt + Ctrl + F8.
Not all distributions handle TTY terminals in the same way. For example, some start the desktop environment on TTY 7 (Alt + Ctrl + F7), and others may have a different number of TTYs available. If you are using a different flavor of Mint and Alt + Ctrl + F8 doesn’t bring you back to your desktop environment, try Alt + Ctrl + F7 instead.
You should notice that the terminal number changes each time you switch between TTY terminals. For example, if you press Alt + Ctrl + F1, you should see a heading that looks similar to Linux Mint XX ReleaseName HostName tty1 (notice the tty number at the end). If you press Alt + Ctrl + F2, you’ll see a heading similar to Linux Mint XX ReleaseName HostName tty2.
You should notice right away that the TTY number corresponds to the function key you used to access it. The benefit of a TTY is that it is an environment separate from your desktop environment, where you can run commands and large jobs. You can have a separate command running in each TTY, each independent of the others, without occupying space in your desktop environment. However, not everyone will find TTYs useful. It all depends on your use case and personal preferences.
Regardless of how you access a terminal in Linux to practice entering your commands, all the examples in this article will work fine. In fact, it doesn’t even matter if you use the bundled GNOME Terminal or another terminal emulator. Feel free to play around as each of them handles commands in the same way and will work fine for the purposes of this article.
While utilizing the shell and entering commands, you will find yourself in a completely different world compared to your desktop environment. While using the shell, you’ll enter a command, wait for a confirmation that the command was successful (if applicable), and then you will be brought back to the prompt so that you can execute another command. In many cases, the shell simply returns to the prompt with no output. This constitutes a success. Be warned though; the Linux shell makes no assumptions. If you type something incorrectly, you will either see an error message or produce unexpected output. If you tell the shell to delete a file and you direct it to the wrong one, it typically won’t prompt for confirmation and will bypass the trash folder. The Linux Shell does exactly what you tell it to, not necessarily what you want it to. Don’t let that scare you though. The Linux Shell is very logical and easy to learn. However, with great power comes great responsibility.
To get started, open your terminal emulator. You can either open the GNOME Terminal (you will find it in the application menu under Accessories or pinned to the left pane of the application menu by default) or switch to a TTY by pressing Ctrl + Alt +F1.
You’ll see a prompt that will look similar to the following:
Let’s take a moment to examine the prompt. The first part of the prompt displays the username that the commands will be executed as. When you first open a terminal, it is opened under the user account that opened it. The second part of the prompt is the host name of the computer, which will be whatever you named it during the installation. Next, the path is displayed. In the preceding example, it’s simply a tilde (~). The ~ character in Linux represents the currently logged-in user’s home directory. Thus, in the preceding prompt, we can see that the current directory that the prompt is attached to is the user’s home directory. Finally, a dollar sign symbol ($) is displayed. This represents that the commands are to be run as a normal user and not as a root user.
For example, a user named C. Norris is using a machine named Neptune. This user opens a terminal and then switches to the /media directory. The prompt would then be similar to the following:
cnorris@neptune /media $
Now that we have an understanding of the prompt, let’s walk through some examples of entering some very basic commands, which are discussed in the following steps. Later in the article, we’ll go over more complete examples; however, for now, let’s take the terminal out for a spin.
Open a prompt, type pwd, and press Enter. The pwd command stands for print working directory. In the output, it should display the complete path that the terminal is attached to. If you ever lose your way, the pwd command will save the day. Notice that the command prints the working directly and completes it. This means that it returns you right back to the prompt, ready to accept another command.
Next, try the ls command. (That’s “L” and “S”, both lowercase). This stands for list storage. When you execute the ls command, you should see a list of the files saved in your current working directory. If there are no files in your working directory, you’ll see no output.
For a little bit of fun, try the following command:
cowsay Linux Mint is Awesome
This command shows that the Mint developers have a sense of humor and included the cowsay program in the default Mint installation. You can make the cow say anything you’d like, but be nice. The following screenshot shows the output of the preceding cowsay command, included in Mint for laughs:
Navigating the filesystem
Before we continue with more advanced terminal usage, it’s important to understand how the filesystem is laid out in Linux as well as how to navigate it. First, we must clarify what exactly is meant by the term “filesystem” as it can refer to different things depending on the context. If you recall, when you installed Linux Mint, you formatted one or more partitions with a filesystem, most likely ext4. In this context, we’re referring to the type of formatting applied to a hard-disk partition. There are many different filesystems available for formatting hard disk partitions, and this is true for all operating systems.
However, there is another meaning to “filesystem” with regards to Linux. In the context of this article, filesystem refers to the default system of directories (also known as folders) in a Linux installation and how to navigate from one folder to another. The filesystem in an installed Linux system includes many different folders, each with its own purpose. In order to understand how to navigate between directories in a Linux filesystem, you should first have a basic understanding of what the folders are for.
You can view the default directory structure in the Linux filesystem in one of the following two ways:
One way is to open the Nemo file manager and click on File System on the left-hand side of the window. This will open a view of the default folders in Linux, as shown in the following screenshot:
Additionally, you can execute the following command from your terminal emulator:
ls -l /
The following screenshot shows the output of the preceding command from the root of the filesystem:
The first point to understand, especially if you’re coming from Windows, is that there is no drive lettering in Linux. This means that there is no C drive for your operating system or D drive for your optical drive. The closest thing that the Linux filesystem has for a C: drive is a single forward slash, which represents the beginning of the filesystem. In Linux, everything is a subdirectory of /. When we executed the preceding command (ls -l /), we were telling the terminal emulator that we’d like a listing of / or the beginning of the drive. The -l flag tells the terminal emulator that we would like a long alphabetical listing rather than a horizontal one.
Paths are written as shown in the following command line example. In this example, the path references the Music directory under Joe’s home directory:
The first slash (/home) references the beginning of the filesystem. If a path in Linux is typed starting with a single forward slash, this means that the path starts with the beginning of the drive. In the preceding example, if we start at the beginning of the filesystem, we’ll see a directory there named home. Inside the home folder, we’ll see another directory named joe. Inside the joe directory, we’ll find another directory named Music.
The cd command is used to change the directory from the current working directory, to the one that we want to work with. Let’s demonstrate this with an example. First, let’s say that the prompt Joe sees in his terminal is the following:
joe@Mint ~ $
From this, we can deduce that the current working directory is Joe’s home directory. We know this because the ~ character is shorthand for the user’s home directory. Let’s assume that Joe types the following:?
Then, his output will be as follows:
In his case, ~ is the same as /home/joe.
Since Joe is currently in his home directory, he can see the contents of that directory by simply typing the following command:
The Music directory that Joe wants to access would be shown in the output as its path is /home/joe/Music.
To change the working directory of the terminal to /home/joe/Music, Joe can type the following:
His prompt will change to the following:
joe@Mint ~/Music $
However, the cd command does not make you type the full path. With the cd command, you can type an absolute or relative path. In the preceding command line using cd command, we referenced an absolute path. The absolute path is a path from the beginning of the disk (the single forward slash), and each directory from the beginning is completely typed out. In this example, it’s unnecessary to type the full path because Joe is already in his home directory. As Music is a subdirectory of the directory he’s already in, all he has to do is type the following command in order to get access to his Music directory:
That’s it. Without first typing a forward slash, the command interpreter understands that we are referencing a directory in the current working directory. If Joe was to use /Music as a path instead, this wouldn’t work because there is no Music directory at the top level of his hard drive.
If Joe wants to go back one level, he can enter the following command:
Typing the cd command along with two periods tells the command interpreter that we would like to move backwards to the level above the one where we currently are. In this case, the command would return Joe back to his home directory.
Finally, as if the difference between a filesystem in the context of hard drive formatting and filesystem in the context of directory structure wasn’t confusing enough, there is another key term you should know for use with Linux. This term also has multiple meanings that change depending on the context in which you use it. The word is root.
The user account named root is present on all Linux systems. The root account is the Alpha and Omega of the Linux system. The root user has the most permissions of any user on the system; root could even delete the entire filesystem and everything contained within it if necessary. Therefore, it’s generally discouraged to use the root account for fear of a typo destroying your entire system. However, in regards to this article, when we talk about root, we’re not talking about the root user account. There are actually two other meanings to the word root in Linux in regards to the filesystem.
First, you’ll often hear of someone referring to the root of the filesystem. They are referring to the single forward slash that represents the beginning of the filesystem. Second, there is a directory in the root of the filesystem named root. Its path is as follows:
Linux administrators will refer to that directory as “slash root”, indicating that it is a directory called root, and it is stored in the root (beginning) of the filesystem. So, what is the /root directory? The /root directory is the home directory for the root account. In this article, we have referred to the /home directory several times. In a Linux system, each user gets their own directory underneath /home. David’s home directory would be /home/david and Cindy’s home directory is likely to be /home/cindy. (Using lowercase for all user names is a common practice for Linux administrators). Notice, however, that there is no /home/root. The root account is special, and it does not have a home directory in /home as normal users would have. /root is basically the equivalent of a home directory for root. The /root directory is not accessible to ordinary users. For example, try the following command:
The ls command by itself displays the contents of the current working directory. However, if we pass a path to ls, we’re telling ls that we want to list the storage of a different directory. In the preceding command, we’re requesting to list the storage of the /root directory. Unfortunately, we can’t. The root account does not want its directories visible to mortal users. If you execute the command, it will give you an error message indicating that permission was denied.
Like many Ubuntu-based distributions, the root account in Mint is actually disabled. Even though it’s disabled, the /root directory still exists and the root account can be used but not directly logged in to. The takeaway is that you cannot actually log in as root.
So far, we’ve covered the /home and /root subdirectories of /, but what about the rest? This section of the article will be closed with a brief description of what each directory is used for. Don’t worry; you don’t have to memorize them all. Just use this section as reference.
/bin: This stores essential commands accessible to all users. The executables for commands such as ls are stored here.
/boot: This stores the configuration information for the boot loader as well as the initial ramdisk for the boot sequence.
/dev: This holds the location for devices to represent pieces of hardware, such as hard drives and sound cards.
/etc: This stores the configuration files used in the system. Examples include the configuration for Samba, which handles cross-platform networking, as well as the fstab file, which stores mount points for hard disks.
/home: As discussed earlier in the article, each user account gets its own directory underneath this directory for storing personal files.
/lib: This stores the libraries needed for other binaries.
/media: This directory serves as a place for removable media to be mounted. If you insert media (such as a flash drive), you’ll find it underneath this directory.
/mnt: This directory is used for manual mount points; /media is generally used instead, and this directory still exists as a holdover from the past.
/opt: Additional programs can be installed here.
/proc: Within /proc, you’ll find virtual files that represent processes and kernel data.
/root: This is the home directory for the root account.
/sbin: This consists of super user program binaries.
/tmp: This is a place for temporary files.
/usr: This is a directory where utilities and applications can be stored for use by all users, but it is not modified directly by users other than the root user.
/var: This is a directory where continually changing files, such as printer spools and logs, are stored.