Skip to content

CS 631-01 Systems Foundations — Meeting Summary

Date: February 12, 2026
Time: 08:10 AM Pacific Time (US and Canada)
Meeting ID: 870 0988 0761

Quick Recap

The session focused on Rust programming concepts in the context of parsing arithmetic expressions. Greg led a walkthrough of Rust code paralleling a previous C implementation, emphasizing:

  • Ownership, borrowing, and mutable references
  • Move semantics and how ownership transfers between parse nodes
  • Memory management differences between Rust and C (owned/heap vs. borrowed/stack)
  • Pattern matching with irrefutable patterns
  • Techniques for updating and mutating nested parse tree nodes

Next Steps

  • Greg: Fix broken or 404 lecture note links after class.
  • Greg: Publish the C visualizer mode code from the previous class for student access.

Detailed Summary

Rust Code Structure and Syntax

  • Discussed Rust modules, imports, enums, and structs, drawing parallels to the prior C codebase to aid comprehension.
  • Introduced token types and their role in parsing.
  • Noted the final project:
  • Expand the NT language to completeness
  • Add evaluation capabilities
  • Due: One week from Monday

Rust Scan Table Implementation Overview

  • Explained implementing a scan table and token types using Rust vectors for arguments.
  • Clarified syntax differences between Rust and C.
  • Mentioned the future-purpose “-E” option for selecting output bases for expressions.
  • Covered type inference and mutability, including creating and using a mutable scan table.

Rust Memory Management Overview

  • Reviewed ownership and borrowing:
  • How ownership transfers between variables
  • Differences from C’s manual allocation and deallocation
  • Clarified module usage with use and the relationship between mod scan and use scan.
  • Distinguished Clone vs. Copy traits and when each applies.
  • Highlighted Rust enums as a flexible way to combine data and structure (more expressive than C’s separate enums and structs).

Rust’s Move Semantics and Ownership

  • Demonstrated move semantics:
  • After a move, the destination (e.g., node 3) owns the data previously held by the source (e.g., node 1).
  • Ownership is immediate and local: a parent owns its direct child; the root does not have special transitive ownership beyond that structure.
  • Used a code example to illustrate direct, one-level ownership in tree structures.

Recursive Ownership in Rust Trees

  • Explained drop behavior in trees:
  • Dropping the root causes each parent to drop what it directly owns, cascading through the tree.
  • Introduced mutable tree examples and irrefutable matching (LTF syntax), emphasizing the ubiquity of pattern matching in Rust.
  • Discussed strategies for accessing tree nodes:
  • Ownership transfer
  • Traversal via matching or recursion
  • Noted that Rust’s ownership model provides rigor compared to C’s less structured memory management.

Node Data Transfer Discussion

  • Described transferring data from node 1 and node 2 into node 3:
  • After transfer, the original nodes are no longer accessible.
  • Clarified the meaning of & in function signatures: passing references to parse nodes.
  • Considered alternative ownership scopes but retained the current, working approach.

Rust Parsing and Ownership Concepts

  • Reviewed parsing functions and why mutable references are required:
  • To update the scan table
  • To manage ownership during parse node construction
  • Explained match structure for recursive parsing and value binding.
  • Covered mutable bindings for updating pointer-like values.
  • Emphasized the logical similarity between the Rust and C parsers.

Rust Arithmetic Expression Parser Implementation

  • Walked through:
  • Token handling
  • Building operator enums
  • Ownership transfer for left and right operands
  • Highlighted exhaustive pattern matching:
  • Use of catch-all patterns for non-exhaustive cases
  • Addressed questions on intermediate ownership states:
  • Confirmed the necessity of mutable references for correct parser behavior.

Rust Ownership and Lambda Functions

  • Clarified that ownership is a compile-time guarantee that does not exist at runtime.
  • Explained function return behavior:
  • A function can return a value without “owning” it at runtime; ownership is enforced by the type system.
  • Differentiated owned types (heap-allocated) from borrowed references (no heap space).
  • Introduced closures (lambdas) for error handling, e.g., applying a function to an error when parsing fails.

Rust Parse Tree Mutations

  • Demonstrated mutating parse trees:
  • Using mut to allow mutation
  • Using if let with pattern matching to access nested nodes
  • Dereferencing Box pointers and replacing subtrees
  • Verified changes through a test case.
  • Encouraged ongoing questions and help-seeking; the next session will be on Tuesday.