Introduction to module 11. [0:00] Garbage collection and why it matters. [1:11] Comparisons with the state of the art. [1:45] What I expect the GC-building experience to be like.

Introduction to module 10. What to expect from closure conversion.

Introduction to module 9. [0:01] The big idea of K-normalization: putting values in registers. [1:40] Continuation-passing style for register allocation [2:25] The other significant piece: environments. [3:44] Code infrastructure you’ll be building. [4:38] Wrapup: what to expect.

Introduction to module 8. A light week of coding: generating calls, tail calls, and returns; code for functions.

Introduction to module 7. What’s ahead: implementing procedure calls using two stacks. Tail-call optimization. Depth points.

Introduction to module 6. This week we’re implementing new instances of concepts we just saw: translation, projection, and the UFT driver. The key is the translation: from K-normal form, we’ll generate assembly code. Good stuff!

Quick comments on module 4. Nice work on parsers and label elimination. One note: the shiny Parsec combinators from Haskell are easily duplicated in ML.

High-level languages and the UFT. This video shows how the second half of the system is built in modules 5 through 10: K-normal form, first-order vScheme, unambiguous vScheme, and vScheme itself. The video also depicts the entire translation pipeline from vScheme source code to running VM code in the SVM.

Low-level languages and the UFT. This video shows how the first half of the system is built in modules 1 through 4: assembly language, virtual object code, their internal representations, their representations on disk, and the translation between them. The video also includes a short demo for the two main use cases of uft so far.

Quick observations after module 3 code review. The roles of assembly language and object code.

Making types work for you. This is an all-screen-capture demo of how to use types to derive code for a function. It’s similar to one of the 105 lectures on the same topic, but with a different example: the Kleisli composition function >=>. Low production values, but it might be useful.

Embedding and projection, part 2: Parsing and unparsing Scheme. This video presents the second of several examples of embedding and projection. This time we’re embedding and projecting programs. Nothing here is urgent, but it will be a good idea to watch before you turn in your reflection for module 3.

Introduction to module 2. Brief comments on last week. Purpose of learning outcomes. Climbing the mountain. Destination: vScheme. Next step (virtual object code) write code in a file, code can include literals. New skill: parsing.

Demonstration of recursive-descent parsing. Grammar for virtual object code. Conversion to railroad diagrams. Implementation of railroad diagram in C.

The course work model. The “flipped classroom.” Our work cycle, which runs Wednesday to Tuesday.

Introduction to module 1. The core of the SVM. What distinguishes the SVM: high-level language values, you get to design VM instructions.
Not much code this week, and it might all get written during lab. Knock rust off your C skills, immigrate into thinking about virtual machines, build on COMP 15 and COMP 40. A dollop of operational semantics, so we can optimize recursion in week 7 (we will help). Staff are here to help; the place to start is Slack.

Overview and welcome. My goals for the course. The idea of a simple virtual machine. Your takeaways. Some information about logistics: small deliverables with frequent deadlines. Plans for class meetings. Something about me and why I’m teaching this course.

Low-level languages and the UFT. This video shows how the first half of the system is built in modules 1 through 4: assembly language, virtual object code, their internal representations, their representations on disk, and the translation between them. The video also includes a short demo for the two main use cases of uft so far.