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 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