Class Notes

These are the class note files, each has a rendered HTML version as well as a text file version (which can be more convenient for reading off-line and for quick search and reference). Note that the last two entries in this list are special: one has all of the notes we covered in one file, and one has the notes we have yet to reach.

Lecture #1 (text)     Tue, Sep 10	Intro to CS4400/CS5400 Intro to Programming Languages
Lecture #2 (text)     Tue, Sep 10	Intro to Racket Side-note: “Goto Statement Considered Harmful” Quick Intro to Racket Lists & Recursion Some Style Tail calls Sidenote on Types Side-note: Names are important
Lecture #3 (text)     Tue, Sep 17	BNF, Grammars, the AE Language Simple Parsing The match Form
Lecture #4 (text)     Tue, Sep 17	The define-type Form The cases Form Semantics (= Evaluation) Side-note: Compositionality Implementing an Evaluator Implementing The AE Language
Lecture #5 (text)     Tue, Sep 24	Intro to Typed Racket Bindings & Substitution WAE: Adding Bindings to AE
Lecture #6 (text)     Tue, Sep 24	Evaluation of with Formal Specs
Lecture #7 (text)     Tue, Oct 1	Lazy vs Eager Evaluation de Bruijn Indexes Functions & Function Values Implementing First Class Functions Side-note: how important is it to have anonymous functions?
Lecture #8 (text)     Tue, Oct 1	The FLANG Language Introducing Racket’s lambda Using Functions as Objects Using define-type for new “type aliases” Currying Using Higher-Order & Anonymous Functions Side-note: “Point-Free” combinators This is not Runtime Code Generation
Lecture #9 (text)     Tue, Oct 8	Substitution Caches Implementation of Cache Functionality Formal Rules for Cached Substitutions Evaluating with Substitution Caches Dynamic and Lexical Scopes
Lecture #10 (text)     Tue, Oct 8	Dynamic versus Lexical Scope Implementing Lexical Scope: Closures and Environments Fixing an Overlooked Bug
Lecture #11 (text)     Tue, Oct 15	Lexical Scope using Racket Closures More Closures (on both levels) Types of Evaluators Feature Embedding Recursion, Recursion, Recursion
Lecture #12 (text)     Tue, Oct 15	Recursion without the Magic The Core of make-recursive Denotational Explanation of Recursion The Y Combinator The main property of Y Yet another explanation for Y Typing the Y Combinator
Lecture #13 (text)     Tue, Oct 22	Lambda Calculus — Schlac Church Numerals More Encodings Alternative Church Encoding Implementing define-type & cases in Schlac
Lecture #14 (text)     Tue, Oct 22	Recursive Environments Recursion: Racket’s letrec Implementing Recursion using letrec
Lecture #15 (text)     Tue, Oct 29	Implementing rec Using Cyclic Structures Boxes and Mutation Types for Boxes Boxof’s Lack of Subtyping Implementing a Circular Environment
Lecture #16 (text)     Tue, Oct 29	Variable Mutation State and Environments Implementing Objects with State The Toy Language
Lecture #17 (text)     Tue, Nov 5	Compilation Is this really a compiler?
Lecture #18 (text)     Tue, Nov 5	Lazy Evaluation: Using a Lazy Racket Lazy Evaluation: Some Issues Lazy Evaluation: Shell Examples Lazy Evaluation: Programming Examples Side Note: Similarity to Generators and Channels Call by Need vs Call by Name Example of Feature Embedding
Lecture #19 (text)     Tue, Nov 12	Implementing Laziness (in plain Racket) Sloth: A Lazy Evaluator Getting more from Sloth The Sloth Implementation Shouldn’t there be more ExprV promises?
Lecture #20 (text)     Tue, Nov 12	Implementing Call by Need Side Effects in a Lazy Language
All notes (text)     Tue, Nov 12	All class notes in a single file, convenient for searching through all of the material that we covered.
Future notes (text)     Tue, Nov 19	All future class notes, in a single file. In case you want to read ahead in the material. Note that notes can change when we go over them in class.

Handouts

• Email and Piazza Policies: Guidelines for writing posts
• Style Guide: Guidelines for writing better code
• Tips: Useful tips for PL work
• FAQ: Common frequently asked questions
• #lang pl work vs Fundies: Work with #lang pl vs Fundies
• About PLQ: What are these PLQs?

Interpreters

• ae.rkt — The AE interpreter (Lecture #4)
• wae.rkt — The WAE interpreter (Lecture #6)
• flang.rkt — The Flang interpreter (Lecture #8)
• flang-env.rkt — The Flang interpreter, using environments (Lecture #10)
• church.rkt — Making Schlac into a practical language (not an interpreter) (Lecture #13)
• church-alternative.rkt — An alternative “Church” encoding: use lists to encode numbers (Lecture #13)
• flang-box.rkt — The FLANG-BOX interpreter (Lecture #15)
• toy.rkt — The TOY interpreter (Lecture #16)
• sloth.rkt — The SLOTH interpreter (Lecture #19)
• sloth-cached.rkt — A call-by-need version of the SLOTH interpreter (Lecture #20)