So this is Microsoft's strategy to defeat Google. Yikes!

UPDATE: 3/19/2008 - Joel Spolsky explains the "big picture" of what's going on here in his Martian Headsets article.

While it’s unlikely that you would ever want to invoke the Volta compiler directly, using it does provide some insight into how Volta works.

Let’s say that you have an existing assembly named BoringObjects.dll.  BoringObjects.dll contains one class named Person.



To do a Volta conversion of this assembly from MSIL to JavaScript execute the following command from the console window. NOTE: you will need "C:\Program Files\Microsoft Live Labs Volta" in your path.

> volta BoringObjects.dll /out:JSOutput

The only argument of interest is /out:JSOutput.  This is the directory that the Volta compiler will write the JavaScript files to.

If we look under our specified output directory we notice that Volta has created a directory that corresponds to the assembly name.  Under that directory there are three items:

[Types] (directory)
assembly.js
typeMapping.js

Under the Types directory there is one file "tA.js" which corresponds to the lone Person class in our original assembly.  If you use /d (debug) option the file will be named "type_0__Person.js" and the JavaScript code will be nicely formatted.

It’s interesting to note that this same structure is seen in "C:\Program Files\Microsoft Live Labs Volta\Cache".  In that directory you will find that some core .NET assemblies and the Volta libraries have been converted to JavaScript. This step is apparently part of the installation process.

A prevalent theme in the Volta documentation is the concept of the three “R”s. These three principles are at the heart of what Volta attempts to provide for developers.  They are retargeting, remodulating, and refactoring.

Retargeting

To me this is the coolest aspect of Volta and the feature that makes it a very interesting technology. At its core Volta is a compiler or more accurately a recompiler.  Instead of recompiling the source code Volta uses a technique called MSIL rewriting. This is what enables the developer to write client-side browser code in C#. Since all CLR languages compile to MSIL, Volta can use that as the common denominator. Volta is capable of MSIL to MSIL, and MSIL to JavaScript conversion.

Remodulating

Another goal of the Volta toolset is seamless cross-browser support. As the documentation states:

 Volta hides as many browser-specific differences as possible, but still allows developers to leverage the unique capabilities of particular browsers. Instead of targeting solely the intersection of browser capabilities, Volta targets the entire union, but makes the intersection browser-agnostic. This is browser remodulating.

Remodulating also deals with the debugging experience. Regardless of the browser platform developers will be stepping through their application code within Visual Studio. That's assuming of course that your target is either IE or FireFox which are the only browsers supported in the current release.

Refactoring

Volta refactoring is about enabling developers to create their applications while deferring decisions about what tier a particular component will run in. In my opinion this will be the most controversial feature of the toolset.  Larry O’Brien has some reservations about it:

This sounds like a bad idea to me. You can't refactor away the difference between an in-memory method call and an Internet message: one happens in nanoseconds and the other in milliseconds

I have some questions of my own about this. The docs claim that:

During development, all code runs in the client for ease of testing and debugging.

What are the implications of this? Not every .NET class is meant to run in a browser context. Does Volta offer any automatic guidance with regard to this? The notion of clicking a “Split Tiers” check box and decorating a class with a [RunAtOrigin] does seem implicitly powerful, I’m just curious to know where the model breaks down. I will try to answer these questions and others as I dig deeper into the framework.

It's kind of ironic.  This morning I was seriously considering taking a look at the Google Web Toolkit.  This is despite the fact that GWT is targeted at Java developers, which I am not.  It's just that GWT seems like such a useful idea - I wanted to play with it a bit.

Luckily Microsoft has, apparently, decided to put out a framework that allows developers to build rich internet applications without having to do a ton of JavaScript coding.

It's called Volta and at first glance it seems pretty cool.

When I was doing a lot of work with ASP.NET AJAX last year, the idea of coding in a more productive language and environment than JavaScript kept coming up again and again.  There was Script# at the time, but I didn't get a chance to look into it as much as I would have liked.

This certainly seems like a great development.  Maybe this even brings .NET developers one step closer to what Joel Spolsky described a few month ago.

Now…on to the samples, tutorials, and docs!

One of my favorite sections in SICP so far has been section 1.3 Formulating Abstractions with Higher-Order Procedures.  Higher-Order Procedures are procedures that deal with other procedures.  They can take a procedure as an argument and/or return a procedure as a result.

Though it is somewhat academic, I really like the example that Abelson and Sussman use in section 1.3.1 to explain the “procedures as arguments” scenario.  To illustrate this concept they implement summation using Scheme.  They implement a higher-order procedure called “sum” that takes two procedures and a range of numbers as arguments.  One procedure is used for computing the value that is added to the sum and the other is used to determine the next value to compute.  The Scheme code can be seen here.

It’s not as useful as map and reduce, but those are not discussed until Chapter 2.

As some of you may know C# 3.0 adds a whole slew of functional/dynamic features.  Whether this is an effort to keep up with the cool kids or merely a necessity for making LINQ work is not important to me.  What I’m curious to know is if the features make it easier to implement the concepts in SICP using C# 3.0.

Implementing “Sum” in C# 3.0

Following along with the example from SICP - let’s say that you have defined the following methods.

I decided to break with the book here and use iteration instead of recursion to make the code a little more digestible.

Common to each method is the idea of iterating over a range of numbers and adding the result of each computation to the total.  If we create a higher-order procedure called “Sum” to abstract out this behavior we can then redefine each method.

