Programming Language Research

Research on programming languages, compilers, functional programming, devtools.

Table of Contents

• Courses
• Books
• Learning Paths
• Experiments
• Papers
• Programming Language Design / PLT
• Compiler
• PL Paradigms
• Interpreter
• PL Research
• Type System
• Parsers
• Backend
• Program Synthesis
• Language Learnings
  • TypeScript
  • Ecmascript
  • Rust
  • Python
  • OCaml
• Browser
• Web UI
• Careers
  • Jobs
  • Schools
• People in PL

Courses

• 🎥 301 - Organization of Programming Languages
• 🎥 Benjamin Pierce - Software foundations
• 🎥 CIS352 - Principles of Programming Languages
• 🎥 CMSC 430: Design and Implementation of Programming Languages
• @matthewflatt489/playlists">🎥 CS 3520/6520 - Programming Languages
• 🎥 CS3110 - Functional Data Structures
• 🎥 CS3MI3 - Principles of Programming Languages
• 🎥 CS520 - Theories Of Programming Languages
• 🎥 CSE340 - Principles of Programming Languages
• 🎥 LINFO1131 - Advanced programming language concepts
• 💻 Accelerated 1
• 💻 All the courses Matthias Felleisen teach
• 💻 Building a Parser from scratch
• 💻 CMSC330 - Organization of Programming Languages
• 💻 CMU - CS6120 - Advanced Compilers
• 💻 Compilers — Stanford
• 💻 Compilers Design Recipe
• 💻 Compilers: Theory and Practice — Udacity
• 💻 Concepts in Programming Languages
• 💻 COP 4020 - Programming Languages I
• 💻 COS 326 - Functional Programming
• 💻 CS 242: Programming Languages, Fall 2019
• 💻 CS019 - Accelerated Introduction to Computer Science
• 💻 CS164 Programming Languages and Compilers
• 💻 CS242 - Programming Languages - Stanford
• 💻 CS2500 - Fundamentals of Computer Science
• 💻 CIS 341 - Compilers
• 💻 CSCI1730 - Programming Languages - Application and Interpretation
• 💻 CSE 131 - Compiler Construction
• 💻 CSE230 - Principles/Programming Languages
• 💻 Essentials of Programming Languages
• 💻 Fundamentals 1
• 💻 Fundamentals 2
• 💻 Hack Your Own Language
• 💻 History of Programming Languages
• 💻 Indiana University Compiler Course
• 💻 Introduction to Compiler Construction
• 💻 Jay McCarthy - 406 Compiler Construction
• 💻 Matthias Felleisen - Intensive Principles of Programming Languages
• 💻 Matthias Felleisen - Principles of Programming Languages
• 💻 Principles of Compiler Design
• 💻 Programming Language Foundations in Agda
• 💻 Programming Languages and Logic
• 💻 Programming Languages Course given by DCC-UFMG
• 💻 Programming Languages Ⅰ
• 💻 Programming Languages Ⅱ
• 💻 Ray Total Courses
• 💻 Theory of Programming Languages

Books

• 📚 Compiler Construction
• 📚 Compiler Design
• 📚 Compiling with Continuations
• 📚 Concepts of Programming Languages
• 📚 Discrete Mathematics for Computing
• 📚 Engineering a Compiler
• 📚 Homotopy Type Theory
• 📚 How to Design Programs: An Introduction to Programming and Computing
• 📚 HTDP
• 📚 Human-Centered Programming Languages
• 📚 Introduction to Compilers and Language Design
• 📚 Modern Compiler Design
• 📚 Modern Compiler Implementation in C
• 📚 Parsing Techniques: A Practical Guide
• 📚 Parsing Techniques. A Practical Guide
• 📚 Practical Foundations for Programming Languages
• 📚 Programming Languages: Application and Interpretation
• 📚 SICP — Structure and Interpretation of Computer
• 📚 The Elements Of Computing Systems
• 📚 Thinking with Types: Type-Level Programming in Haskell
• 📚 Type Theory and Formal Proof: An Introduction
• 📚 Type Theory and Functional Programming

