Microsoft takes .NET open source and cross-platform

In general, open sourcing is helpful decision (it's also a practical business decision in several cases)! And the possibility of running C# on *nix really creates opportunities in a way that contributors grow. It's a win-win.

Even with a complete changing of personnel, factors (eg. business model) could necessitate certain behaviours. For example, every person inside present day Google could be replaced, but the behaviour of learning more about their users in order to more precisely target them with advertising wouldn't change unless they actively tried to reinvent the company. That said, I do think Microsoft are actively trying to reinvent themselves.

The IO monad is just an action. Its a cons pair with a left and a right half. In an imperative language you could model the left half with a closure that takes no arguments, does I/O and produces a value.

The right half is usually empty, except when you use the `>>=` operator (or flatMap) on an existing action, e.g.

let c = a >>= f

That operator chains the function `f` can take the value produced by the first IO action and produce another IO action. After we apply that operator, the result `c` is a cons cell where the left part is the original action `a` and the right part is the function f which takes the value produced by a and produces the next action. Its sort of like a cons cell in regular lists, except the next value is provided by a function. A lazy cons cell, perhaps :)

The final result is a lazy chain of I/O cons cells (called "main", of course :P). Its passed to the Haskell runtime, which executes that chain as a recipe, alternating between doing I/O actions and evaluating the function to decide what to do next.

So what does this buy us? Mostly just referential transparency. What does referential transparency buy us? Easy refactoring. We can replace any expression with its value, even stuff like `putStrLn "test"`. We can say `let writeTest = putStrLn "test"` at the top of the file then write `do writeTest; writeTest` in main.

Another neat thing is that do syntax isn't limited to just IO, but works with anything that implements `flatMap` (and `unit`, which I forgot to mention). That means we can build our own imperative DSLs that produce IO-like monads which are then interpreted by our own interpreter, and the users of those DSLs can use the same do syntax. Which is pretty awesome. Here is a simple example: https://gist.github.com/tonymorris/b5dba9d7d877051d0164 and a much more complex one http://augustss.blogspot.com/2009/02/more-basic-not-that-any... :)

That is not the point of the comparison; the point is that in the same way someone could use an euphemism to describe the behaviour of Stalin, "they're just a technology company looking out for their shareholders" etc. is an euphemistic simplification of why people are wary, if not hostile, towards Microsoft. I might as well have said a bee sting doesn't hurt less just because you call it "a tiny injection of fluid that quickly dissipates"; but I totally reject this squeamishness about strong comparisons when the point of the comparison isn't comparing the "strength", but something else.

But since you brought it up: who knows? How can anyone measure how many people were put out of business and killed themselves because of the ruthless tactics of huge corporations? How many people have wasted how many hours paying for their inferior products, or trying to make them work, and to how many human lifespans does that add up? It's impossible to claim any company "killed X people" that way, but to think the net effect is somehow clean and unbloody is also naive. To put it crassly, some people didn't take to the boardrooms because that is more humane, but because it's more effective, because robbing and killing people is inefficient. Doesn't it make it as bad as Stalin, but since Stalin isn't the baseline for how bad something has to be to be unacceptable, that is irrelevant.

Also, imagine a world where Linus Torvalds had done something else, and a bunch of other factors had worked out slightly differently; as far as open source goes, Microsoft DID try to kill it, they spread as much FUD as they could, they handed out their products to schools and universities for fear of them breaking free, and only now when they still lost they are starting to play nice. So as far as software and software freedom is concerned, Microsoft did kill plenty.

And now imagine repelling the Conquistadores; not because they reconsidered, but because even giving it their best shot, they could not kill enough to totally submit everyone like they originally planned, and had to regroup or be wiped out themselves. And now I am supposed to be grateful and let bygones be bygones? No. Others can do that, but I can't respect them for it, at best despite of it. And you know what, I don't like Apple either. So I'm the position of loving computers and programming, but none of the big players, anymore. And I don't have to chose a side, I can find them all lacking. Because they are not to be compared to each other, but to the behaviour of intelligent humans with dignity, and the vision of an actual information age that empowers and liberates people, instead of just seeking to capture them, so they can be fed any old uninspired BS that is made shiny and big with all the capital leeched off the masses. This doesn't change in a few years or decades, or without fines or even prison sentences, for that matter. I'm not buying it for one second.

Computer manufacturers were told that they could not buy Windows for their computers if they intended to factory-install Netscape. That's not consumer choice, that is the definition of criminally leveraging a monopoly in one market to dominate another.