• Course overview
• Incompleteness theorems and the Halting problem
• Remembering Java (Iteration.java)

Req:	Syllabus Motivation
Hwk:	HW1: Recursion
Sup:	C. Kaplan, Understanding the Halting Problem
Exp:	D. Myers, Goedel's Theorems

• Formal grammars in Backus-Naur form (BNF)
• The Scheme language (examples.ss)
• The Dr. Scheme IDE
• The Scheme expression grammar

Req:	M. Felleisen et al., How to Design Programs, Section 2 Scheme Overview
Sup:	E. Cummings, Since Feeling Is First H. Abelson and J. Sussman, Structure and Interpretation of Computer Programs, Ch. 1.1 (all 9 pages)
Exp:	R. Kelsey et al., Revised5 Report on Scheme (Slightly out of date, but easier to read than R6RS) S. Sperber et al., Revised6 Report on Scheme (R6RS)

• Scheme practice
• AND and OR
• Value domain, as sets and as grammar
• LAMBDA
• Functional programming (higher-order-functions.ss)
• MAP and FOLDL

Req:	H. Abelson and J. Sussman, Structure and Interpretation of Computer Programs, Ch. 1.3
Sup:	PLT Scheme documentation, IF, COND, AND, and OR Normark, Introduction to higher-order functions
Exp:	J. Hughes, Why functional programming matters
Hwk:	HW2: Functional Programming
Due:	HW1: Recursion

• LET and LETREC (let.ss)
• Higher-order functions (higher-order-functions.ss)
• FILTER
• Stream Programming: Map-Reduce-Scatter-Gather
• Structures as functions
• Expressivity and Syntactic Sugar
  • DEFINE-proc vs. DEFINE + LAMBDA
  • Java FOR vs. Java WHILE
  • Iteration vs. tail recursion
  • DEFINE vs. LETREC
  • LET vs. LAMBDA

Req:	PLAI Ch. 1
Sup:	Normark, Mapping and filtering Feldman, The Search for a new HPC language
Exp:	Perlis, Epigrams on Programming Fortress Wiki Dean and Ghemawat, MapReduce: Simplified data processing on large clusters Dickey, Scheming with Objects Ahn, Erez, and Dally, Scatter-Add in Data Parallel Architectures

• Tokenize → Parse → Evaluate
• Compilers and interpreters
• Your first interpreter: calc (calc-interpreter-1.ss, calc-interpreter-1b.ss)
• Strongly typed parser with define-type and type-case (calc-interpreter-2.ss)

Req:	PLAI Ch. 1 (again!), 2
Hwk:	HW3: Interpreter
Sup:	PLAI Scheme additional documentation (Brown) define-type and type-case descriptions (Grinnell)
Exp:	PLT Docs The Reader
Due:	HW2: Functional Programming

• Arrow and product types
• A substitution interpreter (subst.ss)
• Bound and free variables

Req:	PLAI Ch. 3
Sup:	SICP 1.1.5 Programming Language Notes (09-02-24 edition)
Exp:	Tcl - a popular scripting language based on substitution

• The Halting Problem
• Scheme Expressions
• BNF and Syntax
• First Class Procedures
• Substitution Interpreter

• Covers Halting Problem through Substitution
• In class: 75 min
• Closed book, 1/2 page original, hand-written notes
• Similar to homework questions

• Eager and lazy evaluation
• Lambda Calculus Semantics
• Currying
• Scheme LAMBDA and App in λC
• Church Lists: CONS in λC (rewrite.ss)

• Church lists: CAR and CDR in λC
• Church booleans and conditionals (church-bool-and-list.ss)
• Church numerals
• Fixed points
• The Y Combinator (y-derivation.ss)
• The Church-Turing thesis

• The price of substitution
• Deferring substitution
• Semantics vs. implementation
• Environments and binding
• Mutation
• Variable scope
• SET! (PLT Scheme Doc) and BEGIN
• Introduction to closures

Req:	PLAI Ch. 4 Eph Interpreter Source (read over the next two weeks) (eph.zip)
Sup:	SICP 3.2
Due:	HW5: Lambda Calculus
Hwk:	HW6: Save the Environment I (eph.zip)

• Implementing procedures
• Lexical and dynamic scope
• APPLY and EVAL revisited
• Implementing MAP (map.ss)
• Semantics of LET, LET*, LETREC
• Native/built in procedures

