Highlights from Emerging Languages Camp

I'm a programming languages geek, so when Emerging Languages Camp was announced several months ago, I knew I had to attend. Viget was kind enough to send me, so for two days in July I was in programming language heaven. All of the talks were excellent; here are some of my personal highlights.

Go, by Rob Pike

Rob Pike is one of my computing heroes, so it's no surprise that seeing him speak was a thrill. In his talk, Pike explored the history and ideas behind Communicating Sequential Processes (CSP), the concurrency model built in to the Go programming language. (For those who don't know, in CSP processes communicate by exchanging messages instead of sharing variables using locks.) He also praised the original 1978 paper on CSP by C.A.R. Hoare, stating that it has more ideas than any other ten good papers you can find.

Pike also gave one of the OSCON keynotes and spoke about the motivations for creating Go. He believes that mainstream statically typed languages (C++ and Java) are too verbose and non-expressive, so programmers are switching to dynamically typed languages like Python and Ruby, which are more enjoyable to use but can be slow and aren't type-safe. His thesis is that it's possible to fill the gap with a language that is as expressive and fun to use as a dynamically typed language yet has the speed and safety of a statically typed, compiled language. Go is an attempt to meet that need. You can watch this talk right now, and I highly recommend that you do so.

I've been surprised by the reactions to Go. When it was first announced, I expected many developers to embrace it, but that hasn't really happened. I suspect there is a profound misunderstanding about what the language is and what it's suited for. I haven't spent significant time programming with Go, but I've played with it enough to know that I like it and that it's indeed enjoyable to use. I'm looking forward to exploring the language further.

Frink, by Alan Eliasen

I think most attendees would agree that Alan Eliasen's Frink was the surprise hit of the conference. Frink is a programming language for performing calculations with units of measure. The idea is that you can specify your units (from a built-in library of hundreds) directly in your source code, and the runtime tracks them through all calculations. That's just the beginning, though. Frink also does arbitrary-precision math and interval arithmetic, calculates exchange rates, supports regular expressions and Unicode, performs translations via Google Translate, powers web sites via Frink Server Pages, and so much more.

Many programming languages are designed from the start to be general-purpose, but Frink is a great example of a language first designed to solve a very specific problem and later expanded to be general-purpose. As a result, Frink excels at its core goal (calculations with units) and then builds on it with a host of other excellent features. I think language designers would be well served by approaching their languages with the same mindset.

One final note: sadly, Frink is not open source (a mild irony given its presentation at the Open Source Convention), so the community can't contribute code or study the source to learn how Frink does its magic. However, Frink is written in Java and can easily be embedded in Java apps—so if Java is your thing or you're an Android developer, be sure to check it out.

Kodu, by Matt MacLaurin

Kodu is a visual programming language for creating games on Windows and Xbox 360. It's designed to teach programming to kids while also being fun for users of any age. Kodu programs are written using icons and follow (at least conceptually) a sort of event-based model: when something happens do some action. When I see a red apple, move toward it. When I see a green cycle, shoot it with a missile. The game world itself is the programming environment—with the press of a button, the game pauses and every object can be edited and reprogrammed.

Lately, I've been thinking a lot about how to better teach programming to non-programmers, and Kodu has really piqued my interested. Its visual programming model is surprisingly intuitive and needs virtually no explanation, so anyone can pick it up. It looks like the perfect educational tool for kids who are interested in computers and video games. If you're interested, be sure to check out the videos on the Kodu website.

Finch, by Robert Nystrom

Finch was one of the unscheduled talks given during the second day's afternoon break, and I'm glad I stayed for it. Finch is a dynamically typed, object-oriented, prototypal, bytecode-interpreted language inspired by Smalltalk, Self, and JavaScript. It uses message passing like Smalltalk but has a syntax similar to JavaScript and other languages in the C family.

Finch is a nice little language, but I remember this talk for two reasons. First, it was inspirational. It was immediately evident that Nystrom had a blast working on Finch, and seeing his excitement was a great reminder that programming is a ton of fun and that we shouldn't take it so seriously all the time.

Second, Finch is written in C++, and the code is just superb. If you have any interest either in programming language implementation or in how to write great code (and it doesn't matter whether you know C++), I highly recommend studying Finch's source code. Programming language implementation can seem like magic; Finch is proof that it's not nearly as complex as you might think.

~ * ~

Emerging Languages Camp was an absolute blast, and there isn't enough room here to cover all of the amazing talks and languages. Fortunately, all of the talks were filmed by Confreaks and should be available soon. I encourage you to check out the videos when they're available. Thanks to Viget for sending me to such an awesome conference, and I'll see you at Emerging Languages 2011!

You should follow me on Twitter here.