News

The content has been bookmarked!

There was an error bookmarking this content! Please retry.

The Future of Microsoft .NET Programming Languages

Posted by Jon Arild Tørresdal on Jan 16, 2009

Sections: Development
Topics: Language ,; .NET
Tags: Microsoft ,; C#

Looking at the current trends within programming languages targeted at the .NET platform specifically, a few things are showing up at the horizon. During PDC2008 many of Microsoft’s thoughts around .NET and programming languages were revealed, which makes it interesting to look into the future of .NET.

The .NET platform started with C# and VB.NET running on the Common Language Runtime (CLR). The CLR is an implementation of the Common Language Infrastructure (CLI) specification. The CLI specification can be implemented by anyone wanting to create a new language, allowing developers to choose from a broad set of programming languages. On December 10^th 2008 Microsoft released version 0.9 of the Dynamic Language Runtime (DLR) built on top of the CLR, allowing language developers to create dynamic languages for the .NET platform as well.

Some of these languages are developed and maintained by Microsoft, like C#, VB.NET and F#, but most of them are being created in the community as open-source projects. Some of the better known open-source languages are IronPython, IronRuby (both dynamic) and Boo (static). The two first ones are actively being developed at Microsoft as open source projects and are based on the two existing languages, Python and Ruby. Boo has been around since 2003, created by Rodrigo B. De Oliveira and is still actively being developed. You can find a more complete list of .NET languages in Wikipedia.

To find out where the .NET languages are headed, the natural first place to look is to what Anders Hejlsberg (creator of C#) says about the future of C#. In the previous versions of C# Microsoft focused on Managed Code (C# 1.0), Generics (C# 2.0) and then Language Integrated Queries (LINQ) (C# 3.0). Looking forward to C# 4.0, coming soon with Visual Studio 2010, the main focus is Dynamic programming. In his talk at PDC2008, Anders spoke about current language trends:

I think they fall into three large buckets. The first one being this move that we see toward more declarative styles of programming. The next one being the sort of resurgence we’ve seen over the last few years over dynamic programming languages and how that influences us, and then last but not least the coming multi core inflection point if you will.
…
The thing that to me is interesting about these trends is that, the über trend of it all if you will, is that I think the classical taxonomy of programming languages are starting to break down. Where we traditionally would categorize a language to be object oriented, functional, dynamic or structured, we’re increasingly seeing languages borrowing from each other. I really think the new paradigm in a sense is multi paradigm.

This explains why C# has elements of Declarative programming (LINQ) and Dynamic programming (the dynamic keyword in C# 4.0).

In an earlier interview with Anders and Guy Steele about concurrency and language design, Anders points out that:

We already have an existing programming language called C# and now concurrency is happening to us, so now we got to think about what that means. I think a lot of the work with C# 3.0 and LINQ is pretty relevant to the concurrency phenomenon. Like having things like lambda expressions and the other stuff that we’ve added, makes it possible to build higher order kinds of API’s.
…
We’re sort of lacking mechanisms in the language to control side effects or to call attention to them. It would sure be nice to have language support for pure functions and a formalization of immutable data, and possibly support for isolation in some form where you can in the compiler reason about whether an object has been revealed to anybody else. As long as it hasn’t and you’re dealing with it in a local variable then it is actually safe to mutate.

In relation to concurrency there is a project going on at Microsoft called the Parallel Computing Initiative. S. Somasegar, Senior Vice President Developer Division, in a Q&A paper, recently talked about what to expect in Visual Studio 2010:

This will include new .NET Framework libraries such as the Task Parallel Library (TPL) and Parallel LINQ (PLINQ), as well as the Parallel Pattern Library (PPL) and Concurrency Runtime for developing native applications with C++ and parallel profiling and debugging tools. Microsoft is also making ongoing investments in the .NET Framework through the addition of new functionality in Windows Communication Foundation (WCF) and Windows Workflow Foundation (WF).

This project is a natural place for Microsoft to get feedback on which changes are needed on the .NET programming languages in order to easier support concurrency. Moore’s law is still applicable for transistor density, but not for CPU speed (GHz), so the need to go parallel will not go away. Of course, Microsoft knows this and has some major challenges to solve together with the other language implementers working in the same space. More likely this will be the next step for languages like C#.

Talking about programming languages on the .NET platform often brings up the topic of VB.NET vs. C#. Anders talks about a Co-Evolution between C# and VB.NET:

…when we try to do a different feature in one, the other group wants it too. The reality is that co-evolution is the right way to evolve these languages.

To conclude, there is no doubt that concurrency will be the next big thing. Dynamic coding possibilities will show up in C# 4.0, but one would expect more to come in future versions. VB.NET is promised to co-evolve with C#, allowing the two languages to be syntactically different but give the same output. There will be a much greater availability of dynamic languages to the main stream in the coming years with the DLR shipping with Visual Studio 2010 and with the availability of IronPython and IronRuby.