Chunks and Beacons
Reddit r/ProgrammingLanguages
Protos are Wrong: Protobuffers were obviously built by amateurs because they offer bad solutions to widely-known and already-solved problems. ... What’s so frustrating about all of this is a little understanding of how modern type-systems work would be enough to drastically simplify the protobuffer spec and simultaneously remove all of the arbitrary restrictions. The solution is as follows: Make all fields in a message required. This makes messages product types; Promote oneof fields to instead be standalone data types. These are coproduct types; Give the ability to parameterize product and coproduct types by other types. That’s it! These three features are all you need in order to define any possible piece of data. With these simpler pieces, we can re-implement the rest of the protobuffer spec in terms of them.
Books
Experiments
Essays/Papers
- 10 Myths About Scalable Parallel Programming Languages (Redux):
- 10 papers that all PhD students in programming languages ought to know
- A case for feminism in PL design
- 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
- Haai: Reactive programming without lifting
- How Statically-Typed Functional Programmers Write Code
- Migrating Gradual Types
- On Model Subtyping
- On Understanding Types, Data Abstraction, and Polymorphism
- 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
- Relational operators in Apache Calcite
- Simple Programming Languages
- 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 Calculated Typer: We present a calculational approach to the design of type checkers, showing how they can be derived from behavioural specifications using equational reasoning. In addition, we show how the calculations can be simplified by taking an algebraic approach based on fold fusion, and further improved by taking a constraint-based approach to solving and composing fusion preconditions. We illustrate our methodology with three examples of increasing complexity, starting with a simple expression language, then adding support for exceptions, and finally considering a version of the lambda calculus.
- The Design Principles of the Elixir Type System
- The Next 700 Programming Languages
- The Taxonomy of Reactive Programming: Events and State; Deriving and Executing; Reified and Transparent; Composition; Implicit and Explicit Time; Self and External Observation;
- 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
Implementations
Compiler
PL Paradigms
Interpreter
PL Research
Backend
Program Synthesis
Parallel/Concurrent Programming
Language Learnings
Reading
NOTE: Some links from https://github.com/imteekay/programming-language-research
Detail Pages:
- A Compiler Writing Journey Learn network programming and data structures by coding from scratch.
- Amsterdam Compiler Kit A cross-platform compiler and toolchain suite that is small, portable, extremely fast, and extremely flexible.
- ANTLR Code-generating parser tool
- BRIL (Big Red Intermediate Language) A programming language for learning about compilers.
- Canopy A PEG parser compiler.
- ChocoPy A restricted subset of Python 3 designed for classroom use in undergraduate compilers courses.
- coala Command-line utility for linting and fixing code for all languages.
- Code Generation Information on how to generate code (binary or source)
- Compiler correctness reading A collection of links and resources on compiler correctness, certification, validation, verification.
- Compiler Explorer (Godbolt) Run compilers interactively from your web browser and interact with the assembly.
- Compilers Implementation/Optimization Reading Collection of articles on implementing languages.
- Compiler Testing A collection of links and reading on compiler testing.
- Compiler Validation Links on translation validation, equivalence checking, and more.
- Compiler Verification Verifying compiler correctness and compilation of functional programs.
- Continuation-passing style Readings and links on CPS.
- Cool A small language designed for use in an undergraduate compiler course project.
- Courses on Language Development A collection of links to (mostly academic) courses on how to build programming languages.
- Create Your Own Programming Language Notes on the book "Create Your Own Programming Language"
- DSL Evaluation Checklist A collection of questions for evaluating DSLS.
- Effects and effect systems (reading) Reading and notes about effects and effect systems in programming languages (and related).
- Glush A new parser compiler based on Glushkov’s construction algorithm.
- GOLD (Parser) Code-generating parser tool
- GYS the scripting engine which helps to create the embedded interpreter of your own language.
- JavaCC A parser generator.
- JFlex A lexical analyzer generator (also known as scanner generator) for Java, written in Java.
- JLex A Lexical Analyzer Generator for Java.
- JVM Language Summit An open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects.
- L.in.oleum An unstructured, untyped, procedural programming language. And more specifically, it's a form of cross-platform assembly language.
- Language Development Syntax A collection of language syntax examples.
- Let's Build a Compiler (Jack Crenshaw) A very good tutorial on writing a simple compiler in 16 articles. By Jack W. Crenshaw.
- LLVM (toolchain) A collection of tools and libraries for building languages (and language-related tools).
- Modern Compiler Implementation This book covers compiler theory, design, and implementation.
- Modern Programming Languages Notes and materials from the book.
- MPS A language development workbench.
- Ohm A library and language for building parsers, interpreters, compilers, etc.
- parboiled A mixed Java/Scala library providing for lightweight and easy-to-use, yet powerful and elegant parsing of arbitrary input text based on Parsing expression grammars (PEGs).
- Parsing (language syntax) A collection of links on parsers, parser generators, parsing algorithms, and so on.
- People in language development Notable names.
- Practical Compiler Construction A no-nonsense tour through a C compiler.
- Programming Languages: Application and Interpretation Notes on the book.
- QBE Compiler backend that offers 90% of LLVM with about 10% of the complexity.
- Reading on Domain-Specific Languages (DSLs) A collection of articles and other links.
- Resources List: Compilers Collection of articles, books I recommend around general compilers/interpreters topics.
- Spoofax Language Workbench A platform for developing textual (domain-specific) programming languages.
- Syntax Definition Formalism (SDF) a metasyntax used to define context-free grammars: that is, a formal way to describe formal languages. It can express the entire range of context-free grammars.
- Tree-Sitter Tree-sitter generates parsers based on a language and provides insights about the code as seen by the engine.
- Types and type systems (reading) Reading and notes about types and type systems in programming languages (and related).
- Xtext A framework for development of programming languages and domain-specific languages.
Last modified 15 September 2025