Basics of computer systems. Number representations, assembly/machine language, abstract models of processors (fetch/execute, memory hierarchy), processes/process control, simple memory management, file I/O and directories, network programming, usage of cloud services. Credit: 3 hours.
CS 340: Introduction to Computer Systems is a modern approach to computer systems and one of the newest courses in the CS core curriculum, teaching students the foundational of computer architecture, systems progrmaming, and cloud computing. All CS students except CS/ENG can either take a dedicated architecture course (CS 233) and a dedicated systems course (CS 341) or take CS 340 to fulfill both requirements.
One of the highlights of CS 340 is the final project. Each semester, you will be a part of an experience where you are developing a small but integral part of a complex software system. The final system runs with everyone single person in the class contributing code to the project. As part of this project:
The final projects completed in recent semesters have been:
The question I get asked the most is “What is the difference between CS 340 and 233/341?” The answer is two-fold:
CS 340’s focuses on cloud-based systems, which involve all the systems concepts necessary to build systems that run on the cloud. This means we cover the majority of topics in CS 341, plus an additional set of cloud topics only covered in CS 340. You can find a detailed breakdown below.
CS 340 gives you the time (and credit hours) to focus on 400-level courses you’re personally interested in. I feel most of the very best courses we offer at Illinois are at the 400- or 500-level. By taking CS 340, you are able to spend the other 6 credit hours in 400-level courses instead of 200/300-level courses.
Prepared in Summer 2021, based off the content taught Spring 2021.
Topic | CS 340 | CS 233 | CS 341 |
---|---|---|---|
Programming Languages/Technologies | |||
MIPS | ✔️ Many MPs / Labs | ||
C | ✔️ First Half (MP1-MP5) | ✔️ Many Labs (Choice of C or C++) | ✔️ All MPs and Labs |
C++ | ✔️ Many Labs (Choice of C or C++) | ||
Python | ✔️ Second Half (MP6-MP9 + Final Project) | ||
Bash | ✔️ MP7 (Docker) | Lecture Lecture #30 | |
git | ✔️ All Assignments | ✔️ All Assignments | ✔️ All Assignments |
Verilog | ✔️ Early MPs / Labs | ||
Cloud Computing | |||
OSI Model | ✔️ Lecture #14 | ✔️ Lecture #25 | |
IP / IP Addresses | ✔️ Lecture #14 | ✔️ Lecture #24 | |
TCP | ✔️ Lecture #14 | ✔️ Lecture #25 | |
TCP Handshake | ✔️ Lecture #14 | ✔️ Lecture #37 | |
UDP | ✔️ Lecture #14 | ✔️ Lecture #25 | |
HTTP | ✔️ Lecture #11 | ✔️ Lecture #25 | |
HTTP Status Codes | ✔️ Lecture #11 | ✔️ MP Assignment | |
HTTP Verbs | ✔️ Lecture #19 | ✔️ MP Assignment | |
Raw Sockets | ✔️ Lecture #26 | ||
Denial of Service (DoS) | ✔️ Lecture #36 | ||
DDoS / IoT DOS | ✔️ (Not found in course?) | ||
Ports | ✔️ Lecture #16 | ||
Domain Name Service | ✔️ Lecture #20 | ✔️ (Not found in course?) | |
FQDN | ✔️ Lecture #20 | ||
DNS Root Servers | ✔️ Lecture #20 | ||
DNS Records | ✔️ Lecture #20 | ||
CDNs | ✔️ Lecture #20 | ||
Cloud Architectures | |||
Monolithic | ✔️ Lecture #16 | ||
Microservice | ✔️ Lecture #16 | ||
User Account Isolation | ✔️ Lecture #17 | ||
Containerization | ✔️ Lecture #17 | ➕ Optional Content (Honors) | |
Virtualization | ✔️ Lecture #17 | ➕ Optional Content (Honors) | |
MapReduce | ✔️ Lecture #19 | ✔️ Lab MapReduce | |
Data Store: Local Memory | ✔️ Lecture #21 | ✔️ Lab Assignment | |
Data Store: File-Backed Storage | ✔️ Lecture #21 | ||
Data Store: Key-Value Store | ✔️ Lecture #21 | ||
Data Store: NoSQL Databases | ✔️ Lecture #21 | ||
Data Store: SQL Databases | ✔️ Lecture #21 | ||
Infrastructure as a Service | ✔️ Lecture #21 | ||
IaaS: EC2 / GCP | ✔️ Lecture #21 | ||
Platform as a Service | ✔️ Lecture #21 | ||
PaaS: Docker | ✔️ Lecture #21 | ||
Software as a Service | ✔️ Lecture #21 | ||
SaaS: CDN | ✔️ Lecture #21 | ||
Containerization and Virtualization | |||
Container Technology | ✔️ Lecture #18 | ➕ Optional Content (Honors) | |
Docker | ✔️ Lecture #18 | ||
Dockerfile | ✔️ Lecture #18 | ||
Docker Image Hierarchy | ✔️ Lecture #18 | ||
Container File System Mounts | ✔️ Lecture #18 | ||
Container Port Forwarding | ✔️ Lecture #18 | ||
Application Interfaces | |||
API Overview | ✔️ Lecture #19 | ||
RESTful APIs | ✔️ Lecture #19 | ||
Stateful APIs | ✔️ Lecture #19 | ||
Frontend Services | ✔️ Lecture #22 | ||
Middleware Services | ✔️ Lecture #22 | ||
Backend Services | ✔️ Lecture #22 | ||
Common Web Server Stacks | ✔️ Lecture #22 | ||
Computer Architecture | |||
Binary | ✔️ Lecture #2 | ✔️ Lecture #2 | |
Hex | ✔️ Lecture #2 | ✔️ Lecture #2 | |
Two's Complement | ✔️ Lecture #4 | ✔️ Lecture #2 | |
Byte Order | ✔️ Lecture #15 | ✔️ Lecture #7 | ✔️ Lecture #33 |
Endianness | ✔️ Lecture #15 | ✔️ Lecture #7 | |
ASCII | ✔️ Lecture #2 | ✔️ Lecture #11 | |
Unicode / UTF-8 | ✔️ Lecture #2 | ||
File Extensions | ✔️ Lecture #3 | ||
Chunk-Based Encoding | ✔️ Lecture #3 | ||
Serialization | ✔️ Lecture #37 | ||
Compiler Preprocessor | ✔️ Lecture #2 | ||
Circuits / Bit Manipulation | |||
Boolean Logic | ✔️ Lecture #4 | ✔️ Lecture #1 | |
Bitwise Operators | ✔️ Lecture #4 | ✔️ Lecture #1 | |
AND Gate | ✔️ Lecture #4 | ✔️ Lecture #1 | |
OR Gate | ✔️ Lecture #4 | ✔️ Lecture #1 | |
XOR Gate | ✔️ Lecture #5 | ✔️ Lecture #1 | |
NOT Gate | ✔️ Lecture #4 | ✔️ Lecture #1 | |
Truth Tables | ✔️ Lecture #4 | ✔️ Lecture #2 | |
Binary Addition | ✔️ Lecture #4 | ✔️ Lecture #2 | |
Bitshift Operators | ✔️ Lecture #4 | ✔️ Lecture #2 | |
Half Adder | ✔️ Lecture #5 | ✔️ Lecture #3 | |
Full Adder | ✔️ Lecture #5 | ✔️ Lecture #3 | |
Ripple Carry Adder | ✔️ Lecture #5 | ✔️ Lecture #3 | |
Multiplexers | ✔️ Lecture #3 | ||
ALU | ✔️ Lecture #3 | ||
Flip-flops | ✔️ Lecture #4 | ||
Finite State Machines | ✔️ Lecture #4 | ||
Registers | ✔️ Lecture #5 | ||
Reigster Files | ✔️ Lecture #5 | ||
Circuit Propagation Delay | ✔️ Lecture #5 | ||
RAM | ✔️ Lecture #5 | ✔️ Lecture #5 | |
Binary Multiplication | ✔️ Lecture #4 | ✔️ Lecture #6 | |
CPU | |||
Instruction Set Architectures (ISAs) | ✔️ Lecture #1 | ✔️ Lecture #7 | |
Instruction Memory | ✔️ Lecture #7 | ||
Control Instructions | ✔️ Lecture #8 | ||
Load Upper Immediate (LUI) | ✔️ Lecture #8 | ||
LOAD/STORE Pipeline | ✔️ Lecture #9 | ||
CPU Registers | ✔️ Lecture #10 | ||
Register Naming Conventions | ✔️ Lecture #10 | ||
Programming Registers | ✔️ Lecture #10 | ||
Function Call | ✔️ Lecture #11 | ||
Caller Save Functions | ✔️ Lecture #11 | ||
Hardware Interrupts | ✔️ Lecture #13 | ||
Hardware Exceptions | ✔️ Lecture #13 | ||
CPU Registers | ✔️ Lecture #14 | ||
Iron Law of Computing | ✔️ Lecture #14 | ||
Latency and Throughput | ✔️ Lecture #14 | ||
Pipelining | ✔️ Lecture #16 | ||
Stalls and Flushes | ✔️ Lecture #17 | ||
CPU Caches | ✔️ Lecture #20 | ||
Direct-Mapped Caches | ✔️ Lecture #20 | ||
Set Associative Caches | ✔️ Lecture #21 | ||
Cache Prefetching | ✔️ Lecture #23 | ||
TLB | ✔️ Lecture #26 | ✔️ Lecture #21 | |
Power Scaling (Single / Multi-core) | ✔️ Lecture #28 | ||
Cache coherence | ✔️ Lecture #28 | ||
False Sharing | ✔️ Lecture #28 | ||
Computer Systems | |||
Memory Access Patterns | ✔️ Lecture #5 | ✔️ Lecture #22 | ✔️ Lecture #8 |
Memory Hierarchy | ✔️ Lecture #5 | ✔️ Lecture #21 | |
Cache-Optimized Code | ✔️ Lecture #5 | ✔️ Lecture #24 | |
Locality of Reference | ✔️ Lecture #6 | ✔️ Lecture #24 | |
Virtual Memory | ✔️ Lecture #6 | ✔️ Lecture #26 | ✔️ Lecture #21 |
Segmentation | ✔️ Lecture #6 | ✔️ Lecture #8 | |
Heap Memory Allocation | ✔️ Lecture #7 | ✔️ Lecture #1 | |
Pointers | ✔️ Lecture #7 | ✔️ Lecture #12 | ✔️ Lecture #3 |
Pointer Arithmetic | ✔️ Lecture #7 | ✔️ Lecture #11 | ✔️ Lecture #3 |
Malloc Specifics | ✔️ Lecture #7 | ✔️ Lecture #8 | |
Memory Coalescing | ✔️ Lecture #8 | ✔️ Lecture #9 | |
Free Lists | ✔️ Lecture #8 | ✔️ Lecture #9 | |
Buffer Overflow | ✔️ Lecture #10 | ||
Memory Pools | ✔️ Lecture #10 | ||
Memory Byte/Word Alignment | ✔️ Lecture #10 | ||
Page Tables | ✔️ Lecture #9 | ✔️ Lecture #26 | ✔️ Lecture #21 |
Page Table Index and Offset Bits | ✔️ Lecture #9 | ✔️ Lecture #26 | ✔️ Lecture #21 |
Page Table Sizes | ✔️ Lecture #9 | ✔️ Lecture #26 | ✔️ Lecture #21 |
Multi-Level Page Tables | ✔️ Lecture #9 | ✔️ Lecture #26 | ✔️ Lecture #21 |
Virtual Pages | ✔️ Lecture #9 | ✔️ Lecture #21 | |
Page Faults | ✔️ Lecture #9 | ✔️ Lecture #26 | ✔️ Lecture #21 |
Optimal Page Replacement | ✔️ Lecture #9 | ✔️ Lecture #21 | |
Page Replacement Schemes | ✔️ Lecture #9 | ✔️ Lecture #21 | |
Segmentation Fault | ✔️ Lecture #9 | ✔️ Lecture #21 | |
OS, Threads, and Processes | |||
POST / EFI | ✔️ Lecture #10 | ||
Bootloader | ✔️ Lecture #10 | ||
Init Process | ✔️ Lecture #10 | ||
Processes | ✔️ Lecture #10 | ✔️ Lecture #6 | |
Context Switching | ✔️ Lecture #10 | ✔️ Lecture #32 | |
Fork-Exec-Wait Pattern | ✔️ Lecture #6 | ||
Environmental Variables | ✔️ Lecture #16 | ✔️ Lecture #5 | |
Signals | ✔️ Lecture #7 | ||
Signal Masking | ✔️ Lecture #35 | ||
Threads | ✔️ Lecture #10 | ✔️ Lecture #28 | ✔️ Lecture #11 |
Thread Start | ✔️ Lecture #12 | ✔️ Lecture #11 | |
Thread Join | ✔️ Lecture #12 | ✔️ Lecture #11 | |
Thread Parallelism | ✔️ Lecture #12 | ✔️ Lecture #11 | |
Thread Pools | ✔️ (Not found in course?) | ||
Task Queues | ✔️ (Not found in course?) | ||
Processes vs. Threads | ✔️ Lecture #12 | ✔️ Lecture #11 | |
Blocking Operations | ✔️ Lecture #12 | ✔️ Lecture #14 | |
User Accounts | ✔️ Lecture #17 | ✔️ Lecture #30 | |
SUID, UID, EUID | ✔️ (Not found in course?) | ||
Non-blocking I/O | ✔️ (Not found in course?) | ||
Synchronization | |||
Critical Sections | ✔️ Lecture #13 | ✔️ Lecture #13 | |
Atomic Operations | ✔️ Lecture #28 | ||
Mutex Locks | ✔️ Lecture #12 | ✔️ Lecture #28 | ✔️ Lecture #13 |
Race Conditions | ✔️ Lecture #13 | ✔️ Lecture #28 | ✔️ Lecture #14 |
Conditional Variables | ✔️ Lecture #13 | ✔️ Lecture #15 | |
Semaphores | ✔️ Lecture #16 | ||
Barriers | ✔️ Lecture #18 | ||
Producer/Consumer Model | ✔️ Lecture #17 | ||
Readers-Writers Problem | ✔️ Lecture #17 | ||
Deadlock | ✔️ Lecture #13 | ✔️ Lecture #18 | |
Coffman Conditions | ✔️ Lecture #13 | ✔️ Lecture #19 | |
Resource Allocation Graphs | ✔️ Lecture #19 | ||
Livelock | ✔️ Lecture #13 | ✔️ Lecture #20 | |
Dining Philosophers | ✔️ Lecture #13 | ✔️ Lecture #20 | |
Peterson's Solution | ✔️ Lecture #14 | ||
Banker's algorithm | ✔️ Lecture #19 | ||
IPC | |||
Pipes | ✔️ Lecture #10 | ✔️ Lecture #22 | |
mmap | ✔️ Lecture #10 | ✔️ Lecture #21 | |
I/O Multiplexing | ✔️ Lecture #33 | ||
RPC | ✔️ Lecture #10 | ✔️ Lecture #37 | |
Common Message Formats | ✔️ Lecture #10 | ✔️ (Not found in course?) | |
File Systems and Disks | |||
Reading / Writing Files To System | ✔️ Lecture #4 | ✔️ Lecture #4 | |
Technical File I/O | ✔️ Lecture #4 | ||
Circular Buffer | ✔️ Lecture #16 | ||
File Seek | ✔️ Lecture #22 | ||
inodes | ✔️ Lecture #27 | ||
direct blocks | ✔️ Lecture #27 | ||
indirect blocks | ✔️ Lecture #27 | ||
Linux Permission Bits | ✔️ Lecture #28 | ||
Symbolic Links | ✔️ Lecture #29 | ||
Hard Links | ✔️ Lecture #29 | ||
Hidden Files | ✔️ Lecture #29 | ||
I/O Multiplexing | ✔️ Lecture #30 | ||
Linux Virtual File System (/proc, etc) | ✔️ (Not found in course?) | ||
RAID | ✔️ Lecture #26 | ✔️ Lecture #31 | |
HDDs (Spinning Disks) | ✔️ Lecture #26 | ✔️ Lecture #34 | |
SSDs | ✔️ Lecture #26 | ✔️ Lecture #34 | |
Scheduling | |||
CPU Scheduling | ✔️ Lecture #32 | ||
FIFO | ✔️ Lecture #32 | ||
EDF | ✔️ Lecture #32 | ||
Round Robin | ✔️ Lecture #32 | ||
Starvation | ✔️ Lecture #32 | ||
Security | |||
Confidentiality Integrity Availability | ✔️ Textbook Reading | ||
Code analysis | ✔️ Textbook Reading | ||
Broken trust boundaries | ✔️ Textbook Reading | ||
Reuse after free | ✔️ Textbook Reading | ||
Adversarial networks | ✔️ Textbook Reading | ||
Broken thread initialization | ✔️ Textbook Reading | ||
Broken turn-based CSP | ✔️ Textbook Reading | ||
Broken circular buffer | ✔️ Textbook Reading |