UMD 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.
Fennie is independent and not affiliated with University of Maryland. This is an unofficial study guide.
What makes it hard
The projects are autograded against release tests plus hidden tests, so code that 'basically works' loses real points, and the style and submission rules are enforced mechanically. Exams require writing and tracing Java by hand, which is a different skill from coding in an IDE. The course moves at major pace whether or not you've programmed before.
What you'll cover
- • Java fundamentals and program structure
- • Objects, classes, and methods
- • Conditionals and loops
- • Arrays and ArrayLists
- • Reference semantics and memory diagrams
- • Testing and debugging basics
The CMSC 131 study guide
How to study for UMD CMSC 131, step by step.
- 1
Code daily from the first week
CMSC 131's pace assumes momentum, and the projects arrive on a fixed drumbeat. Twenty to forty minutes of daily Java keeps every week's concepts load-bearing for the next project.
- 2
Start projects the day they open
Hidden tests punish deadline-night code: the failures you can't see need calendar time to find. Early starts convert autograder surprises into routine debugging.
- 3
Draw memory diagrams for reference semantics
What a variable holds versus what it points to is the conceptual heart of early CMSC 131 exams. Diagram object references by hand until aliasing questions stop being traps.
- 4
Practice writing Java on paper weekly
Exams are handwritten, with no compiler and no autocomplete. Producing methods and tracing output on paper is a trainable skill that IDE-only practice never builds.
Today's CMSC 131 plan
What a Fennie Daily Plan looks like for CMSC 131. Yours is built from your syllabus and adapts every day to your deadlines and progress.
- Review: Reference semantics and memory diagramsReview · 25 min
Work back through the CMSC 131 material on reference semantics and memory diagrams. In the app, Fennie builds this from your own notes and syllabus.
- Practice: Testing and debugging basicsPractice · 20 min
Targeted problems on testing and debugging basics, the kind CMSC 131 actually tests.
- Quick quiz: Java fundamentals and program structureQuiz · 10 min
Five generated questions to expose weak spots on java fundamentals and program structure before the exam does.
- Preview: Objects, classes, and methodsPreview · 10 min
A first pass over objects, classes, and methods so the next session starts from familiar ground.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CMSC 131 at UMD hard?
It's a real CS-major course: autograded projects with hidden tests, strict submission rules, and handwritten exams. Beginners pass it routinely, but with daily practice and early project starts, not with deadline-night coding.
Do I need programming experience for CMSC 131?
No, it assumes none; students with experience often skip ahead via the placement exam. But it moves at major pace, so true beginners should budget consistent daily practice rather than trusting the gentle first weeks.
How are CMSC 131 projects graded?
By autograder, against release tests you can run plus additional tests you can't see, with style and submission rules enforced. Writing your own edge-case tests and starting early are the two habits that protect project grades.
More UMD courses
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.
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. It's 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.