Emerging Languages camp – day 1

Yesterday was the first day of the Emerging Languages Camp, a part of OSCON specifically organized for language creators and designers. You can read more about it at www.emerginglangs.com. The first day was fantastic, lots of very interesting talks and great conversations. The amount of brain power in this room is really humbling.

The format of the camp is that there are about 20 speakers and each speaker gets 20 minutes. This is a fairly limiting format and means the speakers will have to focus their talks quite substantially. I expected a few talks (including my own) to bomb completely because of this, but it didn’t happen during the whole day. All of the talks were very different but good in many ways.

All of the presentations are filmed by Confreaks and will be available within a few weeks.

I’ll try to write a few sentences about each presentation, with thoughts and impressions baked in.


Rob Pike started out the day by talking about the history of CSP (communicating sequential processes) and the lineage of languages that led to Go. Most of the talk was based on using channels/goroutines to handle concurrency. It was definitely a good talk, but it didn’t get me more interested in using Go for anything.


I had the second slot. I had twenty minutes to cover both Ioke and a new language I’m working on, called Seph. Against all odds, my talk went quite well and I managed to communicate the things I wanted to get said. Hopefully the audience wasn’t too bored.


Thyrd is a proof of concept visual language, focused on using tablets for programming – so it’s distinctly none-textual. In many cases you drag and drop operations instead of typing them. The actual development happens in a recursive grid of cells. I’m wondering what the audience for this language would be – it definitely looks intruiging though, and I like how some algorithms ended up being very easily readable and understandable.


Allison Randall gave a talk about what’s currently happening with Parrot. It seems they are going for a new rewrite of most of the subsystems. One of the changes is going from a CISC style op code system to a RISC style. Parrot apparently has over 1200 op codes at this point, and they want to scale back everything to about 20-30 bytecodes instead. As a preparation for this, they have ripped out the JIT and will revisit most of the subsystems in Parrot to see what can be done. Allison also gave the audience the distinct impression that Parrot is still quite slow for user programs.


Of all the talks during the day, I think I understood the least of the Ur/Web talk. Ur is a functional limited programming language focused specifically on building web applications. It’s got dependent types inspired by Agda and allow you to statically check your whole program. The example shown was a simple CRUD app, and I didn’t get any impression of how complicated it would be to actually use it for a real world application. The speaker said the only real world web app he knows about is a hosting application for Ur applications that he is building himself.


I don’t think I can do this presentation justice. Frink is just incredibly cool and you should check it out. It’s a general purpose programming language, but it’s got units of measure and several other features builtin that makes it very easy to use it to calculate all kinds of interesting facts. As an example, he showed that if all people in China jumped at the same time, that would be equivalent to 4.7 on the Richter scale.


Gilad Bracha talked a bit about the basic ideas and principles behind Newspeak and what the current status is. Gilad focused on no global state, and all names being late bound (including class names). The first feature falls quite naturally out of prototype based OO, so it’s something both Io, Ioke and Seph has (and it’s really nice). The second feature is a bit more obscure, but I’m not sure if it gives as many benefits as the first one.


Joe Pamer talked about what they had to do to take F# from a research language to something Microsoft could ship in Visual Studio 2010. Not something most of us really think about, but there are lots of challenges in doing that kind of transition. Joe covered this quite well and also gave us an insight into the current state of F#.


CoffeeScript is a language that compiles down to JavaScript. In comparison with GWT for example, it’s pretty close in semantics to JavaScript, and the generated code can be debugged and looked out without wanting to stab out your eyes. The syntax of CoffeeScript is very pleasant and looks very nice to work with (it’s indentation based, and focuses on getting lambdas to be as small as possible). Next time I’m reaching for JavaScript, I think I might just go for CoffeeScript instead. Good stuff.


Charles Nutter covered Mirah (the language formerly known as Duby). It looks more and more complete and useful, and sooner or later I’m going to try switching most of my Java development to Mirah. The extensability features makes it possible to do metaprogramming tricks in Mirah that you wouldn’t even try in Ruby.


Steve jumped in last minute to cover for the Objective-J guy who couldn’t be here. Steve covered the basics of Io, talking about concurrency and the other basic features.

It’s been a great first day, and now day two begins – so I’ll have to focus on that.

10 Comments, Comment or Ping

  1. In your summary of Thyrd, I think you meant “tables”, not “tablets”.

    July 22nd, 2010

  2. Scott: no, I meant “tablets”, like the IPad.

    July 22nd, 2010

  3. Hmm. It seems to make sense with either word… sorry.

    July 22nd, 2010

  4. sgwong

    SEPH? Never heard before, any website for this programming language? Where do I get your presentation slide?

    July 23rd, 2010

  5. Newspeak’s feature with late bound class names can be very useful. In languages like Java or Ruby, class names are implicitly resolved by the runtime system, with no user code interacting. Reifying that class lokup allows user code to interact with that operations.

    To give some practical examples: this allows you to implement an object-capability model – if somebody accesses the File class, you can simply deny that, or give out a subclass of File that only allows certain paths to be accessed.

    You can also use that to inject a class into the top of a class hierarchy. Assuming you have a library, and you want certain library classes to extend a new class you wrote. Intercept the call to resolve the superclass and inject your own.

    I think this gives an impressive freedom in the type system. It is probably possible to emulate this in one way or another using Java’s class loaders, but first level support for it in the language without resorting to byte code fiddling seems a lot nicer.

    July 23rd, 2010

  6. Martin:

    Well, maybe. But Ruby can definitely do that too – quite easily – since constants can be reassigned. You can also do const_missing and so on.

    Even better, in Ioke this comes even more naturally. Object Capability models always seem a bit strained to me when done inside of a class based system.

    July 23rd, 2010

  7. Frink has units of measure? Cool! I’ve been wanting that since the early 80s, made a C++ library for it (see http://davearonson.com/meascpp/measure.html), was bummed that Fortress dropped it, and am working on a Ruby gem for it.

    July 24th, 2010

  1. Caciocode - July 26, 2010

Reply to “Emerging Languages camp – day 1”