Skip to main content
Fennie
HomeGet Started
UMD
Computer Science
4 credits

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.

Build my CMSC 131 study plan

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 — and 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. 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. 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. 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. 4

    Practice writing Java on paper weekly

    Exams are handwritten — no compiler, no autocomplete. Producing methods and tracing output on paper is a trainable skill that IDE-only practice never builds.

  5. 5

    Build the rhythm on a Fennie Daily Plan

    Upload the CMSC 131 syllabus and Fennie schedules daily coding practice and project start dates ahead of deadlines, with quizzes generated from your actual course materials to test on-paper fluency before exams do. Free to start.

    Start my CMSC 131 plan free

How Fennie helps with CMSC 131

Fennie's Daily Plans put CMSC 131's project drumbeat on a schedule — start dates ahead of deadlines, daily coding reps in between — so hidden-test failures get found with days to spare. Chat explains why your code behaves as it does, reference by reference, building the tracing skill the handwritten exams grade.

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.

Pass CMSC 131 with a plan, not a cram

Upload your CMSC 131 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 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 — 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.