Abstract Syntax

Assignable References

Binding

Brent's Theorem

Church's λ-Calculus

Communication in the π-calculus

Concurrent Algol

Control Stacks

Cost Dynamics

De Bruijn Indices

Definability and undefinability

Dependently Typed Programming

Dynamic Languages

Dynamic Languages as Typed Languages

Dynamics

Evaluation Dynamics

Free Assignables

Function (computer programming)

Futures and Speculations

Gödel's T and PCF

Judgments as Types

Modernized Algol

Monads

Nested Data Parallelism

Objects and Dynamic Dispatch

Parallelism

Polymorphism (computer science)

Products and Sums

Proof Techniques

Proofs as Programs

Recursive Types

Representation Independence

Rule Induction

Scoped Assignables

Statics

Substitution (logic)

Substitution Lemma

System F

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

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

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

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

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

15-312 Foundations of Programming Languages

Overview

Prerequisites

Learning objectives

Textbooks and other notes

Other courses in Programming Languages

CSE 130: Programming Languages: Principles and Paradigms

CS 242 Programming Languages

CS 164: Programming Languages and Compilers

CSE 505 Programming Languages

Courseware availability

Covered concepts