The Unix Model Curriculum

Chapters...
   1   2   3
   4   5   6
   7   8   9
  10 11 12
  13 14 15
  16 17 18
  19 20 21
  22 23 24
  25 26

Glossary

Appendixes...
  A B C
  D E F
  G H

Command
Summary...

• Alphabetical
• By category

Unix-Linux
Timeline

Internet
Resources

Errors and
Corrections

Endorsements

INSTRUCTOR
AND STUDENT
MATERIAL...

Home Page
& Overview

Exercises
& Answers

The Unix Model
Curriculum &
Course Outlines

PowerPoint Files
for Teachers

The Unix Model Curriculum:
Sections and Objectives

The Unix Model Curriculum is a detailed plan for teaching all the important concepts necessary for an introductory course for Unix or Linux. The Unix Model Curriculum was developed by Harley Hahn to help instructors decide which topics to teach and the order in which to teach them.

Below are the details of the entire Unix Model Curriculum on a single page. What you see here corresponds closely (but not exactly) to the outline of the book Harley Hahn's Guide to Unix and Linux, which is based on this curriculum.

The Unix Model Curriculum was designed to cover all the concepts and skills a student needs to master to understand basic Unix and Linux. However, as you can see, the curriculum is, necessarily, quite large. Indeed, it is so large that it is unrealistic to expect a teacher to cover all this material in a single course. For this reason, there several suggested course outlines have been developed as practical plans for course of various lengths.

Examine course outlines

The Unix Model Curriculum consists of 26 sections. Each of these sections is described by the set of teaching objectives. Many of these teaching objectives require that certain commands and programs that should be taught along with the material. In the outline below, the names of these commands and programs are printed in blue.

The Unix Model Curriculum

Section 1:		Introduction to Unix
		The Unix family of operating systems
		Linux as a type of Unix
		The Unix culture
		Why do we use Unix?
		Who uses Unix?

Section 2:		What Is Unix? What Is Linux?
		What is an operating system?
		What is the kernel?
		Unix = Kernel + Utilities
		Understanding the name "Unix"
		The Free Software Foundation; the GNU Project
		The GPL (General Public License) and Open Source Software
		Unix in the 1970s: Bell Labs, U.C. Berkeley
		Unix in the 1980s: BSD, System V
		Unix in the early 1990s: Linux
		The development of Linux
		Linux Distributions
		BSD Distributions
		How to choose which type of Unix or Linux to use
		How to obtain Linux or FreeBSD
		What is Unix? What is Linux?

Section 3:		The Unix Connection
		Interfaces, terminals, hosts
		The original Unix system; Bell Labs, Multics, Unix
		Multiprogramming, time-sharing
		Teletype terminals; printed output
		Host and terminals paradigm
		Terminal rooms, terminal servers
		The Console
		Remote terminals, terminal emulation programs
		Hosts without consoles, headless systems
		Client/server relationship
		What happens when you press a key?
		Character terminals, graphics terminals

Section 4:		Starting to Use Unix
		System administrator
		Userids and passwords
		Logging in
		What happens after you log in?
		Shell prompt
		Logging out [logout, exit, login]
		Upper- and lowercase
		Changing your password [passwd]
		Choosing a password
		Checking if someone has been using your Unix account [last]
		Userids and users
		The superuser userid [root]

Section 5:		GUIs: Graphical User Interfaces
		What is a GUI?
		X Window
		Who is in charge of X Window?
		Layers of abstraction
		Window manager
		Desktop environment
		KDE and Gnome
		Total cost of ownership
		Choosing a desktop manager
		What should go into a personal Linux system?

Section 6:		The Unix Work Environment
		Multitasking; time slices; the scheduler
		The GUI and the CLI (command line interface)
		Logging in and logging out with a GUI
		Runlevels
		Learning to use a GUI
		Using a mouse and menus
		GUI skills: Resizing, minimizing, maximizing and closing windows
		GUI skills: Controlling the focus; task switching
		Multiple desktops/workspaces
		Terminal windows
		Virtual consoles
		The console
		GUI skills: Selecting, inserting
		GUI skills: Copying, pasting
		Working as superuser [su]
		Configuration files [sudo]
		Shutting down; rebooting [init, reboot, shutdown]
		What happens when the system starts or stops? [dmesg]

