CS 2204: UNIX

Spring 2005

[Syllabus] [Schedule] [Assignments] [Labs]

Final Exam Review Page

This page is intended to help you study for the final exam in CS 2204, Spring 2005.

Exam Format

The exam will be held Monday, May 2, 9:05-9:55 AM, in Torgersen Hall room 2150. This is the last normal lecture meeting of the course. The exam will consist of 25-40 multiple choice questions. Students will fill in their answers on opscan forms. The exam will be closed-book, closed-notes. The exam will start promptly at 9:05 and will end promptly at 9:55. No makeup exams or extra time will be given. Students will be required to sign an honor pledge form at the end of the exam.

Exam Topics

The following topics may be covered on the exam. The topics are organized in the same order as the lectures. Especially important topics are marked in bold letters - you should make sure to understand these concepts thoroughly from lecture notes, textbooks, labs, quizzes, etc.

Introductory UNIX concepts

Differences between UNIX and other operating systems
Logins and passwords
Commanding the system via the shell
Shell commands, arguments, and options (syntax)
Logging out
UNIX filesystem

hierarchical structure
types of files
relationship to physical storage devices
working directory
home directory
absolute vs. relative paths
"." and ".."
file permissions
file owner and group
symbolic links
wildcards in filenames

Basic shell commands and operation

Filesystem commands: cd, ls, rm, cp, mv, rmdir, mkdir, touch, chmod, ln, pwd
Viewing file contents: cat, less
Help commands: man, apropos
Process commands: ps, top, kill, time
Text editing with vi

command vs. insert modes
why UNIX files are usually plain ASCII text
basic vi commands and modes

UNIX window systems

usability motivation for window systems
what X windows does
running X programs remotely using the client-server architecture
other features of X
window systems (e.g. X) vs. window managers vs. desktop environments

Regular expressions

definition and importance
characters vs. metacharacters
concept of quoting in regular expressions
basic use of egrep
basic metacharacters in egrep: . (period), *, ^, $, \, [], +, ?, |, (), {}
interpreting regular expressions (i.e. what does this RE match?)
constructing regular expressions (i.e. what's an RE that matches this set of strings?)

UNIX shells

concept of shell commands as a language
different UNIX shell programs
environment variables: displaying, setting, and using them
aliases in bash
bash login scripts
stdin, stdout, stderr: defaults and redirection
pipes and filters
executing shell scripts
variables in shell scripts: numeric, string, array
referring to command line arguments in shell scripts
concept of quoting in shell variables
conditional, looping, and case constructs in shell scripts

Advanced editing and scripting

purpose and usefulness
line-oriented editing, line addressing
substitution commands
sed scripts

purpose and usefulness
processing model
control structures (if-else, for, while)

UNIX development tools

basic steps in program development
GNU C++ compiler (g++)

what it's used for
types of files: source, headers, object files, executables
key options: -c, -g, -o, -l, -L, -I

make

what it's used for and why it's important for large software projects
concept of "chain of dependencies"
types of lines in makefiles: rules, commands, macro assignments, comments

definition and importance of revision control
basic features of CVS: checkout, commit, release, status, update, merging, revision numbers
process of revision control with multiple programmers

Debugging with gdb

what it's used for and why it's important
high-level features of debuggers: breakpoints, stepping through code, show/change variables
execution commands: run, next, step
breakpoint commands: break, delete, condition, continue
information commands: list, print, display, where

UNIX system programming

definition of system call
file descriptors
raw file I/O calls (concepts, not details of arguments): open(), close(), read(), write(), lseek()
fopen(), fclose(), fread(), fwrite(), fseek()
structured datatypes in file I/O (e.g. fprintf(), fscanf())
process vs. program
process system calls: fork(), exec*(), and wait()
sending signals
IPC: message passing vs. shared memory
IPC with pipes

Study Materials

All of the resources from the course are potential study materials. It's unlikely, however, that you'll be able to review everything. To help you plan your study time, here is a list of resources in priority order. That is, resources higher on the list are more important to review than items lower on the list.

Lecture notes, available on the schedule page
Your own notes from lectures
Quizzes given this semester, available on the Blackboard site
Labs, especially the "assessment" portions and solutions to labs, available on the main labs page
Scripting and programming examples, accessible from links on the schedule page and within lab assignments
Assigned readings from "Linux in a Nutshell"
Programming assignments/solutions

Study Tips

Questions from this semester's quizzes give you a good idea of the style and content of questions likely to be asked on the final
The lecture notes, by their nature, cannot contain all the detail you need about a particular topic. Correlate the lecture notes with your personal notes that you took in lecture and with information in the book or in man pages. Use the lecture notes as pointers to information that the instructor thinks is important.
The more places you find a particular piece of information, the more likely it is to be on the exam. Something that is highlighted in the lecture notes, readings, and in a quiz is more important than something that was a small result in a lab session.
When studying information about specific commands/function calls/etc., it may be useful to go back and try them interactively to refresh your memory. Remember, the best way to learn UNIX is by doing, not by reading or listening. In particular, you may wish to redo some portions of labs as you study.
When studying information from lab sessions, write down a few key concepts that you learned in each lab, especially if you learned additional information beyond the lecture for that week.
Exam questions will be focused more on concepts than on detailed facts. That is, the exam will be designed to test your understanding of the UNIX operating system, not your detailed knowledge of every command, scripting construct, and function call. Therefore, do not spend the major part of your study time memorizing arguments to shell commands or the syntax of shell scripting. Instead, you should be able to look at a shell script or system program and understand what it does. You should understand the concepts behind a hierarchical file system. And so on. Of course, there are certain facts that must be memorized - for example, "What shell command is used to perform such and such a task?", or "What is the directory at the top of the UNIX filesystem tree?"