Nothing has changed, and nobody’s happy
In the last few weeks, Microsoft has shipped WebMatrix and LightSwitch, and further de-emphasized the efforts of IronRuby. This has caused a noticeable uptick in .NET developer anxiety and anger, at least in those who have taken it upon themselves to pursue development by taking cues from other thriving software ecosystems, and to do so loudly.
I don’t think many folks can argue that there is something good about generating interest in software development and providing a path to early productivity for budding developers. But it can, and does, get out of hand. This has happened before with sunset projects like Popfly, whose literature openly promoted the notion that anybody can program, with titles like “Microsoft Popfly: Building Games Without a CS Degree” and the professional developer community on the Microsoft stack normally respond unfavorably to these efforts, citing marketing zeal for the non-programmer or hobbyist.
What I haven’t seen before is the size and consistency of the message that professional developers don’t feel like Microsoft wants them in their community. To wit is open source colleague @jdiller: ”Microsoft has been doing a good job lately in reassuring me that my recent job change out of their ecosystem was the right move”. There are plenty of others making the same observation.
I don’t think it’s navel-gazing so much as Microsoft leadership being completely fascinated by, perhaps since inception, with the automation of software processes and the deconstruction of engineering rigour into pure magic. In other words, “you can do X, without writing a single line of code!” has enjoyed a long run within its walls.
Computer science’s long battle with complexity, perhaps (and hopefully finally) lost just this week with a new proof of P != NP making the rounds, has always been in love with the idea that we can form a description of a problem that’s sufficient to solve the problem itself. In isolation, any programmer with something to prove will invariably flirt with what is essentially the programming equivalent to the perpetual motion machine.
Perhaps the isolation is the problem. Another common sentiment of those who would see Microsoft succeed but only through a heavy course of tough love explain that Microsoft’s developer teams suffer from terminal “Not Invented Here” (NIH) syndrome. This means that despite the high availability of existing (and usually open source and free) solutions, Microsoft wants to create their own rather than adopt, acquire, or support the most promising variant.
There is an obvious commercial advantage here, since many Microsoft customers will only use Microsoft supported solutions, despite competent and free alternatives. Microsoft’s customers are quite literally asking for them to do this. It would appear that these same customers do not listen to their developer teams, if they have them, or appreciate that they share their desires to create better software faster.
Outside of marketing there are good reasons to develop a solution amidst available alternatives, and one of the most respected is that the current alternatives are inadequate to the task. This is a valid reason because it implies that the creator of the new solution has dealt with the complexity of the problem head-on, evaluated the state of the art, and found that it came up short.
Unfortunately, the re-invented solution from Microsoft often displays a demonstrable naivety compared to the existing marketplace. In fairness, this has nothing whatsoever to do with the capability of the developers actually building the software, but everything to do with the complexity of the problem. Usually, the first version of a Microsoft product resembles, at least in spirit, the first version of the competing solution. The difference, is that the competitor already has the years of experience and struggle and hard-won understanding with the problem baked into the shipping code.
I can’t help imagining the end of a conversation that begins one of these projects: “We can do this better than the other guys. Our customers won’t have to worry about relying on scary, risky open source, we’ll support them every step of the way. And our customers’ developers will be delighted. They can accomplish this task without writing a single line of code!”. This conversation could not occur in good faith if there was a true understanding of the complexity of the problem at hand, but the proof of that only shows up much later in the product itself.
The dance of dissent begins and goes something like this: developers in the community decry the Microsoft version of a solution, calling it vastly inferior to existing open alternatives, Microsoft developers who built the product take it personally, as anybody would, and defend that it’s only the first version which will improve over time, some claims to accepting and acting on feedback are promised, and everybody eventually goes back to their desks.
But because complexity seems to be a bad word in the Microsoft culture, we find ourselves at the same crossroads over and over again. Today we face another manifestation of our worst fear as professional developers, and balk at a company whose central theme is, and has nearly always been, the mass commoditizing of the practice of software development, all in the interests of making complexity disappear, like a bad rabbit trick, rather than acknowledging its existence and helping to manage it rather than ignore it.
I find it surprising that we are consistently surprised by something you can almost set your watch to. It’s not as if we haven’t seen this before, that we won’t see it again, and that the solutions we have today, right now, aren’t as viable as ever.
The gorilla in the room? The rest of the world doesn’t need a vendor guarantee that their software will work to make it work for them. Great companies are building great products on supposedly inferior and fragile open source technologies when compared to vendor-supported software. Open source companies trade up to recent revisions to stay relevant, vendor-supported companies upgrade their purchases. The difference, other than the sunk cost, is literally non-existent.
