Program Transformation! That's the key!
My baccalaureate thesis is proceeding apace. I'd be much further already if I'd realized earlier that I can get a ton more work done by sitting in a coffeehouse all day than by sitting at home and falling asleep in a quiet apartment while trying to read. I hope to get another ten pages written today.

I'm writing about compiling functional programming languages against the backdrop of compiling the more conventional imperative programming languages. I'm not going to get into the difference here just now. What's been important for me is that my background in computer science (CS) is not as deep as I'd like, and since compilers unify practically every subject in CS into one big almighty combination, I've had a lot of catching up to do. I was trying to understand the parsing part better, the part that takes in source code and understands how it fits together "as a sentence." (Parsing is an old word for what we call now sentence diagramming, when we even bother to teach it to grammar-school students rather than having them take multiple-choice standardized tests that are supposed to prove they're learning something. ::deep breath::) And I found that it's completely fascinating.[*] It's also similar to a lot else that goes on in a compiler. Compiling is just a continuous process of translation from one form into another; take in characters, spit out parsed text, sanity check it, transform it into a more optimal form, then transform it again to code that your computer can run.

Well, today I figured I might want to cite some papers on a certain kind of parsing, so I went searching for citations. And found some really interesting stuff, but it was what I didn't find that really mattered: when I couldn't get access to a paper through my university, I ran a web search and came up with Program-Transformation.org. It's a wiki founded by one of the researchers whose paper I was searching for, and it's got more than enough information to, say, let you spend a good part of your graduate school years having a lot of fun....

So, that's what I'm interested in, here: not compiling, as I first thought; not parsing, as interesting as that is; no, it's program transformation that subsumes all of these, and that's what I find so totally awesome. It might also go some way to explain my interest in functional programming (and even, gods help us all, logic programming, or, worse perhaps, their bastard child, functional-logic programming...): it eventually gets turned into an imperative program to run on your computer (unless you happen to built a custom dataflow machine, in which case you are awesome), but it's an entirely different way of thinking about and performing programming that requires, well, transforming the way you think and your entire approach.

ETA: On the other hand, this still doesn't explain why I think abstract machines are just the cutest and coolest little things since sliced bread. I want a pet pushdown automaton (PDA)! I'll take a pet finite automaton, too, but only if the PDA won't pick on it for being weaker. I think that might be more tied into why I think embedded programming or assembly is neat: you have to do a lot with very little. (And then it turns out you can do a lot more than you might think, and our hero (Church-Turing-Kleene?) saves the day.)

[*] I was also lucky enough to scare up the work of Dick Grune, who's co-written an entire book (with a new second edition just out) on parsing theory that doesn't restrict itself to the same-old same-old, as well as a book on compilers that I don't remember turning up but likely discarded because I was initially interested particularly in optimization, and it's not focussed on that. It is, however, more modern in that it unifies the presentation of scanning (grouping a sequence of letters, numbers, and whatnot into parts of speech) and parsing (checking that those parts of speech form a grammatical sentence), erasing the historic but artificial division in their presentation, and also uses some newer ideas like attribute grammars and bottom-up rewrite systems that are still coming into their own in professional practice (regardless of how theoretically developed they might be). It also, in the face of every other book I've ever seen on the subject, particularly of those meant for undergrads, addresses the various paradigms on pretty much equal footing, talking about concerns peculiar to imperative/object-oriented programming, functional, logic, and parallel/distributed programming. Oh, and this is the guy who invented CVS. Totally awesome. Check out his website: the first edition (1/3 the length of the second) of the parsing book is up for free download, and he's got a good amount of literature citations up with annotations. Cool stuff.