UW CSE 331: Software Design and Implementation
CSE 331 teaches how to design and build reliable, maintainable software: specifications, reasoning about correctness, testing strategies, and program structure, with substantial programming in a modern high-level language. It's the course where students learn to write code that other people, and their future selves, can trust and extend.
Fennie is independent and not affiliated with University of Washington. This is an unofficial study guide.
What makes it hard
The hard part isn't writing code, it's writing code you can argue is correct. Formal specifications, reasoning about invariants, and justifying design decisions are unfamiliar to students used to 'it compiles and passes my tests.' The assignments are large, multi-week builds where early design mistakes compound, and the conceptual material on specs and abstraction functions is dense.
What you'll cover
- • Specifications and preconditions/postconditions
- • Reasoning about correctness and invariants
- • Abstraction functions and representation invariants
- • Testing strategies and coverage
- • Program structure and modularity
- • Event-driven and interactive programs
The CSE 331 study guide
How to study for UW CSE 331, step by step.
- 1
Internalize specifications before the first big assignment
CSE 331 lives and dies on precise specs: preconditions, postconditions, what a method promises. Spend the early weeks writing and reading specifications until they feel natural, because every later assignment assumes the skill.
- 2
Design on paper before writing code
The multi-week assignments punish students who start coding immediately. Sketch your abstraction, the invariants it must maintain, and the interfaces first. Design mistakes caught on paper are cheap; the same mistakes found mid-build are not.
- 3
Write tests from the spec, not the implementation
Practice deriving test cases from what a method promises rather than from the code you wrote. That's both the course philosophy and the way the assignments are graded for thoroughness.
- 4
Reason about invariants out loud
For each data structure, articulate the representation invariant and the abstraction function in plain words. Being able to explain why your code is correct is the conceptual core CSE 331 is testing.
Today
Today's CSE 331 plan
What a Fennie Daily Plan looks like for CSE 331. 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 331 hard?
It's conceptually demanding in a different way than the intro courses. The challenge is reasoning rigorously about correctness and design, not raw coding. The large assignments also reward starting early and designing before building.
What language does CSE 331 use?
It's taught in a modern high-level language with an emphasis on specifications and design principles that transfer across languages. Check the current course offering, as the specific language and tooling have shifted over the years.
How should I approach CSE 331 assignments?
Design on paper first: sketch abstractions, invariants, and interfaces before coding. Then write tests from the specification rather than the implementation. Starting late is the single most common way students struggle.
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 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.