S X / Linux / Unix Command-Line in 15 Minutes

OS X / Linux / Unix Command-Line in 15 Minutes

This tutorial describes a few of the most important commands that you will use on the command-line (Linux, Unix, or OS X).

Some Useful Commands

javac: To compile a Java program from the command-line, use the javaccommand.
```
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.