Learning Paths

• Advanced Programming Languages
• Compiler Engineer Path
• Learn Type Theory
• PLR & Compiler Learning Path
• Programming Language Theory Path
• So You Want to Be a (Compiler) Wizard
• Programming languages resources

Experiments

• A miniature model of the Typescript compiler
• An interpreter for the Lox programming language
• An interpreter for the Monkey programming language
• How the TypeScript compiler works

Papers

• 📜 10 papers that all PhD students in programming languages ought to know
• 📜 A syntactic approach to type soundness
• 📜 A Theory of Type Polymorphism in Programming
• 📜 Abstracting Gradual Typing
• 📜 An Axiomatic Basis for Computer Programming
• 📜 Call-by-name, call-by-value, and the λ-calculus
• 📜 Classic Papers in Programming Languages and Logic
• 📜 Efficient Gradual Typing
• 📜 Fundamental concepts in programming languages
• 📜 Gradual Type Theory
• 📜 Gradual Typing for Functional Languages
• 📜 Gradual Typing: A New Perspective
• 📜 How Statically-Typed Functional Programmers Write Code
• 📜 Migrating Gradual Types
• 📜 On Model Subtyping
• 📜 On Understanding Types, Data Abstraction, and Polymorphism
• @mikhail.barash.mikbar/papers-on-programming-languages-ideas-from-70s-for-today-2931891d4dbd">📜 Papers on programming languages: ideas from 70’s for today
• 📜 Papers to read
• 📜 Pluggable Type Systems
• 📜 Programming in Homotopy Type Theory
• 📜 Refined Criteria for Gradual Typing
• 📜 Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages
• 📜 The Behavior of Gradual Types: A User Study
• 📜 The Design Principles of the Elixir Type System
• 📜 The Next 700 Programming Languages
• 📜 Towards a theory of type structure
• 📜 Towards Practical Gradual Typing
• 📜 Type Inference Algorithms
• 📜 Type Inference for Records in a Natural Extension of ML
• 📜 Type Systems for Object-Oriented Programming Languages
• 📜 Type Systems
• 📜 What every compiler writer should know about programmers
• 📜 Why Dependent Types Matter

Programming Language Design / PLT

• 🎥 A Language Creators’ Conversation: Guido van Rossum, James Gosling, Larry Wall & Anders Hejlsberg
• 🎥 A Tale of Two Asyncs: Open Source Language Design in Rust and Node.js
• 🎥 Another Go at Language Design
• 🎥 Bjarne Stroustrup : C++: evolving a useful language
• 🎥 Concepts of Programming Languages
• 🎥 CS520 Theories of Programming Languages — KAIST
• 🎥 Delimited Continuations, Demystified by Alexis King
• 🎥 Going beyond JavaScript
• 🎥 Growing a Language, by Guy Steele
• 🎥 How Rust does OSS
• 🎥 JavaScript Static Analysis for Evolving Language Specifications
• 🎥 Linguistics and Compilers
• 🎥 On understanding types, data abstraction and effects
• 🎥 Principles of Programming Languages by Robert M. Siegfried
• 🎥 Principles of Programming Languages
• 🎥 Rob Pike - What We Got Right, What We Got Wrong
• 🎥 So many programming languages so little time
• 🎥 Stephanie Weirich speaks about Programming Language Design
• 🎥 The Economics of Programming Languages
• 🎥 The Mess We’re In
• 🎥 The Next Programming Language - Douglas Crockford
• 🎥 What’s Next for Our Programming Languages
• 🎥 Why Programming Languages Matter
• 📜 Programming language semantics: It’s easy as 1,2,3
• 📜 Programming Language Semantics
• 📝 A Frontend Programmer’s Guide to Languages
• 📝 Building a Debugger: Code Analysis
• 📝 Concepts of Programming Languages
• @mikhail.barash.mikbar/grammars-for-programming-languages-fae3a72a22c6">📝 Grammars for programming languages
• 📝 How To Create Your Own Programming Language
• 📝 Language-oriented software engineering
• 📝 Let’s Build a Programming Language
• 📝 Minimalism in Programming Language Design
• 📝 Panel: The Future of Programming Languages
• 📝 Principles of Programming Languages
• 📝 Programming and Programming Languages
• 📝 Programming Language and Compilers Reading List
• 📝 Programming Language Foundations in Agda
• 📝 Programming language theory and practice in ReScript
• 📝 Shriram Krishnamurthi and Joe Gibbs Politz - Programming Languages: Application and Interpretation
• 📝 The Programming Language Enthusiast
• 📝 The Study of Programming Languages
• 📝 Why Study Programming Languages

