Using a Command Line Interface
A CoS126
Introduction
Long ago, before operating systems with graphical user interfaces (GUIs), everyone used command line interfaces (CLIs). For example, instead of starting a program by clicking the icon for your program in the Launchpad or whatever new‐fangled mawhoozawhatzit, you instead typed the name of your program. And instead of clicking on menus in your program to adjust settings, open files, etc, you could specify these things as command line arguments.
In fact, expert computer users still use command prompts quite heavily. It’s an incredibly useful abstraction that you’re now going to begin making use of.
A specific instance of the command line interface is called a “terminal window” by Mac OS X (which utilizes a version of Unix under the hood), and the term “command prompt” is used by Windows. The terms are virtually interchangeable. We will use the term “command line interface” throughout this document.
Learning to fully utilize a command line interface is something that could (and does) fill an entire book. In this tutorial, we’ll address the key ideas, give a few examples, and leave you to learn the rest on your own as you choose.
The Basics – Opening the Command Line Interface
In Mac OS X, the terminal application can be found in Applications‐>Utilities>Terminal.
In Windows, it can be found in Programs‐>Accessories‐>Command Prompt.
Note, there are many other ways of accessing the command line interfaces. All of them are fine to use.
Prompt text
When you open your CLI, the first thing you’ll see is a prompt, i.e. a string of text that lets you know the computer is waiting for you, the user, to take action.
In Windows, the default prompt is the entire path to your present working directory (we’ll discuss what that means later) followed by a > sign. For example:
In Mac OS X, the default command prompt is your computer name, followed by the name of your present working directory, followed by your user name, followed by a $. For example:
Here, my computer is named Jorberts‐Macbook‐Air:, I am in the “~” directory [more on this later], my user name is jug, and there’s that dollar sign.
Both of these prompts can be changed. I leave it to you to google this.
Present Working Directory
Your CLI can be thought of as being “in” a particular directory. We call this directory the present working directory.
In Windows, you always know your present working directory, because the default prompt tells you the entire path to the present working directory. In the example below, we see that the command prompt starts off in a directory called “Hvagvarfis”, and the whole path is “E:\users64\Hvagvarfis”.
In Mac OS X, you must run a program called pwd in order to see your present working directory. To do this, type “pwd”. For example, on my computer, if I use pwd right after opening a terminal window, I get:
This means that the name of the present working directory is jug, and the full path of the present working directory is /Users/jug. Note that in Unix based operating systems, the “~” directory is shorthand for your home directory.
One important distinction is that in Windows, all paths start with a drive letter and then a colon symbol. In Unix based operating systems, everything simply starts with
/.
Listing the Files in a Directory
To list files in the present working directory in Windows, use the dir command:
In Mac OS X, use the ls (that’s lowercase LS) command:
Here we see that there are 11 things inside of my /users/Jug directory. In Mac OS X, subdirectories are listed in exactly the same format as files. You can tell Mac OS X to mark folders with a / by typing “ls –F”.
Creating, Removing, and Navigating between Directories
In both Mac OS X and Windows, you can create a new directory by using the mkdir command.
In this section, we recommend that you follow along.
First, type “mkdir temporary” and press enter. Now type “ls” or “dir” to get the directory listing. You’ll see that a new folder named “temporary” exists.
In fact, you can even go to your Finder or Explorer Window, and you’ll see that the GUI can see the folder you’ve made. For example, on a Mac, we have:
To change directories in Mac OS X or QWindows, one uses the command cd. Try it out by typing “cd temporary”.
In Mac OS X, type pwd and ls, and you will see the following:
There are no files, unsurprisingly. We also note that the “~” has changed to “temporary”, which means that our current directory has changed from our home directory to a directory with the name “temporary”.
In Windows, the command prompt automatically shows you what folder you’re in. Type “dir “and you will also see that there are no files in the temporary directory:
How does one go back, you may ask? Simply type “cd ..” to go back one directory. For example:
Running a Program
To run a program, simply type the name of the program. Programs in Windows typically (but don’t always) have the extension .exe (for executable). In Mac OS X, they typically have no extension at all.
For this to work, the program must be either in the present working directory, or on the system path (see appendix).
Running Programs Using the Full Path
If you want to run something that’s not on the system path, and not in the present working directory, you can instead type the full path of the file.
For example, if we type /usr/bin/ls at the command prompt, we get an error, because the computer tries to find ls in the wrong location:
/bin/ls works just fine, by contrast
Command Line Arguments
You can provide additional information to a program about what you’d like to do with command line arguments. For example, if you give the ls or dir programs a directory as a command‐line argument it will instead list the contents of the directory name that you give.
For example, try ls /bin ,
and you should
get
something like:
Or in Windows, try “dir C:\” and you should get something like:
Finding Where a Program is Located
In Mac OS X, you can type which “[name of program]”, and it will tell you where that program is located. On Windows, use where instead. For example:
Redirecting StdOut
Ordinarily, programs print their text output to the screen. However, you can redirect the output of most programs to a file. To do this, one simply types:
Program name [command line arguments] > [filename]
The > indicates to the operating system that output should be sent to a file instead of the screen.
For example, try “ls > curdir.txt” or “dir > curdir.txt” depending on your operating system.
This will output the results of ls to the file curdir.txt.
Redirecting StdIn
Ordinarily, when a program requests input from StdIn, this information is gathered from the keyboard. However, one can redirect StdIn to refer to a file. To do this, you type:
Program name [command line argments] < [filename]
Now, all calls to StdIn will be referred to the file given by filename.
And there’s more… much more…
We have scratched the surface of what it’s possible to do using a command line interface. There are many tutorials on the web that you might find interesting to explore.
Appendix: System Path
The system path is a special list of directories that the computer always checks when you ask it to run a program.
To see the system path in Windows, type: echo %PATH%
In Mac OS X, type echo $PATH
Here we see that the path on my computer includes the directories /Users/jug/scuts, /usr/bin, /bin, /usr/sbin, etc.
As an example of using the path, “ls” is actually a program, and it is located at /bin/ls. If we did not have /bin/ls in our path, then typing “ls” would result in an error.
