Oregon State CS 361: Software Engineering I
CS 361 introduces software engineering practice: requirements, agile processes, design principles, version control workflows, and a term-long team project built in sprints. It's the course where the program stops grading programs and starts grading how software gets built by groups of humans.
Fennie is independent and not affiliated with Oregon State University. This is an unofficial study guide.
What makes it hard
The challenge is the team: sprints with four or five working adults across time zones, where your grade partially rides on collective output and the process artifacts (user stories, reviews, sprint documents) are graded work, not overhead. Students expecting a coding course are blindsided by how much of the grade is communication, coordination, and writing.
What you'll cover
- • Agile development and sprints
- • Requirements and user stories
- • Software design principles
- • Git workflows and code review
- • Team communication and documentation
The CS 361 study guide
How to study for Oregon State CS 361, step by step.
- 1
Treat process artifacts as graded deliverables
User stories, sprint plans, and reviews carry real points in CS 361. Write them with the same care as code; they're the course's actual subject.
- 2
Establish team rhythms in the first week
Standup cadence, channel, time-zone overlap windows, and a norm for surfacing blockers early. Teams that skip this spend week five discovering why it existed.
- 3
Make your contributions visible and steady
In team grading, invisible work is ungraded work. Commit regularly, write up what you did each sprint, and keep your share of the board moving.
- 4
Learn the Git workflow cold before the project needs it
Branches, pull requests, merge conflicts: practice them solo, before a teammate's deadline depends on your merge. Git fumbles under pressure are the course's most avoidable crisis.
Today
Today's CS 361 plan
What a Fennie Daily Plan looks like for CS 361. 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 CS 361 hard in the OSU postbacc?
Rarely on the technical side; the difficulty is coordination. Team sprints across time zones with everyone employed full-time is the genuine curriculum, and the students who thrive treat communication as part of the job rather than friction around it.
How are teams chosen in CS 361?
Typically assigned or formed early in the term, varying by instructor. Either way, the highest-value move is the same: establish meeting rhythm, channels, and blocker norms in week one, because the sprint clock starts immediately.
What's the difference between CS 361 and CS 362?
361 is building software as a team: process, requirements, design, sprints. 362 turns to verifying it with testing strategies, unit tests, coverage, and CI. They're designed as a sequence, and the 361 project habits carry directly into 362.
More Oregon State courses
CS 161: Introduction to Computer Science I
CS 161 is Oregon State's first programming course: variables, control flow, functions, basic data structures, and program design, currently taught in Python after the curriculum moved away from C++. It opens both the Corvallis CS degree and the Ecampus postbacc, where for many students it's the first code they've ever written.
CS 162: Introduction to Computer Science II
CS 162 continues the intro sequence with object-oriented programming, recursion, basic data structures, and significantly larger programs, taught in Python like CS 161. It carries a reputation as the Ecampus program's first real filter: the course where assignment scope jumps and time management becomes the curriculum.
CS 225: Discrete Structures in Computer Science
CS 225 is the CS department's discrete math course, covering logic, proofs, sets, functions, combinatorics, and graphs. It's required in the Ecampus postbacc and a prerequisite mindset for CS 325. For career changers from non-quantitative fields, it's often the first proof-based math they've ever faced.
CS 261: Data Structures
CS 261 covers the core data structures (dynamic arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs) with implementation assignments and complexity analysis throughout. In the Ecampus postbacc it's taught in Python (older blog posts reference the earlier C version), and it's the technical-interview foundation for the whole program.