The “=>” and “Func” constructs come from the new Lambda expressions feature in C#.  Lambda expressions are a great new aspect of the language and they make implementing higher-order procedures a lot easier.  In this case the "term" and "next" arguments can be passed as Lambda expressions.

I had to cheat and do some casting shenanigans because the division operation in "PiSum()" brings floating point numbers into the mix, but I feel like this code does capture the essence of the original Scheme implementation.  Implementing "Sum" as a generic method might be a way to make the code more elegant.

If subverting the type system does not appeal to you, the following JavaScript implementation might be of interest.

JavaScript is more similar to Scheme (dynamic typing/first class functions) so it makes sense that the translation is smoother.

It turns out that there are other people interested in implementing SICP in different languages.  Chris Rathman has translated parts of SICP into 19 other languages.  One disturbing thing to note about Chris’s C# translation is that it doesn’t go beyond chapter 1.  Does that mean that it is not possible to implement the code from the rest of the book in C#? 

A couple of weeks ago I decided that I needed a break from the stresses of daily office life.  I walked down to the company cafeteria and purchased a Big Kat from the vending machine.  A Big Kat is like a regular Kit Kat, but bigger.  It’s absolutely delicious.  Anyway, I looked down at an open copy of the Globe (or was it the Herald?) and saw something that caught my attention.  Apparently, IFC was going to be showing a documentary that night focusing on the topic of LARP.

LARP! I thought to myself.  Live Action Role Playing.  A bunch of geeks playing Lord of the Rings on a soccer field!  YES!!!  I have to see this.  The documentary was called Darkon and about five minutes into it I was scolding myself for taking such a narrow-minded view.  

One thing I should have realized about LARPers is that they take their game very seriously.  I admire how much work these folks put it into it.  Watching the interviews and hearing the reasons why they play was truly enlightening.

The larger theme of the movie is obviously the idea of escapism and fantasy.  Why do people feel the need to escape reality?  To what lengths will they go to maintain the fantasy?  Trying to answer these questions goes a long way in explaining why World of Warcraft and Second Life are so popular.  I find all this stuff fascinating. 

Aside from the thematic elements, Darkon is also an intriguing story with interesting characters (both real and imagined).  Different players come to the game for different reasons, but most are motivated by the desire to be something that they can’t be in real life.  I’m not going sugar coat it, at some points this a little uncomfortable to watch, but it doesn’t make it any less compelling.

As you might guess there are political struggles and ego clashes both inside and outside the confines of the game.  The film primarily focuses on the conflict between Skip Lipman (Bannor of Laconia) and Kenyon Wells (Lord Keldar).  A scene at the beginning of the film makes it clear that these two leaders are headed for a showdown. 

If you’ve ever been near an RPG or simply can relate to the need to escape every day life, I heartily recommend Darkon.

Hail Laconia! Hail Mordom! Hail Darkon!

I’ve really been enjoying the Orange Box so far.  Unfortunately, I’ve encountered an apparent bug in Half Life 2: Episode 2.  During “Chapter 2: Vortal Coil” the game will consistently crash at the same point.  The crash occurs after you escape from the guardian ant-lion by dropping into a corridor.  At the end of the corridor there is a medic sitting against the wall.  When you walk closer to the medic, the display will freeze and you will be dumped back into Windows.  You receive an error informing you that the “hl2.exe” process has crashed.  After doing some Google searches I was able to find a solution posted here and here.  The workaround is to basically shoot the web at the end of the passage, face the wall on the right, crouch, and then strafe until you get into the next room.  I followed these instructions and I was able to avoid the crash.  I love being a PC gamer!!!

For reasons beyond my control I recently found myself developing in classic ASP.  After years of developing in ASP.NET this was obviously a little jarring.  However, what surprised me about the experience was that there were some things about classic ASP that I actually enjoyed.  Most notably I felt I had more control with classic ASP.  Nothing was in my way.  Things that should be simple were simple.  For a moment I imagined that this is what it must feel like to be a PHP developer.  

I wondered why I felt this way.  After all, the whole the whole point of ASP.NET is to save me from having to deal with “icky” HTML, JavaScript, and CSS…right?  I really like developing in ASP.NET.  I would take ASP.NET over classic ASP any day of the week (and twice on Sunday).  ASP.NET is certainly one of most thoughtfully designed and well implemented frameworks I have ever worked with.  Scott Guthrie is a genius and he has the patents to prove it.  However, I couldn’t ignore the fact that some things were a lot easier to accomplish in classic ASP.

I realized the unfortunate truth that there are some abstractions in ASP.NET (and all frameworks for that matter) that can transform into obstacles.  In order to use these abstractions you end up having to learn a lot about the internals of the framework.  I’m talking about Reflector. You have to codify assumptions about the underlying technologies into your application.  In other words, the abstraction leaks.  I borrow this term from Joel Spolsky’s Law of Leaky Abstractions.  I think that the small sense of empowerment I was feeling when developing in classic ASP came from the fact that I wasn’t forced to dig too deep into, or worse, code around the framework in order to get the job done.  There was no framework. 

Another, even more heretical thought occurred to me during this process.  I wondered if code-behind is always necessary. Is it always essential to separate code and markup?   If you simply replaced VBScript with C# and gave yourself a set of libraries as rich as the BCL, would combining code and markup be more palatable or even more productive in some scenarios?  Can some aspects of ASP.NET be abandoned entirely?  I’m not sure, but I’m now a little more inclined to find out.