↩

Schedule

Table of Contents

Week 1: Basics

TUE 01-21 Lecture 1

  • Title: Course Introduction
  • Topics:
    • Discuss the course structure, expectations, etc.
    • Briefly talk about Rust
    • Install Rust and Cargo
    • Set up our first Cargo project
  • Reading:
  • Discussion Questions:
    • Why are you taking this course? What do you want to get out of it?
    • Have you heard of Rust before this course?
    • Do you like using a low-level programming language like C?

THU 01-23 Lecture 2

  • Title: Basic Programming
  • Topics:
    • Reminder ourselves how to read BNF grammars
    • Do some "normal" programming with Rust
    • Look more carefully at the grammar of Rust
  • Reading:
  • Discussion Questions:
    • How well does Python or C++ programming transfer to basic Rust programming? Do you feel you could write any program on integers in Rust that you could already write in Python? Why or why not?
    • One somewhat strange feature of Rust's parser is that it allows trailing commas. Why do you think this is?
    • Are there features you wish Rust had? Are there features it has (that we've seen so far) that you don't like?

Week 2: Ownership

TUE 01-28 Lecture 3

  • Title: The Stack and Heap
  • Topics:
    • Determine the role of the stack and the heap in a systems PL, and how these things affect how we use Rust
    • Look at a couple ways of managing memory
  • Reading:
  • Discussion Questions:
    • Why do we have to know the size of data that will be put on the stack at compile time?
    • What are the benefits of Rust's ownership model over automatic reference counting? What are the downsides?
    • What about the tradeoffs between reference counting and garbage collection?

THU 01-30 Lecture 4

  • Title: References and Borrowing
  • Topics:
    • Look more carefully at Rust's borrow system
    • See some examples of things we can't do according to Rust's borrow checker
  • Reading:
  • Discussion Questions:
    • How do references relate to pointers?
    • Is it worthwhile to enforce a single mutable reference if you aren't interested in concurrency?
    • How might you think of visualizing ownership and borrowing? (There are a couple existing tools to do this, but I think there's still room for improvement.)

Week 3: Data

TUE 02-04 Lecture 5

  • Title: Structures and Enumerations
  • Topics:
    • Cover structures (product types) and enumerations (union types) in Rust
    • Look at how Rust's borrow system interacts with more complex data
  • Reading:
  • Discussion Questions (from Piazza):
    • What is the difference between matching-expressions and nested if-expressions? What are the tradeoffs?
    • How are enumerations and structures laid out in memory?
    • Is it possible to define structures with immutable fields?
    • When should a structure store it's own data or references to other data?

THU 02-06 Lecture 6

  • Title: Collections and Slices
  • Topics:
    • Cover vectors and hash maps in Rust (they are very similar to data structures in other PLs, modulo the interaction with the borrow system)
  • Reading:
  • Discussion Questions (from Piazza):
    • How does string concatenation work? What does push_str do and who owns what data after it's called?
    • Why does Rust implement deref coercion?
    • It is possible to replace a value in a vectors and take ownership of the original value?

Week 4: Functions

TUE 02-11 Lecture 7

  • Title: Generics and Traits
  • Topics:
    • Look at how to write polymorphic functions with generics
    • Learn how to restrict generic using traits to write general code against an explicit interface
  • Reading:
  • Discussion Question (from Piazza):
    • Does using generics impact performance?
    • What are the differences between the different trait parameter syntax?
    • How are traits different from interfaces?

THU 02-13 Lecture 8

  • Title: Closures and Iterators
  • Topics:
    • Anonymous functions in Rust which capture their environment
    • Iterators as a "zero-overhead abstraction" for processing collections of data
  • Reading:
  • Discussion Questions (from Piazza)
    • Are there safety/performance advantages to using iterators versus loops?
    • Can we define polymoprhic closures? Why or why not?
    • When do we need explicit type annotations on closures?

Week 5: Lifetimes

THU 02-20 Lecture 9

  • Title: Lifetimes
  • Topics:
    • Define lifetimes and determine when we need explicit lifetime annotations
    • Discuss the relationship between lifetimes and references
  • Reading:
  • Discussion Questions (from Piazza):
    • Do lifetime annotations have any effects on efficienty/safety? Do they provide additional functionality?
    • How do lifetimes affect the type theory of Rust?

Week 6: Smart Pointers

TUE 02-25 Lecture 10

THU 02-27 Lecture 11

Week 7: Midterm

TUE 03-04 Lecture 12

  • Title: Primer on Concurrency (+ Midterm Prep)
  • Topics:
    • Look very briefly at how Rust handles message-passing concurrency and shared-state concurrency
  • Reading:

THU 03-06 Midterm Exam

Week 8: Theory

TUE 03-18 Lecture 13

  • Title: Primer on Proof/Type Theory
  • Topics:
    • Introduce the notion of a formal system and its use in defining proof/type systems
    • Show how to prove meta-theoretic properties about proof/type systems
    • Discuss the Curry-Howard isomorphism, a deep connection between proof theory and type theory (that allows us to think of them as essentially the same thing)
  • Reading:

THU 03-20 Lecture 14

Week 9: Interpreters

TUE 03-25 Lecture 15

  • Title: Workshop: An Interpreter for LTLC
  • Topics:
    • Build an interpreter for the linear typed λ-calculus
    • Discuss how to translate theoretical specifications into implementations

THU 03-27 Lecture 16

  • Title: Featherweight Rust: An Introduction
  • Topics:
    • Introduce featherweight rust (FR), the system we will study for the remainder to the course
    • Motivate the design of the system
    • Discuss fuzz testing as an application of building interpreters
  • Reading:

Week 10: FR Semantics

TUE 04-01 Lecture 17

  • Title: Featherweight Rust: Small-Step Semantics
  • Topics:
    • Introduce the small-step semantics of FR
    • Focus on the mathematical structures we need to define this system
  • Reading:
    • LFR (pg. 14-19)

THU 04-03 Lecture 18

  • Title: Workshop: An Evaluator
  • Topics:
    • Finish our discussion on the small-step semantics of FR
    • Look at the structure of an evaluator for FR
    • Start the process of builidng an evaluator

Week 11: FR Borrow Checking

TUE 04-08 Lecture 19

  • Title: Featherweight Rust: Type and Borrow System
  • Topics:
    • Introduce the flow-sensitive type/borrow system of FR
    • Focus on the mathematical structures we need to define this system
  • Reading:
    • LFR (pg. 19-27)

THU 04-10 Lecture 20

  • Title: Workshop: An Type/Borrow Checker
  • Topics:
    • Finish our discussion of the type/borrow system of FR
    • Start the process of building a type/borrow checker for FR

Week 12: FR Extensions

TUE 04-15 Lecture 21

  • Title: Featherweight Rust: Extensions
  • Topics:
    • Look at some of the things we can add FR to make it more "realistic"
    • Look briefly at other systems similar to FR
  • Reading:
    • LFR (pg. 40-52)

THU 04-17 Lecture 22

  • Title: Workshop: Extensions
  • Topics:
    • Finish our discussion of possible extensions to FR
    • Look briefly at how to implement these extensions
    • Work on the final project

Week 13: FR Soundness I

TUE 04-22 Lecture 23

  • Title: Featherweight Rust: Progress and Preservation
  • Topics:
    • Prove progress and preservation for FR
    • Discuss how to "read between the lines" when reading academic white-paper proofs
  • Reading:
    • LFR (pg. 27-31, 62-67)

THU 04-24 Lecture 24

  • Title: Workshop: FR Syntax
  • Topics:
    • Discuss the AST of FR in Rust
    • Begin the process of building a parser for FR

Week 14: FR Soundness II

TUE 04-29 Lecture 25

  • Title: Featherweight Rust: Type and Borrow Safety
  • Topics: Prove type and borrow safety for FR
  • Reading:
    • LFR (pg. 27-31, 62-67)

TUE 05-01 Lecture 26