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

=====C4ENG=====
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)
</WRAP>

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

<WRAP column 49%>
  * 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
  * Singly Linked Lists
    * creating
	* inserting
	* appending
	* obtaining
	* copying
	* deleting
  * 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>

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

  * network communications
  * coding
  * protocols
  * network/socket programming
  * error detection
  * data transmission
  * TCP/IP protocol family
  * datagrams
  * transport layer
  * internet/network layer
  * link layer
  * physical layer
  * Programming with Datagrams
  * Threads
  * Inter Process Communication

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

  * Basic Logic
  * Predicate Calculus
  * Sets
  * Set Operations
  * Induction and Deduction
  * Algorithmic Efficiency
  * Matrix Operations
  * Recursion
  * Counting
  * Combinatorics
  * Relations
  * Graphs
  * Trees
  * Boolean Algebra
  * Theory of Computation

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

<WRAP>
  * Introduction
  * Fundamental Game Elements
  * Collaborative Software Development
  * Media libraries: SDL
  * Algorithms and Logic
  * Collision detection
  * Interaction
  * Game Play Considerations
  * Graphics
  * Sprites
  * User Interaction
  * Animation
  * Input: keyboard
  * Input: joystick/gamepad
  * Input: mouse
  * Data files
  * Two player interactions
  * Concurrency/threads
  * Basic Artificial Intelligence
  * Basic networking
  * Audio
</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
  * projects
</WRAP>
<WRAP>
  * research
  * resource configuration and 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>

=====PHP=====
coming soon

=====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 vs. Remote resources
    * Client, Host, Node, Peer, Server
  * Types of files
    * Regular
    * Directory
      * Current/Present Working Directory
      * Home Directory
      * Parent Directory
      * Root Directory
      * Traditional Directory Structure
        * location of common utilities
      * Links (Symbolic)
    * Special
  * Manual Pages
    * Manual Sections
    * apropos, man
  * History
    * origins
    * strains of UNIX
    * flavors of Linux
    * lineage, influence
  * File Manipulation
    * Creating
    * Duplication (Copying)
    * Moving
    * Deleting
    * Archiving, Unarchiving
    * Compressing, Uncompressing
    * Encoding, Decoding
    * Encrypting, Decrypting
  * File Access
    * Ownership
      * User, Group, World
    * Permissions
      * Read, Write, Execute/Search
  * UNIX Philosophy
    * Everything is a File
    * Do One Thing, and Do that One Thing Extremely Well
    * Small is Beautiful
  * Text Processing
    * moded editing, vi/vim editor
    * Filtering
      * cat
      * head, tail
      * tr, cut, grep, sed, diff
  * The UNIX Shell
    * variables
      * local, ENVIRONMENT
      * declaring, initializing, accessing
      * <nowiki>$PATH, $HOME, $USER</nowiki>
      * performing arithmetic
    * wildcards
    * quotes
    * expansion
      * variable expansion
      * command expansion
    * tab completion
    * I/O redirection
      * STDIN, STDOUT, STDERR
      * write/overwrite, append
    * hidden/dotfiles
  * Job Control
    * foreground/background(ing) jobs
    * process management
      * viewing status of running processes (ps, top)
      * altering priority of processes (nice)
      * terminating processes (kill, pkill)
    * job scheduling
      * cron, at
  * The UNIX Programming Environment
    * Compiler (gcc), Assembler, Linker, Loader
    * Source Code, Object Code, Binary Code, Library
    * Relationship between UNIX and C
  * Regular Expressions
    * Pattern Matching
    * Pattern Creation
    * Extended Regular Expressions
      * egrep
  * Shell Scripting
    * shabang
    * bash syntax
    * variables
    * I/O
    * selection statements
      * if
      * case
    * loops
      * numeric for loop
      * list-based for loop
      * while
    * arrays
    * functions
  * Networking
    * UNIX Networking Tools
      * ping, ifconfig, traceroute, route, nslookup
    * TCP/IP
    * standards, protocols, RFCs
  * Security
    * groups
    * application of permissions
    * considerations of access
      * public_html
  * System Administration
    * software
      * package management
      * source
    * logs
    * configuration
    * deployment
  * X Window System
    * X server, X clients, interactions thereof
  * Projects
    * installation of OS
      * virtualization
    * web server
    * blog
    * version control (hg)
    * screen / tmux
    * irc
    * irc bot
    * vim configuration
    * brute-force password cracking
    * automated drawing
    * puzzle box
    * course list processing
</WRAP>