Figure: Twenty questions modern data systems answer

Twenty course questions in four columns: AI agent data stacks, reads at scale, writes at scale, and trust, security, and streaming. Each question names the techniques the course uses to answer it.

Figure: Four eras of data systems, compared on the same four questions

A four-column grid. The columns are Banks and retail in the 1970s to 1980s, the web from 1995 to 2010, the cloud era from 2004 onwards, and AI agents from 2025 onwards, the last one filled blue as the era the course is built for. Four rows compare them: the products of each era, who is on the other end of the query, the hard question each era had to answer, and what the industry invested in during it. The middle row escalates from hundreds of clerks, to millions reading, to billions writing at human pace, to machines at machine pace. The investments row runs from transactions and the relational model, through replicas and NoSQL and MapReduce, to LSM trees and object storage and columnar scans, to vector indexes and KV caches and lineage and Iceberg, the table format that lets any engine read the same storage.

Figure: What you need on day one, and what helps a lot

Three panels. The first, with an ink top strip marking it as required, is Python and Colab: read Python and run a notebook, needed from day one. The next two, with grey strips marking them as helpful rather than required, are CS 161 Algorithms, giving sort and hash and complexity, and CS 111 Systems, giving filesystems and the memory hierarchy and scheduling. A closing line says CS145 runs those same concepts on data 100 to 1,000,000 times bigger, and points at the ten-question concept check that opens PSET 0.

Figure: One week in CS145, and the eleven weeks it repeats across

Two blocks in one picture. The top block is one week in three lanes, read top to bottom in the order you do them. LECTURES holds the two lectures, Tuesday and Thursday. PRACTICE shows section slots on Wednesday and Friday running the same Colab walkthrough. Students pick one slot; timings are on Ed. READING holds the same page used in lecture with its three to five minute video, and the week's industry case study. Between them, a line says section and the reading are the rehearsal and the PSET is the same material on your own, graded. The bottom block is the quarter: eleven week columns with the module each covers, M1 SQL through M5 Distributed, a Thanksgiving gap at week ten and industry lessons at week eleven, then two rows of real deadlines. Six PSETs: M0 Sep 25, M1 Oct 5, M2 Oct 12, M3 Oct 19, M4 Nov 9, M5 Dec 2, each landing the week after its module ends. Three project milestones: Project 1 Oct 16, the Project 2 proposal Oct 30, and Project 2 Nov 20.

Figure: One hundred points: fifty fixed, and fifty you can earn two different ways

A hundred-point scale. The first fifty points are fixed for everyone: Project 1 worth ten, PSets worth fifteen, Project 2 worth twenty-five. From the fifty-point mark the bar splits into two alternatives for the remaining fifty. Path 1 accrues fifteen points from nano quizzes and puts thirty-five on the final. Path 2 is a final worth fifty. A brace on the right marks that you are given whichever of the two scores higher, automatically.

Figure: Where AI is allowed in CS145, and what is graded in each place

Two panels. On the left, the projects: every AI tool is allowed, credited, and the grade is on four things you do after the model answers, namely verify the answer, fix the semantics, cut the cost, and defend the design. On the right, the paper test: no AI, standing in for a whiteboard interview and measuring the systems thinking you carry yourself.

Figure: Five you learn, then the modern systems you build

Top row: five capability modules, from SQL and storage on one machine through indexing, transactions, and distributed systems across many machines. Below, M6 applies those mechanisms to phones, AI-agent memory, and modern data platforms.

Figure: Three systems, reconstructed

Three blue cards run from one machine to many. Small analytics starts with Pandas in memory and Polars streaming supported work. Agent memory separates working context from persistent memory. UberEats coordinates shared transactional state across many machines and saves unfinished phone actions through network failures.

Figure: How Pandas holds a DataFrame

Pandas reads listens.csv from disk into memory as a DataFrame with named, typed columns. The DataFrame stores each column in a typed array and materializes its data in memory.

Figure: Pandas: the whole dataset has to fit in RAM

Pandas reads a CSV or Parquet file into a DataFrame on one machine. Group, sort, and join operations use that machine's memory. As data and intermediate results approach the available RAM, the process may slow, swap, or fail an allocation.

Figure: How far each engine gets on a data-size axis, and where one machine ends

An illustrative data-size axis compares three execution models. Pandas normally materializes data and intermediate results in memory. Polars can stream supported operations in batches on one machine, although some operations still materialize. A distributed database divides storage and execution across machines. Actual limits depend on the query and hardware.

Figure: Agent memory from local retrieval to a global service