Compiler

• 🎥 Anders Hejlsberg on Modern Compiler Construction
• 🎥 Building a parser in C#, from first principles
• 🎥 Compiler Design course
• 🎥 How To Build A Programming Language From Scratch
• 🎥 How would compilers change in the next 10 years?
• 🎥 Implementing a bignum calculator
• 🎥 JavaScript ∩ WebAssembly
• 🎥 JavaScript implementation in SpiderMonkey
• 🎥 KAIST CS420: Compiler Design
• 🎥 Lexical Scanning in Go
• 🎥 Mozilla Hacks Compiler Compiler
• 🎥 Quick look at the TypeScript Compiler API
• 🎥 Rethinking compiler technology in a heterogeneous world
• 🎥 The business of selling compilers
• 🎥 Typescript Compiler explained by the Author Anders Hejlsberg
• 🎥 Understanding compiler optimization
• 📝 A miniature model of the Typescript compiler
• 📝 Alias analysis in React Compiler
• 📝 Alias analysis
• 📝 An Incremental Approach to Compiler Construction
• 📝 An Introduction to Interpreters and JIT Compilation
• @dinis.cruz/ast-abstract-syntax-tree-538aa146c53b">📝 AST (Abstract Syntax Tree)
• 📝 Bob Nystrom - Expression Parsing Made Easy
• 📝 Building a Parser from scratch
• 📝 Compiler Theory and Reactivity
• 📝 Compilers and Interpreters
• 📝 Compilers Resources
• 📝 Compilers: Nuts and bolts of Programming Languages
• 📝 Compiling Scheme to C with closure conversion
• 📝 Compiling to Java
• 📝 Compiling to lambda-calculus
• 📝 Douglas Crockford - Top Down Operator Precedence
• 📝 Dr. Dobbs - Bob: A Tiny Object-Oriented Language
• 📝 Flattening ASTs (and Other Compiler Data Structures)
• 📝 Fredrik Lundh - Simple Town-Down Parsing In Python
• 📝 Garbage Collection Algorithms
• 📝 How to implement a programming language in JavaScript
• 📝 IU Compiler Course
• 📝 Jack W. Crenshaw - Let’s Build a Compiler!
• 📝 Language grammar
• 📝 Lessons from Writing a Compiler
• 📝 Let’s build a compiler
• 📝 Let’s make a Teeny Tiny compiler, part 1
• 📝 Let’s make a Teeny Tiny compiler, part 2
• 📝 Let’s make a Teeny Tiny compiler, part 3
• 📝 Lexical Analysis
• 📝 Lexing in JS style
• 📝 Make a Lisp
• 📝 Nick Desaulniers - Interpreter, Compiler, JIT
• 📝 Parsing Algorithms
• 📝 Pursuit of Performance on Building a JavaScript Compiler
• 📝 Resources for Amateur Compiler Writers
• 📝 Scheme from Scratch - Introduction
• 📝 TypeScript Compiler Notes
• 📝 Understanding GC in JSC From Scratch
• 📝 Which Interpreters are Faster, AST or Bytecode?
• 📝 Write you a Haskell

PL Paradigms

• 🎥 Compiling with Continuations or without? Whatever
• 📝 Continuation-passing style in JavaScript
• 📝 Continuation-passing style

Interpreter