Req:	PLAI Ch. 5, 6
Exp:	PLAI Ch. 14 A. Belapurkar, Functional programming in the Java language Dickey, Scheming with Objects (in case you didn't read it before) Steele and Sussman's Lambda Papers

Erdem Sahin will present on a topic of his choice.

• Apply/eval revisited
• Continuations and control flow
• RETURN, BREAK, THROW, and backtracking (throw.ss return.ss)

Req:	PLAI Ch. 19
Sup:	A short introduction to call/cc
Exp:	PLAI Ch. 15-20 (they're short)
Due:	HW6: Save the Environment I
Hwk:	HW7: Save the Environment II

• Macros are parser plugins
• C #DEFINE (assert.c)
• Scheme DEFINE-SYNTAX-RULE (while.ss)
• Practicing good hygiene (or.ss)
• DEFINE-SYNTAX (infix.ss)

Req:	PLAI 36 parts 1, 2, 5, 6
Sup:	Donnelly, Scheme syntax-rules primer
Exp:	PLAI 36.3, 36.4 Groovy: Compile-time Metaprogramming (for Java)

• Formal progress rules
• Literal Expressions vs. Values (review)
• Rules with environments
• Introduction to types
• Exam Review:
  • Halting Problem
  • Grammars
  • Interpreters
  • Functional Programming
  • Stream Programming
  • λ Calculus
  • Closures
  • Macros
  • How to learn a language

Req:	PLAI Ch. 23 pl-notes (09-04-09 version), section 5
Due:	HW7: Save the Environment II
Hwk:	HW8: Operational Semantics

Covers all material from the course. Emphasis on:

• λ Calculus
• Lazy and Eager Evaluation
• Environments
• Macros

• Review slides (not comprehensive)
• In class: 75 min
• Closed book, 1/2 page original, hand-written notes

• Validity vs. correctness
• Types are sets of values
• Type judgements are reductions for types
• Type annotations
• Procedure Types

Req:	PLAI Ch. 24, 25 Steele, Growing a Language, 1999 (for HW9, not discussed in class today)
Exp:	Erwig and Burnett, Adding Apples to Oranges, PADL '02
Due:	HW8: Operational Semantics
Hwk:	HW9:Judgements

• Discussion of Judgements
  • Curry-Howard correspondance
  • Casts
• Type Inference
  • T-Lambda revisited
  • The Hindley-Milner-Damas unification algorithm
  • Patterns and inference in ML
• Syntax Revisited (slides)

Req:	PLAI Ch. 30 (you may skip 30.1.0, 30.1.2, 30.5.3)
Sup:	Spiewak, What is Hindley-Milner? Pottier, A modern eye on ML type Inference
Exp:	Tarjan, Efficiency of a Good But Not Linear Set Union Algorithm, J. ACM, 1975 (implementation in C from Sedgewick)

• Overloading (Complex.cpp)
• Dynamic types (List.py)
• Parametric Polymorphism (List.java List.cpp)
  • What's Java's problem? (Array.java Array.h)
  • Digression: template metaprogramming in C++ Factorial.cpp
• Experimenting

Req:	PLAI Ch. 29
Exp:	C++ Template Metaprogramming
Due:	HW9: Judgements
Out:	HW10: Babel

• Subtypes
• Covariance and contravariance
• Objects and inheritance
• The curious cases of null and void

Sup:	Covariance and contravariance
Exp:	C.A.R. Hoare, Null References: The Billion Dollar Mistake

• Protecting state with closures: next procedure in Scheme
• (Exploring semantics)
• Stack and heap revisited
• Constructors and destructors in C++ (constructor.cpp)
• Manual mangement: new and delete in C++
• Dangling references and memory leaks (...and buffer overrun exploits)
• Identifying dead objects is undecidable
• Memory management for Trees is easy
• Reference counting for Directed Acyclic Graphs (ala Python)
• Extending C++ with reference counting (ReferenceCount.cpp)

Req:	PLAI Ch. 21
Exp:	Berger et al., Composing High-Performance Memory Allocators, PLDI 2001
Due:	HW10: Recursion (Now due 5/5/09 because of server and network outages during in the heat wave)

• Cycle detection is difficult
• Free lists and allocation lists (alloc.py)
• Block allocation
• The Mark-Sweep collection algorithm (mark-sweep.py)
• Conservative collection
• Fragmentation
• Stop-and-Copy collection algorithm

• Yielding
• Threads and processes
• Barrier synchronization
• Mutexes and semaphores
• Java synchronized
• Signal and wait
• Lockless structures

Out:	HW12: Conclusions
Due:	HW11: Memory Management

• Scheme: list
• Python, TCL, and Perl: string
• C: byte
• C++, Java, and Smalltalk: object
• APL, Excel, and Fortress: equation
• Matlab and Fortran: matrix
• GLSL: 3D vector
• Prolog: logical proposition
• CUDA: thread

• Programming for parallelism
• Accessible programming
• Safety and security
• Course evaluations

Handout:	PL Notes (5/12/09 version)--may be brought to final exam.
Due:	HW12: Conclusions