=====ASM=====
The following is a list of the major topics being covered in this course:

<WRAP>
  * von Neumann vs. Harvard architecture
  * Fetch-Execute Cycle
  * Binary and Hexadecimal Number Representation
  * Processor & Memory Organization
  * Registers (General Purpose/Integer, Floating Pointer, Accumulator, Data)
  * Registers (Stack Pointer, Program Counter, Flag/Status)
  * Registers (Index/Pointer)
  * Instruction Sets (CISC, RISC)
  * Boolean Arithmetic Operations (Addition, Subtraction, Multiplication, Division)
  * Logic Operations (AND, OR, XOR)
  * Negated Logic Operations (NOT, NAND, NOR, XNOR)
  * Data Instructions (Data Movement, Address Movement, Data Conversion, Bit Manipulation)
  * Control and Data Flow
  * Subroutines (Calling, Return Address)
  * Storage
  * Machine Word
  * Stack Operations
  * Data Representation (Big Endian, Little Endian, Size, Integer, Floating Point, ASCII)
  * Data Representation (Sign Representation, One's Complement, Two's Complement)
  * Linking, Object and Machine Code
  * I/O
  * Interrupts
  * Address Bus
  * Data Bus
</WRAP>

=====COMPESS=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * Number Systems
  * Digital Processing
  * Computer Hardware
  * System Software
  * Application Software
  * Artificial Intelligence
  * System Development
</WRAP>
<WRAP>
  * Telecommunications
  * Internet and Web
  * Databases
  * Security, Privacy, Ethical Issues
  * Programming
  * Computer History
</WRAP>

=====CPROG=====
The following is a list of the major topics being covered in this course:

<WRAP>
  * Standard I/O (STDIO, STDOUT, STDERR)
  * Header Files (Local and System), C Standard Library (Libc), Libraries
  * arithmetic (equations, operators)
  * logic and operators (and, or, not, xor)
  * Variables (types, ranges, sizes)
  * Scope (Block, Local, Global, File)
  * Pointers (address of, assignment, dereferencing)
  * Type Casting
  * Selection Structures (if, case/switch)
  * Repetition/Iteration Structures (for, while, do while)
  * Arrays (standard notation, pointer arithmetic, single-dimensional, multi-dimensional)
  * File Access (Read, Write, Append)
  * Structures (Declaration, Accessing Elements, Pointers to)
  * typedef, enum, union
  * Functions, Parameters (Pass by: Value, Address, Reference), Return Types, Recursion, Command-line arguments
  * Compiler, Preprocessor, Flags, Assembler, Linker, Multi-file programs (how to structure, how to compile)
  * I/O Streams (cin, cout, cerr, stream operators) [C++]
  * Namespaces [C++]
  * Type Casting Operators, Const-Volatility Specifiers (const, volatile) [C++]
  * Classes (Objects, Constructor, Destructor, Access Control, Public, Protected, Private, Friend, "this" pointer) [C++]
  * Inheritance (single, multiple Inheritance), Polymorphism/Virtual Functions, Abstract Base Class [C++]
  * Overloading (Functions, Operators) [C++]
  * Exception Handing (throw, try, catch) [C++]
  * Templates, STL (Standard Template Library) [C++]
</WRAP>

=====DATA=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * Version Control (checkout, commit, update, add, log)
  * Pointers (address of, assignment, dereferencing)
    * arrays, pointer arithmetic
    * pointers to pointers
    * null pointers
    * void pointers
    * function pointers
  * Static allocation vs. Dynamic allocation
    * Memory allocation (malloc(), new)
    * Memory De-allocation (free(), delete)
  * structures
    * structure pointer
  * Linked Lists
  * Doubly Linked Lists
  * Stacks (array-based, linked-list based)
    * Pushing
    * Popping
    * Top
    * Overflow condition (where applicable?)
    * Underflow condition
    * LIFO or FIFO?
