Making the Transition to Linux

	Tip
	If you're using SSH,[2] you can skip to Section 1.4, “Shells, the shell prompt, and your home directory”. Recall that graphical applications are unavailable while you're using SSH, unless you're using X tunneling.[3]

Fundamentally, there are two different ways to work with the Linux operating system:

As suggested by the title, this guide focuses on the use of the CLI.

Discussion of GUIs is restricted to Section 1.2, “Graphical user interfaces (GUIs) for Linux”, Section 1.3, “Accessing the Linux CLI through a GUI's terminal window”, and Appendix B, Graphical alternatives.

If your primary use of Linux is not via an SSH connection,^[2] your first experience with Linux will probably be with a graphical user interface called a desktop environment,^[8] which is often used in place of the lower-level command line-based approach.

There are two particularly popular desktop environments for Linux:^[9]

As explained in the next section, even if you're using a GUI, you can still access the CLI.

When you're using a GUI (in our case, a desktop environment), you can access the CLI through a terminal window, or terminal.

The procedure for bringing up a terminal varies depending on which desktop environment you are using.^[10]

Once you open a terminal (or connect to a server via secure shell [SSH]),^[2] you type in commands to interact with a program known as a shell.^[11] Although GNU Bash (the Bourne Again Shell) is the most popular shell for Linux, some Linux servers and the computers in some Linux computer labs use tcsh as the default shell.^[12] If you're interested in trying the Bash shell, see Section A.3.2, “Changing your shell temporarily to Bash”.

Once the shell starts up, you’ll see the shell prompt, which indicates that the shell is ready for you to type a command.

Here is the prompt that I see when I log in to the CEC's grid server: [jg18@grid ~]$

Thus, the format being used is: [username@host_machine current_directory]$

In addition, your current directory will initially be your home directory,^[13] as is indicated by the tilde (~) in the prompt above.^[14]

Before you start working with the Linux CLI, you should be aware of some important differences between Linux and operating systems with which you're more familiar.

Unlike Windows or Mac OS X, Linux has a case-sensitive file system. This means that home, Home, and HOME would all be names for different directories. Similarly, as you will see in Section 3.2, “Navigating the file system”, you type cd to change directories: typing CD or Cd instead will not work.

When you're working with the CLI, you’ll soon discover what Eric Raymond calls the “Rule of Silence: When a program has nothing surprising to say, it should say nothing.”^[15] When a command finishes running (say, if you create a directory foo using mkdir), there will be no confirmation message of something like

directory ‘foo’ created

Rather, there will only be a message if there’s a problem, as in

