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.
Categories
Code Generation | Concurrency implementation | Continuations | Correctness | DSLs | Effects | Implementation | Lists | Logic | Parsing | Syntax | Testing | Types and Type Systems | Validation and Verification
Resources: Courses
Reading
Articles/Blogs/Essays/Papers
-
10 Myths About Scalable Parallel Programming Languages (Redux):
-
A case for feminism in PL design
- A Frontend Programmer's Guide to Languages
- A Generic Framework for Automated QA of Software Models: references the OMG's Generic AST Model (GASTM) which I think is related to Abstract Syntax Tree Metamodeling (ASTM), here (PDF) This kinda looks like the generic AST I was futzing about with.
- A Language Creators' Conversation: Guido van Rossum, James Gosling, Larry Wall & Anders Hejlsberg
- A syntactic approach to type soundness
- A Tale of Two Asyncs: Open Source Language Design in Rust and Node.js
- A Theory of Type Polymorphism in Programming
- A wish list for a new programming language
- Abstracting Gradual Typing
- An Axiomatic Basis for Computer Programming
- An Incremental Approach to Compiler Construction: Scheme and Functional Programming 2006; Abdulaziz Ghuloum -- Github Step-by-step development of a Scheme-to-x86 compiler
- Building a Debugger: Code Analysis
- Call-by-name, call-by-value, and the λ-calculus
- Complete and Easy Bidirectional Typechecking for Higher-Rank Polymorphism;
- Delimited Continuations, Demystified by Alexis King
- Dual-Language General-Purpose Self-Hosted Visual Language and new Textual Programming Language for Applications (PDF): "Most visual programming languages (VPLs) are domain-specific, with few general-purpose VPLs like Programming Without Coding Technology (PWCT). These general-purpose VPLs are developed using textual programming languages and improving them requires textual programming. In this thesis, we designed and developed PWCT2, a dual-language (Arabic/English), general-purpose, self-hosting visual programming language. Before doing so, we specifically designed a textual programming language called Ring for its development. Ring is a dynamically typed language with a lightweight implementation, offering syntax customization features. It permits the creation of domain-specific languages through new features that extend object-oriented programming, allowing for specialized languages resembling Cascading Style Sheets (CSS) or Supernova language. The Ring Compiler and Virtual Machine are designed using the PWCT visual programming language where the visual implementation is composed of 18,945 components that generate 24,743 lines of C code, which increases the abstraction level and hides unnecessary details. Using PWCT to develop Ring allowed us to realize several issues in PWCT, which led to the development of the PWCT2 visual programming language using the Ring textual programming language. PWCT2 provides approximately 36 times faster code generation and requires 20 times less storage for visual source files. It also allows for the conversion of Ring code into visual code, enabling the creation of a self-hosting VPL that can be developed using itself. PWCT2 consists of approximately 92,000 lines of Ring code and comes with 394 visual components." Source
- Dynamic Language Embedding
- Efficient Gradual Typing
- Flattening ASTs (and Other Compiler Data Structures)
- From Lisp S-Expressions to Java
- "A Generic Abstract Syntax Model for Embedded Languages": "Representing a syntax tree using a data type often involves having many similar-looking constructors. Functions operating on such types often end up having many similar-looking cases. Different languages often make use of similar-looking constructions. We propose a generic model of abstract syntax trees capable of representing a wide range of typed languages. Syntactic constructs can be composed in a modular fashion enabling reuse of abstract syntax and syntactic processing within and across languages. Building on previous methods of encoding extensible data types in Haskell, our model is a pragmatic solution to Wadler’s “expression problem". Its practicality has been confirmed by its use in the implementation of the embedded language Feldspar."
- Generic Abstract Syntax Tree (geast)
- "GAST" (PDF)
- Going beyond JavaScript
- Growing a Language, by Guy Steele
- Haai: Reactive programming without lifting
- How Big Should a Programming Language Be?: "... a long-held opinion I have about programming language design: we have a tendency to keep adding features to a language until it becomes so big that its sheer size makes it difficult to use reliably." Yes!
- How OCaml type checker works -- or what polymorphism and garbage collection have in common
- How Rust does OSS
- How To Create Your Own Programming Language
- How to Implement Local Type Inference - https://www.reddit.com/r/ProgrammingLanguages/comments/1gkjkz4/how_to_implement_local_type_inference/
- Intrinsically-Typed Definitional Interpreters for Linear, Session-Typed Languages
- JavaScript Static Analysis for Evolving Language Specifications
- Language-oriented software engineering
- Linguistics and Compilers
- Migrating Gradual Types
- Minimalism in Programming Language Design
- On Model Subtyping
- On Understanding Types, Data Abstraction, and Polymorphism
- On understanding types, data abstraction and effects
- Panel: The Future of Programming Languages
- Papers on programming languages: ideas from 70's for today
- Pluggable Type Systems
- Practical Foundations for Programming Languages (PDF)
- Principles of Programming Languages by Robert M. Siegfried
- Principles of Programming Languages
- Principles of Programming Languages (course) (Source)
- Principles of Programming Languages
- Program Analysis
- Programming and Programming Languages
- Programming Language Foundations in Agda
- Programming Language Semantics
- Programming language semantics: It’s easy as 1,2,3
- Programming language theory and practice in ReScript
- PROGRAMMING A PROBLEM-ORIENTED LANGUAGE
- Programming type-safe transformations using higher-order abstract syntax
- Programming in Homotopy Type Theory
- Reactive Functions without Functions (PDF)
- Refined Criteria for Gradual Typing
- Relational operators in Apache Calcite
- Simple Programming Languages
- So many programming languages so little time
- Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages
- Stephanie Weirich speaks about Programming Language Design
- 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 Economics of Programming Languages
- The Mess We're In - Joe Armstrong
- The Naked Truth About Writing a Programming Language
- The Next Programming Language - Douglas Crockford
- The Next 700 Programming Languages
- The Slow March of Progress
- The Study of 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;
- Three Things I Wish I Knew When I Started Designing 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
- What's Next for Our Programming Languages
- Why Dependent Types Matter
- Why Programming Languages Matter
- Why Study Programming Languages
-
Languages I want to write
- Less is more: language features
- Let Arguments Go First;
- Notation as a Tool of Thought
- Open, extensible object models: "The artificial distinction between implementation language and end-user language can be eliminated by implementing the language using only end-user objects and messages, making the implementation accessible for arbitrary modification by programmers. We show that three object types and five methods are sufficient to bootstrap an extensible object model and messaging semantics that are described entirely in terms of those same objects and messages."
- S-Expressions in Javascript
Books
Object-Oriented
- "The concept of class invariant in object-oriented programming": "Class invariants — consistency constraints preserved by every operation on objects of a given type — are fundamental to building, understanding and verifying object-oriented programs. For verification, however, they raise difficulties, which have not yet received a generally accepted solution. The present work introduces a proof rule meant to address these issues and allow verification tools to benefit from invariants."
Gradual Typing
Language Learnings
PL Paradigms
PL Research
Backend
Program Synthesis
Parallel/Concurrent Programming
Implementing Functional Languages: A Tutorial - Simon Peyton Jones, David Lester
Introduction to Compilers and Language Design | Introduction to Compilers and Language Design - Douglas Thain (PDF)
Let's Build a Compiler (PDF)
Practical and Theoretical Aspects of Compiler Construction (class lectures and slides)
Resources for Amateur Compiler Writers
Semantics Engineering with PLT Redex: The PhD-level programming languages course at Northeastern uses the Redex book, and I found it to be a good introduction. The tool itself (Redex) is a great way to experiment with semantics, including reduction relations (roughly, the part of the semantics that says how the program runs) and type systems. You could use this book as a substitute for TAPL (at least for learning the basics of formal semantics), or you could use Redex to experiment with the languages described in TAPL.
mpri-2.4-public: Resources for course MPRI 2-4 on functional programming and type systems.
"Bits of History, Words of Advice": The creator of Newspeak and one of the core developers working on Java and the JVM offers some advice about Smalltalk's lack of success in the mainstream.
- Runtime Semantics:
- "Open, Extensible Object Models": "We show that three object types and five methods are sufficient to bootstrap an extensible object model and messaging semantics that are described entirely in terms of those same objects and messages." (Source)
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 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 11 December 2025