Drifting away from .Net


I don’t think there’s .Net fatigue, in the same way as described on Eric Clemmons’ Javascript Fatigue. At the very least, I don’t think it’s the same feelings at play, considering how people breaking up with Javascript talk about it.

I just think .Net may have missed the love boat altogether.

But let me back up a bit here.

I didn’t realize until reading Ryan Riley’s piece on .Net fatigue that I qualify as one of those long-standing .Net developers who have been looking elsewhere. It seems to have crept up on me.

It’s an odd situation, though. I don’t really have a fundamental complaint about the platform. I could write an epic poem of minor gripes, but so can anyone about anything that they’ve used for a long time.

It’s complicated.

Some background

The partner

In late 2001 a partner and I had a difference of opinion about which platform to pursue.

He loved Java’s potential as a free platform. His eyes glittered when he rambled about a future of cross-platform applications. .Net had similar potential, in theory, but he was also highly suspicious of the murky patent situation. He was adamant that Microsoft was laying in wait to sue anyone who’d attempt a cross-platform implementation (funny how that turned out).

I, on the other hand, had a utilitarian view of the situation. C# looked better thought-out than Java. I thought the tooling for Java was subpar, and it was clear they wouldn’t be able to compete with Visual Studio for years. .Net looked like it would be rapidly adopted by potential clients. I appreciated its practicality, and the fact that it would let me get work done faster, with better support. The cost-benefit favored it.

Unsurprisingly, open-source developers thought like my partner. While they were building things they were passionate about, things Microsoft would eventually adopt, most .Net users were building sensible and rational projects that they could invoice.

Those sensible, rational people will revisit that cost-benefit calculation, and move elsewhere when the balance changes. It might even be somewhere they love, and if it is, you won’t get them back.

Java, on the other hand

It was over ten years ago, so I can’t remember who said it, but back when I was doing a lot of work in Groovy I read a remark that perfectly described Java. It said that the state of the Java could be gauged by how much effort platform users put into working on it using anything other than the Java language.

Java has since taken some steps out of its cave, but it can’t be denied than its years of hibernation helped spur alternate developments.

Java’s linguistic kludginess, combined with a well-defined VM behavior was the perfect place for innovation to emerge. People were attached to (or stuck with) the platform, whether by virtue or dictum, and wanted to work on something better while still being able to argue they retained compatibility.

These new efforts like Groovy and Scala and Clojure were born out of passion. People brought love with them. Some happened just because it was a way to plant a flag - the creators had a cause.

Long-term progress requires love

These labors of love never really happened in .Net. Open-source purists may blame the fact that it was closed source, but I think that’s not the only reason.

C# was a decent enough language. Decent enough stifles competing improvements, and hesitation around the cross-platform implementations did nothing to compensate.

Java pretty much demanded it, and the love of the users who had embraced it nurtured these side projects.

As a side effect, progress started happening elsewhere. Grails was out a good two years before ASP.NET MVC, and Rails predated Grails. Entire ecosystems considered Windows an afterthought, and fumble around for a niche as Xamarin might, Windows was what people associated .Net with.

Users didn’t try to build these things on .Net - they waited instead for Microsoft to build them.

Yes, we had some projects, like the IronPython or IronRuby, a lot of which were promptly abandoned or never really used in production. Some alternate languages even appeared for .Net first, like Boo. Show of hands, though - who has ever deployed something written in Boo?

Without these parallel developments, .Net was bound to stagnate eventually.

Being practical

I don’t seem to be alone. It wasn’t until F# came along that I started meeting people who had fallen in love with the platform.

Most of us were happy with it. We found it a productive way to work, and a pleasant alternative to Java. It was practical and effective.

Even though C# was my go-to language for years (and still is for some cases) it never engendered the love that Clojure does. It felt more like we were a couple who went directly from meeting to the quiet mutual acceptance of a long-term relationship.

Part of this is Microsoft’s fault. Much as that has changed in the last couple of years, they made it really hard to love them for decades: draconian practices, flip-flopping on which products they were going to support, temperamental management.

If you were considering a personal project, it did not instill confidence. Would you want to spend years of your life on an unpaid effort geared towards something where cross-platform implementations may or may not run into patent issues?

And yes, ironically, part of it was because C# was actually competent and evolving, whereas Java felt like it was born full-grown as kludgy committee-driven dinosaur.

C# was closed-source, so even if you had a gripe you couldn’t improve it directly. Your sole alternative would have been designing a new language from scratch. Few people have both the skills and commitment for such a task. Even fewer want to bother.

It was easier to live with the gripes until something you loved came along.

It’s not you, it’s me

Letting go

A key part of platform success is to be good enough that people want to use you, but let go enough of control that you don’t stifle innovation. Otherwise this innovation will happen elsewhere, and you’ll miss out.

There’s also that, in order to open source something, you need a dose of humility. You are saying “I made this, but I’m putting it out here because you can probably improve it”.

Letting go of control and humility are things that Microsoft hadn’t historically been good at.

Drifting apart

Under Nadella, Microsoft has been taking steps that should (by all rights) add points to the love tally.

It might be too late, though. Their audience is too used to the utilitarian approach. Their users have become too accustomed to asking “what’s in it for me?”.

The thing is I suspect F# would have done the trick for me (even with its lack of S-expressions) if I hadn’t gotten into Clojure first. It might have lit a spark. I would have tried it earlier, but for a few years I expected Microsoft to drop it.

So I wouldn’t say I’m fatigued, or that I’ve fallen out of love with .Net. We were never in love in the first place. We seem to have imperceptibly drifted apart over the years, then back together every so often.

I’m happy to use .Net where my interest and its capabilities align, but it’s not about romance.


Ricardo J. Méndez