I had a great time at Lang.NEXT last week! There were a ton of amazing presentations and a lot of interesting conversations in between and after. There was a nice ongoing debate between native and managed languages and it was interesting to see some of what was going on in these fields.
What really interested me though was on the talks about Domain Specific Languages (of course). There was a talk about DSLs in Haskell and a talk on Bloom which is an internal DSL in Ruby and also a talk about R which is a DSL for statisticians.
But the one that really blew me away was the talk on pervasive parallelism in Scala, which turned out to be almost completely about the power of DSLs.
Specifically it was this slide that really got my attention:
Which is a pick2 diagram for programming languages, positioning DSLs as the solution for the problem of Productivity and Performance.
What was most amazing about this talk is that this is really the first time I’ve seen someone stand up and present DSLs with authority. And by that I mean someone who is making claims that are backed up by data and high quality research. When I talk about DSLs it’s based on my experiences and my intuitions and my understandings but not really very convincing data. The guys in the PPL however, really have some awesome papers on DSLs. I definitely felt validated to see such positive results and I hope this grants me some authority as well. When someone seems dubious of the promises of DSLs I can point them to the PPL and they can read for themselves the benefits that can be had.
In this talk Kunle Olukotun very clearly says that DSLs raise your level of abstractions and grant you a high level of developer productivity. He also brings up the very important concept of restriction in DSLs as a virtue. This is one very important fact that is not usually understood by advocates of internal-DSLs. Restriction is a very important key component to an internal DSL and is actually a virtue. From restricting the types you can use to what you can do with those types to the semantics and syntax of the language itself. For example, in a highly parallel application restricting your ability to mutate shared state is necessary, and making this restriction explicit in the language itself is actually a virtue of the language and helps to channel a developer into the path of least resistance. In many other languages they attempt to give you more features and less restriction but the opposite should be true for DSLs.
He even goes on to explain how patterns in the middle of their architecture can be considered ops for parallelism and how they use this for multiple DSLs. They even find overlapping parts of their domains that can be abstracted and shared between each other. This is really thinking about DSLs correctly, this is truly applying these ideas in a good direction. The PPL is using Scala for their runtime and they also use Scala to make restricted internal DSLs but I think this can apply for any language. He mentions that Scala has some good constructs for parallelism but also has some good features for making restricted internal DSLs. I think they ended up having to hack the Scala compiler some, but I am not completely sure.
One problem remains however… It takes about this many PhD students and faculty to make a DSL.
I’m working on that. 🙂
I’m heading to Lang.NEXT next month, check out this video on Channel 9 with some big brains talking about it:
Mads Torgersen, Donna Malayeri and Erik Meijer: ReIntroducing Lang.NEXT | Charles | Channel 9.
I sometimes think about what I would have done with the $5,000 Jeff Atwood gave away to the ScrewTurn Wiki project if he had given it to me instead. Here was what they had to say about using the money.
The grant money is still untouched. It’s not easy to use it. Website hosting fees are fully covered by ads and donations, and there are no other direct expenses to cover. I thought it would be cool to launch a small contest with prizes for the best plugins and/or themes, but that is not easy because of some laws we have here in Italy that render the handling of a contest quite complex.
What would you suggest?
A part of me wonders if it wouldn’t have turned out similarly for me.
But days like this make me realize that I would spend that money to go to Portland and attend the Emerging Languages Conference. I also had the experience of creating my own logos for MetaSharp which I would have happily paid an artist to make for me instead (which I think turned out pretty well despite my not being an artist).
Here it is, btw.
Anyway, in addition to sounding really interesting the people of the emerging languages conference apparently have a great sense of humor as well. Here is one of my new favorite quotes taken from the newly created google group:
That’s the beauty of functional programming — you can almost say
anything and make it sound good. For example, I fully plan to support
I tried to tweet this but Fogus irreverently failed to contain his wit to less that 140 characters. Also… check out coffee script, very cool.
I’m giving a talk tonight on MetaSharp and I’ve decided to use SketchFlow instead of Powerpoint to present my talking points. The topic is complex and I want the audience to be more interactive and I want to be able to be flexible in how deep into a topic I can go without having to skip over slides. I’ve never done this before, or seen it before so I have no idea what to expect but I’m going to give it a try.
The people at the TCLangUG tend to be more interactive and fun than your typical straight presentation crowd anyway, so this should be a good forum for experimentation like this.
Anyway, I thought the map that SketchFlow makes of all the screens is pretty neat so I thought I’d put a snapshot of it here.
The white screen is the starting point and the various colors and layers are screens going deep and depper into a particular topic. The blue lines are connections between concepts.
While running the SketchFlow player I can use back and forward browser like buttons to navigate as well as use this exact map to jump to topics. I also have a list of all connections available and even some interactive controls on the screen itself that allow me to jump directly to a subject. This should be interesting!
This thursday I will be presenting MetaSharp to the TCLangUG. It should be pretty interesting and you should stop by if you can!
Here are the details:
METASHARP (FEB. 11TH, 2010)
MetaSharp is a developer tool designed to assist in the creation of programming languages. Using MetaSharp’s fully extensible, pipelined transformation engine you can easily create your own domain specific languages or general purpose programming languages.
Justin Chase is a software developer from St. Paul MN and works for Microsoft on the Expressionteam. In addition to loving WPF and Xaml and Expression Studio he has special interests in domain specific languages and games.
5:45 pm at Magenic, in Golden Valley.