Skip to content

CS 631-02 Systems Foundations — Meeting Summary

Meeting Details

  • Date: February 24, 2026
  • Time: 02:47 PM Pacific Time (US and Canada)
  • Meeting ID: 882 2309 0019

Quick Recap

The session focused on: - Debugging tools and techniques for C and Rust using GDB and LLDB on the Beagle machines. - Demonstrations of setting breakpoints, inspecting variables, and stepping through code in GDB, including Rust-specific GDB extensions. - Introduction to RISC-V assembly beginning Thursday, emphasizing how assembly maps human-readable instructions to machine code. - Project 1 expectations: proper git hygiene, testing with the autograder, and hands-on engagement with the code rather than relying on AI.

Action Items

For All Students

  • Verify Beagle machine access; build Project 1 (or starter code); run and debug the C code using GDB before Thursday.
  • Before final submission:
  • Clone the GitHub repo into a fresh temporary directory.
  • Run the autograder locally.
  • Ensure no binary artifacts are committed (use .gitignore or run make clean).
  • Resolve Beagle access issues promptly; if needed, contact Solias (system admin) or Shreyas (TA) during office hours.
  • Review the new lecture notes for Thursday on RISC-V assembly.
  • Complete Project 1 by the due date (tomorrow night).
  • Seek help on campus-wide channels or during Shreyas’s office hours for Project 1 questions.

For Greg

  • Add a .gitignore file to the Project 1 starter repository.
  • Request and/or install the VS Code server on the Beagle machines to enable remote VS Code access.

Discussion Summary

Debugging and Project 1 Overview

  • Emphasis on mastering debuggers (GDB/LLDB) for both C/Rust and upcoming RISC-V assembly work.
  • Students should treat the autograder as the gold standard and test on the Beagle machine prior to submission.
  • Avoid committing compiled artifacts; use .gitignore to keep repositories clean.

Expression and Script Mode Development

  • Recommended workflow: implement expression mode first, then extend to script mode.
  • Script mode requires:
  • New parsing functions and an updated parse tree.
  • An evaluation environment to track and update variable values.
  • Students were encouraged to consult cloud.md for hints while developing, with a focus on independent problem-solving.

Rust Learning and Cloud Coding

  • A hands-on approach to learning Rust was encouraged, with selective use of AI assistants for clarification.
  • Strategy: focus deeply on one language (e.g., Rust) while maintaining practical fluency in others (e.g., C).
  • Demonstrated creating a convenient alias for Cloud Code and described its usefulness for complex tasks.
  • Students were encouraged to experiment with debuggers over the break and to note feature differences across account types.

Context Windows and Coding Agents

  • Explained how coding agents use system prompts and context windows, noting differences between Claude’s desktop app and web app.
  • Introduced Explorer sub-agents that spin up new contexts—powerful but potentially slower.
  • Recommended using “plan mode” for clearer agent interactions and better results with Cloud Code.

LLM Debugging and Development Techniques

  • Advocated for “plan mode” and consistent human review of LLM-generated code.
  • Introduced the concept of “rewind” for undoing changes.
  • Reviewed GDB and LLDB usage; noted macOS security restrictions can complicate GDB usage on Macs.
  • Confirmed that RISC-V topics will be a focus in upcoming classes.

Understanding and Using Debuggers

  • Described the mental model: the OS kernel manages processes; GDB attaches to and controls a target process to inspect state.
  • Demonstrated:
  • Setting breakpoints.
  • Stepping through execution.
  • Inspecting variables and call stacks.
  • Highlighted the role of symbolic debug info in mapping machine code to source.
  • Encouraged replacing print-debugging with debugger workflows.

GDB Techniques and Tooling

  • Showed GDB for C and Rust on the Beagle board and via QEMU for RISC-V VMs.
  • Noted that Rust builds a debug target by default; students should debug debug builds, not release builds.
  • Suggested LLDB for Rust on macOS where appropriate.
  • Thursday’s session will extend GDB setup to assembly-level debugging.

Course Logistics and Strategy

  • Acknowledged possible VPN/connectivity issues when using GDB remotely; students should seek help from Solias or Shreyas as needed.
  • Discussed curriculum trade-offs (e.g., less time on floating-point details to make room for other topics).

RISC-V Assembly and Rust-GDB

  • Clarified that “Rust GDB” is a wrapper that enhances GDB with Rust-aware features (types, syntax).
  • Covered VS Code access on RISC-V via the VS Code server.
  • Introduced RISC-V fundamentals:
  • Instruction set architecture vs. assembly language
  • Registers and the 64-bit RISC-V variant
  • Function calling conventions (to be emphasized)
  • Previewed examining Rust code at the machine level to illustrate zero-cost abstractions.
  • New lecture notes will be available for Thursday.