• 🎥 Cheaply writing a fast interpreter
• 💻 Building an Interpreter from scratch
• 💻 Crafting an Interpreter
• 📝 (How to Write a (Lisp) Interpreter (in Python))
• 📝 A Python Interpreter Written in Python
• 📝 Building an Interpreter
• 📝 Crafting Interpreters
• 📝 How languages work #1: String interpolation
• 📝 Implementing a Simple Compiler on 25 Lines of JavaScript
• 📝 Let’s Build A Simple Interpreter
• 📝 Little lisp interpreter
• 📝 Little Lisp interpreter
• 📝 Pratt Parsers: Expression Parsing Made Easy
• 📝 What do people mean when they say “transpiler”?

PL Research

• 📝 Increasing the Impact of PL Research
• 📝 What is PL research and how is it useful?

Type System

• 🎥 “Hindley-Milner Type Inference — Part 1
• 🎥 “Hindley-Milner Type Inference — Part 2
• 🎥 “Propositions as Types” by Philip Wadler
• 🎥 A Taste of Type Theory
• 🎥 A Type System From Scratch
• 🎥 Bringing Types to Elixir by Giuseppe Castagna and Guillaume Duboc
• 🎥 Discrete Math — Dr. Trefor Bazett
• 🎥 Gradual Type Theory
• 🎥 Gradual Typing: A New Perspective
• 🎥 How to Evaluate the Performance of Gradual Type Systems
• 🎥 Let’s build a typesystem in Haskell!
• 🎥 The Hindley-Milner Type System
• 🎥 Thinking with Types
• 🎥 Type Systems - The Good, Bad and Ugly
• 🎥 Type-safe embedded domain-specific languages 1/4
• 🎥 Type-safe embedded domain-specific languages 2/4
• 🎥 Type-safe embedded domain-specific languages 3/4
• 🎥 Type-safe embedded domain-specific languages 4/4
• 🎥 Types and Programming Languages Book club
• 🎥 Types are like the Weather, Type Systems are like Weathermen
• 🎥 Typing the Untyped: Soundness in Gradual Type Systems
• 🎥 What is Decidable about Gradual Types?
• 🎥 Why Static Typing Came Back
• 💻 Building a Typechecker from scratch
• 📜 How to evaluate the performance of gradual type systems
• 📜 Optimizing and Evaluating Transient Gradual Typing
• 📜 Putting gradual types to work
• 📜 Safe & Efficient Gradual Typing for TypeScript
• 📜 What Is Decidable about Gradual Types?
• 📝 A brief introduction to type theory and the univalence axiom
• 📝 A reckless introduction to Hindley-Milner type inference
• 📝 An accessible introduction to type theory and implementing a type-checker
• 📝 Bootstrapping a Type System
• 📝 Gradual Typing from Theory to Practice
• 📝 Hindley-Milner Type Checking AST
• 📝 How should I read type system notation?
• 📝 Introduction to Type Theory
• 📝 MyPy TypeChecker
• 📝 Programming and Programming Languages: Type Inference
• 📝 Propositions as types: explained
• 📝 Python internals: Symbol tables, part 1
• 📝 Python internals: Symbol tables, part 2
• 📝 Strong arrows: a new approach to gradual typing
• 📝 Type Checking If Expressions
• 📝 Type inference under the hood
• 📝 Type system of the React compiler
• 📝 Type Systems by Luca Cardelli, Microsoft Research
• 📝 Type Theory Workshop
• 📝 Understanding types as sets
• 📝 What is Gradual Typing

Parsers

• 📝 Building Extensible Parsers with Camlp4
• 📝 Demystifying Pratt Parsers
• 📝 Rewriting the Ruby parser

Backend

• 🎥 How LLVM & Clang work
• 💻 Building a Virtual Machine

Program Synthesis

• 🎥 Generating Programs from Types

Formal Methods

• Métodos Formais by @bugarela

Parallel/Concurrent Programming