Section 7:		Using the Keyboard With Unix
		The First Unix Terminals
		Teletypes and the Unix Culture
		Termcap, terminfo, curses
		How does Unix know what type of terminal you are using?
		Modifier keys
		Unix keyboard signals [erase, werase, kill]
		<Backspace>, <Delete>, ^H
		Stopping a program [intr, quit]
		Pausing the display [stop, start]
		End of file signal [eof]
		Shell: Trapping the eof signal
		Key mappings [stty]
		Command line editing
		Return; linefeed; newline
		Resetting the terminal [stty sane, reset]

Section 8:		Programs to Use Right Away
		Finding a program on your system [which, type, whence]
		How do you stop a program?
		Displaying the time and date [date]
		Displaying a calendar [cal]
		Reminder service [calendar]
		Information about your system [uptime, hostname, uname]
		Information about you [whoami, quota]
		Information about other users [users, who, w]
		Locking your terminal temporarily [lock]
		Asking Unix to remind you when to leave [leave]
		Built-in calculator [bc, dc]

Section 9:		Documentation:

9A:		The Unix Manual
		The Unix tradition of teaching yourself
		RTFM
		What is the Unix manual? [man]
		Man pages
		Displaying man pages
		Alternatives: GUI-based, Web [xman]
		Organization
		Section numbers
		Referencing man pages
		Format of a man page
		Finding out what a command does [whatis]
		Searching for a command [apropos]
		Foo, bar and foobar

9B:		The Info System
		The Info system [info]
		Info and trees
		Starting Info
		Learning about Info
		Reading an Info file
		Jumping from one node to another

Section 10:		Command Syntax
		Entering more than one command at a time
		What happens when you enter a command?
		Command syntax
		Options
		Dash options; dash-dash options
		Arguments
		Whitespace
		One or more; zero or more
		Syntax: the formal description of a command
		Learning command syntax from the Unix manual
		Dealing with a lot of options

Section 11:		The Shell
		What is a shell?
		The Bourne shell family [sh, ksh, bash]
		The C-Shell family [csh, tcsh]
		Which shell should you use?
		Changing your shell temporarily
		Changing your login shell [chsh]

Section 12:		Using the Shell: Variables and Options
		Interactive shells; non-interactive shells
		Environment; processes; variables
		Environment variables; shell variables
		Displaying environment variables [env, printenv]
		Displaying shell variables [set]
		Displaying and using the value of a variable [echo, print]
		Bourne shell family: Using variables [export, unset]
		C-Shell family: Using variables [setenv, unsetenv, set, unset]
		Shell options [set -o, set +o]
		Displaying shell options
		Machine-readable; human-readable

Section 13:		Using the Shell: Commands and Customization
		Metacharacters
		Quoting; escaping
		Strong quotes; weak quotes
		Builtin commands [type]
		External commands
		Search path
		Shell prompt
		Using the value of a variable
		Quoting variables
		Escape character
		Command substitution
		Typing commands; making changes
		History list [fc, history]
		Event number & working directory in shell prompt
		Autocompletion
		Command line editing [bindkey]
		Aliases [alias, unalias]

Section 14:		Using the Shell: Initialization Files
		Initialization files; logout files
		Names of initialization and logout files
		Dotfiles and rc files
		Using a simple text editor
		Login shells; non-login shells
		When are initialization files executed?
		What to put in initialization files
		Displaying, creating and editing initialization files
		Comments in shell scripts
		Bourne shell family: sample initialization files
		C-Shell family: sample initialization files

