• Grading policy
• Course content
• Lecture note #0 (Administrivia) handed out.
• Lecture note #1 (Introduction) handed out.

• Martin Luther King Holiday, no class.

• Introduction to functional programming.
• Lecture note #2 (Functional Programming) handed out.

Scheme

Week 3

Lecture #4, Mon, Jan 24: Introduction to Scheme

• Numbers.
• Lecture note #3 (Scheme --- Introduction) handed out.
• Read HTDP, Section 2
• Read HTDP, Section 3
• Download and install Dr Scheme on your home machine, if you have one.
• Play with Dr Scheme, either on lectura or one of the Windows machines in the lab.
• On lectura, run /usr/local/plt/bin/drscheme.
• Read Take the Dr Scheme Tour!

Lecture #5, Wed, Jan 26: Scheme Functions

• Tracing function applications
• Tests and conditional execution
• Recursive function definitions
• Symbols and Structures
• Nested data structures
• History of LISP and Scheme
• Deep recursion over lists of lists
• List processing
• Lecture note #4 (Scheme --- History) handed out.
• Lecture note #5 (Scheme --- Conditional Expressions) handed out.
• Lecture note #6 (Scheme --- Symbols and Structures) handed out.
• Lecture note #7 (Scheme --- List Processing) handed out.
• Lecture note #8 (Scheme --- Higher-Order Functions) handed out.
• Lecture note #9 (Scheme --- Metacircular Interpretation) handed out.
• Assignment 1 (Metacircular Interpretation) handed out.
• Read Scott, Programming Language Pragmatics, pp. 589-606, 609-610

Haskell

Week 4

Lecture #6, Mon, Jan 31: Introduction to Haskell

• Metacircular Interpretation
• Read Scott, Programming Language Pragmatics, pp. 601-602
• Introduction to Haskell
• Haskell basics, syntax, types, commands, etc.
• Assignment 1 (Metacircular Interpretation) is due.
• Lecture note #10 (Haskell --- Introduction) handed out.
• Lecture note #11 (Haskell --- Basics) handed out.
• Lecture note #12 (Haskell --- Function Definitions) handed out.
• Read Scott, Programming Language Pragmatics, pp. 606-607, 403

Lecture #7, Wed, Feb 2: Haskell Patterns

• Function definitions
• Patterns
• Recursive functions
• Lecture note #13 (Haskell --- Patterns) handed out.
• Lecture note #14 (Haskell --- Recursion) handed out.
• Lecture note #15 (Haskell --- Curried Functions) handed out.

Week 5

Lecture #8, Mon, Feb 7: Higher-Order Functions

• Higher-Order Functions
• Lecture note #16 (Haskell --- Higher-Order Functions) handed out.
• Lecture note #17 (Haskell --- Composing Functions) handed out.
• Function composition
• Haskell Data types
• Lazy evaluation.
• Lecture note #18 (Haskell --- Data Types) handed out.
• Lecture note #19 (Haskell --- Lazy Evaluation) handed out.
• Lecture note #20 (Haskell --- Exercises) handed out.
• Assignment 2 (Haskell and Lambda Calculus) handed out.

Lambda Calculus

Lecture #9, Wed, Feb 9: Syntax

• Introductory example
• Syntax
• Free/Bound variables
• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, pp. 145--150
• Lecture note #21 (Lambda Calculus --- Introduction) handed out.
• Read Scott, Programming Language Pragmatics, pp. 616--618

Week 6

Lecture #10, Mon, Feb 14: Substitutions

• Substitution rules
• Lecture note #22 (Lambda Calculus --- Reductions) handed out.
• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, pp. 139--143
• Read Scott, Programming Language Pragmatics, pp. 614--615

Lecture #11, Wed, Feb 16: Lambda Calculus 2

• Arithmetic
• Application strategies
• Lecture note #23 (Lambda Calculus --- Pure) handed out.
• Data structures
• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, pp. 145--150
• Read Scott, Programming Language Pragmatics, pp. 616--618

Week 7

Lecture #12, Mon, Feb 21: Lambda Calculus 3

• Combinators
• Recursive functions
• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, pp. 145--150
• Data structures
• Read Scott, Programming Language Pragmatics, pp. 616--618
• Functional programming - Conclusion
• Lecture note #24 (Functional Programming --- Conclusion) handed out.
• Read Scott, Programming Language Pragmatics, pp. 622-623

