list.md

Meta-Programming

• Towards a fully-reflective meta-programming language (G. Neverov, P. Roe)

• D-Expressions: Lisp Power, Dylan Style (J. Bachrach, K. Playford)

• The Java Syntactic Extender (J. Bachrach, K. Playford)

• Template Meta-Programming for Haskell (T. Sheard, S.P. Jones)

• First-class macros have types (A. Bawden)

• Macros that work (W. Clinger, J. Rees)

• Macros as multi-stage computations: type-safe, generative, binding macros in MacroML (S.E. Ganz, A. Sabry, W. Taha)

• Hygienic macro expansion (E. Kohlbecker, D. Friedman, M. felleisen, B. Duba)

• Compile-time meta-programming in a dynamically typed OO language (L. Tratt)

• Contrasting compile-time meta-programming in Metalua and Converge (F. Fleutot, L. Tratt)

• Extensible syntax with lexical scoping (L. Cardelli, F. Matthes, M. Abadi)

• Programmable syntax macros (D. Weise, R. Crew)

• Dylan macros rewrite rules

• Phase Distinctions in the Compilation of Epigram

• Honu: Syntactic Extension for Algebraic Notation through Enforestation

• Zero-Overhead Metaprogramming

Parsing

• Parsing mixfix Operators (N.A. Danielsson, U. Norell)

DSLs and DSELs

• DSL implementation in MetaOCaml, Template Haskell, and C++ (K. Czarnecki, J. O'Donnell, J. Striengnitz, W. Taha)
• Domain Specific Language Implementation via Compile-Time Meta-Programming (L. Tratt)
• Meta-programming and DSLs in dynamic languages (Vasco Carvalhão Duarte Andrade e Silva)

Lenses

• Combinators for bidirectional tree transformations: A linguistic approach to the view-update problem

Actors & Processes

• An actor system for Scala.js

GC

Compilers / JIT

• An Efficient Non-Moving Garbage Collector for Functional Languages
• Eliminating Global Interpreter Locks in Ruby through Hardware Transactional Memory
• Partial Evaluation of Computation Process — An Approach to a Compiler-Compiler
• A Trace-based Java JIT CompilerRetrofitted from a Method-based Compiler

Variance, subtyping and polymorphism

• Java Wildcards Meet Definition-Site Variance
• F-Bounded Polymorphism for Object-Oriented Programming
• A library for polymorphic dynamic typing

Dependent typing / Liquid types

• Simply Easy! An Implementation of a Dependently Typed Lambda Calculus (2007)
• Faking It: Simulating Dependent Types in Haskell
• Dependent Object Type (DOT)
• Down with kinds: adding dependent heterogeneous equality to FC (extended)

Homotopy Type Theory

• Homotopical Patch Theory

Arrows

• Generalized Arrows

IRs / Codegen

• Cross-platform Compilers for Functional Languages

Events / Threads

• A Language-based Approach to Unifying Events and Threads

FRP

• Elm Thesis

Flow control, continuations, exceptions

• Delimited Control in OCaml, Abstractly and Concretely System Description

To Read

• Resource-safe Systems Programming with Embedded Domain Specific Languages
• Codata
• (gwydiondylan)
• Continuations and delimited control
• Scalable Components Abstractions
• Satisfiability Solvers
• Why Don’t Software Developers Use Static Analysis Tools to Find Bugs?
• (Idris) Resource-safe Systems Programming with Embedded Domain Specific Languages
• (Coq) Library universes
• Tribe: A Simple Virtual Class Calculus
• Subject/Observer is Dual to Iterator - Erik Meijer
• Fundamental Concepts in Programming Languages
• Uniqueness and Reference Immutability for Safe Parallelism
• First-class labels for extensible rows
• Theorems for free !
• Objects and Aspects: Row Polymorphism
• Stackless Scala With Free Monads
• Object-Oriented Pickler Combinators
• Mirrors: Design Principles for Meta-level Facilities of Object-Oriented Programming Languages
• Resource-dependent Algebraic Effects
• Church and Curry: Combining intrinsic and extrinsic types
• Blame, coercion, and threesomes: Together again for the first time
• Process Bottlenecks within Erlang Web Applications
• Feature-Oriented Programming with Object Algebras
• Using Circular Programs for Higher-Order Syntax - Functional Pearl

Logic

• The Enduring Scandal of Deduction