Section 15:		Standard I/O, Redirection, and Pipes
		The Unix philosophy regarding tools
		(combining tools, small is beautiful)
		Standard input; standard output; standard error
		Redirecting standard output
		Preventing files from being replaced or created by redirection
		Redirecting standard input
		File descriptors
		Redirecting standard error: Bourne Shell family
		Subshells
		Redirecting standard error: C-Shell family
		Combining standard output and standard error
		Throwing away output (/dev/null)
		Pipelines
		Splitting a pipeline [tee]
		Conditional execution

Section 16:		Filters: Introduction and Basic Operations
		Variations of commands and options
		Filters
		Creating filters
		The problem solving process
		The simplest possible filter [cat]
		Increasing the power of filters
		The most useful filters
		Combining files [cat]
		Splitting files [split]
		Combining files while reversing lines [tac]
		Reversing the order of characters [rev]
		Selecting lines from the beginning or end of data [head, tail]
		Deleting columns of data [colrm]

Section 17:		Filters: Comparing and Extracting
		Comparing files
		Comparing any two files [cmp]
		Comparing sorted text files [comm]
		Comparing unsorted text files [diff]
		Diffs and patches
		Extracting columns of data [cut]
		Records; fields; delimiters [cut]
		Extracting fields of data [cut]
		Combining columns of data [paste]

Section 18:		Filters: Counting and Formatting
		Creating line numbers [nl]
		Counting lines, words, characters [wc]
		How Unix uses tabs
		Visualizing tabs and spaces
		Changing tabs to spaces [expand]
		Changing spaces to tabs [unexpand]
		Formatting lines [fold]
		The 80-character line
		Formatting text: paragraphs [fmt]
		Formatting text: pages [pr]
		Formatting text: columns [pr]

Section 19:		Filters: Selecting, Sorting, Combining, and Changing
		Selecting lines that contain a specified pattern [grep]
		The most important grep options [grep]
		Variations of grep [fgrep, egrep]
		Selecting lines beginning with a specific pattern [look]
		Finding words that begin with a specific pattern [look]
		Sorting data [sort]
		Controlling the order in which data is sorted [sort -dfn]
		Checking if data is sorted [sort -c]
		ASCII code
		Collating sequences
		Locales
		Finding duplicate lines [uniq]
		Merging sorted data from two files [join]
		Creating a total ordering from partial orderings [tsort]
		Searching for character strings in binary files [strings]
		Translating characters [tr]
		Translating unprintable characters
		Using sed for non-interactive text editing [sed]
		sed: Substitutions
		sed: Specific lines only
		sed: Very long commands

Section 20:		Regular Expressions
		Introduction to regular expressions
		Origin of regular expressions
		Basic and extended regular expressions
		Matching lines
		Matching words
		Matching characters
		Character classes
		Predefined character classes
		Ranges
		Locales and collating sequences
		Repetition operators
		Understanding complex regular expressions

Section 21:		Displaying Files
		Survey of programs used to display files
		Using less for paging [less]
		less: Starting, stopping, help
		less: Most common commands
		less: Searching within a file
		Raw and cooked mode
		less: Options
		Comparing less to cat
		Using environment variables to customize your pager
		less: Displaying multiple files
		Displaying a file [more]
		Displaying the beginning of a file [head]
		Displaying the end of a file [tail]
		Watching the end of a growing file [tail -f]
		Binary, octal, hexadecimal
		Why we use hexadecimal rather than octal
		Displaying binary files [hexdump, od]

Section 22:		The vi Text Editor

22A:		Introduction to vi
		Introduction to the vi text editor [vi]
		Vim: an alternative to vi
		Starting vi
		Starting Vim
		Command mode; input mode
		Knowing what mode you are in
		Starting vi as a read-only editor: [view, vi -r]
		Recovering data after a system failure
		Stopping vi
		How vi uses the screen
		Using vi and ex commands
		How to learn vi commands
		Creating a practice file

