DISCLAIMER: If you are a student currently taking 15-150 at Carnegie Mellon University, know that these notes and videos are not a substitute for going to lecture. You will learn more by being in an environment live, rather than 2x speeding through the material late at night. Use these lectures only as a reference.

I give you these resources in the pursuit of your learning. I trust you to make the right choice to make the optimal use of it.

Introduction

I had the pleasure of serving as the summer instructor for 15-150, the introduction functional programming class for computer science students at Carnegie Mellon, in the Summer 2023 semester.

This course typically serves as the second or third course in the traditional computer science undergraduate sequence, a privilege which not many other universities get to enjoy, as functional programming is often considered a niche topic.

Despite this, I (and CMU) believe this to be of the utmost importance. A disciplined, type-oriented, safety-first view of programming can be of utmost benefit to burgeoning computer science scholars, and I have often heard feedback from students that it is has a transformative view on their perspective of computer science in general.

To that end, I have made my lecture materials from my iteration of the course available for free on the Internet. Please feel free to use this knowledge in any way that you see fit, and I hope that it aids you in your future endeavors.

Lectures

Lecture 01: Prologue
"Welcome to the rest of your life!"
Lecture 02: Equivalence, Binding, and Scope
"Equivalences save lives."
Lecture 03: Induction and Recursion
"Recursion is the bread and butter of doing anything in a functional language."
Lecture 04: Structural Induction and Tail Recursion
"Proving things about pretty much any kind of data you can imagine."
Lecture 05: Trees
"Trees are the most fundamental data structure."
Lecture 06: Asymptotic Analysis
"A step is not always a step. We care about analyzing performance mathematically."
Lecture 07: Sorting and Parallelism
"What do we do when we have infinitely many processors?"
Lecture 08: Polymorphism
"Code reuse at different types, without breaking any of our safety properties."
Lecture 09: Higher-Order Functions
"We can take in functions and also return functions, like any other value."
Lecture 10: Combinators and Staging
"You shouldn't have to wait on something unrelated when you can do work right now."
Lecture 11: Continuation-Passing Style
"CPS is the difference between writing instructions now, or remembering them later."
Lecture 12: Exceptions
"Exceptions make mathematical thinking harder."
Lecture 13: Regular Expressions
"Regular expressions are one of the most practical things you can learn."
Lecture 14: Structures and Signatures
"SML has one of the most sophisticated module systems of any programming language."
Lecture 15: Functors
"Functors will show us how we can write code that depends upon modules."
Lecture 16: Red-Black Trees
"Red-black trees are a very good application of modules for protecting invariants."
Lecture 17: Sequences
"With sequences, we can keep immutability and also have the benefits of arrays."
Lecture 18: Lazy Programming
"With laziness, only pay for for the computations you want to use."
Lecture 19: Imperative Programming
"We invented immutability and purity, but we do not serve them. It's OK to be a little mutable."
Lecture 20: Compilers
"A long time ago, programming languages did not exist."
Lecture 21: Program Analysis
"We are solving an unsolvable problem."
Lecture 22: Finale
"You can never go back, because you are forever a functional programmer."

Supplemental Lectures

Supplemental Lecture 01: From SML to OCaml
"From one language to another."