Skip to content

CS 631-01 Systems Foundations — Meeting Summary

  • Date: Feb 05, 2026
  • Time: 08:12 AM Pacific Time (US and Canada)
  • Meeting ID: 870 0988 0761

Quick Recap

Greg reviewed course materials and lab assignments, emphasizing self-service learning resources. He contrasted Rust’s memory management with C, using examples and diagrams to explain Rust’s ownership model, string types, and bindings. He concluded with an overview of building a scanner and parser for NT-Lang (NTLAN), covering tokenization, AST construction, and recursive descent parsing.

Next Steps

  • Students: Complete Lab 2 (C and Rust implementations of the NT-Lang parser) by the due date (one week from Monday).
  • Students: Integrate the completed scanner from Lab 1 into the Lab 2 starter code for both C and Rust.
  • Students: Review the provided C and Rust parsing starter code, including data structures and parsing functions, as described in the notes and slides.
  • Students: Direct questions about C code or parsing concepts to Greg via CHAS or Aspen Campus Wire.
  • Students: Continue working with Rust learning materials and experiment with Rust syntax and concepts.

Summary

Rust Course Lab Assignments

  • Greg highlighted the importance of self-directed learning and encouraged use of the provided materials.
  • He shared his learning workflow (e.g., using tools like ChatGPT and Google to clarify doubts).
  • Lab 2 was introduced with a one-week timeline.
  • Upcoming topics include scanning and parsing, with references to example C and Rust implementations in the course repository.
  • He emphasized Rust’s safety advantages over C, particularly regarding memory safety.

Rust String Types Explained

  • Greg distinguished between Rust’s string types:
  • &str: an immutable string slice (often a constant or a view into a string).
  • String: a mutable, heap-allocated string.
  • He showed how to create mutable local strings and discussed how Rust manages memory at compile time through ownership and borrowing rules.
  • He introduced the concept of bindings (names bound to data), noting that fully understanding bindings and ownership takes time.

Rust vs. C Memory Management

  • Using a diagram, Greg compared C and Rust:
  • In C, a function can return a pointer to heap-allocated memory stored in a stack variable.
  • In Rust, strict ownership rules prevent unsafe patterns (e.g., returning references tied to stack-allocated data or violating single ownership without borrowing).
  • He underscored Rust’s safety mechanisms while acknowledging that internalizing the ownership model takes practice.

Rust Memory Management Explained

  • Greg described how Rust tracks ownership via bindings that live on the stack and may reference heap data with associated metadata.
  • Ownership and borrowing rules ensure correct deallocation and prohibit returning references to invalid (e.g., stack) data.
  • He noted that additional details will be covered in the following session.

Rust’s Approach to Data Structures

  • Greg explained that Rust favors simple, fully owned data structures over complex graphs with shared, mutable references.
  • He discussed the challenges of implementing linked structures and recommended using indirect references (e.g., indices) instead of direct pointers.
  • Using a course–student example, he showed how index-based relationships can simplify ownership.
  • He emphasized that Rust’s constraints promote better design and simpler reasoning compared to languages with automatic memory management (e.g., Java, Python).

NT-Lang Compiler: Scanner and Parser

  • Greg outlined the implementation of a scanner and a recursive descent parser for NT-Lang:
  • Scanner: converts input strings into tokens.
  • Parser: builds an Abstract Syntax Tree (AST) from tokens.
  • He reviewed grammar rules, AST data structures, and the importance of understanding memory management when implementing parsers in C and Rust.
  • He encouraged students to implement the parser and provided resources to support the work.