The Future of Microsoft Development

Since the recent unveiling of Windows 8, a lot of press time has been given to the new immersive user interface and what this means for WPF and Silverlight, and, though not as many people are talking about it, what it means to the .NET platform as a whole.

What We Know

The new Windows 8 apps will be built using HTML5 and JavaScript. We know that new development tools are coming (in some format) that will enable developers to build these apps. We know that Silverlight/WPF developers are extremely upset over what this could mean for them. We also know that we are going to have to wait until the BUILD Conference in September to find out what’s really going on.

What We Don’t Know

What happens to Silverlight and WPF? What happens to .NET? Will the new development platform be the next release of .NET, or some new development platform? Will these tools be built into Visual Studio, or a new IDE?

Predictions

Disclaimer: These are my predictions only, and are mostly for fun. I do not have any inside information, I do not work for Microsoft, and I’m not drinking buddies with Scott Guthrie (though if you’re ever in town Scott…). If you agree or disagree, leave me a comment below and let me know!

The Future of Silverlight

In a word: bright. According to this post by Mary Jo Foley, Jupiter is a new Silverlight library built within Windows 8. Supposedly this will allow native operating system support for Silverlight applications to be deployed directly within the operating system as AppX packages.

In addition to Silverlight support within Windows 8, Windows Phone apps will continue to utilize Silverlight as the development platform, and Silverlight apps are also coming to the Xbox.

The Future of WPF

I think WPF will have continued support on Windows 8 (obviously), but developers will be encouraged through tooling and support to move to the new HTML5/JavaScript and Silverlight development platforms. WPF will still be around for sure, especially if the limitations of Silverlight still exist on the new platform, but I predict will be less of a focus for Microsoft moving forward.

The Future of .NET

With most of the attention focused on Silverlight and WPF, I think the biggest changes will be in .NET itself. I think .NET is going to be phased out much the same way that COM was phased out. Can you still build a COM application? Absolutely. Do you want to? Probably not. I think the same thing is going to happen to .NET. I think a new application development platform is coming, and not just for the UI. To understand what that new platform might look like, all we need to do is look at the world around us.

If you look at the most useful applications today, they almost exclusively have two things in common: they are service oriented and cloud enabled. To illustrate this point, we will use Twitter as an example.

Service Orientation

Twitter is a service that many of us consume everyday. This “as-a-service” model is service orientation. I’m not talking about the architectural patterns that were used to build the application, I’m talking from a consumption model. Whether Twitter is an OOP application with a service API or a “true” service oriented application is irrelevant. We consume Twitter as a service, either via a browser or one of the 1.72 gazillion Twitter clients (I like Seesmic) available on your phone or other device.

Cloud Enabled

You could also describe these most useful applications as cloud enabled. What is a cloud enabled application? A cloud enabled application is nothing more than an application delivered over the internet. Back to our example, Twitter is of course delivered over the internet. Whether or not Twitter utilizes a public, private or hybrid cloud is again irrelevant. What is important however is how people use Twitter.

How This Fits

Now match these two qualities, service orientation and cloud enabled, to the current .NET development platform. You can certainly build an internet based application using ASP .NET WebForms or MVC, Silverlight, etc, and you can certainly build your application to be delivered as a service by using Windows Communication Foundation (WCF). You can also build your application to run in one of the many clouds available. But think of how you actually go about doing that, especially from a services standpoint. You build .NET objects, and expose those .NET objects in some manner.

For example, let’s say that I have a Widget Engine, and it’s the greatest Widget Engine in the whole world (of course it is, I built it!). Now I want everyone else to use my Widget Engine. What do I do? In a greatly simplied WCF example, I would decorate the interface (you are using interfaces, right?) of my Widget Engine with the ServiceContract attribute, and any operations that I wish to expose to the world with the OperationContract attribute, like this.

Widget Interface

[ServiceContract]
public interface IWidgetEngine
{
  [OperationContract]
  void DoSomethingUseful();
}

Widget Engine

public class WidgetEngine : IWidgetEngine
{
  public void DoSomethingUseful()
  {
    //something useful here
  }
}

Then depending on my hosting model, I would configure the endpoints on which I wish to expose this service to the world. Now I’m service-oriented in the sense that I can be consumed as a service, and I’m cloud based in the sense that I’m delivered over the internet. My WidgetEngine object is now exposed over my service endpoints.

Though this approach certainly works well, the downside is that it’s largely a multi-step process. First I build the application with objects, then add the right stuff to expose those objects. The application architecture itself may be service-oriented, and my application is service-oriented in that it can be consumed as a service, but the approach is to basically service enable the objects in my application.

Now imagine a world where those objects were already services.

New Development Platform

This is what I think the new platform is, or at least what it should be. Instead of service enabling my objects, my objects should be services. I should then be able to easily and graphically configure which services are exposed and how they should be consumed (REST vs. SOAP, HTTP vs. TCP, etc). I think this new development platform will be an abstraction layer built on top of WCF, the same way that WCF was built on top of .NET, which was built on top of COM, which was built on top of C++…

What It Might Look Like

In this new platform, instead of creating a .NET object, I think I will instead be creating a service. So something like this:

public service WidgetEngine : IWidgetEngine
{
  public void DoSomethingUseful()
  {
    //something useful here
  }
}

I should then be able to graphically wire my services together to fit my use cases, and rewire them in the future as those use cases change. This is true service-orientation, where everything is a service, loosely coupled through the contracts, where the coupling can be changed quickly and easily.

And most importantly, this new development platform should come out of the box with the glue that every application needs pre-built. All of the things that you get with WCF today out of the box, security, transactions, interoperability, concurrency, etc, provided by the platform and without the headaches.

This of course could be accomplished today, but would come at a high price. You either have to have a strong WCF abstraction layer built on Discovery, or a high config hell pain threshold. I predict the forthcoming application development platform will alleviate much of this pain, and allow us to build truly service oriented applications right out of the box.

Conclusion

Silverlight, WPF and .NET aren’t going anywhere anytime soon, but I do think the new development platform will be a dramatically different way to build applications, and not just from a UI standpoint. Are any of these technologies dead? I don’t think so, but I predict that they are going to change. A lot.