Episode 57: Compile-Time Metaprogramming

This episode is about compile-time metaprogramming, and
specifically, about implementing DSLs via compile-time
metaprogramming. Our guest, Laurence Tratt, illustrates the idea
with his (research) programming language called Converge.

We started by talking about the importance of a custom syntax for
DSL and took a brief look at the definition of DSLs by a chap
called Paul Hudak. We then briefly covered the disctinction between
internal and external DSLs.

More to the point of this episode, we discussed the concept of
compile-time metaprogramming, and the language features necessary
to achieve it: in converge, these concepts are called splice,
quasi-quote and insertion. We then looked at how the Converge
compiler works, and at the additional features that are required to
implement DSLs based on the metaprogramming features mentioned
above. Using an example, we then walked through how to implement a
simple DSL.

Looking at some of the more technical details, we discussed the
difference between the parse tree and the abstract syntax tree and
at different kinds of parsers - specifically, the Earley parser
used by Converge. In multi-stage languages (i.e. languages that
execute programs and meta programs) error reporting is important,
but non trivial. We discussed how this is done in Converge. We
finally looked at how to integrate Converge's expression language
into your DSL and how to package DSL definition for later
use.

The last segment look at the process of implementing a DSL in
converge and about some of the history and practical experience
with Converge. Lessons learned from building Converge wrap up the
episode.