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 Linux:

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,^[7] which is often used in place of the lower-level command line-based approach.

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

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.^[9]

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.^[10] 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.^[11] To learn more about which shell you're using and about how to switch to Bash if it isn't your default 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 after I log in to Washington University Engineering'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,^[12] as is indicated by the tilde (~) in the prompt above.^[13]

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'll learn 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.”^[14] 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 simply execute your command without asking you for confirmation. 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 and can't be recovered.

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.^[15] 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.^[15] 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.^[17] 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 than 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.^[18] 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.^[19] You can also find the built-in documentation for the GNU C library (or glibc) by typing info libc at the prompt.^[20]

There are several useful features of the shell:

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

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.

Tarballs are typically compressed using GNU zip, or gzip, resulting in their file extension of .tar.gz or .tgz. However, some tarballs are created with the newer bzip2 compression, which results in a smaller file size. Their file extension then becomes .tar.bz2 or .tbz. The commands in the table below use gzip. If you'd prefer to use bzip2, you can use the commands below, replacing z with j among the command options (so that, for example, -czf becomes -cjf) and replacing .tar.gz with .tar.bz2.

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,^[29] 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.^[30] 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”).

	Note
	This is a new section and is still under development.

TODO groups, chmod, chgrp, chown, rwx, etc. Examples!

Note

Since job control is an important component of making effective use of the Linux CLI over SSH, this section is undergoing revisions to better accommodate the needs of SSH users. If you absolutely require authoritative information on job control at this time, or if you need to know more than just how to kill a process, I suggest that you try Machtelt Garrels's Introduction to Linux, specifically Section 1 (“Processes Inside Out”).

[will need rewrites!]For users who are using a computer, since it's easy to open multiple terminals, all the job control skills you really need are to terminate a process. For those using SSH, however, TODO

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
        

Caution

SCP is a powerful command: it allows you to easily and quickly send a file, directory, or set of files, but it doesn't prevent you from making such mistakes as sending files to (or receiving files from) the wrong location on the remote machine. It also does nothing to stop you from overwriting files (without notification that you're doing so, of course) if you specify the wrong path on the destination machine - the author managed to do this with his home page! If you use SCP with the -r option to recursively send a directory and all of its contents (including subdirectories), be aware that SCP will follow symbolic links (also called aliases or shortcuts; they are created in Linux using ln, as shown in Example 3.5, “Using ln”). Thus if there are symbolic links in the directory tree that you're sending, using -r could potentially cause you to send more data than you had intended.

If you want to transfer a single file (such as a tarball),^[36] a directory in its entirety, or all of the files (but not subdirectories) in a given directory, and if you know the exact path of the source and destination, you can use SCP (a secure version of cp^[34]) to transfer that file/directory or those files.

To upload a file from the current directory on your machine (say, a file called my_file) to your home directory^[12] on the server, type:

scp ./my_file your_username@server_name:

To download a file from the server (say, a file called my_file from the path ~/classes/cse332^[35]) to the current directory on your machine, type:

scp your_username@server_name:classes/cse332/my_file .

To upload a directory (including all of its subdirectories), type:

scp -r /path_to_source_directory/ your_username@server_name:path_to_destination

To download a directory (including all of its subdirectories), type:

scp -r your_username@server_name:path_to_source_directory /path_to_destination/

To upload a single directory's files (but not its subdirectories), type:

scp /path_to_source_directory/* your_username@server_name:path_to_destination

To download a single directory's files (but not its subdirectories), type:

scp your_username@server_name:path_to_source_directory/* /path_to_destination/

As opposed to SCP, which only allows for single-command transfers, SFTP provides the user with a simple interactive shell for transferring files between your machine and another computer (most likely a server). In addition to providing support for uploading and downloading files, the SFTP shell allows for limited navigation through and manipulation of the local and remote file systems.

Start SFTP by typing sftp username@server_name at the prompt, filling in the appropriate values for your username and the server's name. The commands that you'll most likely need are listed in Table 4.1, “SSH file transfer (SFTP) commands”.

	Note
	SFTP commands look a lot like those discussed in Section 3.2, “Navigating the file system” and Section 3.3, “Manipulating the file system”, but commands to be run on the local machine (the one in front of you) have an l prefix (such as lls), while commands to be run on the remote machine (the one you're connecting to) don't have an l prefix (such as ls).

As far as I can tell, command history and command completion (discussed in Section 3.1, “Features of the shell”) are not available in SFTP. In addition, you cannot transfer entire directories through SFTP; you must compress them first into a tarball^[36] and then transfer the tarball.

	Note
	This section is nearly finished but is still under development.

	Tip
	Only the commands that start with a colon (:) (which are from the ex line editor) require pressing Enter to be executed. All other commands in vi and Vim are executed immediately after they are entered. In addition, all vi and Vim commands are case-sensitive.

Vi (pronounced VEE-EYE)^[37] “was the first real screen-based editor for Unix systems.”^[38] 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.

Vi is closely connected to the even older line-based text editor ex, whose commands begin with a colon (:). [reference! Also something (very) short about age/origin of vi.] In fact, you can start either editor from the command line and can switch between the two while using them. As can be seen from the tables below, vi users must know a few essential ex commands. However, a thorough coverage of ex is beyond the scope of this guide.

Since the original vi was a closed-source project,^[39] developers created their own clones of vi, adding new features along the way. One of the most popular of these clones is Vim (short for vi improved), created by Bram Moolenaar. Vim seems to be the standard version of vi on Linux machines, although other vi clones, such as elvis and vile, exist. However, the rest of this section will focus exclusively on Vim. Although Vim has much in common with the original vi and with the various vi clones, there are differences among them, including incompatibilities between Vim and vi. This guide will not cover those distinctions; anyone who is interested can check the references listed in the further reading section.

Vim is a modal editor that fundamentally has two modes: a normal (or command) mode for entering commands and an insert mode for entering and editing text. By comparison, modeless editors such as Emacs are always in insert mode, so that the characters you type always appear as text on the screen. As listed in Table 5.10, “Other modes in Vim”, Vim also includes a replace mode, which differs from insert mode in that any characters typed will overwrite existing characters in the buffer, as well as three types of visual modes, which allow for selecting text for cutting or copying.

	Tip
	You can return to normal mode at any time by pressing the Escape key.

[TODO - Importance of normal/command mode, operators/commands and motions/text-objects, delete vs. change vs. yank (and put?), etc.]

When vi was invented, the H, J, K, and L keys doubled as arrow keys, since there was no separate set of arrow keys on the keyboard. Thus vi and its clones still use those keys as arrow keys in the format shown in Table 5.1, “The Arrow Keys in Vim” below. Although the now-standard arrow keys work in Vim as expected, you may wish to try using the HJKL keys in their place, as you may find it faster to use them rather than having to reach to the arrow keys to use them.

To type a command like C-r, press the R key while holding down the Ctrl/Control key.

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

Described as “a complete working environment,” GNU Emacs has all of the functionality that you could ever want from a text editor.^[40] 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.13, “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.^[41]

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.”^[42] 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,^[43] it is much easier (and strongly recommended) to simply type ./lab0 at the prompt instead,^[44] 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)”.

[TODO -]

[TODO -]