Unix in 15 Minutes

There are only a few Unix commands that you will need to master to make it through COS 126. The following is a brief tutorial covering the most important ones.

What is Unix

Briefly, Unix is an operating system, which means it is a program that interacts with the hardware (such as processors, disks, keyboard, mouse) and manages their resources (such as keeping track of where a file is on a disk). The operating system you are most familiar is probably Windows. Just like Windows, Unix organizes the files you create and the application programs you will use. Unix works at a lower level than Windows. This means that you will have more control over the machine. The disadvantage is that it is less user-friendly.

Unix comes with thousands of commands, most of which you will not need to use in COS 126. After following this brief tutorial (about 15 minutes), you will be acquainted with enough Unix to get you through COS 126.

You enter Unix commands in a terminal window. The Unix prompt should look something like:

phoenix.Princeton.EDU%

This is where you type commands. The boldface type below (that follows the Unix prompt) is what you should type as you work through this tutorial.

Some Useful Commands

javac: To compile a Java program, we recommend using the javac command. Your program should compile without any errors or warnings (or if there are warnings be absolutely sure that they do not indicate a flaw in your program). Ultimately, we will compile the assignments you turn in with the same command, so it is to your advantage to use it.
```
phoenix.Princeton.EDU% javac HelloWorld.java
```
more: Display the contents of a file one screenful at a time.
```
phoenix.Princeton.EDU% more HelloWorld.java
```

Working with Files and Directories

Unix organizes files into a directory hierarchy. A directory can contain both files and other directories. They are completely analogous to folders in Windows.

pwd: It is frequently useful to know in which directory you are currently working. In order to find out, type pwd at the Unix prompt.
```
phoenix.Princeton.EDU% pwd
/n/homeserver0/user0i/wayne
```
If you've just logged in, you should see your login name at the end of the directory name. This is your home directory.
ls: To view the contents of a directory, type ls. This command will list all the files and directories within the current directory. It is analogous to clicking on a Windows folder to see what's inside.
```
phoenix.Princeton.EDU% ls
Mail          SunWS_config  autosave      HelloWorld.java       
public_html   readme
```
There are 6 items in this directory. Some of them are files, like HelloWorld.java. Others are directories, like public_html. If you want to know which of these items are files and which are directories, you can use the command ls -F. The -F is called a flag. Many Unix commands have such flags that give you precise control over their behavior, in this case appending the '/' character to items that are directories.
```
phoenix.Princeton.EDU% ls -F
Mail/          SunWS_config/  autosave/      HelloWorld.java        
public_html/   readme.txt
```
mkdir: To create a new directory, use the command mkdir. The following command creates a directory named hello, which you can use to to store all of your files associated with the Hello World assignment.
```
phoenix.Princeton.EDU% mkdir hello
```
To see that it actually worked, use the ls command.
```
phoenix.Princeton.EDU% ls -F
Mail/          SunWS_config/  autosave/      hello/         hello.c
public_html/   readme
```

mv: Now, move the two files HelloWorld.java and readme.txt into the hello directory using the mv command.

phoenix.Princeton.EDU% mv HelloWorld.java hello
phoenix.Princeton.EDU% mv readme.txt hello
phoenix.Princeton.EDU% ls -F
Mail/          SunWS_config/  autosave/      hello/         public_html/

The two files are no longer visible from the current directory.

cd: To access the two files, change directories with the cd command. To confirm the directory change, you could use the pwd and ls commands.

phoenix.Princeton.EDU% cd hello
phoenix.Princeton.EDU% pwd
/n/homeserver0/user0i/wayne/hello
phoenix.Princeton.EDU% ls
HelloWorld.java  readme.txt

