In the place through which we wander

It’s been hard to find any time for blogging lately. At work, I’ve been fully occupied getting Reflector to handle the new async feature in C# and VB, as well as doing loads of other Reflector enhancements. At home, I’ve been reading up on some mathematics, and preparing a lightening talk on Erlang for our bi-weekly lightning talk sessions. Any free time I’ve had, I’ve spent catching up with the channel9 videos of the recent Lang.NEXT and Going Native conferences which Microsoft hosted this year.

The Lang.NEXT conference had plenty of material if you’re interested in languages and virtual machines.

The first keynote by Martin Odersky called Reflection and Compilers covers recent work in Scala on exposing the compiler’s abstract syntax tree information via Reflection and links this with the addition of macros to the Scala language. The implementation of macros is rather clever, using a reify macro to move back from functions to their syntax trees, without having to add any special operators to the language. John Rose covered a nice example in his write up of the conference here. Here’s hoping that some of the ideas make it into C#.

Various Microsoft people covered the up and coming areas of Windows: async, language support for asynchronous programming, the Windows Runtime and Roslyn, the managed compiler infrastructure that allows users access to semantic analysis features of the compiler. These are all interesting and are going to affect your day job if you work on the Window platform.

Two other interesting talks were one on how they have successfully used Haskell at Galois for the last ten years, and one on the implementation of IKVM.NET, a .NET application which allow you to execute Java JAR files on the .NET platform and which also offers various libraries such as a better Reflection.Emit.

Channel9 recorded some interviews that happened alongside the main conference. One was a discussion between Eric Meijer and Carl Hewitt on the Actor model, in which Hewitt describes his Actor model in great detail. There are lots of concurrency implementations in languages which are “based on the Actor model”, and it was great to hear a description from one of the inventors which made it clear that none of these implementations are truly faithful. Hewitt raised the idea of unbounded nondeterminism, an interesting idea that caused me to go off on a Google hunt where I found a good paper on the history of process algebra as well as an interesting wikipedia article.

Going Native also covered some interesting material, with Stephan Lavavej doing a presentation on the most recent STL and a talk on extensions to templates in C++ 11. The panel discussions were also interesting, particularly the one about the importance of being native.

Advertisements
This entry was posted in Computers and Internet. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s