The Zen of Volta
by Richard Blewett

In December 5th, 2007 Microsoft announced an incubation project they have been working on called Volta (http://labs.live.com/volta). The announcement talked about a new way of writing applications that allowed developers to work in familiar environments and leave various decisions, which are often decided during the design phase, till later in the development cycle. Along with the Volta announcement Microsoft posted a version of the Volta infrastructure for people to start experimenting with. This is not an official CTP or beta, simply a way for people to get an early view of what Microsoft are looking at and to be able to provide feedback. The infrastructure requires Visual Studio 2008 and creates a number of new Volta project types.



The samples that shipped with the downloads are all web based and the technology that caught all the commentators eye was the ability to write the application in C# but then have post compilation rewrite the IL to JavaScript so the application ran as a true web application. On that basis Volta has been compared to Google Web Toolkit (GWT). However, Volta is much more than that and so this article attempts to explain the real power behind the Volta infrastructure.

IL Re-Writing
The real technology that Volta encapsulates is IL re-writing. In other words, taking the compiled assembly in IL form and using information in the assembly (in the form of attributes) rewriting the IL to provide extra functionality -functionality that the developer didn’t directly have to code themselves. The developer simply declares their “intention” and Volta writes the code.

The Volta team class their rewriting in three areas: repurposing, remodulating and refactoring.

Repurposing
This is the one that got all the attention; taking the IL and transforming it into something else for consumption by a different platform – in the sample case JavaScript and web applications. There is no reason, however, that the same approach could not be used to create Silverlight applications.

Remodulating
Generating code that is directed at a specific browser that takes advantage of its strengths rather than creating a least common denominator approach. This is probably the least interesting as the web controls in ASP.NET have in theory been able to do browser dependent rendering since ASP.NET’s inception.

Refactoring
Taking the application and changing the code to add new functionality or change the architecture of the existing application. This, I think, has by far the most potential for making a big impact on the development world. The Volta team showcased two examples of refactoring: Async and TierSplitting. We’ll now move on and look in more detail at these two refactors.

Async Refactoring
The Async rewriting allows a developer to write the synchronous version of a method and then declare a method signature for the asynchronous version and simply annotate that with the [Async] attribute. Volta then creates the asynchronous version of the code under the covers. For example, imagine we had a class whose job it was to take a generated log file and reformat it to, say, XML. For a large file this may be a time consuming task so it would be good to be able to run this asynchronously. However, it would be good to allow the developer to concentrate solely on the functionality of the log file rewrite and to leave the async details to Volta. Here is the code:



When rewriting the IL, the Volta compiler sees the [Async] attribute and generates the actual code for making the method asynchronous:



So what is this code actually doing? Well it creates a new object passing in a delegate wrapped around the synchronous version of the Reformat method and the callback. Then calls Invoke on the new object – let’s have a look at what Invoke does:



This should look pretty familiar to most .NET developers – it is simply calling the SynDelegate instance asynchronously passing a method called Handle to be called when the synchronous version completes. Let’s finally have a look at the Handle method:



Again this should look familiar. EndInvoke is called on the SynDelegate instance to get the result of the synchronous call and then the callback is fired passing this result.

So although Volta isn’t performing magic (the generated code is not hugely complex) it is allowing the developer to concentrate on the business problem at hand and just declare that they would like the operation to also support asynchronous execution. Volta takes care of providing the actual implementation of the asynchronous version.

TierSplitting
TierSplitting is a far more radical refactor than the async one. In this case you annotate types and the Volta compiler rewrites the IL into multi-tier application. The idea is that you concentrate on developing the functionality of the application and worry about deployment issues later in the development cycle. You decide on what classes to split by using the Refactor menu option:



This adds the RunAt attribute and sets up the project to run a test web server to host the server part of the application

Here "Server" is a reference to a url in the config file. For web applications there is another option attribute called [RunAtOrigin] which will run the server code on the web server from which the application was loaded.

How, then, does this actually work? Underneath the covers the Volta compiler creates a __TierSplit.aspx web page and this invokes the server code, storing server side application state in ASP.NET session in between server calls by building custom serializers for the server based state. All in all it looks very seamless. I do have some reservations about the current implementation of tiersplitting which, rather than spend more time repeating here I’ll just direct you to the blog posts, here and here, I made about them.

Conclusion
All in all I think Volta is a very exciting technology with some real potential benefits for developers. The more time developers can concentrate on solving the business problems rather than writing the plumbing the better. I also think Volta has to be seen for what it is at the moment – a technology preview. This is not a finished product but an idea with a bunch of implementations that are applicable to different scenarios – and I must admit some of those scenarios are very compelling. However, there is a long way to go before whatever Volta becomes is released. Now is a great time to pull down the bits and experiment with how you could conceptually use this technology. Send feedback to the team – this is, after all, why they announced the preview. We have a chance to influence the direction of a potentially very powerful technology.

To contact our CTO Richard Blewett, please send email to: richardb@develop.com

Upcoming Guerrilla Events

What You Can Expect: - Multiple instructors (2-5) per event - Extended course hours - A team of industry leading experts - Leading-edge technologies - Innovative course materials, including slides, labs, books, demos - Your own PC and development platform - Peer-to-peer collaboration and competition - An exciting, multi-media learning environment All Inclusive Price includes: 5-NIGHTS HOTEL, ALL MEALS AND BEVERAGES

ABOUT GUERRILLA EVENTS

back to top

Upcoming Courses