Three panels left to right. A model call can miss an earlier decision when the current context does not contain it. A local agent can retrieve saved project evidence from SQLite. A global product can serve user memory from a replicated Postgres deployment supporting 800 million users.

Figure: A plausible answer is still wrong

On Tuesday you ask the agent to extend the auth module you built on Monday. The current request does not include the earlier decision, and the agent does not retrieve the relevant code. It predicts a plausible function named verifyJWTWithScope, but the codebase contains no such function.

Figure: The context window is working memory

Three model calls run left to right. The first context reaches its token limit. Later calls contain only the context the application supplies. A persistent database below the calls retains saved records, and retrieval selects which records return to a later context.

Figure: Local memory: capture, store, retrieve

Local agent memory. A model captures records in SQLite on your machine. Keyword search uses FTS5. Vector search can use Chroma or sqlite-vec: claude-mem documents Chroma, while QMD uses sqlite-vec. Retrieved records return to the model through the retrieval arrow.

Figure: Global memory: one primary, nearly 50 read replicas

ChatGPT users send writes to one PostgreSQL primary. The primary replicates changes to nearly 50 read replicas across regions. Read results return from the replicas to the users. This is a simplified view of OpenAI's reported read-heavy PostgreSQL deployment.

Figure: Three retrieval signals feed combined fusion ranking

Three vertically stacked boxes show BM25 keyword matching, vector similarity, and graph ranking. Arrows connect each signal to a fourth box for combined fusion ranking, which merges ranked candidates, removes duplicates, and selects evidence for the next context. This illustrates a possible combined pipeline, not a claim that every tool uses all three signals.

Figure: UberEats: shared state for three sides

A simplified model of a three-sided order. The diner, driver, and restaurant apps hold temporary state. A distributed transactional database coordinates the shared order, assignment, and inventory records. One transaction applies the related changes together. Green marks the persistent shared state; the apps hold only volatile state.

Figure: One order. Three records. All or none.

A simplified order transaction updates the payment, driver assignment, and inventory together. A successful order applies all three changes. A failed order leaves all three unchanged. The database also rejects a conflicting driver assignment so two competing updates cannot both finish successfully.

Figure: The disconnected edge: save now, send later

The driver app saves an unfinished action and its latest state to disk when the phone loses its connection. After reconnecting, the app sends queued actions to the server and updates its local state if the server returns a different result. Green marks the shared server state.

Figure: The project path: Project 1, then one of two Project 2 options

Everyone does Project 1 (BigQuery's First Heist, solo, Sep 25 to Oct 16, 16 to 20 hours, blue) and builds decision-worthy SQL and scalable cloud analytics, then picks one Project 2 (Oct 16 to Nov 20, pairs by default with solo optional, about 40 hours per person for a Tier 93 project (about 8 hours a week over five weeks), with the Tier 100 capstone adding about 8 more): Science (NanoQuery, violet, SQL, semantic search, and text-to-SQL evaluation, an analysis combining tabular data with a knowledge base) or Systems (NanoMem, green, a search engine giving AI coding agents persistent memory that races real production tools). Each card lists focus, skills you build, and the portfolio story. Blue is the SQL foundation, violet is data science, green is systems.

Figure: Project 1 architecture: query a public dataset with SQL to answer questions

Left to right: a read-only public dataset in BigQuery (three or more tables such as posts, users, and comments, at least 500 MB, grey) is queried by the SQL you write in a Colab notebook (a code card shows a CTE with a RANK window function and a join). It produces a result table of decision-worthy answers, one row starred as the insight. Below, you hand-trace two paper debug tables to verify how the SQL executes. Blue is what you build; grey is the read-only data you query.

Figure: CS145 career journey map

A left-to-right map. The two blue boxes are CS145 itself, the content in focus: the core curriculum with Project 1, then a Project 2 choice of the Science path or the Systems path, NanoMem. The grey box is what you keep learning beyond the course, out of focus here. The green box is where it leads, the careers the path opens. Color key: blue is CS145 content, green is where it leads, grey is beyond CS145.

Figure: One query, three parts

The power-users query has three parts. The first CTE counts distinct songs, distinct genres, and total listens per user. The second keeps users spanning at least three genres and ranks them into deciles by total listens. The final SELECT joins user names and returns the top decile.

Figure: Spotify: from a client event to analysis

Three panels show Spotify's published data-platform path. Client software publishes typed events. Event delivery uses managed queues, anonymization pipelines, and streaming jobs. Scheduled workflows run in BigQuery, Flink, or Dataflow so teams can analyze the resulting data. Color key: blue is collection, grey is movement and processing, green is analysis.