Course materials
Fall 2025
01 · Syllabus
This course examines the design, implementation, analysis, and classification of programming languages. Using Racket and Haskell, students study functional programming and approach language design from a creator’s perspective, connecting formal principles to modern language features.
Course programming uses Racket and Haskell. The official Racket and Haskell documentation serve as the primary references, with DrRacket and the Haskell toolchain used for guided practice.
Ten assignments contain programming questions across the semester. All work must be submitted on time; late submissions are not accepted.
Assignments constitute 50% and exams constitute 50% of the final grade. Standard letter-grade thresholds begin with A at 93, A− at 90, and B+ at 87.
The classroom must remain respectful and free of discrimination, bullying, and other harmful conduct. Violations are addressed through course and college procedures.
Seven guided virtual labs in Racket provide seven fourth-hour sessions, and seven guided virtual labs in Haskell provide seven sessions. Together they account for fourteen structured hours outside regular class meetings.
AI can be a useful assistant when used reasonably, but it must not replace a student’s thinking. Assignments must be completed independently. Students should understand and be able to reproduce and explain all submitted work; significant inconsistencies may require an in-person demonstration and may be reported under academic-integrity procedures.
02 · Contents
DrRacket, programs and expressions, definitions, style, conditional expressions, compound data, modules, and testing.
Core data types, lists, tuples, operators, conditionals, functions, type classes, custom types, and type variables.
Imperative and functional paradigms, side effects, purity, grammars, parse trees, abstract syntax trees, denotational semantics, and operational semantics.
Syntax, free and bound variables, beta-redexes, substitution, beta-reduction, and the relationship between lambda expressions and computation.
Recursive datatypes, structural recursion over lists, tail calls, tail-call optimization, pattern matching, and recursive problem solving.
Map, filter, folds, composition, currying, partial evaluation, apply, closures, and functions that return functions.
Global and local bindings, lexical and dynamic scope, strict and non-strict evaluation, delayed evaluation, and evaluation order in Racket and Haskell.
Classes as higher-order functions, methods, self-reference, symbols, pattern-based macros, macro rules and ellipses, and AST-based transformations.
Lazy and infinite streams, generators, ambiguous and nondeterministic expressions, continuations, local mutation, choices, predicates, and backtracking.
Strong and weak typing, static and dynamic typing, algebraic data types, parametric polymorphism, type classes, and ad-hoc polymorphism.
Functorial mapping, Option, Either, and List as monads, failure representation, lifting, state, mutation in pure functional programs, and the IO monad.
Constructing type-safe Racket and Haskell solutions while reasoning about correctness, abstraction, composition, and programming-language design.
03 · Exam preparation
The student is expected to conduct himself, at all times, both on and off the campus, as a gentleman and a responsible citizen.
I will complete this exam in a fair, honest, respectful, responsible, and trustworthy manner. This means that I will complete the exam as if the professor was watching my every action. I will act according to the professor’s instructions, and I will neither give nor receive any aid or assistance other than what is authorized. I know that the integrity of this exam and this class is up to me, and I pledge not to take any action that would break the trust of my classmates or professor, or undermine the fairness of this class.
04 · Assignments
Open each assignment to work directly from the original Racket, Haskell, formal-language, and type-system questions.
05 · Projects