What’s New in CS 61A

Starting in Fall 2026, CS 61A includes a 2-week unit on the design of software applications, which introduces students to AI-assisted programming using agentic tools. While the course has always involved building large and interesting programs (including an interpreter), developing a full application involving multiple programming languages, a web browser, and a client-server architecture has historically been delayed until the upper-division Software Engineering course.¹

Large language model (LLM) technology has transformed the process of writing programs for many software developers, shifting their effort from hand-authoring programs to architecting, describing, reading, and verifying them. Building a full application using agentic AI tools provides students experience with this new process. AI also enables this update by helping students navigate the many details of how different parts of a software application compose together.

While CS 61A now concludes with an AI-assisted programming project, most of the course continues to focus on writing correct programs by hand using techniques for managing complexity, such as abstraction, modularity, function decomposition, and object-oriented design. Building foundational knowledge about programming and programming languages is still the primary purpose of the course, and writing programs by hand is a proven way to build this knowledge.²

To encourage students to practice programming without AI assistance: (1) the process by which students complete take-home programming assignments is recorded and reviewed for evidence of misconduct, (2) students are prompted to demonstrate their understanding of the code they write via a conversation with either a member of the course staff or a new LLM-based tutoring tool, and (3) regular quizzes confirm their ability to complete similar work in a proctored environment.

Adding a unit on software applications has prompted other changes, including removing and consolidating some existing material. The course still covers functional, object-oriented, and declarative programming paradigms and requires students to build an interpreter. Some content that also appears in CS 61B has been removed, along with two lectures on macros (recently added).

Perhaps the most visible change is that the course no longer teaches students Scheme, and instead introduces the Gleam language for the unit on interpreters and functional programming. Students use Gleam, JavaScript, Python, SQL, and optionally TypeScript in their software application project.

CS 61A is not a course about particular languages, but instead about programming in general, and the languages it uses might change again in the future. However, this change is substantial, especially in light of the history of the course, and so the remainder of this article describes this particular language choice and its implications.

Programming Languages in Past Versions of CS 61A

CS 61A, introduced at UC Berkeley in 1986 as CS 60A, is named after the classic textbook Structure and Interpretation of Computer Programs (SICP) and was taught for 25 years in Scheme, an influential (and beautiful) Lisp dialect developed in the 1970s and used by that textbook. The course evolved to include some content beyond what appears in the textbook, such as object-oriented programming, but maintained the close connection between the course concepts and the Scheme language, which is exceptionally well-suited to illustrate them. Brian Harvey eloquently described why Scheme is an excellent fit for CS 61A.

In 2011, Python was introduced as the main language of the course and the textbook switched to the online text Composing Programs, which is based on SICP and contains most of the same lessons and concepts. This revision of the course included a unit on interpreters and functional programming using Scheme, which is a superb language for expressing the concepts of interpreters and manipulating programs as data. It also revised the unit on declarative programming to use SQL. Covering multiple programming languages that differed in syntax and features helped to reinforce the lesson that CS 61A’s material isn’t particular to any programming language, but instead applicable to many, and a new language can often be learned in a few days.

Gleam and TypeScript

Python remains a popular language used for application development, data analysis, and machine learning. However, different languages excel in different contexts. Two new CS 61A topics benefit from introducing Gleam:

• Static typing, by which data type compatibility can be checked before a program runs, has increased in adoption due to broader support (e.g., TypeScript and Python type hinting) and inference improvements, which allow for better error messages and less verbose code. The 2026 revision of CS 61A includes the program correctness guarantees afforded by algebraic data types and pattern matching, which have helped drive the adoption of Rust.

• Web browsers execute JavaScript, and languages that can be compiled to readable JavaScript (e.g., TypeScript, Gleam, and JavaScript itself) are natural choices for learning about web applications. The 2026 revision of CS 61A includes the Document Object Model, browser technologies, and the Elm architecture (via Gleam’s Lustre package) for browser-based single-page applications.

Learning Gleam will prompt students to generalize their knowledge of programming in Python to a new language, just as learning Scheme did in past offerings. The design of both Scheme and Gleam illustrates important lessons about programming, such as the effectiveness of organizing programs as a collection of pure functions and data definitions, and how a small functional language without statements, object systems, or exception handling can nonetheless express programs clearly and succinctly.

Gleam has some characteristics that make it a natural fit for the UC Berkeley curriculum. The C-style syntax will be familiar when students learn Java (CS 61B) and C (CS 61C), and the type system will prepare students to learn Rust (now an option for CS 162) and OCaml (CS 164). While neither a teaching language nor a mainstream industry language, Gleam’s elegance and simplicity should impart useful foundational understanding about programming to CS 61A students, much like Scheme did for decades.

Of course, some advantages of using Scheme will be lost. Scheme is an ideal language for introducing interpreters and macros. But Scheme is not a natural fit for learning about static typing or web applications, and there is only so much time in a semester.

Aside from Gleam, TypeScript is an obvious choice for learning about static typing and web applications. However, it is a large and complex language. It would be quite a challenge for students to learn even its core features well enough to write an interpreter for a meaningful subset of TypeScript in just a few weeks.

Since TypeScript is now the dominant statically typed language for modern web application development, it should be an option for CS 61A students who are excited to learn it on their own. Therefore, the final AI-assisted application development project can be completed either in its standard version that uses Gleam, JavaScript, Python, and SQL or in its alternate version that uses TypeScript and SQL.

Good luck to all the students who enroll in this revised version of CS 61A. We hope you enjoy the course and learn a lot. We look forward to your feedback!

1. The revised portion of CS 61A is also offered as a 1-unit CS 194 (only in Fall 2026) for students who previously took CS 61A and would like to learn the new content. ↩

2. As stated in the course syllabus, the instructors believe that currently the most capable users of AI for programming are those who have a strong foundational understanding of programs and programming languages. Effective use of AI, whether for programming or other domains, is enabled by understanding precisely what outcome one desires and then being able to describe it. Therefore, most of the content of the course has remained unchanged in this update. Understanding programming well enough to read, write, and manipulate programs, even without AI assistance, remains a core learning goal of this course and a great use of students’ time.

   This perspective has been echoed by leading AI researchers.

   Andrew Ng, Co-Founder of Google Brain and Stanford AI Professor, March 2025: “One of the most important skills in the future will be the ability to tell a computer exactly what you want, so it can do that for you.”

   Demis Hassabis, Co-Founder of DeepMind and Nobel Laureate, July 2026: “Those people who understand the deep technical, they’ll be able to use these tools 10 times more effectively than people who don’t have that technical knowledge.” ↩