Microsoft Developing Parallel Programming Language

Microsoft is working on a new language for parallel programming named Axum.

At the Lang.NET 2009 conference on Microsoft’s campus on 15 April, Joshua Phillips, a program manager on Microsoft’s Parallel Computing Platform team, touted the Axum language to an audience of computer language experts. Phillips said his group recently had to change the name of the language from Maestro to Axum.

A description of Phillips’ talk read:

“Axum is an incubation project from Microsoft’s Parallel Computing Platform that aims to validate a safe and productive parallel programming model for the .NET framework. It’s a language that builds upon the architecture of the Web and the principles of isolation, agents and message-passing to increase application safety, responsiveness, scalability and developer productivity. Other advanced concepts we are exploring are data flow networks, asynchronous methods and type annotations for taming side-effects. We currently have a working prototype with basic Visual Studio integration and a few demonstrations of working code.”

Phillips said his group is working on a number of technologies, “some of which are shipping within Visual Studio 2010 and some are incubator technologies. One of which is Axum—a safer, scalable, more productive programming model for .NET through isolation, actors and message passing.”

Phillips said the Axum value propositions are:

• Reduce complexity by eliminating implicit dependencies

• Provide a declarative model for dealing with state

• Provide an application model that is inherently concurrent and responsive

Phillips said that not too long ago was “a time where if you wanted to increase the perf [performance] of your application, you would wait 18 months and get a faster chip.” But with the advent of multicore processors and parallel systems, more has to be done on the programming side to take advantage of the advances, he said. “So let’s make everything concurrent by default, and you can opt out of it.”

From what he called a 50,000-foot view, Phillips said, “We wanted [Axum] to feel like C#; we didn’t want you to have to take a whole new syntax style.”

Phillips said Axum is imperative, actor-oriented—as opposed to object-oriented, object-aware and special-purpose.

“We’re not talking about objects as a primary concept anymore; it’s object-aware rather than object-oriented,” Phillips said. “In fact, you can’t even define objects in Axum. It’s special-purpose, so we don’t intend for Axum to be the general-purpose language that C# is. You’re going to define objects and types in another language like Visual Basic or C# and then you can use Axum to coordinate and get safe concurrency out of it.”In an interview with Dr. Dobbs Journal, Niklas Gustafsson, a software architect and member of Microsoft’s Parallel Computing Platform team, said:

“The basic principle of Maestro is to reduce the complexity of a parallel application to the point where most programmers should be able to write a parallel application without even thinking about it as being parallel. In a model based solely on shared memory, such as we have with all object-oriented languages, you have enormous problems with reference aliasing. This means that any two given reference variables of the same type may or may not point at the same object. If they don’t, concurrent access is safe, if they do, it’s typically not; a lot of programmer productivity is lost trying to rein in this complexity.”

Axum has five core concepts, according to Phillips: domain, channel, agent, schema and pattern.

The objectives of the Axum incubation are to find answers to several key questions, including whether a new language is the better way to go to address parallel programming. Another question is whether the Axum model reduces complexity and adds benefits such as productivity and scalability gains. Still other questions include whether it is feasible to migrate legacy applications over to Axum and whether Microsoft is even building it right.

“A lot of feedback that our customers give me is, ‘I want to be able to take my junior programmers and throw them at concurrency problems.’ And they can’t because it’s too hard to think that way. But when you’re within an agent, it’s easier to think … because nothing is affecting you; you’re single-threaded.”