Skip to main content
Fennie
HomeGet Started
Michigan
Electrical Engineering and Computer Science
4 credits

Michigan EECS 280: Programming and Introductory Data Structures

EECS 280 is the second course in Michigan's CS sequence, covering C++ programming in depth: pointers, dynamic memory, container ADTs, polymorphism, and recursion. It's a prerequisite for nearly everything in the CS major and the course where Michigan students first hit serious multi-week projects.

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

Build my EECS 280 study plan

What makes it hard

The projects are the course — four or five large C++ projects with autograders, hidden test cases, and a strict honor code around code similarity. Pointers and dynamic memory wreck students who only skimmed lecture, and the exams test reading and tracing C++ by hand, which is a different skill than getting the autograder to pass.

What you'll cover

  • • C++ pointers and references
  • • Dynamic memory and the Big Three
  • • Container ADTs and templates
  • • Inheritance and polymorphism
  • • Recursion and functional patterns
  • • Testing and debugging large programs

The EECS 280 study guide

How to study for Michigan EECS 280, step by step.

  1. 1

    Start projects the week they're released

    EECS 280 projects take 15-30 hours and are designed to span multiple weeks. Starting early is the single biggest predictor of success in this course — the autograder queue and office hours both get ugly near deadlines.

  2. 2

    Draw a memory diagram for every pointer exercise

    Pointers and dynamic memory wreck students who only skimmed lecture. Sketch the stack and heap by hand until you can predict exactly what each line does to memory.

  3. 3

    Write your own tests before trusting the autograder

    Hidden test cases mean a green submission isn't a finished project. Build small unit tests for edge cases as you go — it's also the fastest way to actually understand the Big Three.

  4. 4

    Drill hand-tracing with old exams

    Michigan keeps past EECS 280 exams accessible, and the exams test reading and tracing C++ on paper — a different skill from getting projects to pass. Predict output before checking, every time.

  5. 5

    Let Fennie pace the whole semester

    Feed the EECS 280 schedule to Fennie and Daily Plans spread project work and exam prep across the weeks so project crunch never collides with midterms, with quizzes and flashcards built from your own course materials. It's free to start.

    Start my EECS 280 plan free

How Fennie helps with EECS 280

Feed Fennie the EECS 280 schedule and Daily Plans spread project work and exam prep across the weeks so the notorious project crunch doesn't collide with midterms. Use chat to work through pointer semantics and memory diagrams until they actually click, and drill exam-style code-tracing with generated practice questions — Fennie helps you understand the material, not write your project for you.

FAQ

Is EECS 280 hard?

It's widely considered the first real filter in Michigan CS. The concepts (pointers, memory, polymorphism) are genuinely hard the first time, and the projects take 15-30 hours each. Students who start projects the week they're released do fine; procrastinators suffer.

How much time does EECS 280 take per week?

Plan on 10-15 hours a week, spiking higher during project deadlines. The projects are designed to take multiple weeks — the single biggest predictor of success is starting early.

How do I prepare for EECS 280 exams?

The exams emphasize tracing C++ by hand — pointers, memory diagrams, polymorphism behavior. Practice with old exams and force yourself to predict output on paper before checking. Passing the autograder on projects is not the same skill as exam tracing.

Pass EECS 280 with a plan, not a cram

Upload your EECS 280 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 Michigan courses

EECS 183 — Elementary Programming Concepts

EECS 183 is Michigan's intro programming course for students with little or no coding experience, taught in C++ and Python. It's the standard entry point into the CS sequence for students who aren't ready to jump straight into EECS 280, and it ends with an open-ended final team project.

EECS 281 — Data Structures and Algorithms

EECS 281 is Michigan's data structures and algorithms course and the gateway to upper-level CS — most 400-level EECS courses require it. It covers algorithm analysis, sorting, hashing, trees, graphs, and dynamic programming, with large C++ projects graded heavily on runtime performance.

EECS 203 — Discrete Mathematics

EECS 203 is the discrete math requirement for the CS major, covering logic, proofs, set theory, combinatorics, graphs, and an introduction to algorithm analysis. It's typically taken alongside EECS 280, and together they form the gateway pair into the Michigan CS core.

EECS 370 — Introduction to Computer Organization

EECS 370 covers how computers actually execute programs: assembly language, instruction set architecture, pipelining, caches, and virtual memory. It's a core requirement after EECS 280, with projects that include building a simulator and an assembler in C.