• Reference vs. value semantics.
• Type equivalence
• Lecture note #25 (Types --- Introduction) handed out.
• Lecture note #26 (Types --- Classification) handed out.
• Lecture note #27 (Types --- Equivalence) handed out.
• Read Scott, Programming Language Pragmatics, pp. 319-334

• Short-Circuit Evaluation
• Selection
• If, Case, ...
• Iteration
• while, repeat, for,...
• Enumerators (Java)
• Iterators (Icon, Clu, C#)
• Lecture note #28 (Control --- Introduction) handed out.
• Lecture note #29 (Control --- Iterators) handed out.
• Read Scott, Programming Language Pragmatics, pp. 249-, 280-296

• Stack allocation
• Calling conventions
• Parameter passing
• Pass-by-name
• Pass-by-value
• Pass-by-reference
• Pass-by-value/result
• Non-local variables
• Read Scott, Programming Language Pragmatics, pp. 427-441
• Lecture note #30 (Procedures --- Introduction) handed out.
• Lecture note #31 (Procedures --- Parameters) handed out.

• Inlining
• Static vs. Dynamic Scope
• Lecture note #32 (Procedures --- Inlining) handed out.
• Lecture note #33 (Procedures --- Scope) handed out.
• Lecture note #34 (Procedures --- Dynamic Scope) handed out.
• Read Scott, Programming Language Pragmatics, pp. 441-442, 298-301

• Closures
• Coroutines (Modula-2)
• call/cc (Scheme)
• Lecture note #35 (Procedures --- Closures) handed out.
• Lecture note #36 (Procedures --- Coroutines) handed out.
• Read Scott, Programming Language Pragmatics, pp. 105-115

• No class

• No class

• Pascal
• Binding time
• Object lifetimes
• Static allocation
• Stack Allocation
• Heap allocation
• Relsference Counting
• Mark-and-sweep
• Lecture note #38 (Garbage Collection --- Introduction) handed out.
• Lecture note #39 (Garbage Collection --- Mark and Sweep) handed out.
• Read Scott, Programming Language Pragmatics, pp. 105-115

• Copying Collection
• Generational Collection
• Lecture note #40 (Garbage Collection --- Copying Collection) handed out.
• Lecture note #41 (Garbage Collection --- Generational Collection) handed out.
• Assignment 4 (Garbage Collection) handed out.
• Read Scott, Programming Language Pragmatics, pp. 382-400
• Uncooperative Languages
• Discussion
• Lecture note #42 (Garbage Collection --- Uncooperative Languages) handed out.
• Lecture note #43 (Garbage Collection --- Discussion) handed out.

• Exception Handling
• Lecture note #37 (Exceptions) handed out.
• Read Scott, Programming Language Pragmatics, pp. 464--474

Object-Oriented Programming

Lecture #23, Wed, Mar 30: Introduction

• Language constructs
• Run-time typechecking
• Lecture note #45 (OO Languages --- Introduction) handed out.
• Lecture note #46 (OO Languages --- Polymorphism) handed out.

Week 13

Lecture #24, Mon, Apr 4:

• Lecture note #47 (OO Languages --- Multiple Inheritance) handed out.
• Multiple inheritance

Lecture #25, Wed, Apr 6: Smalltalk

• Lecture note #48 (OO Languages --- Smalltalk) handed out.

• Traditional Operational Semantics
• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, Chapter 1
• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, Chapter 8
• Lecture note #50 (Semantics --- Introduction) handed out.
• Lecture note #51 (Semantics --- Syntax) handed out.

• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, Chapter 8
• Assignment 5 (Operational Semantics) handed out.
• Lecture note #52 (Semantics --- Operational Semantics) handed out.

• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, Chapter 9
• Lecture note #53 (Semantics --- Denotational Semantics) handed out.

• Read Slonneger and Kurtz, Syntax and Semantics of Programming Languages, Chapter 9
• Assignment 5 (Operational Semantics) is due.
• Assignment 6 (Denotational Semantics) handed out.

Modularity

Week 16

Lecture #30, Mon, Apr 25: Separate compilation

• Modules
• Modula-2, Ada
• Information hiding
• Opaque types
• Lecture note #49 (Modularity) handed out.
• Read Scott, Programming Language Pragmatics, pp. 122--129,539--542