Michigan 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.

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

Build my EECS 370 study plan

What makes it hard

Pipelining and caches are the walls — the concepts are simple to state and brutally detailed to execute, and exam questions about hazards, stalls, and cache hit patterns demand exact bookkeeping. The projects are long C programs where a subtle indexing bug costs hours, and students who let project crunch eat exam prep get caught by the detail-dense midterms.

What you'll cover

• Assembly language and ISAs
• Datapath and control
• Pipelining and hazards
• Caches and memory hierarchy
• Virtual memory
• C programming for systems projects

The EECS 370 study guide

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

1
Trace the pipeline by hand, cycle by cycle
Draw pipeline diagrams for instruction sequences and mark every stall and forward. Exams grade exact cycle bookkeeping, and the precision only comes from doing it on paper repeatedly.
2
Work cache problems until the arithmetic is boring
Index, tag, offset, hit, miss — cache questions are mechanical once the address-breakdown habit is automatic. Volume now buys back exam minutes later.
3
Start projects early and test incrementally
The simulator and assembler projects punish big-bang debugging. Build in small tested pieces, because finding an indexing bug in 500 untested lines is how weekends disappear.
4
Use old exams as the study spine
Past EECS 370 exams show exactly how pipelining and cache questions are framed. Work them timed and audit every miss down to the specific bookkeeping slip.
5
Deconflict projects and exams with Fennie
Upload the EECS 370 schedule and Fennie's Daily Plan interleaves project milestones with steady exam-topic review, generating cache and pipeline quizzes from your actual course materials. Free to start.
Start my EECS 370 plan free

How Fennie helps with EECS 370

Fennie's Daily Plans interleave EECS 370's project deadlines with steady exam review, so pipeline and cache fluency isn't sacrificed to debugging marathons. Chat through a hazard scenario step by step when the lecture diagram won't click, and drill address-breakdown problems with generated quizzes.

FAQ

Is EECS 370 hard at Michigan?

It's considered moderate-to-hard in the core — easier than 281 for most, but the exams demand exact detail on pipelining and caches, and the C projects are real time commitments. Students who keep cycle-level tracing skills sharp through the term find the exams fair.

How long do EECS 370 projects take?

Plan for 10-20 hours per project depending on your C comfort and debugging luck. Incremental testing is the variable you control — students who build in small verified pieces spend dramatically less time lost in debugging.

What should I review before EECS 370?

C programming from EECS 280 — pointers, arrays, and bit manipulation get used immediately in projects. The architecture content is taught from scratch, but weak C turns every project into a double assignment.

Pass EECS 370 with a plan, not a cram

Upload your EECS 370 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 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.

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.