Lambda Calculus

Abstract Syntax

Continuations

Function (computer programming)

Monads

Boolean

Lambda

Regular Expressions

Intermediate Representations

Register Allocation

Garbage Collection

Type Checking

Compiler

Functional Programming (FP)

OCaml

Pattern Matching

Types

Custom Types

S-Expression

Unary Operations

Correctness and Testing

Conditional (computer programming)

Binary Operations

Naming Expressions

Pairs

Handling Errors

Tail Call Optimization

Parsing

First-Class Functions

Function Pointers

Optimization

Constant Folding

CS 164: Programming Languages and Compilers UC Berkeley Fall 2022 Explores how compilers translate high-level languages into machine-understandable code, offering practical experience with developing compilers for various languages. Also covers reasoning about compiler correctness and understanding runtime errors.  Have you ever wondered why C programs seem to run faster than Python programs? Have you ever been confused by an error message and wondered why Java couldn’t understand your program? In CS 164, we’ll learn how compilers take in code in one language and produce code in another; in particular, we’ll learn how to translate high-level languages into code that your computer’s processor can understand. We’ll get hands-on practice developing compilers for a series of increasingly complex languages. Along the way, we’ll learn some general best practices for developing and testing complex software systems. After completing this course, students will be able to:

- Develop programs to translate between different programming languages
- More broadly, develop programs that operate on programs
- Explain the relationship between compilers and interpreters, and the differences between them
- Understand the tools they use to run programs—and the errors those tools produce
- Assign meaning to high-level language constructs
- Implement high-level language constructs
- Reason about what it means for a compiler to be correct
- Reason about undefined behavior
- Read and write assembly language
- Write a parser - [CS 61B. Data Structures](https://www2.eecs.berkeley.edu/Courses/CS61B/)
- [CS 61C. Machine Structures](https://www2.eecs.berkeley.edu/Courses/CS61C/)

### Course Culture

Students taking CS 164 come from a wide range of backgrounds. We hope to foster an inclusive and safe learning environment based on curiosity rather than competition. All members of the course community—the instructor, students, and GSIs—are expected to treat each other with courtesy and respect. Some of the responsibility for that lies with the staff, but a lot of it ultimately rests with you, the students. There is no textbook for the course; all readings will be provided digitally.

CS 164: Programming Languages and Compilers

Functional Programming

Proofs: Numbers, Lists, Trees

Semantics via Interpreters

Transition Systems

Inductive Invariants

Operational Semantics

Hoare Logic

Metatheory

Church Encodings

Simply Typed Lambda Calculus (STLC)

Type Safety in STLC

System F: Polymorphism

Compiler Correctness

Simulation Relations

Graduel Types

CSE 505 Programming Languages University of Washington Spring 2021 University of Washington's course develops rigorous tools to study the meaning of programs. It aims to improve formalism, proof skills, and precision in programming, while also discussing practical applications. It covers operational semantics, Hoare Logic, compiler correctness, and more.  Develop tools to rigorously study what programs mean.

### Benefits

- Writing a PL-ish thing is inevitable
    - Extensible systems, rich data structures, domain-specific languages (DSLs)
- Build skills with formalism and proof
    - Precision, expressiveness, communication, clarity, confidence
- Become better programmers
    - Travel to understand where you’re from!


### Approach

- Develop the core of real languages
    - include distinguishing features, omit sugar
- Start simple, extend w/ richer features
    - develop reasoning techniques in parallel
- Discuss application to industrial PLs
    - implement and prove to connect theory with code

### Subgoals

- Develop tools for studying programs
    - structural induction, inference rules
- Investigate core PL concepts
    - types, functions, scope, mutation, iteration
- Learn how to use proof assistants
    - powerful tools with increasing adoption
  

CSE 505 Programming Languages

JavaScript

Scope

Storage Management

Function Implementation

Haskell

Type Polymorphism

type Inference

Type Classes

Object (computer science)

vtables

Subtyping

Inheritance (object-oriented programming)

Control flow

Exception handling

IO Monad

CSE 130: Programming Languages: Principles and Paradigms UC San Diego Winter 2017 UC San Diego's CSE 130 provides an overview of basic concepts and design trade-offs related to programming languages. The course covers a wide range of topics like scope, storage management, exceptions, and concurrency, through practical implementation. This course will cover basic concepts and design trade-offs related to programming languages. The first half of the course focuses on functions, types, scope, storage management, exceptions, and continuations. The second half covers object-oriented features and concurrency. We will conclude with a few special-topics in programming languages. The class also has a number of small labs where students get to implement some of the language features discussed in class. The course consists of lectures, written homeworks, and programming assignments. The goal of the course is to (1) familiarize you with various modern programming language concepts and paradigms and (2) get you to think about and understand the design trade-offs and implementations of different language features. We will use real-world languages (e.g., JavaScript, Haskell, and C++) to explore the different concepts. But, we will not cover any one language in full – this course is not meant to make you a proficient programmer, learning how to proficiently program in any of these languages is a course in of itself.  We will be following John Mitchell’s [Concepts In Programming Languages](https://books.google.com/books?id=AUUgAwAAQBAJ) textbook and assigning reading from this book and various other online resources and papers. Some of the book chapters have been revised, we will be handing out PDFs of these chapters. Cheaper renting options for the book seem to be available online (e.g., on [Amazon](https://www.amazon.com/Concepts-Programming-Languages-John-Mitchell-ebook/dp/B00AHTN2TA/ref=mt_kindle?_encoding=UTF8&me=)).

If you are serious about programming languages Benjamin Pierce’s [Types and Programming Languages](https://www.cis.upenn.edu/~bcpierce/tapl/) is a must.

CSE 130: Programming Languages: Principles and Paradigms

Combinator Calculus

Combinators

Typed Lambda Calculus

Polymorphic Types

Object Calculus

State (computer science)

Type State

Pi Calculus

Program Verification via Type Theory

Gradual Types

Loop Invariants

Lean (proof assistant)

CS 242 Programming Languages Stanford University Fall 2022 Stanford University's CS 242 teaches the basics of programming language theory, its applications, and future trends. It focuses on the practical and theoretical understanding of programming languages, covering typed lambda calculus, state, monads, and more. CS242, Programming Languages, covers the basics of the theory of programming languages, its applications to widely used languages today, and trends in the field that are likely to help define the programming languages of tomorrow. The techniques covered in the class also provide a set of intellectual tools that students can use to understand unfamiliar programming languages and improve their ability to design and write software.  - Theory: CS 103
     - First-order logic, induction, discrete math
- Systems: CS 107 + 110
- Comfortable with programming
    - And learning new programming systems 

CS 242 Programming Languages

Rule Induction

Binding

Substitution (logic)

Dynamics

Statics

De Bruijn Indices

Gödel's T and PCF

Substitution Lemma

Definability and undefinability

Products and Sums

Recursive Types

Objects and Dynamic Dispatch

Proof Techniques

Dynamic Languages

Dynamic Languages as Typed Languages

Church's λ-Calculus

Modernized Algol

Scoped Assignables

Assignable References

System F

Polymorphism (computer science)

Representation Independence

Evaluation Dynamics

Cost Dynamics

Parallelism

Nested Data Parallelism

Control Stacks

Brent's Theorem

Free Assignables

Futures and Speculations

Communication in the π-calculus

Concurrent Algol

Proofs as Programs

Judgments as Types

Dependently Typed Programming

15-312 Foundations of Programming Languages Carnegie Mellon University Spring 2014 A comprehensive course at Carnegie Mellon University that introduces fundamental principles of programming language design and implementation from a mathematical perspective. It delves deep into the structural and dynamic aspects of programming languages, studying concepts like recursion, objects, polymorphism, and parallelism. This course introduces the fundamental principles of programming language design, semantics, and implementation. Our goal is to examine the fundamental structure of programming languages from a mathematical perspective.   

15-312 Foundations of Programming Languages

Programming Languages talks about the modern programming langauge concepts and paradigms, and the design trade-offs and implementations of different language features. Common sub-topics include compilers, interpreters, parsing, optimization, etc.

Programming Languages

Computer Science

Programming Languages

Prerequisites

Common concepts