UCLA CS 35L: Software Construction
CS 35L is UCLA's software-construction course, teaching the practical toolchain upper-division CS assumes: the Unix/Linux command line, shell scripting, Git, build systems, Python and scripting, and a collaborative software project. Long associated with Professor Eggert, it's the course that turns students into functional engineers.
Fennie is independent and not affiliated with UCLA. This is an unofficial study guide.
What makes it hard
The breadth is the difficulty: weekly assignments jump across tools, and there's no single textbook thread to follow. Eggert's reputation for precise, detail-punishing assignments is well earned, and the open-ended final project plus a ten-week pace mean small daily friction with unfamiliar tools compounds quickly.
What you'll cover
- • Unix/Linux command line
- • Shell scripting
- • Version control with Git
- • Build tools and debugging
- • Python and scripting languages
- • Collaborative software projects
The CS 35L study guide
How to study for UCLA CS 35L, step by step.
- 1
Live in the terminal from week one
CS 35L's tools only stick through use. Make the command line and Git your default for everything immediately. The fluency you build casually is exactly what the assignments grade.
- 2
Read each assignment spec twice before starting
Eggert-style assignments punish detail misses as much as bugs. Parse exactly what's asked, note the edge cases, and start early; the friction is in the tooling, not the logic.
- 3
Keep a personal command-and-flag notebook
The breadth means you'll re-learn the same Git and shell incantations repeatedly otherwise. A running cheat-sheet of commands you've actually used turns recurring friction into lookups.
- 4
Start the project and pin down your group early
The collaborative final project rewards teams that establish a Git workflow and a working cadence in week one. Late coordination is where group projects lose points in a ten-week quarter.
Today
Today's CS 35L plan
What a Fennie Daily Plan looks like for CS 35L. 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 35L hard at UCLA?
It's not conceptually deep, but the breadth and detail-strictness make it deceptively time-consuming. The tools are unfamiliar and the assignments punish small misses, so daily practice with the command line and Git matters more than raw CS ability.
What does CS 35L teach?
The practical software toolchain: Unix/Linux command line, shell scripting, Git, build and debugging tools, Python scripting, and collaborative development. It's the bridge between knowing data structures and being able to actually build and ship software.
How do I do well in CS 35L?
Make the terminal and Git your daily defaults so fluency builds passively, read every assignment spec twice, and keep a personal command cheat-sheet. Start the group project and settle your team early; coordination is where ten-week projects slip.
More UCLA courses
CS 31: Introduction to Computer Science I
CS 31 is UCLA's intro programming course, taught in C++, covering control flow, functions, arrays, pointers, and basic program design. It's the first required course for CS majors and a common choice for engineering and math students adding programming skills.
CS 32: Introduction to Computer Science II
CS 32 is UCLA's data structures course in C++, covering recursion, linked lists, stacks, queues, trees, hash tables, and algorithm analysis. Its multi-thousand-line projects, including the famous game-engine project, are a step change in scale from CS 31.
CS 33: Introduction to Computer Organization
CS 33 is UCLA's computer organization course, taking students below C into machine-level representation, x86-64 assembly, the memory hierarchy and caches, linking, and concurrency basics. It follows CS 32 and is where CS majors first see what their code becomes on real hardware.
CS 111: Operating Systems Principles
CS 111 is UCLA's operating systems course, covering processes and threads, scheduling, synchronization, memory management and virtual memory, file systems, and protection, with substantial systems-programming projects in C. It's a core upper-division requirement and one of the most respected courses in the major.