kvb

In my opinion, yes, but others are free to disagree (and "inferior" is subjective). In addition to the kinds of applied research that Google also does (machine learning, etc.), MSR also does a lot of fundamental research much further afield, like that done by the biology group at MSR Cambridge [1], or the quantum computing work done in the quantum computing group and Station Q [2] (see also Scott Aaronson's relevant blog post [3]).

[1] http://research.microsoft.com/en-us/groups/biology/

[2] http://research.microsoft.com/en-us/groups/quarc/

[3] http://www.scottaaronson.com/blog/?p=1471

While this is true, I think Microsoft Research is much more akin to Bell Labs than Google (though I'm biased). See e.g. this list of top CS papers [1].

[1] http://jeffhuang.com/best_paper_awards.html

Particularly when the cheap drug isn't FDA approved for the treatment in question.

The main focus of the Oracle case was copyright, not patents.

How much of the stack are you willing to look at when you hit a guard page? The non-tail call might not be right near the top, depending on the structure of the code. I'm not saying it's impossible, but I think the approach of having the higher-level language add the annotations is probably more practical.

Right, my thought was that doing real tail calls everywhere that's eligible would almost certainly be a performance disaster. I'm not sure that hotspot could help, at least if applied naively, since correctness depends on never missing a tail call that could lead to unbounded stack usage.

For example, consider an F#-like language on the JVM. Given the definition `let apply f x = f x`, you could imagine `apply` getting called in all sorts of contexts that don't result in unbounded recursion, so a hotspot-like system would not generate a tail call when compiling the method given the first N invocations. But then if another function is defined as `let rec loop n = if n < 1 then n else apply loop (n-1)` and invoked as `loop 10000000`, then the lack of a tail call in `apply` is fatal.

What do you mean by "The JVM could implement tailcalls via analysis"? Offhand, I can't see a way for this to be practically viable, but I may just be lacking imagination.

Note that Scala doesn't implement general tail call optimization; it only applies to direct self-recursive calls (as far as I'm aware). By contrast, on .NET F# implements true tail call optimization, including cases where the call is statically unknown at compile time (as in `let apply f x = f x`).

As many comments point out, he neglects the .NET approach to generics, which avoids most of the drawbacks of C++'s approach and Java's.

This is incorrect - see the definition of a text element in the remarks of http://msdn.microsoft.com/en-us/library/system.globalization....

But I was wrong and it's actually by grapheme, as danbruc correctly notes.

Good point - I meant one codepoint at a time.

.NET uses 16-bit characters, but you can use the System.Globalization.StringInfo class to iterate through a string one Unicode character at a time, index into strings by Unicode character, etc. The API's a bit awkward, but it works.

Where did the skeleton tracking come from?

How does open allocation address performance evaluation/compensation? Doesn't Valve have both open allocation and stack ranking?

What leads you to believe that Microsoft applies the curve at that level?

I love F#, and greatly prefer it to C# for most tasks, but I think you're overreaching a bit. C#'s dynamic feature is also extensible (via IDynamicMetaObjectProvider) and much more complete than F#'s (e.g. F# probably ought to have (?[]) and (?[]<-) operators for dynamic indexed properties). Likewise, there are several real benefits to having built-in support for async/await, such as the improved performance of a state-machine-based approach and a far better debugging story (e.g. call stacks that are async-aware).

C# is truly a great language; it was just created by people who have different priorities than you (or I) do.

On the other hand they ensured that every Windows user had free access to a high quality browser (at least, at the time IE6 came out).

Of course there's a good reason: copyright exists to motivate the production of creative works, but creators typically are not motivated by the thought of royalties 80 years down the road.

Also, real/personal and intellectual property differ enough that I don't think the analogy from your second paragraph is particularly instructive. For example, with physical property I can't think of any obvious analogs to remixes and derived works.

Really? http://www.engadget.com/2013/10/21/microsoft-surface-2-revie...

No, really you don't need Taylor series at all; see for example Conal Elliott's "Beautiful Differentiation"[1], which shows how to handle arbitrary derivatives of multidimensional functions and never uses Taylor series for anything; all you need to know is that d/dx sin(x) = cos(x), etc. Just as a warning, Conal's paper is quite dense and is probably not a good introduction.

[1] http://conal.net/papers/beautiful-differentiation/

Why would you need that? The F# compiler's open source and runs just fine in MonoDevelop/Xamarin Studio (or outside of an IDE, for that matter).

Was OS revenue ever a big source of income for Apple?

Thankfully the compiler is open source and there's a thriving community outside of Microsoft (see http://fsharp.org), so this shouldn't be a big worry. And Microsoft hasn't shown a lack of commitment thus far (in fact, with the Visual Studio 2013 release F# gets new features but C# doesn't, as I recall).

I like C#, and I think that it's an objectively well-designed language given its designers' priorities. But if you have different priorities, there's plenty to dislike. If you want a scripting language, or a really expressive type system, or raw-metal performance, then C#'s not going to scratch your itch.

C++ has features like operator overloading that make faking lambdas via Boost feasible. And even Java has anonymous inner classes that allow a rather ugly local transformation somewhat akin to closures. But if you removed that feature, then you'd need a non-local transformation to fake them.

It's hard to do, but it is being done. See e.g. Gonthier's celebrated work formalizing the Feit-Thompson theorem[1].

[1] http://www.msr-inria.fr/news/feit-thomson-proved-in-coq/

See Felleisen's "On the Expressive Power of Programming Languages"[1] for one formalization that differs from conciseness. Essentially, Turing complete languages can express the same programs at the very coarse "whole program" level, but the paper advocates taking a more local view to assess expressiveness (e.g. what programs in L1 can you write in L2 without having to do a whole program transformation). See also Neal Gafter's related commentary[2] (in the context of the various proposals for closures in Java).

[1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.51.4...

[2] http://gafter.blogspot.com/2007/03/on-expressive-power-of-pr...

Root against Microsoft all you want - I just think that stack ranking is too convenient a scapegoat. Valve and Google stack rank, too, but that doesn't mean they're not great companies. Also, Wikipedia's not necessarily an infallible source; see [1] for evidence that stack ranking dates back to '96 or so (at the latest).

[1] http://www.alexstjohn.com/WP/2013/08/30/microsoft-review-tim...

Wasn't stack ranking in use during Gates's tenure as well?