cp: To make a copy of a file, use the cp command. The following command creates a backup copy of our HelloWorld.java program. This is especially useful when you modify a working program, but might want to revert back to the original version if your modifications don't succeed.
```
phoenix.Princeton.EDU% cp HelloWorld.java HelloWorld.bak
phoenix.Princeton.EDU% ls 
HelloWorld.bak  HelloWorld.java    readme.txt
```
rm: Subsequently, you might want to clean up useless files. The rm command deletes a file. By default, you will have to confirm that you really want to delete a file by typing yes or y. The reason for this is that, unlike with Windows, deleted files are really deleted when you delete them. There is no Recycle Bin to act as a safety net. So be careful. Files on arizona are backed up daily, so it may be possible to recover an essential file that you accidentally delete, but you will have to contact OIT to do so.
```
phoenix.Princeton.EDU% rm HelloWorld.bak
rm: remove HelloWorld.bak (yes/no)? y
phoenix.Princeton.EDU% ls 
HelloWorld.java  readme.txt
```
To return back to your home directory, use the cd command, but this time with no directory name.
```
phoenix.Princeton.EDU% cd
phoenix.Princeton.EDU% pwd
/n/homeserver0/user0i/wayne
```
wildcards: You can also apply the cp, rm, and mv commands to several files (or directories) at once. To create a new directory called loops, and copy all of the files in the directory /u/cos126/files/loops/ into this newly created directory type:
```
phoenix.Princeton.EDU% mkdir loops
phoenix.Princeton.EDU% cp /u/cos126/files/loops/* loops
```
Here the * matches all files in the cos126/files/mandel directory. It copies them to your newly created mandel directory.

Redirection

Two important abstractions in Unix are standard input and standard output. By default standard input is your keyboard, and standard output is your monitor. For example, in Assignment 1, we write a program CenterofMass.java that reads input using StdIn.java and writes output using System.out.println(). To run our program, the user types the command "java CenterofMass" and enters double type values in triplets (xposition, yposition and mass) from the keyboard. The results appear in the terminal window.

phoenix.Princeton.EDU% java CenterofMass
0 0 10
1 1 10
0.5  0.5  20

Redirecting standard input. As an alternative, we can have created a file that consists of the same six numbers. Using a text editor (like emacs), create a file named input.txt, and type in the six numbers. After saving the file, type the following command to verify that you entered the integers correctly:
```
phoenix.Princeton.EDU% more input.txt
0 0 10
1 1 10
```
Then to read the integers from the file instead of the keyboard, we use the redirection symbol "<".
```
phoenix.Princeton.EDU% java CenterofMass < input.txt
0.5  0.5  20
```
This produces exactly the same result as if the user had typed the numbers, except that the user has no opportunity to enter numbers from the keyboard. This is especially useful for two reasons. First, if there are lots of input values (there are over 700 inputs for Assignment 2) it would be tedious to retype them in each time we run our program. Second, it allows programs to be automated, without waiting for user interaction. This means that your grader can process your homework programs without typing in the input values by hand each time.
Redirecting standard output. Similarly it is possible to redirect the output to a file instead of to the screen. Continuing with the same example, if we want to save the output permanently, we can use the output redirection symbol '>'.
```
phoenix.Princeton.EDU% java CenterofMass > output.txt
0 0 10
1 1 10
```
The user still types in the input values from the keyboard, but instead of sending the output to the screen, it is sent to the file named output.txt. Note that all printf output is sent to the file, even the statement that tells the user what to do. Be careful, if the file output.txt already exists, it will be overwritten. (To append use '>>' instead.)
```
phoenix.Princeton.EDU% more output.txt
```
Redirecting standard input and standard output. It is often useful to use both redirection operations simultaneously.
```
phoenix.Princeton.EDU% java CenterofMass < input.txt > output2.txt
```
After executing this command, no output appears on the screen, but the file output2.txt now contains exactly the same data as output.txt above.

Piping

Another useful abstraction in Unix is piping. Piping is when the output of one program is used as the input of another program. For example, suppose we want to view the output of a program, but there is so much that it whizzes by on the screen too fast to read. (The program RandInts.java prints out a bunch of random integers.) One possible way to accomplish this is to type the following two commands.

phoenix.Princeton.EDU% java RandInts > temp.txt
phoenix.Princeton.EDU% more < temp.txt

Note that more will work by redirecting the file temp.txt to standard input (as is done here) or by simply using the filename (as is done at the beginning of the document). Instead, we could do this in one line using the pipe symbol '|'

phoenix.Princeton.EDU% java RandInts | more

This is often useful when debugging a program, especially if your program goes into an infinite loop and you want to see the first few values that it prints.

Written by Jake Brenner, Donna Gabai and Kevin Wayne.