• 📚 A Science of Concurrent Programs
• 📚 The Art of Multiprocessor Programming
• 📚 The Parallel Event Loop Model and Runtime

Language Learnings

• JavaScript
• Python
• Ruby
• Haskell
• Elixir
• Clojure
• Rust

TypeScript

• 🎥 A horrifically deep dive into TypeScript module resolution
• 🎥 A Trip into the Compiler
• 🎥 Advanced Types in TypeScript
• 🎥 AreTheTypesWrong with Andrew Branch
• 🎥 Hidden Gems of TypeScript compiler
• 🎥 How safe is “safe enough” for TypeScript
• 🎥 How the TypeScript Compiler Compiles
• 🎥 The Road to Private Methods
• 🎥 Type Level Programming in TypeScript
• 🎥 Typescript Performance: Going Beyond The Surface
• 🎥 TypeScript Performance
• 🎥 Typescript Type System
• 📝 @typescript/analyze-trace
• 📝 A preview of Ezno’s checker
• 📝 An Introduction To Type Programming In TypeScript
• 📝 Debugging the TypeScript Codebase
• 📝 Designing with types: Making illegal states unrepresentable
• 📝 Investigating TypeScript compiler APIs
• 📝 JavaScript scope, Closures, and the TypeScript compiler
• 📝 Making Sense of TypeScript Generics
• 📝 Making sense of TypeScript using set theory
• 📝 Modules in TypeScript
• 📝 Optimizing TypeScript Memory Usage
• 📝 Reconstructing TypeScript, part 0: intro and background
• 📝 Reconstructing TypeScript, part 1: bidirectional type checking
• 📝 Reconstructing TypeScript, part 2: functions and function calls
• 📝 Reconstructing TypeScript, part 3: operators and singleton types
• 📝 Reconstructing TypeScript, part 4: union types
• 📝 Reconstructing TypeScript, part 5: intersection types
• 📝 Reconstructing TypeScript, part 6: narrowing
• 📝 Static TypeScript
• 📝 Type level programming in TypeScript
• 📝 Types as axioms, or: playing god with static types
• 📝 TypeScript / How the compiler compiles
• 📝 TypeScript and the dawn of gradual types
• 📝 TypeScript AST Resources
• 📝 TypeScript Bytecode Interpreter / Runtime Types
• 📝 TypeScript Compiler API: Improve API Integrations Using Code Generation
• 📝 TypeScript Compiler Internals
• 📝 TypeScript Compiler Manual
• 📝 TypeScript Modules - Theory
• 📝 TypeScript Performance Tracing
• 📝 TypeScript Performance
• 📝 TypeScript’s type-independent output
• 📝 The Making of a TypeScript Feature: Inferring Type Predicates

Ecmascript

• 🎥 Create Your Own JavaScript Runtime
• 🎥 Ectype - bringing type safety (and more!) to vanilla JavaScript
• 🎥 Implementing one feature set in two JavaScript engines
• 🎥 JavaScript and C++ in Node.js core
• 🎥 Node.js startup performance
• 🎥 Static Hermes: the Next Generation of Hermes
• 🎥 TC39 – From the proposal to ECMAScript - Step by Step
• 📝 SingleEscapeCharacter
• 📝 Automatic semicolon insertions in JavaScript
• 📝 Deep JavaScript
• 📝 Empty Statement
• 📝 From Research Prototypes to Continuous Integration: Guiding the Design and Implementation of JavaScript
• 📝 JavaScript Closures
• 📝 JavaScript Garbage Collector
• 📝 JavaScript Memory management
• 📝 JavaScript Static Analysis for Evolving Language Specifications
• 📝 Relation of Garbage Collector and Closure in JavaScript
• 📝 V8: full compiler
• 📝 V8: Garbage Collection

Rust

• 🎥 Things I Learned (TIL) - Nicholas Matsakis
• 📝 Notes on a smaller Rust
• 📝 Removing Garbage Collection From the Rust Language
• 📝 Rust fact vs. fiction: 5 Insights from Google’s Rust journey in 2022
• 📝 Rust: Project Goals
• 📝 Rust’s language ergonomics initiative
• 📝 Why Static Languages Suffer From Complexity

