Skip to content

Meeting Summary: CS 631-01 Systems Foundations

Date: Jan 29, 2026, 08:05 AM Pacific
Meeting ID: 870 0988 0761

Quick Recap

The session focused on setting up development environments and foundational compiler concepts:

  • Environment setup: SSH access to Beagle machines, Git configuration, and autograder setup (Rust port).
  • Tooling: Demonstration of Claude Code (referred to in class as “Cloud Code”) for coding assistance, including configuration and usage modes.
  • Language topics: Scanning and tokenization using EBNF, with comparisons between C and Rust implementations.
  • Mini-language: Introduction to HDLANG and its token set.
  • Systems concepts: Memory management, pointers, and differences between C and Rust.
  • Assignment: Overview of the current lab and available resources, including a claude.md configuration file for personalized assistance.

Next Steps

  • All students:
  • Complete SSH setup to Beagle machines using the updated instructions in lectures/dev environment. Configure SSH config and private key; test SSH and GitHub access. Aim to finish today and seek help from Greg or Shreyas if needed.
  • Set up and test the Rust port of the autograder on the Beagle machines: download the RISC‑V binary release, untar, and add to PATH per instructions on Campus Wire.
  • Sign up for and configure Claude Code using the provided resources.
  • Review the recommended Rust tutorial (Google’s Rust tutorial) and other posted resources.
  • Complete the current lab: implement lexical scanners for NT‑lang in both C and Rust using the starter code.

  • Provide feedback to Greg and Shreyas on the effectiveness of in‑person vs. online office hours after the initial schedule.

  • Greg:

  • Post the Claude Code guide and claude.md file (student-mode configuration) on the course website and Campus Wire.
  • Share links to recommended Claude Code courses and news sources (e.g., Hacker News, Simon Willison’s blog).

  • Post additional resources and guides (e.g., micro editor guide) upon request.

  • Shreyas:

  • Hold office hours as scheduled and finalize the exact weekly schedule (some references suggested 12–1 or 12–3 with mixed in‑person/online days; another reference mentioned 12–5 PM daily). Communicate the final schedule to students.

Detailed Summary

SSH and Git Configuration

  • Direct SSH access should target Beagle 5 machines, using Stargate as a proxy.
  • Students should:
  • Configure SSH locally (including adding a private key and username in SSH config).
  • Test GitHub access via SSH.
  • Configure SSH for Git operations on Beagle machines to enable cloning and pushing to GitHub.
  • Students are encouraged to seek help during office hours if issues arise.

RISC‑V Assembly Lab Setup

  • Beagle machines support RISC‑V assembly projects; while not mandatory for the initial labs, they are beneficial for running and debugging.
  • Claude Code does not run on RISC‑V and should be used on local machines.
  • The autograder setup is recommended via the Rust port for better performance; students should complete the setup and ask for help if needed.

Claude Code Demo and TA Introduction

  • Claude Code (referred to as “Cloud Code” during the session) was demonstrated:
  • Modes: Immediate edit mode and plan mode.
  • Configuration: via a claude.md file.
  • Capabilities: Suggest code, execute commands, and assist with tasks end-to-end.
  • Emphasis: While Claude Code can accelerate assignment completion, understanding underlying concepts remains essential.
  • TA introduction: Shreyas will hold regular office hours; final schedule to be confirmed.

Teaching Balance and Coding Assistants

  • Instruction will be primarily in-person with online availability as needed.
  • Students are encouraged to learn to work effectively with coding assistants while maintaining independent problem-solving skills.

Tokens, Scanning, and EBNF

  • Tokens: Characters are grouped into tokens for easier processing in compilers.
  • HDLANG: A mini-language supporting bit manipulation and operations on various number representations.
  • EBNF:
  • Used to describe language syntax.
  • The class will focus on translating EBNF token rules into executable code.
  • Note: EBNF can represent recursive structures, making it more powerful than regular expressions for parsing.

Tokens in LLMs

  • Tokenization in LLMs is statistical rather than rule-based:
  • Token sets are predefined before training.
  • Tokens are embedded as vectors updated during training.
  • Command-line basics were briefly reviewed (e.g., pwd, mkdir).
  • The concept of an End of Transmission (EOT) token was mentioned in relation to class code.
  • A comprehensive Rust tutorial was recommended, especially for understanding ownership.

C Compilation and Preprocessing

  • The C toolchain was outlined:
  • Preprocessing and compilation convert source code to machine executables.
  • Header inclusion in C is analogous to module imports in Python/Java, exposing type signatures for compilation.
  • The man command was introduced for documentation of library functions.
  • Similarities between C and Rust were noted (e.g., main function, primitive types).

C vs. Rust Memory Management

  • C:
  • Local variables are stack-allocated; manual memory management via malloc/free is common.
  • Rust:
  • Strong memory safety guarantees and ownership model.
  • Arrays and locals are stack-allocated; global data usage is more restricted.
  • Eliminates explicit malloc/free through ownership and borrowing.
  • Emphasis: Understand where data lives (stack/heap/globals), pointer semantics in C, and ownership/borrowing in Rust.

C and Rust: Pointers and Scanning

  • C pointers:
  • Pointer syntax, dereferencing, and mental models were reviewed.
  • Scanning tokens:
  • Implementations in both C and Rust were compared, including syntax and functional differences.
  • Rust provides powerful enums and the ability to associate methods with structs/enums, often yielding more concise code.
  • Students are encouraged to experiment with the provided code; additional Rust content will follow in the next session.