I was asked to comment recently on Microsoft's announcements last week on making Windows free for small screens and open sourcing .NET. Some of my thoughts were published in a Wired article by Cade Metz, but following that discussion and a conversation today with Alex Handy of SDTimes I thought my reflections would be worth publishing here.
The Soul of a New Microsoft?
Microsoft's move to make Windows free is obvious and not really worth comment, apart from "Why not do this last decade?" Several of us in the Platform Strategy team at Microsoft stated this to what was then the "Windows Mobile and Embedded" group in 2007. The economics of devices are fundamentally different than PCs, with much smaller margins; as a result, any licensing cost at all for an operating system means much higher impact to COGS and margins than they did in the PC business. The proof was simple and empirical - we pointed to market adoption of Linux for embedded and mobile. This was before even the explosion of Android (which started in late 2007).
Open sourcing .NET is a much more interesting discussion. The open sourcing of .NET should have been done years ago.
Back in 2008 I recall Ray Ozzie asking pointedly, "When are we going to stop hanging the Sword of Damocles over the Mono community?" He understood the need to bless the third party innovation on .NET so that it could keep pace with the JVM. No stranger to open source and a true technology visionary, Ray knew Microsoft needed more tools in order to succeed.
A commercial ecosystem has hardened in place around .NET's closed-source Windows-only core. The key exception is Xamarin and its core: Mono. If .NET is going to have a life that matches the new philosophy that's demonstrated in the "Office for iPad" strategy, it needs Xamarin as a non-Windows development & delivery technology. The non-stop effort and technical innovation from Miguel de Icaza, Nat Friedman, and their team has produced real impact and Microsoft is lucky to have them available as partners in the post-PC world.
The Cloud Runs on the JVM
Since .NET is so far behind Java in the open sourcing timeline, the JVM has been the big winner in the open source language community. Miss writing LISP? No problem, use Clojure (LISP for the JVM). Not confident in Node.js in large-scale production? No problem, use Nashorn and Trireme (Node.js for the JVM). How about Scala? How about Grails? Also on the JVM.
This is the core source of the momentum behind Java right now and there's no sign of it slowing down. Because these are open communities they keep innovating without the impedance that comes from worrying about licensing.
For example, at Apigee we're now using a new language for large-scale cloud event management (required to operate our service). This language is Riemann, and it in turn is built on Clojure, on the JVM. Twitter uses a project built by Nathan Marz called Storm, another powerful event processor based on Clojure. Open source is being battle-tested at Internet scale and then being adopted by other companies. It's no longer restricted to solving well-known problems like operating systems and word processing.
With the number of new classes of problems we all have to solve in cloud computing, and our ability to freely share the implementations of our solutions, JVM-based languages are booming.
A Short Walk Through The History of .NET and the CLR
The .NET CLI and CLR have always been great technology, but they've been closed. For many years Microsoft's approach was to support a broad range of 1st party languages on the CLR - COBOL, C#, J#, VB.NET, ASP.NET, and many more. The .NET CLR supported many more languages than the JVM for years. Microsoft could do this because they could marshal more smart engineers for a single project than any other company. The resulting success of "internally directed development" built an amazing software corporation to be emulated and feared.
In 2006, Jim Hugunin ported Python to the CLR as something of a prank - "to show how bad the CLR was" - and ended up as a promoter of the CLR, creating IronPython and ultimately joining Microsoft. John Lam created IronRuby about the same time and joined Microsoft as well. The two collaborated to build the DLR (dynamic language runtime) to support dynamically interpreted languages on the .NET CLR.
Despite excellent work and great technology developed by Jim, John, and the DLR team, Microsoft struggled to rationalize the existence of these languages and teams and ultimately both projects died (IronPython in 2010 and IronRuby in 2011). It was just too hard to compete for internal resources with ASP.NET and C#. Microsoft's structural feature - internally directed development - had become a structural defect.
But outside Microsoft, developers were hacking new langugages against the JVM, like Jython and JRuby. In 2008, Sun responded by embracing the shift with an update to the JVM: The Da Vinci Machine, designed to be easy to write new languages against. At OSCON that year I remember Ted Leung stating "what's happening in languages now is unpausing the nuclear winter of languages imposed by Java." The net effect of this by 2010 was that .NET was lagging behind the JVM for modern Internet applications, a fact that is still true today.
Looking to the future: what would success look like?
To understand if open sourcing .NET is meaningful, we will need to look at activity over the next 12 months.
We should look to see if there are a number of new community-led language projects that show up for .NET - these would be observed through their usage of Roslyn (the .NET Compiler). Will a vibrant community show up to build Node.js for Roslyn? Erlang? LISP?
Another thing to look for will be whether there is a significant growth in use of .NET to target Android and iOS. With lagging market share for Windows on mobile devices, winning hearts and minds will have to show up in the use of .NET to target non-Windows devices.
Overall, it seems like a very great challenge. It's economics - the majority market share technology (JVM) is hard to unseat because there are so many external subsidies (community projects, word of mouth, commercial products). These external subsidies are aligned into network effects which grow at an increasing pace. This is the same structural feature that drove Windows to dominance on the desktop and iOS to dominate smartphones.
The one area that seems relatively viable for Microsoft is in enterprise developers. Even now, there are large enterprise IT shops (think: 1,000 to 5,000 developers) that have 30-50% of their developer force building .NET solutions. These enterprises are under the same pressure as every other to ship new mobile apps for iOS and Android phones and tablets. These teams would really benefit from an open source renaissance on .NET.
A Long Road To Travel
History is a major impedance here, though, as I learned first hand back in 2006-2009 leading open source at Microsoft: .NET is a commercial ecosystem first and foremost, and everything else is secondary. This is great for revenue growth but poor for open source innovation. The majority of the worldwide .NET developer community is nervous about open source due to years of conditioning from Microsoft that open source is bad, dangerous, and anti-commercial.
We started trying to change that message seven years ago, and made a little progress, but even today there is a long, long way to go.