mkdir: cannot create directory `foo': File exists

Although you might use spaces in file and directory names in Windows or Mac OS X (such as Paper due tomorrow.doc), don't use spaces in file or directory names in Linux. Use underscores (the _ character, usually on the same key as -) in a file or directory name (such as Paper_due_tomorrow.doc) instead of spaces. In fact, it's best if the only characters that you use in file and directory names are letters, numbers, hyphens (-), underscores (_), and periods (.), although you shouldn't start a file or directory name with a period, since, as noted in Section 3.2, “Navigating the file system”, doing so makes the file or directory hidden.

When you use a command that would make some permanent change in the file system (such as deleting files or renaming a file such that it would replace a pre-existing file), the system will not ask you

Are you sure?

You will only be prompted for confirmation if you explicitly ask for it, such as by using the -i command option that is mentioned in Table 3.3, “Commands for manipulating the file system”.

Similarly, the Linux CLI has no Trash or Recycle Bin for files that you decide to delete but might want to restore later. Deleted files are simply deleted.

Throughout this guide are tables summarizing many of the most commonly used Linux commands and command options. Most table entries, like the one in the example below, follow a format similar to that used by Linux's built-in manual pages.^[16] Some table entries, such as those found in Section 5.2, “GNU Emacs”, use a different format, although the differences are explained where relevant.

Since most commands have many options available, only a few options will be listed. To view all options for a given command, check the command's manual page.^[16] Square brackets (that is, []) around an item indicate that it's an optional argument for the command.

You can start learning about the man pages by typing man intro or man man at the shell prompt.^[18] The man pages’ help (which you can find by typing h while reading a man page) will give you the full list of navigation commands, but to start, you can scroll along a man page using b for back, f for forward, < to jump to the start of the man page, and > to jump to the end, typing q to quit. It is always worth checking the man pages when you are faced with an unfamiliar command or when you want to learn more about a command that you already know.

As mentioned in Section A.2.1, “General Linux resources”, a list of Web-based repositories of Linux manual pages can be found in the Wikipedia article on Unix manual pages.

Info pages, which are another component of the built-in help system, are available for many software products from the GNU Project.^[19] To get started, try typing info or info info or info some_program (such as info gcc) at the prompt. The navigation commands are different from those for the man pages: ? provides a list of commands and h starts a tutorial (but q still quits). It is worth checking the info pages for information on specific GNU programs.^[20] You can also find the built-in documentation for the GNU C library (or glibc) by typing info libc at the prompt.^[21]

There are several useful features of the shell:

In addition to the features listed above, GNU Bash (the Bourne-Again Shell) has other features^[26] that you can learn about from the resources listed in Section A.3.1, “General information on the Bash shell” and the sections that follow.

You can find your way around the Linux file system using the commands listed in Table 3.1, “Commands for navigating the file system” and the symbols listed in Table 3.2, “Common symbols from the file system”. Note that ls will not display hidden files or directories (whose names start with a period, such as .history) unless you include the -a option by typing ls -a at the prompt.

The command find is particularly powerful, although I think that the example below illustrates the most common use you'll have for it. To learn about all that find can do, consult man find.

While being able to examine the file system is important, you'll also need to be able to make changes to it, by creating, copying, moving, and removing files and directories, as well as making symbolic links. Relevant commands can be found in Table 3.3, “Commands for manipulating the file system”. Note that mv can be used either to rename a file/directory or to move it, depending on the arguments passed to mv.

Caution

If mv is used to move a file to a place where a file with the name already exists or to rename a file such that a file with the new name already exists in that directory, the old file will be silently replaced, unless you specify the -i option when using mv (see Table 3.3, “Commands for manipulating the file system”). Similarly, cp can silently replace files in the copying process. As with mv, you can specify the -i option to prevent cp from overwriting files.

	Caution
	Although you can use rm with the wildcard (*) to quickly and easily remove files and directories, be careful: you can easily delete files that you did not mean to delete, and those deleted files cannot be recovered. This issue is particularly important when you are using the -rf option.

The tar utility (tar is short for tape archive) allows you to compress files and directories into a single file called a tarball. Note that compressing, listing, and extracting all use the same command (tar), but the options used differ depending on which action you wish to perform.

Like with all commands, you can find more information by checking man tar, but since the version of tar used on Linux is a GNU product, you can also find information by typing info tar.

	Caution
	As with the commands mv and cp from Section 3.3, “Manipulating the file system”, if you direct the I/O redirection operator > to a pre-existing file, that file will be silently replaced (overwritten). Thus you must be careful when selecting the name of the file to which > will direct its output.

The Linux CLI depends on programs communicating with each other (and with the user) through text streams,^[31] including through the commands that you type at the keyboard (called the standard input stream, or stdin) and the results or errors displayed on the terminal screen (called the standard output and standard error streams, or stdout and stderr). As such, you may benefit from having some ability to work with text streams.

The command grep and its variants (such as egrep) are particularly powerful and complex commands, since they're designed to search for textual patterns called regular expressions.^[32] Thus, consulting man grep and info grep, possibly in addition to checking sources such as those mentioned in Section A.1, “Suggested resources for finding information” for information on grep, is highly recommended.

More information on text processing with the shell can be found in Section A.3.3, “Text processing with the shell”.

More information on I/O redirection can be found in Barr, CLI for Noobies, Chapter 5 ("Everything's a File") and Garrels, Introduction to Linux, Chapter 5 ("I/O redirection").

Since it's now easy to open multiple terminals in either KDE or GNOME, job control (that is, handling multiple programs running simultaneously while being able to switch between them) is not as important as it used to be, when one terminal was all that was available. Thus, I will only cover how to kill (that is, terminate) a process (that is, a running program).

More information on processes and job control can be found in Barr, CLI for Noobies, Chapter 10 ("background, foreground, suspend"), and Garrels, Introduction to Linux, Chapter 4 ("Processes"), particularly Section 1 ("Processes Inside Out").

  PID TTY          TIME CMD
21947 ?        00:00:00 sshd
21948 pts/6    00:00:00 tcsh
23482 pts/6    00:00:00 vim
23484 pts/6    00:00:00 ps
        

[1]    Killed                        vim
        

	Note
	Substantial revisions to this section, including new tables of commands, are in the works. Stay tuned.

Vi (pronounced VEE-EYE)^[38] “was the first real screen-based editor for Unix systems.”^[39] It is present on all Unix and Unix-like operating systems (including Linux). Another frequently used text editor, GNU Emacs (discussed in Section 5.2, “GNU Emacs”), is usually (but not always) installed as well. You can start vi by typing vi or vi file_to_edit (such as vi lab0.c) at the prompt.

Unfortunately, I am not familiar with vi, so I cannot provide much help with using it. If you are interested in using vi, try typing :help^[40] when you are in vi to access its built-in help. You can also start a tutorial by typing vimtutor at the shell prompt. The most valuable command in any text editor is quitting without saving any changes, which is :q!^[40] in vi.

References to further reading on vi can be found in Section A.4.1, “More on vi”.

Described as “a complete working environment,” GNU Emacs has all of the functionality that you could ever want from a text editor.^[41] It is also, in my opinion, considerably easier to use than vi. You may wish to try both vi and Emacs and see which one you prefer. You can start Emacs by typing emacs or emacs file_to_edit (such as emacs lab0.c) at the prompt.

Emacs makes frequent use of the Control (Ctrl) and Meta keys, but don’t bother looking for the Meta key on your keyboard: I don’t know of any modern keyboards that have one. Instead, the Escape (Esc) key functions as the Meta key. In most configurations of Emacs, the Alt key also works as a Meta key. To type a command such as C-x C-c, press Ctrl and X, let go of the Ctrl and X keys, then press Ctrl and C.

Instead of working directly with files, when you use Emacs, you work with temporary buffers that affect the file on disk only when you save the buffer. When you create a file with C-x C-f, that file isn't saved to disk (that is, actually created) until you make a change in the initially blank buffer and then save it with C-x C-s.

Any text that you cut, copy, or delete (using the commands in Table 5.3, “Manipulating text in Emacs” below) is moved to the kill ring, where Emacs stores such text until you paste it (or yank it, as it is also called) using C-y. Do not confuse the kill ring with the clipboard that exists in Windows or in Mac OS X: text in the kill ring can only be used within Emacs. Graphical versions of Emacs, however, provide mechanisms for working with the system clipboard via the pull-down menu.

The C-u shortcut allows you to repeat a command for a given number of times. For example, to scroll down to the 50th line of a buffer when the cursor is initially at the top of the buffer, type C-u 5 0 C-n (without pressing Enter).

If you accidentally type the start of some command in Emacs, you can use the C-g shortcut to discard the partially typed command. C-g can also be used to interrupt a running Emacs command.^[42]

You can use M-x to type in longer commands. For example, to switch into C++ editing mode, type M-x c++-mode and then press Enter. As with the shell, however, you can use Tab completion by typing M-x c+ and then pressing the Tab key. You can also use Tab completion with file names when you are trying to open files with C-x C-f.

References to further reading on Emacs can be found in Section A.4.2, “More on GNU Emacs”.

Programmers using Linux compile programs with the GNU Compiler Collection (GCC), a “compiler driver that invokes the language preprocessor, compiler, assembler, and linker, as needed on behalf of the user.”^[43] A list of commonly used compiler flags (which are options to adjust the compiler’s behavior) is provided in Table 6.1, “Commonly used GCC flags”. For a listing of all of the available flags, see man gcc or info gcc under the section "Invoking GCC."

To compile C source code or assembly programs with GCC, type: gcc [flags] file_list.

	Note
	When you are compiling C++ source code, type g++ in place of gcc.

If you don't specify a file name for the resulting executable file using the -o compiler flag, GCC will use the default name of a.out.

Although you can use GCC directly to compile your programs, programmers typically use other software, such as GNU Make, for automating the build process. A discussion of Make is beyond the scope of this guide, but references to more information on Make are provided in Section A.5.3, “GNU Make and Makefiles”.

References to further reading on GCC can be found in Section A.5.2, “More on GCC”.

If you try to run your compiled program (which we’ll call lab0) by typing lab0 at the prompt, you’ll receive this message:

lab0: Command not found.

When you type a command at the prompt, the shell checks all directories listed in the PATH environment variable (which you can view by typing echo $PATH) to see if it is present there. If the shell can’t find it, it will print the message listed above.

By default, the current directory (.) is not included in the PATH, and although you can add it,^[44] it is much easier (and strongly recommended) to simply type ./lab0 at the prompt instead,^[45] specifying that the shell should check the current directory for lab0.

	Note
	To use the GNU Debugger (GDB) effectively, you need to direct the compiler to include debugging information when it compiles your program. You can do this by using either the -g or the -ggdb compiler flag, as mentioned in Table 6.1, “Commonly used GCC flags”.

To debug a program using the GNU Debugger (GDB), type gdb program_to_debug (such as gdb lab2) at the prompt. You can then use GDB’s commands, some of which are listed in Table 6.2, “Commonly used GDB commands, Part 1” and Table 6.3, “Commonly used GDB commands, Part 2” below, to debug your program. GDB has many more commands than what is listed here; consult GDB’s built-in help for a complete listing. Also note that many commands have shortened versions: for example, you can type r in place of run. As with the shell (discussed in Section 3.1, “Features of the shell”), command history and command completion are available.

Finally, the command x/ (listing the contents of memory) is a particularly powerful command, but it's a fairly complex one, and describing it in detail is beyond the scope of this guide. Therefore, consulting help x while in GDB is recommended.

References to further reading on GDB can be found in Section A.5.4, “More on GDB”.

You can inspect and modify object files (including executables) using the GNU Binary Utilities (binutils), a set of tools that also includes the GNU assembler (as) and linker (ld).

References to further reading on binutils can be found in Section A.5.5, “More on the GNU Binary Utilities (binutils)”.