Oregon State CS 374: Operating Systems I
CS 374, the renumbered CS 344 (search both codes), covers operating system fundamentals through serious C programming: processes, signals, threads, synchronization, memory, and I/O on Unix. Its centerpiece is the legendary smallsh project, where students build a working shell from scratch.
Fennie is independent and not affiliated with Oregon State University. This is an unofficial study guide.
What makes it hard
It's the program's famous gauntlet: students arrive from Python and meet C, pointers, manual memory management, and Unix process semantics simultaneously, with projects that segfault rather than explain. The smallsh shell project is the rite of passage (fork, exec, signal handling, and process management in one assignment), and the quarter clock makes late starts unrecoverable.
What you'll cover
- • C programming and memory management
- • Processes, fork, and exec
- • Signals and signal handling
- • Threads and synchronization
- • Inter-process communication
- • Unix system calls and I/O
The CS 374 study guide
How to study for Oregon State CS 374, step by step.
- 1
Rebuild your C before the term starts
Pointers, malloc/free, strings, and structs, all solid before week one. CS 374 teaches operating systems; it only reviews C at a pace that punishes anyone learning it fresh.
- 2
Draw the process diagrams
Fork trees, file descriptor tables, signal flows: on paper, for every example and every project component. Unix process behavior is graphical; text-only understanding is the segfault factory.
- 3
Start smallsh the day it opens
The shell project is the course, and it cannot be compressed into a weekend; community wisdom and the assignment's own structure both say weeks. Early commits are the only known path.
- 4
Learn the debugging tools as survival gear
gdb and valgrind aren't optional extras in C; they're how invisible memory errors become visible. An evening learning them repays itself on the first mysterious crash.
Today
Today's CS 374 plan
What a Fennie Daily Plan looks like for CS 374. 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 374 the same as CS 344 at Oregon State?
Yes. Operating Systems I was renumbered from CS 344 to CS 374, so the years of blog posts, GitHub repos, and Reddit threads under the old number describe this course's lineage. Verify current project details against your own syllabus, since the course evolves.
How hard is the smallsh project?
It's the program's most storied assignment: a working shell with fork, exec, redirection, and signal handling. It's very doable started early and built incrementally, and nearly undoable started the weekend before. Plan it like a multi-week project, because it is one.
How much C do I need before CS 374?
Comfortable pointers, manual memory management, and C strings, learned before the term rather than during it. The course's hardest weeks are hardest precisely for students debugging their C and their understanding of processes at the same time.
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.