UIUC CS 128: Introduction to Computer Science II
CS 128 is the second course in UIUC's CS sequence, moving students into C++ with memory management, object-oriented design, and an introduction to data structures and software engineering practice. It bridges CS 124 and the heavyweight CS 225.
Fennie is independent and not affiliated with University of Illinois Urbana-Champaign. This is an unofficial study guide.
What makes it hard
The transition to C++ (pointers, memory, compilation) is the core difficulty, especially for students whose only experience is CS 124's managed languages. Many students take it alongside CS 173, and the combined workload of that pairing is a recurring warning on the UIUC subreddit.
What you'll cover
- • C++ fundamentals
- • Pointers and memory management
- • Object-oriented design in C++
- • Introductory data structures
- • Testing and debugging
- • Software engineering practices
The CS 128 study guide
How to study for UIUC CS 128, step by step.
- 1
Plan the semester load honestly
CS 128 paired with CS 173 is the heaviest lower-division semester in the major and a recurring subreddit warning. If that's your schedule, block the hours for both up front instead of discovering the overload in week six.
- 2
Draw memory for every pointer exercise
C++ exposes the memory management CS 124's languages hid. Sketch the stack and heap until you can predict exactly what each pointer operation does; CS 225 assumes this fluency without mercy.
- 3
Befriend the compiler by breaking things
Compilation errors, segfaults, and undefined behavior teach faster when you trigger them deliberately. Modify working code to fail in specific ways and explain each failure. That's real C++ understanding forming.
- 4
Drill code tracing for the proctored assessments
CBTF-style assessments test reading and predicting C++ behavior under proctored conditions. Regular paper-tracing practice keeps the format from costing you points the content didn't.
Today
Today's CS 128 plan
What a Fennie Daily Plan looks like for CS 128. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CS 128 hard at UIUC?
It's a meaningful step up from CS 124 because C++ exposes memory management the earlier course hid. The course itself is well-run; difficulty spikes mostly for students pairing it with CS 173 in the same semester, which is common and demanding.
Should I take CS 128 and CS 173 together?
It's the standard path and it's doable, but it's the heaviest lower-division semester in the major, so budget accordingly. If your schedule allows splitting them, the lighter load makes both courses more learnable.
How does CS 128 prepare me for CS 225?
CS 225 assumes C++ fluency (pointers, classes, memory), and CS 128 is where you build it. Students who limp through 128's memory material are the ones who suffer most in 225, so invest in genuinely understanding it now.
More UIUC courses
CS 124: Introduction to Computer Science I
CS 124 is UIUC's first programming course for CS majors, taught in Java or Kotlin (students choose), covering programming fundamentals through basic data structures and even Android development. It replaced the old CS 125 and is known for its polished homework infrastructure with daily small assignments.
CS 173: Discrete Structures
CS 173 is UIUC's discrete math course, covering logic, proofs, induction, sets, functions, graphs, and counting. It's the theory foundation for CS 225 and the algorithms coursework beyond. For most students it's their first proof-based mathematics.
CS 225: Data Structures
CS 225 is UIUC's famous data structures course in C++, covering lists, trees, AVL and B-trees, hashing, heaps, disjoint sets, and graph algorithms, delivered through MPs (machine problems) and weekly labs. It's the make-or-break course of the CS major and the one alumni still talk about.
CS 233: Computer Architecture
CS 233 is UIUC's computer architecture course, covering digital logic, MIPS assembly, processor datapaths, pipelining, and caches, taken after CS 225 in the CS core. It's known for its tightly engineered PrairieLearn workflow: practice problems with unlimited retries feeding frequent proctored quizzes.