Wrapping the Cloud with .NET

Volta is exploring innovation that empowers programmers to delay decisions about tier-splitting to the last possible responsible moment by using either code refactoring or declarative annotations.

Erik Meijer: Volta - Wrapping the Cloud with .NET - Part 1 [Channel 9 Video, 25 minutes]

Erik Meijer: Volta - Wrapping the Cloud with .NET - Part 2 [Channel 9 Video, 32 minutes]

LINQ 2.0: Democratizing the Cloud (pdf)

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

just curious

Isaac Gouy: [cites] LINQ 2.0: Democratizing the Cloud (pdf)

Do you personally know anyone interested in this? Is it you? (The paper also didn't spell out an audience. It's kind of like passive voice scaled up to an entire paper: there shall be dataflow, and it will be good.) I don't mean to ask marketing questions, as if I cared about popularity. I just hope for an existence proof there's someone who likes it, whose psychology might be tested with questions to grasp their interest.

I'm interested in the dataflow part, if one can loosely collapse all rhetoric in the paper to an observation tiers might get less complex if imperative middlemen layers are stripped. The paper proposes a new middleware layer — not based on standards — be substituted as a form of simplification. Meijer assumes the API is simplification, and maybe implementation and debug legs as well.

Those are my substantive comments; I don't want to analyze spin nuance. What part of the paper is about programming languages?


Some people have problems viewing channel 9 video - I attached a paper which they might find useful in deciding if they should even try and watch the videos. Courtesy really.


I'm interested because I see the huge area of immediate pragmatic needs they are trying to address.

I also think there's a strong PL content there -- in the vicinity of their claim that their algebraic abstractions are a better answer in PLs than would be, say, having PLs at all tiers of the stack settle on XML as their "native" types.

The problem presented by the paper is a cool, fun topic with lots of PL relevance. The solution presented -- I don't have much to say about that.

I've been (for fun) sort of planning my first-ever attempt to have accepted a top-level post here, in spite of having to keep in mind that I'm just not at all of the academic sort the regular great posters are (and so, inclined to make dumb mistakes and to suffer a linguistic barrier). I might get it done this summer and it's curiously close to the topic of the paper linked here. Of course, my thinking and solution and even my articulation of the problem are much, much better :-) (Well, we'll see about that, of course.)



In the first minute of the video Eric says that there's a web renaissance going on, that web 2.0 makes the web cool again, and we haven't made programming the web easy yet. Hmmm, will cramming stateful application into a stateless medium every be easy? I couldn't watch any more. Everything I've seen from ms research is just laughable. Well, this and asml.

The first minute's just

The first minute's just pitch, you'll have to get used to that in material aimed at the mainstream. And it's true that there's more interesting stuff going on with the web lately and that web programming isn't as easy as it should be yet.

Stateful into stateless? I do it all the time, but then I'm a Haskell hacker.

Stateful into stateless

Stateful into stateless... stateful into stateless...

> @hoogle IO a -> a
Foreign.unsafePerformIO :: IO a -> a

unsafePerformIO was not what

unsafePerformIO was not what I had in mind! Not all state is IO.

This reasearch employee

This reasearch employee seems to be pretty popular around here:


Anyway, first the bashers complain because Microsoft doesn't do anything innovative. Then when Microsoft does real research, and tries experiments knowing full well and good they might fail, the bashers complain that they aren't doing anything productive.

And yes, the channel 9 videos don't have the academic rigor that the main page here at ltu has, but I think it does a good job of bringing the 'egghead' reasearcher's work to the 'mort/elvis' professional programmers.

Anyway, only time will tell if LINQ itself fails (spectacularly) or succeeds (spectacularly).

McCusker and 29-n, rhymes with ad hominem

Erik is not with MSR, but is working on products, and probably got more people sustainably interested in lambda calculus than all LTU posts taken together. Not that this would excuse him to write any stuff he likes, so here is probably a relevant part (i haven't seen the videos)

On both the client and the server, we do not assume the existence of a native .NET runtime. Instead we will target any available existing runtime. In particular we anticipate that the client is a browser that supports JavaScript, and we have implemented a complete deep embedding of MSIL into JavaScript.

my attempt at sparking some discussion, plus: while criticism can be healthy and constructive some people should learn how to find the salient and good parts in a contribution, regardless where it comes from. I find the idea of MS technology targetting JavaScript quite rebellious, the MS hype department seems to be more about Silverlight etc.

I've been spun! :-)

I neither said nor implied a position toward either Meijer or MS. I don't have one. I do have a position on LINQ (looks ugly) I didn't mention because my taste didn't seem relevant.

my bad then

oh then I misunderstood you. no bad feelings. taste can be relevant, after all programming is not (only) a science.


The disjunct between Microsoft Research and Microsoft Hype is worthy of a thread of its own -- Haskell, for example, is better integrated with GTK & X11 than it is with the Win32 drawing API (GDI?).

Triangles in Javascript

Well if you haven't watched the videos you missed Erik Meijer's delightful enthusiasm for Triangles in Javascript, and the suggestion that in some sense the approach is a dual to Ajax.


Yes, Turing would have marveled at the way one has to draw triangles in Javascript -- since he lived in a time, where something like the "software crisis" was not known, let alone acknowledged by scientists.

The "Volta" thing is not really clearly defined in these videos, but one should not forget that the whole MS-way of development defies attempts at definition. Focusing on a proprietary platform allows to write programs in IDEs that then work on servers, clients, more recently browsers... and with the advent of the interactive internet applications, browsers have become platforms as well.

It's hard to follow the discussion in the video if you don't accept the challenge that we should be able to write networked, interactive systems in one programming language.

It turns out, that this is not a problem of the language (the right choice of primitives, the syntax, the type system), but the underlying infrastructure like the libraries and the IDE. It's not so much a question of API, but what is done with the source.

Similar to GWT, there are two different implementations for each piece of code -- one that runs natively as IL on .net, and one that is interpreted in Javascript. Erik talks on lookup mechanisms that achieve "(browser) platform independence" by downloading the appropriate version.

I think the interview has some insights for people that are developing similar things (like Links hackers), which have exactly the same objectives and are confronted with the same platforms.