Shell Basics

Version 1107 (Mon Nov 27 20:45:55 2006)

Most modern tools have a graphical user interface (GUI)
- They're easier to use
- A picture is worth a thousand words
But command-line user interfaces (CLUIs) still have their place
- Easier to build a simple CLUI than a simple GUI
- Higher action-to-keystroke ratio
  - Once you're over the learning curve
- Easier to see and understand what the computer is doing on your behalf
  - Which is part of what this course is about
- Most important: it's easier to combine CLUI tools than GUI tools
  - Small tools, combined in many ways, can be very powerful
This lecture focuses on Unix
- Because while there are good Unix emulators for Windows, there aren't good Windows emulators for Unix
Send comments

You Can Skip This Lecture If...

You know what a shell is
You know the difference between an absolute path and a relative path
You know what ls, cp, and wc do
You have read [Ray & Ray 2003], [Kernighan & Pike 1984], or something similar
Send comments

The Shell

The most important command-line tool is the command shell
- Usually just called “the shell”
- Looks (and works) like an interactive terminal circa 1980
- Figure 3.1: A Shell in Action
Manages a user's interactions with the operating system by:
- Reading commands from the keyboard
- Executing those commands…
- …or running another program
- Displaying the output
The shell is just one program among many
- Many different shells have been written
- The Bourne shell, called sh, is an ancestor of many of them
  - It's still a lowest common denominator that you can always rely on
- We'll use bash (the Bourne Again Shell) in this course
  - Even on Windows (thanks to Cygwin)
Send comments

The Shell is Not the Operating Sytsem

The operating system is not just another program
- Automatically loaded when the computer boots up
- Runs everything else (including shells)

Figure 3.2: Operating System

The OS manages the computer's hardware
- Provides a common interface to different chips, disks, network cards, etc.
- So that user-level applications can run anywhere
The OS also keeps track of what programs are running, what privileges they have, etc.
- Which makes it crucial to security
Send comments

The File System

The file system is the set of files and directories the computer can access
- “Everything that doesn't go away when you reboot”
Data is stored in files
- By convention, files have two part names, like notes.txt or home.html
- Most operating systems allow you to associate a filename extension with an application
  - E.g., .txt is associated with an editor, and .html with a web browser
- But this is all just convention: you can call files (almost) anything you want
Files are stored in directories (often called folders)
- Directories can contain other directories, too
- Results in the familiar directory tree
- Figure 3.3: A Directory Tree
- Everything in a particular directory must have a unique name
  - Otherwise, how would you identify it?
- But items in different directories can have the same name
On Unix, the file system has a unique root directory called /
- Every other directory is a child of it, or a child of a child, etc.
On Windows, every drive has its own root directory
- So C:\home\gvwilson\notes.txt is different from J:\home\gvwilson\notes.txt
- When you're using Cygwin, you can also write C:\home\gvwilson as c:/home/gvwilson
- Or as /cygdrive/c/home/gvwilson
  - Some Unix programs give ":" a special meaning, so Cygwin needed a way to write paths without it…
Note: file and directory names are case-sensitive on Unix, but case-insensitive on Windows
- So don't ever rely on case differences when naming things
Send comments

Paths

A path is a description of how to find something in a file system
- An absolute path describes a location from the root directory down
  - Equivalent to a street address
  - Always starts with "/"
  - /home/hpotter is Harry Potter's home directory
  - /courses/swc/web/lec/shell.html is this file
- A relative path describes how to find something from some other location
  - Equivalent to saying, “Four blocks north, and seven east”
  - From /courses/swc, the relative path to this file is web/lec/shell.html
Every program (including the shell) has a current working directory
- “Where am I?”
- Relative paths are deciphered relative to this location
- It can change while a program is running
Two special directory names:
- "." (pronounced “dot”) is the current directory
- ".." (pronounced “dot dot”) is the directory one level up
  - Also called the parent directory
  - In /courses/swc/data, .. is /courses/swc
  - In /courses/swc/data/elements, .. is /courses/swc/data
  - Figure 3.4: Parent Directories
Send comments

Navigating the File System

