UMD CMSC 132: Object-Oriented Programming II

CMSC 132 continues UMD's Java sequence into data structures and design — inheritance, recursion, linked lists, trees, hash tables, and intro threads — with bigger autograded projects and the same handwritten-exam format as 131.

Fennie is independent and not affiliated with University of Maryland. This is an unofficial study guide.

Build my CMSC 132 study plan

What makes it hard

Recursion and linked structures are the famous walls: both require reasoning about references and call stacks abstractly, and trial-and-error coding stops working. The projects get long enough that late starts are unrecoverable, and 132's material is exactly what CMSC 216 and 250 assume on day one.

What you'll cover

• Inheritance and polymorphism
• Recursion
• Linked lists, stacks, and queues
• Trees and binary search trees
• Hash tables
• Intro threads and synchronization

The CMSC 132 study guide

How to study for UMD CMSC 132, step by step.

1
Enter with 131 genuinely solid
CMSC 132 assumes reference semantics, classes, and basic design fluently from day one. If any of it is shaky, rehab it in the first week — the course won't slow down to review.
2
Draw every linked-structure operation
Diagram what each reference points to before and after every insert, delete, and traversal. Exams test hand-execution of these operations, and drawing is how the mental model gets built.
3
Learn recursion inductively
Trust the recursive call to handle the smaller case while you reason about one frame. Tracing every call of every example burns students out; the inductive mental model is the actual breakthrough.
4
Start projects the day of release
Debugging recursion and linked structures takes calendar days, not heroic nights, and the autograder's hidden tests find what rushed code misses. Early starts are the whole strategy.
5
Space the hard topics with Fennie
Upload your CMSC 132 syllabus and Fennie's Daily Plan spreads recursion and data-structure practice across weeks, schedules project starts early by design, and quizzes you from the actual course content. It's free to start.
Start my CMSC 132 plan free

How Fennie helps with CMSC 132

Fennie's Daily Plans give CMSC 132's walls — recursion, linked structures — the spaced practice they require, with project starts scheduled early because the autograder shows no mercy to rushed code. Chat traces operations reference by reference and call by call until you can run the code in your head, which is the exam skill.

FAQ

Is CMSC 132 at UMD hard?

It's the course where the CS major gets real: recursion and linked structures demand abstract reasoning, projects grow long, and exams test hand-implementation. Early project starts and consistent tracing practice get students through.

How do I prepare for CMSC 132?

Make CMSC 131's material genuinely fluent — especially references and object design — and practice basic recursion before the course needs it. During the semester, draw diagrams for every data-structure operation you study.

What comes after CMSC 132?

CMSC 216 (computer systems) and CMSC 250 (discrete structures), usually together — a demanding pair that assumes 132's programming maturity. How solidly you finish 132 is a good predictor of how that semester goes.

Pass CMSC 132 with a plan, not a cram

Upload your CMSC 132 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.

Get started free

More UMD courses

CMSC 131 — Object-Oriented Programming I

CMSC 131 is UMD's first programming course for CS majors, taught in Java — objects, control flow, methods, arrays, and intro design — with weekly projects graded by an autograder against test cases you can't see all of. It sets the tone for the entire CMSC sequence.

CMSC 216 — Introduction to Computer Systems

CMSC 216 drops UMD CS majors below the Java abstraction: C programming, pointers, dynamic memory, the UNIX environment, and assembly-level concepts, with substantial autograded projects. It's taken alongside or near CMSC 250 in the sequence.

CMSC 250 — Discrete Structures

CMSC 250 is UMD's discrete math course for CS majors — logic, proof techniques, induction, sets, functions, combinatorics, and probability basics — the course where computer science becomes mathematics for a semester.

CMSC 320 — Introduction to Data Science

CMSC 320 is UMD's data science course — the Python data pipeline from collection and cleaning through exploratory analysis, visualization, basic machine learning, and communication of results, typically culminating in an open-ended final project.