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.

Build my CS 35L study plan

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.
5
Sequence the toolchain with Fennie
Upload the CS 35L syllabus and Fennie's Daily Plans pace the weekly tool jumps and project milestones across the quarter, generating command-and-concept quizzes from your actual course materials. Free to start.
Start my CS 35L plan free

How Fennie helps with CS 35L

Fennie's Daily Plans pace CS 35L's weekly tool jumps and the group project across the ten-week quarter so the breadth never piles up. Chat through what a shell pipeline or Git command is actually doing when it confuses you, and quiz yourself on the command and concept details the precise assignments expect.

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.

Pass CS 35L with a plan, not a cram

Upload your CS 35L materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.

Get started free

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.