Easiest way to learn basic Unix commands is to see them in action
Type pwd (short for "print working directory”) to find out where you are
- Unfortunately, most Unix commands have equally cryptic names

Then type ls (for “listing”) to see what's in the current directory

$ ls
LICENSE.txt     conf        data        docs    index.swc   license.swc     print.css   swc.css     tests
Makefile        config.mk   depend.mk   img     lec         press           sites       swc.dtd     util

To see what's in the data directory, type ls data

$ ls data
bio     elements    haiku.txt   morse.txt   pdb         solarsystem.txt

Or:

Type cd data to “go into” data
- I.e., change the current working directory to data
Type ls on its own
Type cd .. to go back to where you started

$ cd data
$ pwd
/home/hpotter/swc/data
$ ls
bio     elements    haiku.txt   morse.txt   pdb         solarsystem.txt
$ cd ..
$ pwd
/home/hpotter/swc

Send comments

Execution Cycle

When you type a command like ls, the OS:
- Reads characters from the keyboard
- Passes them to the shell (because it's the currently active window)
The shell:
- Breaks the line of text it receives into words
- Looks for a program with the same name as the first word
  - See in a moment how the shell knows where to look
- Runs that program
That program's output goes back to the shell…
…which gives it to the OS…
…which displays it on the screen
- (Actually, the OS hands it to the window manager, which takes care of the display)

Figure 3.5: Running a Program

All well-designed software systems work this way
- Break the task down into pieces
- Write a tool that solves each sub-problem
- Hook 'em up
Allows you to:
- Develop and test components independently
- Replace or re-use components incrementally
- Add new components as you go along
Send comments

Providing Options

Can make ls produce more informative output by giving it some flags
- By convention, flags for Unix tools start with "-", as in "-c" or "-l"
- Some flags take arguments (such as filenames)

Show directories with trailing slash

$ ls -F
LICENSE.txt     conf/       data/       docs/   index.swc   license.swc     print.css   swc.css     tests/
Makefile        config.mk   depend.mk   img/    lec/        press/          sites/      swc.dtd     util/

Show all files and directories, including those whose names begin with .

By default, ls doesn't show things whose names begin with .
- So that . and .. don't always show up

$ ls -a
.   .svn        Makefile    config.mk   depend.mk   img         lec         press       sites   swc.dtd util
..  LICENSE.txt conf        data        docs        index.swc   license.swc print.css   swc.css tests

We'll see what the .svn directory is for later

Flags can be combined

$ ls -a -F
.   .svn/       Makefile    config.mk   depend.mk   img/        lec/        press/      sites/  swc.dtd util/
..  LICENSE.txt conf/       data/       docs/       index.swc   license.swc print.css   swc.css tests/

Send comments

Creating Files and Directories

Rather than messing with the course files, let's create a temporary directory and play around in there
- Note: no output (but -v (“verbose”) would tell mkdir to print a confirmation message)
Go into that directory: no files there yet
Use the editor of your choice to create a file called earth.txt with the following contents:
- Notepad (on Windows) runs in a window of its own
- Pico (on Unix) takes over the shell window temporarily
- We'll look at more advanced programming editors later
Easiest way to create a similar file venus.txt is to copy earth.txt and edit it
- -t tells ls to list by modification time, instead of alphabetically
Send comments

Looking at Files

Check the contents of the file using cat (short for “concatenate”)
- Prints the contents of a file to the screen

Compare the sizes of the two files using:

ls -l (“-l” meaning “long form”)

$ ls -l
total 2
-rwxr-xr-x  1 gvwilson None 73 Jan  4 15:58 earth.txt
-rwxr-xr-x  1 gvwilson None 73 Jan  4 15:58 venus.txt

Fifth column is size in bytes

wc (for “word count”)

$ wc earth.txt venus.txt
  4   9  73 earth.txt
  4   9  73 venus.txt
  8  18 146 total

Columns show lines, words, and characters

Send comments

Basic Tools

Table 3.1: Basic Command-Line Tools
`man`	Documentation for commands.
`cat`	Concatenate and display text files.
`cd`	Change working directory.
`clear`	Clear the screen.
`cp`	Copy files and directories.
`date`	Display the current date and time.
`diff`	Show differences between two text files.
`echo`	Print arguments.
`head`	Display the first few lines of a file.
`ls`	List files and directories.
`mkdir`	Make directories.
`more`	Page through a text file.
`mv`	Move (rename) files and directories.
`od`	Display the bytes in a file.
`passwd`	Change your password.
`pwd`	Print current working directory.
`rm`	Remove files.
`rmdir`	Remove directories.
`sort`	Sort lines.
`tail`	Display the last few lines of a file.
`uniq`	Remove adjacent duplicate lines.
`wc`	Count lines, words, and characters in a file.

Exercise: what are the native Windows equivalents of each of these?
Send comments

Summary

Command-line tools will be with us for a long time
- Easiest way to do many simple tasks
- Easiest way to see what the computer is actually doing
Often the only thing you can rely on having on a new machine
- A handful of basic commands will get you a long way
Send comments

Exercises

Exercise 3.1:

Suppose ls shows you this:

Makefile    biography.txt   data    enrolment.txt   programs    thesis

What argument(s) will make it print the names in reverse, like this:

thesis  programs    enrolment.txt   data    biography.txt   Makefile

Exercise 3.2:

What does the command cd ~ do? What about cd ~hpotter?

Exercise 3.3:

What command will show you the first 10 lines of a file? The first 25? The last 12?

Exercise 3.4:

What do the commands pushd, popd, and dirs do? Where do their names come from?

Exercise 3.5:

How would you send the file earth.txt to the default printer? How would you check it made it (other than wandering over to the printer and standing there)?

Exercise 3.6:

The instructor wants you to use a hitherto unknown command for manipulating files. How would you get help on this command?

Exercise 3.7:

diff finds and displays the differences between two text files. For example, if you modify earth.txt to create a new file earth2.txt that contains:

Name: Earth
Period: 365.26 days
Inclination: 0.00 degrees
Eccentricity: 0.02
Satellites: 1

you can then compare the two files like this:

$ diff earth.txt earth2.txt
3c3
< Inclination: 0.00
---
> Inclination: 0.00 degrees
4a5
> Satellites: 1

(The rather cryptic header "3c3" means that line 3 of the first file must be changed to get line 3 of the second; "4a5" means that a line is being added after line 4 of the original file.)

What flag(s) should you give diff to tell it to ignore changes that just insert or delete blank lines? What if you want to ignore changes in case (i.e., treat lowercase and uppercase letters as the same)?

Send comments