@Will Appreciate you asking that — we software people are often quick with offering solutions before really understanding the problem… the thing is, in this case I'm actually looking for a wide variety of different solutions, because I can't describe my problem well. Yet. I'm looking for different perspectives on how language implementors split that problem into different parts and why. Do you write an interpreter or a compiler? Do you hook into something like LLVM? Do you use a virtual machine? Do you explicitly design for multiple stages/passes (tower of interpreters-style)? Maybe "tutorial" is framing it the wrong way and I'm more looking for design documents and field reports; something like https://www.goodreads.com/book/show/1168500.LISP_in_Small_Pieces or https://www.lua.org/doc/jucs05.pdf.

I'm particularly interested in the separation of the "static" and "dynamic" parts and implementations that make conscious design decisions to split them up and have well-defined interfaces between them. So an interpreter-based language would less likely qualify than a compiler+vm approach.

So the resources I need are along the lines of “how do I efficiently map my language to the Wasm VM? (Or similar VMs?)”

Because my language is declarative, the challenge is in the serialization of the declared computation to a "sequence of instructions". For the most part I think this is an open problem: there are ideas from existing functional language compilers like "loop fusion" and dataflow analyses but I think many of the compilation approaches will depend on the fine details of the language itself. So I'll probably start by reading the literature on FP compilation and then probably have to invent the rest. (Traditional compiler books spend a lot of time on topics like parsing, lexing, type checking, and register allocation, none of which I need: My language isn't based on text files, it doesn't have static types, and Wasm doesn't have registers.) So that's my current perspective anyway.

https://www.amazon.com/Language-Implementation-Patterns-Domain-Specific-Programming/dp/193435645X has a nice collection of patterns, the scope is not super wide but I think it is a pretty useful resource anyway to get acquainted with a particular way of solving "language problems"

The Jonathan Blow streams are often good, but past his design streams they're probably a bit too sparse in terms of insight for language development

Hopefully this isn't too flame-war-like 😄, but I'd also want to encourage the notion that "performance is a feature", particularly when you're creating software infrastructure such as a language compiler. (This is more relevant once you have a design/prototype you're happy with and are going to make it available for public consumption.) ESBuild provides an example of the importance of caring about performance in build tooling (pic attached). Speedups of this order of magnitude significantly improve the ways in which you can use the tool.

Also found this, which is somewhere in between tutorials and what I was asking for, but if anybody interested ever finds this thread again (hello, future me!), probably worth knowing about: https://c9x.me/compile/bib/