UW CSE 311: Foundations of Computing I
CSE 311 is UW's discrete math and theory course: propositional logic, proofs, set theory, induction, regular expressions, and finite automata. It's the first course in the major where the work is writing proofs instead of writing programs, and it underpins everything from CSE 312 to algorithms.
Fennie is independent and not affiliated with University of Washington. This is an unofficial study guide.
What makes it hard
The jump from programming to proof-writing is the whole difficulty: students who have never written a formal proof suddenly need induction arguments graded on rigor, not just correctness. English-to-logic translation and strong induction are common midterm killers, and partial credit depends on precise notation.
What you'll cover
- • Propositional and predicate logic
- • Set theory
- • Modular arithmetic
- • Induction and strong induction
- • Regular expressions and context-free grammars
- • DFAs, NFAs, and uncomputability
The CSE 311 study guide
How to study for UW CSE 311, step by step.
- 1
Accept that CSE 311 is a writing course
You're being graded on rigor and notation, not just correct answers. Slow down, define your variables, and justify every step. Partial credit lives in the precision.
- 2
Practice English-to-logic translation daily
Take sentences from anywhere and formalize them with quantifiers, then negate them. Translation errors are the most common midterm point-loss, and the skill only builds through volume.
- 3
Rewrite lecture proofs from memory
After each lecture, close your notes and reproduce the day's main proof. Where you get stuck is exactly what you didn't actually understand. Reread, then try again the next day.
- 4
Grade your own homework against posted solutions
Compare line by line, not just conclusion to conclusion. An induction proof with a vague inductive hypothesis feels right and scores poorly; learning to see the difference is the course.
Today
Today's CSE 311 plan
What a Fennie Daily Plan looks like for CSE 311. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CSE 311 hard?
It's widely considered one of the harder required CSE courses because it's the first proof-based class. Programming skill doesn't transfer directly. Rigor and notation do the heavy lifting.
What math do I need before CSE 311?
Comfort with algebra and the maturity from the calculus sequence helps, but the course teaches its own toolkit. The prerequisite chain runs through the CSE 12X programming courses and MATH 126 or equivalent per current requirements.
How do I get better at CSE 311 proofs?
Volume and feedback. Write proofs daily, compare against posted solutions line by line, and rework every problem you missed. Reading proofs feels productive but doesn't build the skill.
More UW courses
CSE 121: Introduction to Computer Programming I
CSE 121 is UW's no-experience-required intro to programming in Java, the first course in the CSE 12X sequence that replaced the old CSE 142/143 in 2022. It's designed for students who have never written code, covering variables, control flow, methods, and arrays through weekly programming assignments.
CSE 122: Introduction to Computer Programming II
CSE 122 is the second course in UW's intro programming sequence, and the usual starting point for students with AP CS A credit or prior coding experience. It covers data structures from the client perspective (lists, sets, maps, stacks, queues) plus file processing and reasoning about code complexity.
CSE 123: Introduction to Computer Programming III
CSE 123 completes UW's intro programming sequence, shifting from using data structures to building them. Students implement linked lists and binary trees, write recursive algorithms, and design class hierarchies with inheritance and interfaces, the material that used to be the back half of CSE 143.
CSE 332: Data Structures and Parallelism
CSE 332 is the Allen School's core data structures and algorithms course: asymptotic analysis, balanced trees, hashing, sorting, graph algorithms, and, distinctively, parallelism and concurrency with the ForkJoin framework. It's a gateway to most upper-division CSE courses.