Python

• 🎥 A JIT Compiler for CPython
• 🎥 Python’s type system explained: Static vs dynamic typing | Guido van Rossum

OCaml

• 📝 How Jane Street is making OCaml the new Rust

Browser

• 🎥 The internet computer
• 🎥 Servo: Designing and Implementing a Parallel Browser
• 🎥 Servo: A Web View From Somewhere Else
• 🎥 Intro to Rust-lang (Building the Dom and an HTML Parser)
• 🎥 Intro to Rust-lang (Adding a Style Tree to our Browser)
• 🎥 Intro to Rust-lang (Adding a CSS engine and CSS parsing to our Browser)
• 🎥 Intro to Rust (Building a Browser Engine: Commands and Rendering in OpenGL)
• 🎥 In The Loop - setTimeout, micro tasks, requestAnimationFrame, requestIdleCallback
• 🎥 Critical rendering path - Crash course on web performance
• 🎥 Chrome University 2018: Life of a Script
• 🎥 Browser From Scratch Live Streams
• 📚 Web Browser Engineering
• 📝 Browser from scratch
• 📝 Browser from Scratch
• 📝 Browser Performance
• 📝 Building a Rust Web Browser
• 📝 Concurrent JavaScript: It can work!
• 📝 David Baron’s blog: Blink engineer
• 📝 How Browsers Work: Behind the scenes of modern web browsers
• 📝 How browsers work
• 📝 Key data structures and their roles in RenderingNG
• 📝 Let’s build a browser engine!
• 📝 Notes on how browsers work
• 📝 Notes on JavaScript Interpreters
• 📝 Notes on Javascript Memory Profiling in Google Chrome
• 📝 Overview of the RenderingNG architecture
• 📝 reflows & repaints: css performance making your javascript slow?
• 📝 Rendering: repaint, reflow/relayout, restyle
• 📝 RenderingNG deep-dive: LayoutNG
• 📝 RenderingNG: an architecture that makes and keeps Chrome fast for the long term
• 📝 Round-up of web browser internals resources
• 📝 Understanding Reflow and Repaint in the browser
• 📝 Web Browser Engineering
• 📝 What forces layout / reflow

Web UI

• 🎥 Algebraic effects, Fibers, Coroutines
• 🎥 React Forget: React for developers and compilers
• 📝 Algebraic Effects for React Developers
• 📝 Algebraic Effects for the Rest of Us
• 📝 PL web frameworks
• 📝 React - Basic Theoretical Concepts
• 📝 React Concurrent mode
• 📝 TypeScript + fp-ts: ReaderTaskEither and React

Careers

Jobs

• Chromium Engineer at Browser Company
• Senior Software Engineer at Mozilla Corporation
• JavaScript Virtual Machine Compiler Engineer at Apple
• Compiler Jobs
• Swift Type System Engineer
• Compiler Engineer
• Groq Compiler Engineer
• Modular AI Compiler Engineer

Schools

• Programming Language and Compiler Research Groups
• Indiana University Bloomington
• KAIST Programming Language Research Group
• Tokyo Institute of Technology
  • TIT: How to Join the Group
  • Scholarships: Mext
  • Examples of Dissertations

People in PL

• Anders Hejlsberg
• Bob Nystrom
• Cynthia Richey
• Dmitry Soshnikov
• Gavin Bierman
• Gilad Bracha
• Graham Hutton
• Jihyeok Park
• Lexi Lambda
• Mads Torgersen
• Matthias Felleisen
• Niko Matsakis
• Patrick Walton
• Paulette Koronkevich
• Programming Linnguistics
• Researchers in Programming Languages and Compilers
• Roberto Giacobazzi
• Simon Peyton Jones
• StackExchange: Programming Language Design and Implementation
• Stefan Marr
• Sukyoung Ryu
• Ronald Garcia
• TK

License

MIT © TK