=====ASM=====
The following is a list of the major topics being covered in this course:
* 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
=====COMPESS=====
The following is a list of the major topics being covered in this course:
* Number Systems
* Digital Processing
* Computer Hardware
* System Software
* Application Software
* Artificial Intelligence
* System Development
* Telecommunications
* Internet and Web
* Databases
* Security, Privacy, Ethical Issues
* Programming
* Computer History
=====CPROG=====
The following is a list of the major topics being covered in this course:
* 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++]
=====DATA=====
The following is a list of the major topics being covered in this course:
* 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?
* 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)
=====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
=====HPC0=====
The following is a list of the major topics being covered in this course:
* 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
* networking services
* system administration
* documentation
* backups
* virtualization
* visualization
* installation
* configuration
=====HPC1=====
The following is a list of the major topics being covered in this course:
* lab operations
* maintenance
* logging
* accessibility
* upgrades
* backups
* documentation
* resource usability
* remote administration
* on-site administration
* security - internal
* log analysis
* troubleshooting
* security - external
=====HPC2=====
The following is a list of the major topics being covered in this course:
* lab operations
* maintenance
* logging
* accessibility
* upgrades
* backups
* documentation
* resource usability
* remote administration
* on-site administration
* security - internal
* log analysis
* troubleshooting
* security - external
=====SYSNET=====
The following is a list of the major topics being covered in this course:
* Communication
* Concurrency
* Documentation
* Investigation
* Creation
* Collaboration
* Clusters
* Resource Utilization
* Exploration
* Projects
* Deployment
* Implementation
=====SYSPROG=====
The following is a list of the major topics being covered in this course:
* 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
* 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
=====UNIX=====
The following is a list of the major topics being covered in this course:
* 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