</WRAP>
<WRAP>
  * Queues (array-based, linked-list based)
    * Enqueuing
    * Dequeuing
    * Overrun and Underrun conditions
    * LIFO or FIFO?
  * Computational Complexity
    * Big-O, Theta, bounds
  * Sorting Algorithms
    * Selection sort algorithm
    * Bubble sort algorithm
    * Insert sort algorithm
    * Quick sort algorithm
    * Merge sort algorithm
  * Binary Search algorithm
  * Trees, Binary Trees (nodes, parents, children)
    * insertion
    * removal
    * searching
    * traversal (pre-order, post-order, in-order)
  * Graphs
  * Hash Tables (keys, collisions)
</WRAP>

=====HPC0=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * Introduction & Getting Started
  * UNIX review (as a user)
  * UNIX review (as a developer)
  * UNIX as an administrator
  * UNIX networking tools
  * security
  * package management
  * file access / transfer
</WRAP>
<WRAP>
  * networking services
  * system administration
  * documentation
  * backups
  * virtualization
  * visualization
  * installation
  * configuration
</WRAP>

=====HPC1=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * lab operations
  * maintenance
  * logging
  * accessibility
  * upgrades
  * backups
  * documentation
</WRAP>
<WRAP>
  * resource usability
  * remote administration
  * on-site administration
  * security - internal
  * log analysis
  * troubleshooting
  * security - external
</WRAP>

=====HPC2=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * lab operations
  * maintenance
  * logging
  * accessibility
  * upgrades
  * backups
  * documentation
</WRAP>
<WRAP>
  * resource usability
  * remote administration
  * on-site administration
  * security - internal
  * log analysis
  * troubleshooting
  * security - external
</WRAP>

=====SYSNET=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * Communication
  * Concurrency
  * Documentation
  * Investigation
  * Creation
  * Collaboration
</WRAP>
<WRAP>
  * Clusters
  * Resource Utilization
  * Exploration
  * Projects
  * Deployment
  * Implementation
</WRAP>

=====SYSPROG=====
The following is a list of the major topics being covered in this course:

<WRAP column 49%>
  * UNIX Systems Programming
    * User space
    * Kernel, Kernel space
  * Users, Files, and the Manual
    * File Access (open, read, write, lseek, close)
    * File descriptors
    * Buffering
    * System Calls
  * Directories and File Properties
    * File Types and File Properties
    * Bit Sets and Bit Masks
    * User IDs, Group IDs
  * Focus on File Systems
    * Filesystem Structure; inodes and data blocks
    * Directories
    * Links
  * Connection Control
    * Device files
    * Race conditions
    * Atomic Operations
    * Streams
  * Terminal Control and Signals
    * Blocking vs. Non-Blocking
    * Signals
  * Event-Driven Programming
    * Alarms, Interval Timers
    * Reentrant code, critical sections
    * Asynchronous input
</WRAP>
<WRAP>
  * Processes and Programs
    * UNIX process model, processes
    * Parent/Child processes
  * Shell Variables and the Environment
  * I/O Redirection and Pipes
    * I/O Redirection
    * Pipes
  * Servers and Sockets
    * Client/Server model
    * Coroutines
  * Connections and Protocols
    * Server sockets
    * Client sockets
    * Zombies
  * Programming with Datagrams
    * TCP vs. UDP
    * Distributed Systems
    * UNIX domain sockets
  * Threads
    * Multithreading
    * Creating/destroying threads
    * Sharing data between threads
    * Synchronizing data
  * Inter Process Communication
    * Named pipes
    * Shared memory
    * File locks
    * Semaphores
</WRAP>

=====UNIX=====
The following is a list of the major topics being covered in this course:

<WRAP>
  * Local host
  * Remote host
  * Home directory
  * Current working directory
  * Types of files (regular, directory, special)
  * File manipulation
  * Text Processing
  * The VI editor
  * The UNIX Shell
    * Environment variable
    * $PATH
    * wildcards
    * tab completion
  * Job Control
  * The UNIX Programming Environment
    * Compiler, Assembler, Linker, Loader
    * Source Code, Object Code, Binary Code, Library
  * Pattern Matching
  * Regular Expressions
  * Filtering
  * Shell Scripting
  * networking, UNIX Networking Tools
  * Security
  * X Window System
</WRAP>