> What are the chances of Enterprise switching to .Net instead of Java?
Plenty of enterprise shops are Microsoft full-stack shops (Windows Server/.NET/SQL Server/IIS). I get the impression -- though I haven't seen systematic data -- that .NET has been making gains against JVM as an Enterprise platform.
It mostly depends on perspective. I work .Net enterprise and NEVER hear of Java - giving me the obvious false impression that it is Java that is unused. The only thing under the Sun that we really hear of is Oracle: that's one or two customers.
Both Java and .Net are viable, relevant and widespread technologies. It all depends on which segment of the market you happen to be catering to.
It just seems that Google, Twitter, Facebook or many other big Data companies will have some / many pieces of tech dependent on JVM. But I never heard anyone them using .Net
Big data isn't even analogous to enterprise. I don't even think if Google, Twitter and Facebook should be considered to be classically enterprise. However, what you say about big data is certainly true - that's not something .Net is competent at: keep in mind that doesn't make it wholly incompetent. The corollary is true: .Net does things some things really well that Java is dreadful at (e.g. last time I played with Java the UI situation was a complete joke).
That doesn't make either language/runtime bad or better than the other. Their strengths aren't static, either. They are merely different tools suited for different tasks. Both have some extremely large names using them.
The C# language has improved considerably over the years when compared to Java. It will take some time before everything is ported over, opened sourced and running on Linux however, once that happens, I wouldn't be surprised if companies start experimenting with it. It's going to take along time before anyone would really switch I think considering so much JVM is built up but as long as the performance is at least similar (better would be awesome) I don't see why people wouldn't at least toy with the idea of migrating.
Too early to say anything. IMO, it was only a few years ago that .Net felt completely dead and developers were not sure what Microsoft was going to do. This is why .Net didn't take over the Enterprise market in my opinion.
Now, that it is going to be open-source and MS is pushing it harder than it has before, it might have a good chance being used for "new projects" but I've seen MS do this before only to fall off the wagon and stop focusing on these type of stuff.
In addition, the "enterprise" market move much slower than anybody and they care about backward compatibility. It would be several years before .NET would be considered for new projects. It is in that timeframe that Microsoft needs to seriously focus on this and explain why .NET should be used instead of Java.
.NET improving faster than the JVM would be a very hard thing to measure or even estimate. There are very exciting and impressive things happening in JVM land, for example Graal and Truffle.
Except, in both of the examples you cite, .Net has had those features since day 1 ( more than 13 years now ).
I think it's pretty disingenuous to say those things are hard to measure or even estimate. Java and C# are close enough that you actually CAN measure them in a pretty useful way.
Java has been behind the curve for YEARS as compared to .Net with perhaps the exception of the cross platform aspects and the more permissive licensing.
Not sure we're talking about the same thing. To my knowledge no other ecosystem has anything close to Graal and Truffle at this point, much less "since day 1" of .NET.
The closest thing I can think of is PyPy, which like Graal+Truffle lets you write a dynamic language in a high-level way, but still get specialized JIT compilation "for free". (In PyPy you write an interpreter, in Graal+Truffle it's more declarative.)
Both PyPy and Graal+Truffle achieve state of the art performance. I'm not aware of any dynamic language on .NET coming even close to that.
As I understand it, Graal+Truffle is basically the DLR. This has been around since 2008 from Microsoft.
Both IronPython and IronRuby have used this for years.
The "Day 1" comment was specifically pointed at the read-between the lines for Graal, which is basically to create a real IL for Java instead of using the InvokeDynamic semantic that is currently envogue for Scala, Clojure, etc. .NET has had the multi-language one VM paradigm since day one.
No, Graal+Truffle, and PyPy for that matter, are light-years ahead of the DLR. That's why IronPython etc. are nowhere near the state of the art of dynamic language performance, while both the JVM and PyPy have multiple dynamic languages on them that meet that criterion.
The fundamental issue is that dynamic languages need JITs that are very aware of their internals. It's not enough to just emit some code interspersed with PICs and to add fast dynamic dispatch. You also need to speculatively compile and deoptimize in a way that is specific to each dynamic language. Without that, IronPython and other dynamic languages on .NET are often not a little slower but 10x slower than the same languages on the JVM or PyPy.
The precise GC support in LLVM mentioned by Microsoft is work that is being done by an employee of Azul Systems, a JVM vendor. Stuff is happening, perhaps just not as loudly.
> Additionally the pace of .NET doesn't matter, because the enterprise is dog slow to upgrade.
In some cases they will never upgrade. I'm talking about places still running WebLogic 8 and JVM 1.4.2. Huge business critical production systems. They'll probably still run on that exact stack for the next 5 years at the very minimum. Everything new gets written in whatever the new stack is, that old stack just stays there, forever.
It depends on what you count as JVM land, I'd say.
If you live in JVM land and value modern development you are probably already on Groovy, Gradle and Grails - where Grails imo. is ahead of the MVC4/5/6 stack...
The JVM ecosystem is far bigger than Groovy, Gradle and Grails. Think Scala and Clojure for languages, Spring and Play for frameworks, and Maven for builds. Groovy has 2 big use cases in industry:
* scripting to manipulate Java classes, for testing and 50-line scripts in Gradle, though Gradle's been opening up its API so any JVM language can use it. When Java 8 becomes more widespread, a future version of Gradle might standardize on Java lambdas and ignore use of Groovy closures in its DSL
* the MOP used by Grails, though Grails is following its namesake Rails into obscurity
Although Groovy 2 bundled a statically-typed compiler to compete with Java, virtually no-one uses it. There's far better choices for developers who want to replace Java on the JVM, such as Scala. Groovy really should've stuck to its dynamic roots and niche by adding scripting support for Scala-compiled classes instead of going into head on competition with it and Java.
Plenty of enterprise shops are Microsoft full-stack shops (Windows Server/.NET/SQL Server/IIS). I get the impression -- though I haven't seen systematic data -- that .NET has been making gains against JVM as an Enterprise platform.