UCLA 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.

Fennie is independent and not affiliated with UCLA. This is an unofficial study guide.

Build my CS 31 study plan

What makes it hard

Learning C++ as a first language on a ten-week quarter is the core difficulty — pointers and C-strings arrive before beginners have fully digested loops. The projects are specification-strict, and the exams (often associated with Professor Smallberg's famously precise style) test exact understanding of C++ behavior, including edge cases.

What you'll cover

• C++ fundamentals and control flow
• Functions and program decomposition
• Arrays and C-strings
• Pointers
• Structs and classes
• Debugging and program correctness

The CS 31 study guide

How to study for UCLA CS 31, step by step.

1
Code a little every day from week one
Ten weeks leaves no recovery time, and C++ as a first language punishes gaps. Daily practice — even 45 minutes — beats weekend bursts, especially before pointers arrive mid-quarter.
2
Start each project the day the spec posts
CS 31 specs are famously precise, and projects lose points to spec misreadings as often as to bugs. Read the spec twice, start immediately, and leave days for the edge cases.
3
Learn to predict code without running it
The exams test exact understanding of C++ behavior, including edge cases — a very different skill from debugging until it works. Trace programs on paper weekly and check your predictions against the compiler afterward.
4
Give pointers and C-strings double the time
They arrive before beginners have digested loops, and they're the make-or-break unit. Draw memory pictures for every pointer exercise until the indirection is second nature.
5
Quarter-proof your schedule with Fennie
Upload the CS 31 syllabus and Fennie's Daily Plans pace projects and exam prep across the ten-week clock so one late project can't sink the grade, with code-tracing quizzes generated from your actual course materials. Free to start.
Start my CS 31 plan free

How Fennie helps with CS 31

Upload the CS 31 syllabus and Fennie's Daily Plans pace the quarter so each project gets started early — on a ten-week clock, one late project can sink the grade. Chat through pointer behavior and tricky C++ semantics until you can predict what code does without running it, the exact skill the exams test.

FAQ

Is CS 31 hard at UCLA?

For students new to programming, yes — C++ is an unforgiving first language and the quarter system gives you ten weeks. The projects are manageable if started early; the exams demand precise understanding of language behavior, not just working code.

Can I take CS 31 with no programming experience?

Yes, it assumes none — but expect to outwork classmates who've coded before. Budget consistent daily time rather than weekend bursts; in a ten-week quarter there's no slack to recover from a lost fortnight.

What's the difference between CS 31 and CS 32?

CS 31 is intro programming in C++; CS 32 is the follow-up covering data structures and algorithms, with substantially bigger projects. The 31-32 pair is UCLA's equivalent of the classic two-course intro CS sequence.

Pass CS 31 with a plan, not a cram

Upload your CS 31 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 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 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.

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.