22B:		Fundamental vi Skills
		Moving the cursor
		Moving through the editing buffer
		Jumping to a previous location
		Searching for a pattern
		Using line numbers
		Inserting text
		Changing text
		Replacing text
		Deleting text
		Undoing or repeating a change
		Recovering deletions
		Moving text
		Copying text
		Changing the case of letters
		Setting options
		Displaying options
		Breaking lines automatically as you type
		Breaking lines; joining lines
		Copying lines
		Moving lines
		Entering shell commands
		Inserting data from a file into the editing buffer
		Inserting the output of a shell command into the editing buffer
		Using a program to process data [fmt]
		Writing data to a file
		Changing to a new file
		Abbreviations
		Macros
		Initialization files: [.exrc, .vimrc]
		Using two initialization files
		Learning to use Vim

Section 23:		The Unix Filesystem
		What is a file?
		Types of files
		Directories; subdirectories
		Introduction to special files
		Special files: hardware
		Special files: terminals [tty]
		Special files: pseudo-devices
		Named pipes [mkfifo]
		Proc files
		Tree-structured filesystem
		Filesystem Hierarchy Standard (FHS)
		Root directory and subdirectories
		Mounting a filesystem [mount, umount]
		Contents: root directory
		Contents: /usr directory
		Directories that hold programs
		Home directories
		Virtual file system

Section 24:		Working With Directories
		Pathnames: absolute, relative
		Working directory
		Pathname abbreviations ( .. . ~ )
		Moving around the directory tree [cd, pwd]
		Making a new directory [mkdir]
		Removing a directory [rmdir]
		Moving or renaming a directory [mv]
		Directory stack [pushd, popd, dirs]
		Using ls to list files [ls]
		Directory listings [ls -CrR1]
		Collating sequences, locales and ls
		Checking file types I [ls -f]
		Checking file types II [ls --color]
		Checking file types III [file]
		Keeping track of disk space usage [ls -hs, du, df, quota]
		File size; blocks; allocation units [dumpe2fs]
		Globbing; wildcards
		Dot files (hidden files) [ls -a]
		Long directory listings [ls -dhltu]
		Aliases for using ls
		Displaying a directory tree [tree]

Section 25:		Working With Files
		Creating a file [touch]
		Rules and conventions for naming a file
		Copying a file [cp]
		Copying files to a different directory [cp]
		Copying a directory to another directory [cp -r]
		Moving a file [mv]
		Renaming a file or directory [mv]
		Deleting a file [rm]
		How to keep from deleting the wrong files [rm -if]
		Deleting an entire directory tree [rm -r]
		File permissions
		Setuid
		How Unix maintains file permissions [id, groups, ls -l]
		File modes
		Changing file permissions [chmod]
		Permissions for new files [umask]
		Wiping out the contents of a file [shred]
		Introduction to links [stat, ls -i]
		Multiple links to the same file
		Creating a new link [ln]
		Symbolic links [ln -s]
		Using symbolic links with directories
		Finding files: Associated with a Unix command [whereis]
		Finding files: Searching a system database [locate]
		Finding files: Searching a directory tree [find]
		The find program: paths
		The find program: tests
		The find program: negating a test
		The find program: file permission error messages
		The find program: actions
		Processing files that have been found [xargs]

Section 26:		Processes and Job Control
		How the kernel manages processes
		Forking
		Orphans; abandoned processes
		Distinguishing between parent and child
		The very first process [init]
		Foreground and background processes
		Creating a delay [sleep]
		Job control
		Running a job in the background
		Suspending a job [fg]
		Suspending a shell [suspend]
		Job control vs. multiple windows
		Displaying a list of jobs [jobs]
		Moving a job to the foreground [fg]
		Moving a job to the background [bg]
		Using ps to display process information [ps]
		The ps program: Basic skills
		The ps program: Choosing options
		The ps program: States
		Monitoring system processes [top, prstat]
		Displaying a process tree [pstree, ptree]
		Compare how Unix organizes processes vs. files [fuser]
		Killing a process [kill]
		Sending a signal to a process [kill]
		Setting the priority for a process [nice]
		Changing the priority of an existing process [renice]
		Daemons

Jump to top of page

Unix Model Curriculum home page

Instructor/Student home page