Microsoft meets Open Source

tl;dr Hadi Hariri has made a few observations regarding the churn we’re seeing in the Microsoft open-source space (around .NET Core and ASP.NET Core, among other things). But I don’t think this is a permanent state of affairs; what I think is going on is that Microsoft is finding that managing an open-source project is more than just owning the GitHub repo and just reviewing pull requests.

First off, let’s get two points of fact out of the way.

One, Hadi’s a friend. He and I have known each other for many years, and anything I say here, I’m comfortable saying in front of him. (Not that I think he’d disagree with any of this, but sometimes people see conflict where there isn’t any.)

Two, Hadi’s right about everything he says when he talks about “RC means something”. Terms have meaning, and if you change that meaning without your audience understanding that the meaning has changed, they become nonsensical and useless. If an “RC” doesn’t mean “We’re close to a final release”, then it’s not an “RC”, it’s a “milestone” or an “alpha”. Say what you mean, and mean what you say.

Hello, FOSS

Here’s the thing, though: For the most part, this is the first large-scale exercise Microsoft has undertaken in the FOSS world, and they’re going through the inevitable growing pains that come with it. There’s a lot of lessons they’re learning the hard way—adjusting schedules and rearranging priorities being out in the open, and being more than a little messy being just one of them.

Microsoft isn’t the only company who’s run into this. Oracle had its own share of growing pains when it first acquired Java, and that was after the people running the projects were running them in the open-source world for quite some time. When Sun first open-sourced Java, it took them close to eighteen months to migrate the build infrastructure, the code, and everything else over to a format that would enable people to not only get the code and build on their own, but be able to submit a pull request or patch. (As one of the first people to ever get the JDK to build on Windows—and Lordy, what a pain that was—I have a little knowledge of what was required just to shift the build infrastructure over to use the most recent tools.)

But even accomplished open-source projects run into this problem. Not all Linux releases have gone smoothly. Spring’s hit a few snags from time to time. And let’s not forget the incredibly crowd-pleasing approach that Rails (and its creator ) have taken over the years. Microsoft is, of course, not trying to play “the DHH Card” in any way (at least, that I can see), but at the end of the day, managing that relationship between your developers and your customers—particularly when developers are your customers—is a tricky thing, and in some ways much harder to do from a position of transparency and openness.

So… for now, what?

Does this mean that developers should steer clear of .NET Core? Well…. that kinda depends.

If you’re a developer who is accustomed to working with solidly-released software, and you’re not super-comfortable dealing with alphas/betas/Previews/RCs, then yes. Frankly, stay away from .NET Core until it ships it’s “1.0” release, with no suffixes, adjectives, or qualifiers.

But truthfully, that’s not a “.NET OSS” or even a “Microsoft” position; that’s a position that you should hold regardless of the thing in question. Java’s had its own share of “Whoops! Sorry, that thing’s not ready yet” releases that they’ve had to backtrack on, too. (If you’re a Java developer, you’re familiar with the long-running cluster-f*ck that has been Java Modules that may, one day, actually ship. Current signs suggest that it will be JDK9, but we thought they’d be in Java6, Java7 and Java8, too.) If you want to build things on top of “reliable” software, then you want the releases that lack any sort of modifier or qualifier to the name, regardless of who made it, whether that’s Microsoft, Google, Apple, Oracle, the open-source team behind the project, your own development team or even Linus Torvalds Himself.

And let’s be honest, the actual term—whether it be “alpha”, “beta”, “RC” or “Preview”—is really sort of meaningless here. In an OSS world, these terms really just aren’t all that necessary anymore. They used to be an indication of intent on the part of the software manufacturer, signaling how close to “final” the product was considered to be. But in a world where you can look at the source, take it out for a test drive yourself, examine the test cases (and test coverage) and see how well it handles your particular scenarios by yourself, the terms really aren’t necessary anymore.

So, yeah, if you like living the bleeding edge, keep playing with .NET Core, but don’t complain when stuff changes, because it’s “qualified” (meaning, it’s name has a qualifier to it, so it’s not yet shipped). Doesn’t matter what the qualifier is, so long as it remains qualified, then it’s still subject to change.

And in the meantime, yeah, you can bet that Microsoft is going to learn the lessons it needs to in order to figure out how to get along in this brave new world. Because…

Well, because they have to. This is the world in which they have chosen to live, and like any new immigrants, it’s going to take some time to get used to how things work here. Over time, they’ll adjust, and before long, they’ll be the veterans on the block teaching the new kids how it’s done.

It just takes time.