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, Jan 9	Intro to CS4400/CS5400 Intro to Programming Languages Intro to Racket Side-note: “Goto Statement Considered Harmful” Quick Intro to Racket
Lecture #2 (text)     Tue, Jan 9	Lists & Recursion Some Style Tail calls Sidenote on Types Side-note: Names are important
Lecture #3 (text)     Tue, Jan 16	BNF, Grammars, the AE Language
Lecture #4 (text)     Tue, Jan 16	Simple Parsing The match Form The define-type Form The cases Form Semantics (= Evaluation) Side-note: Compositionality Implementing an Evaluator Implementing The AE Language Intro to Typed Racket
Lecture #5 (text)     Tue, Jan 23	Bindings & Substitution WAE: Adding Bindings to AE Evaluation of with
Lecture #6 (text)     Tue, Jan 23	Evaluation of with (contd.) Formal Specs 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 #7 (text)     Tue, Jan 30	The FLANG Language
Lecture #8 (text)     Tue, Jan 30	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 Substitution Caches Implementation of Cache Functionality Formal Rules for Cached Substitutions
Lecture #9 (text)     Tue, Feb 6	Evaluating with Substitution Caches Dynamic and Lexical Scopes
Lecture #10 (text)     Tue, Feb 6	Dynamic versus Lexical Scope Implementing Lexical Scope: Closures and Environments
Lecture #11 (text)     Tue, Feb 13	Fixing an Overlooked Bug Lexical Scope using Racket Closures More Closures (on both levels) Types of Evaluators Feature Embedding Recursion, Recursion, Recursion
Lecture #12 (text)     Tue, Feb 13	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 Lambda Calculus — Schlac Church Numerals
Lecture #13 (text)     Tue, Feb 20	More Encodings Alternative Church Encoding Implementing define-type & cases in Schlac
Lecture #14 (text)     Tue, Feb 20	Recursive Environments Recursion: Racket’s letrec Implementing Recursion using letrec Implementing rec Using Cyclic Structures Boxes and Mutation
Lecture #15 (text)     Tue, Feb 27	Types for Boxes Boxof’s Lack of Subtyping Implementing a Circular Environment
Lecture #16 (text)     Tue, Feb 27	Variable Mutation State and Environments Implementing Objects with State The Toy Language
Lecture #17 (text)     Tue, Mar 12	Compilation Is this really a compiler?
Lecture #18 (text)     Tue, Mar 12	Lazy Evaluation: Using a Lazy Racket Lazy Evaluation: Some Issues Lazy Evaluation: Shell Examples Lazy Evaluation: Programming Examples
Lecture #19 (text)     Tue, Mar 19	Side Note: Similarity to Generators and Channels Call by Need vs Call by Name Example of Feature Embedding Implementing Laziness (in plain Racket) Sloth: A Lazy Evaluator Getting more from Sloth
Lecture #20 (text)     Tue, Mar 19	The Sloth Implementation Shouldn’t there be more ExprV promises? Implementing Call by Need Side Effects in a Lazy Language
Lecture #21 (text)     Tue, Mar 26	Designing Domain Specific Languages (DSLs) Syntax Transformations: Macros Macro Problems Complexity of S-expression transformations Scoping problems
Lecture #22 (text)     Tue, Mar 26	Scheme (and Racket) Macros Meta Macros Lazy Constructions in an Eager Language Recursive Macros
Lecture #23 (text)     Tue, Apr 2	Another example: a simple loop Yet Another: List Comprehension Problems of syntax-rules Macros
Lecture #24 (text)     Tue, Apr 2	Racket’s “Low-Level” Macros Solving the syntax-rules problems [extra] Breaking Hygiene, How Bad is it? [extra] Macros in Racket’s Module System [extra] Defining Languages in Racket [extra] Macro Conclusions Side-note: macros in mainstream languages
Lecture #25 (text)     Tue, Apr 2	Types What is a Type? Our Types — The Picky Language Typing control Extending Picky
Lecture #26 (text)     Tue, Apr 9	Implementing Picky Improving Picky
Lecture #27 (text)     Tue, Apr 9	Typing Recursion Extending Picky with recursion Typing Data Judgments for recursive types “Runaway” instances [extra] Type soundness
Lecture #28 (text)     Tue, Apr 9	Explicit polymorphism [extra] Polymorphism in the type description language [extra] Type judgments for explicit polymorphism and execution [extra] Explicit polymorphism conclusions [extra]
Lecture #29 (text)     Tue, Apr 16	Web Programming Basic web programming Continuations: Web Programming Simulating web reading More Web Transformations Transforming a recursive function Using sum/k Converting stateful code Converting higher order functions Highlevel Overview on Continuations
Lecture #30 (text)     Tue, Apr 16	An Automatic Continuation Converter Continuations as a Language Feature Continuations in Racket
Lecture #31 (text)     Tue, Apr 16	Playing with Continuations [extra] The Ambiguous Operator: amb [extra] Generators (and Producers) [extra] Delimited Continuations [extra] Continuation Conclusions Sidenote: JavaScript: Continuations, Promises, and Async/Await
All notes (text)     Tue, Apr 16	All class notes in a single file, convenient for searching through all of the material that we covered.

Handouts

• Email and Piazza Policies: Guidelines for writing posts (in piazza and in general).
• Style Guide: A collection of guidelines for writing better code.
• Tips: Some useful tips for PL work, DrRacket tips and more.
• FAQ: Common frequently asked questions.
• #lang pl work vs Fundies: The new #lang pl work vs the good old Fundies days.
• About PLQ: What are these PLQs?
• Debugging Macros: For the macro homework

Interpreters

• ae.rkt — The AE interpreter (Lecture #4)
• wae.rkt — The WAE interpreter (Lecture #5)
• flang.rkt — The Flang interpreter (Lecture #7)
• 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 #20)
• sloth-cached.rkt — A call-by-need version of the SLOTH interpreter (Lecture #20)
• mylang.rkt — A language that is built as an extension on top of Racket (Lecture #24)
• picky1.rkt — The Picky interpreter, verbose version (Lecture #26)
• picky2.rkt — The Picky interpreter, almost no explicit types (Lecture #26)
• picky3.rkt — The Picky interpreter, no explicit types (Lecture #26)
• web-base-library.rkt — Fake web interaction library (to be used with manual code CPS-ing examples) (Lecture #29)
• web-simple-language.rkt — Simulation of web interactions with a CPS converter (not an interpreter) (Lecture #30)
• cps-language.rkt — A language that is CPS-transformed (not an interpreter) (Lecture #30)
• continuation-based-web-library.rkt — Simulation of web interactions with Racket’s built-in continuation facility (Lecture #30)
• amb.rkt — The ambiguous operator and related utilities (Lecture #31)
• producer.rkt — An implementation of producer functions (Lecture #31)