UCLA CS 131: Programming Languages

CS 131 is UCLA's programming-languages course, surveying language paradigms and concepts — type systems, scoping, functional programming, concurrency, and memory models — through a rotating cast of languages such as OCaml, Prolog, Scheme, and Java or Python. It's a core upper-division requirement, also long associated with Professor Eggert.

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

Build my CS 131 study plan

What makes it hard

The course makes you learn several unfamiliar languages quickly and think about what language features mean rather than just using them — a mental shift that catches students used to writing working code. The homeworks are concept-dense, and Eggert-style exams ask precise questions about type inference, evaluation order, and language semantics.

What you'll cover

• Functional programming and higher-order functions
• Type systems and type inference
• Scoping and binding
• Logic programming
• Concurrency and memory models
• Language evaluation and design tradeoffs

The CS 131 study guide

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

1
Learn each new language by writing in it, fast
CS 131 rotates through OCaml, Prolog, and others, and reading about a paradigm isn't enough. Write small programs in each new language the week it's introduced so the syntax stops blocking the concepts.
2
Focus on concepts behind the languages
The languages are vehicles for ideas — type inference, scoping, evaluation order. For each feature, ask what problem it solves and how languages differ, because that comparison is what exams test.
3
Trace evaluation and type inference by hand
Eggert-style exams ask precise questions about how an expression evaluates or what type is inferred. Work through these on paper for small examples until the rules are mechanical.
4
Start the concept-dense homeworks early
The assignments demand thinking in unfamiliar paradigms, which takes longer than ordinary coding. Begin the week they post so the mental shift has room to happen before the deadline.
5
Pace the paradigm-hopping with Fennie
Upload the CS 131 syllabus and Fennie's Daily Plans schedule each language and concept with time to absorb it across the quarter, generating type-inference and evaluation quizzes from your actual course materials. Free to start.
Start my CS 131 plan free

How Fennie helps with CS 131

Fennie's Daily Plans pace CS 131's parade of languages and paradigms so each gets real absorption time across the ten-week quarter. Chat through what a language feature actually means — why type inference works, how scoping rules differ — and drill generated quizzes on the type-inference and evaluation questions the precise exams favor.

FAQ

Is CS 131 hard at UCLA?

The difficulty is conceptual and breadth-based — you learn several unfamiliar languages and reason about language semantics, a shift from just writing working code. Students who write in each language early and focus on the concepts behind them do well.

What languages does CS 131 use?

It rotates through paradigm-representative languages — commonly OCaml for functional programming, Prolog for logic programming, Scheme, and a mainstream language for concurrency. The specific set varies by instructor and term.

How do I study for CS 131 exams?

Trace evaluation and type inference by hand on small examples until the rules are mechanical, and build comparisons of how languages handle scoping, types, and evaluation. The exams ask precise semantics questions, not just whether you can write code.

Pass CS 131 with a plan, not a cram

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