Lang.NET, DSL DevCon Highlights

Intentional Software has forged a silver bullet. It’s terribly difficult not to go into that in great depth (I will shortly), but for now, I simply don’t want to bury the lede.

OK, so other than that what was interesting?

There are several categories that need to be talked about:

  • Platforms (how do we support languages in VMs?)
  • Tools (how we make the creation of languages easier / faster?)
  • Techniques
  • Experiences & Patterns

I had the intuition that Lang.NET would be about the first two topics and DSL DevCon would focus on the latter, but it turned out fuzzier than that. Lang.NET was a smaller group and probably a little more academic but the real difference between the conferences was structural. Lang.NET had 30-minute talks and 15-minute lightning talks. DSL DevCon had 45-minute talks. I think the Lang.NET structure was widely perceived as better.

“Domain-Specific Languages” has been a term of art for 30 years and if you’re reading this blog, you presumably have an interest in higher-level discussions of productivity and industry direction, so I’ll take it as read that “language issues are important, interesting, and have an impact on productivity.”

If you’ve been reading this blog or my column for any amount of time, you know that I’ve been predicting DSLs as the next big buzzword / buzzphrase for quite some time. Eventually I had to be right. So I quite expected a full-court press articulating a model covering all four of the above categories; I expected to hear something like this:


But I didn’t hear that or any alternative development process model (other than from Intentional Software), and that’s my number one takeaway:

The DSL marketing wave is dangerously ahead of the pedagogical wave.

Highlights in the various categories


Lars Bak on implementation of the V8 JavaScript engine was dynamite. Concrete, informed, impressive. (Not incidentally, I think Harry Pierson, Chris Sells, and Microsoft should be given great credit for bringing in people from Google, Sun, and the Linux community and encouraging a collegial atmosphere.)

Paul Vick gave two talks on Oslo, but I think his first had more on the “platform-y” aspects of Oslo. The vocabulary of Oslo was covered and questions from the audience (I hope they’re in the video) pressed on the question of “runtime projection onto the DLR” (which, it turns out, is “what we’re talking about when we’re talking about DSLs”).


There were many talks about tools. I think everyone wished that Jeffrey Snover talked longer than 15 minutes about Powershell. The videos for DSL DevCon aren’t up yet but when they are, Update: Here they are, don’t miss Gilad Bracha on NewSpeak. Among the many excellent talks, Guillaume Laforge on Groovy had a few particularly memorable points.


The technique talks almost all had the same theme: functional programming. Pattern-matching this, parser combinator that. This was usually not separated from a specific tool (not surprisingly, we heard much of F#), and I think that lack of distinction was unfortunate.

The standout “technique” talk was Erik Meijer on reactive programming. For all the functional love in the room, only Meijer and Philip Wadler gave talks structured around proofs. Wadler’s talk was very good, but Meijer sketched a proof while throwing coins and calling out above the rolling laughter of the audience. We walk in the garden of his turpulence.

Experience & Patterns

There were several talks that sounded like they might be about techniques or experience (“the implementation of X”), but they turned out to be about the tool or the domain itself (“X does this and that”). Matthew Wilson on Bootstrapping Perl 6 onto .NET didn’t make that mistake, nor did Paul Cowan when discussing the Horn Package Manager implemented in Boo (it took him a few minutes to get to the good stuff).

Amanda Laucher’s experience optimizing an insurance application was actually the only talk that I felt was centered on process issues! (And there, it seemed the main issue was object-functional mindsets, not the “language-y” issue of deferring the specification of intent.)

For the first several slides of the Brad Cross / Ted Neward “Functional vs. Dynamic DSL Smackdown” I thought we had finally gotten to the core process issues: defining terms, contrasting approaches, and then asking not “in which is it possible?” (Both. But everyone who’s been paying attention knew that before last week.) but “which has a chance of succeeding in the real world?” Unfortunately, the talk got bogged down in technical specifics.

Final thoughts

Lang.NET is my favorite conference of the year. I pay for it out of my own pocket. If this stuff is interesting to you and you have the time to watch every video, by all means do so.

This year I thought my deep interest in programming language issues was going to be joined with my deep interest in process issues. It was not to be. This worries me greatly, because I submit that the amount of DSLs written is determined not by technical issues but by people issues.

One implicit premise very clearly on-hand was “the [functional|dynamic] mindset facilitates the meta-level reasoning that’s a necessary precondition to recognizing a language-based opportunity.” OK, two valid premises. But where’s the evidence? And even if there’s a correlation between a particular mindset (whether it be functional or dynamic) and language-based approaches, does the mindset cause (or at least facilitate) that, or is it the case that those prone to meta-level reasoning gravitate towards a particular mindset? And are these mindsets teachable to those whose minds have been corrupted by exposure to the real-world or is our only hope a new generation that doesn’t make any of the same mistakes we did? (Because that hope always pans out.)

I find those questions fascinating and I don’t pretend to know the answers (beyond insisting that the answer has to acknowledge the historically small percentage of people who have exploited these techniques to date). I’m only sad I’ll have to wait a year to hear what the smartest people in the business have to say on the matter.

4 thoughts on “Lang.NET, DSL DevCon Highlights

  1. Pingback: Tech | Lang.NET, DSL DevCon Highlights | Conference calling

  2. I personally think experience implementing compilers (or at least recognizers + interpreters) and creating languages is a better predictor of facility to recognize language-based opportunity.

    I used to joke in my previous job (after starting to implement the DSL) that I tend to see every problem as an excuse to write a compiler. That’s not even nearly true in practice with me, but it seems to be true when folks new to the DSL concept see the thought process in action etc.

    Functional or dynamic? Tree structures and fluent recursive thinking is necessary to implement languages competently. Functional teaches that better than dynamic; dynamic, however, tends to give one a language in which one can create the tree-shaped structures directly, and piggy-back on the existing lexer and syntax and expression dynamics to build the tree automatically. You still need the recursive thinking to interpret / generate, of course.

  3. Pingback: Newspeak, F# Productization and More « Tales from a Trading Desk

Comments are closed.