Lets start with how it currently works...
When you create an application or website in C#,F#,VB.NET or any other .NET language you are not really 'compiling' it per se to native code, you are compiling it to an intermediate language called IL - very much like Java byte code. When your application or website is run for the first time the .NET runtime converts this code to native code on the local computer and then caches this binary and officially compiled native version of your code. The result is, the first time you run your app or a section of the code there is a small performance hit while the .NET runtime converts your code to native. Let me be perfectly clear, this is a one time thing - a first time thing. Once you have gotten past that every subsequent run is going to be as fast as other native code. (Why is it not as fast as something written in c or c++ you may ask - because there are other things the .net runtime is providing for you like garbage collection, but that is a whole other talk)
So how is this different?
This preview allows you to skip this JIT process and image caching process altogether. This is first targeted for Windows store apps, when you would first run it on your machine it was slow on first launch because all this extra work was being done. Microsoft decided they could take the server side resources they had and run this JIT and imaging process ahead of time and when someone downloads and installs your app - this work was already done and first launch would be faster - as much as 60% faster. There are also lots of changes under the hood to make this all work better - Andrew Pardoe is on this comment thread further down and mentioned things like a refactored runtime, static-optimized libraries, static marshalling all combining for performance wins.
Does this mean I can build apps for Unix with C#
No, Mono is still the best way to do that
Can I build simple console apps with this and deploy to machines without the .NET runtime?
No, right now this is only available for Windows Store apps. Besides, unless you have some Windows 98 machines sitting around nearly every PC has the .NET runtime.
Will this make my app run faster?
Starting up, yes. Normal operation, probably not. .NET runtime and jitter have been around a long time and they are impressively efficient and fast. This includes some tweaks to parts of the runtime but don't expect to see your text file processing app go from 10 seconds to 2 or something like that.
Will this help me pick up chicks?
Your post provided essentially everything
that was missing.
But, what the heck is a "Windows store app"?
What the heck is "jitter"?
In the past if you were writing a client side or 'desktop' app for Windows you used C++ and MFC or a .NET language with Windows Forms or WPF (or lots of other options) to build that experience. Going forward Microsoft would prefer you build using this new model they are calling Windows Store apps. Along with that comes a set of rules and explicit declarations about what your app will do (much like we have on Android or iOS). This should in theory limit the number of crapware that exists, though that remains to be seen.
Jitter is a term we often use for a program that does the JIT work, JIT is an acronym for Just In Time which in context means Just In Time Compiler; it runs just before the code is needed. You have a program with 10K lines of code but the command you just sent the program only invokes 500 lines - a jitter or Just in time compiler will only convert the code that is actually needs to perform the operation you requested (thus performing faster).
will this help me pick up chicks?
as a dba, i appreciate your response, though i think that the answer is most likely, "probably not."
We haven't done many systematic performance comparisons. However, it seems to be the case that whilst Mono still performs worse than .NET in a few areas (e.g. loading new AppDomains), in general there isn't a significant performance difference between running OpenSimulator on Mono and on Windows.
.NET is not a language, presumably you're referring to C# vs. Java? C# may have the upper hand over Java currently, but Java 8 is a very good sign from Oracle that they're finally willing to push the language forward, which down the road may not necessarily mean C# > Java.
As for .NET being so much better than the JVM, that's not a factual statement ;-) Certainly the JVM, with Clojure, Scala, Kotlin, Ceylon, Groovy, JRuby, etc. running on it, has proven the JVM to be a pretty awesome environment for emerging languages, while the CLR has proven to, not surprisngly, be an awesome environment for Microsoft backed projects.
If you're tied to Linux and Mono isn't a viable solution, why not try one of the above Java alternates?? JVM is a kickass dev environment these days if you're able to break away from Java...
FWIW, last time I tried Mono (a couple of years ago) it was quite impressive, particularly the IDE, incredibly responsive. The biggest drawback was the feature lag between latest and greatest from .NET side of the fence.
> Can I build simple console apps with this and deploy to machines without the .NET runtime?
Darn. I was hopeful that this would help us run .NET applications in Wine by eliminating the need for the full VM, but it appears not.
> Besides, unless you have some Windows 98 machines sitting around nearly every PC has the .NET runtime.
Well, or a Unix machine trying to run Windows apps in Wine. We are (well, one single dev is, really) still trying to get Mono to work for us, but it's a very long road to get the missing APIs and VM features in place.
Edit: This is a much better link: http://msdn.microsoft.com/en-US/vstudio/dn642499.aspx
Still not sure though, as they say "only Windows Store apps can be created" which sounds suspiciously like "no".
"However, apps will get deployed on end-user devices as fully self-contained natively compiled code (when .NET Native enters production), and will not have a dependency on the .NET Framework on the target device/machine."
I suspect that there's things that require this which they haven't announced yet, since on its own it seems like something kinda nice but not beneficial enough to justify creating.
Are you sure? You still need the standard libraries, a garbage collector, its security checks when loading other code, and may want to use its compiler from your code. Together, that's a lot, maybe all, of what's in the framework.
The biggest difference with NGen is the fact that .NET Native doesn't ever "fall back" to JIT compiled code. There are other differences--refactored runtime, static-optimized libraries, static marshalling, etc.--which can be seen by the perf wins over NGen. We're seeing 40% startup performance gain over NGen apps for top Windows Store apps.
Project N compiles to fully native code, so there can be no JIT, and significantly smarter optimizations can happen since they don't impact performance at runtime.
.NET Native produces completely native binaries. MDIL/Triton produces NGen binaries that still need a runtime and, occasionally, a JIT.
Sorry. Triton is the Windows Phone 8 "Compiler in the Cloud". It basically split NGen into two pieces, allowing the optimization to happen in the Store while the .exe generation happened on the device. The interface between these two halves is MDIL.
Bing will tell you a ton about Triton.
Also, is it just me, but this sounds like a glorified NGen in the usual build process (compiling for production goes straight to native), instead of NGen in the background optimisation service?
I am all about getting the new tools, switching to new, more productive ways of development (in fact I was programming in C# for about 3 years), I simply hate when false information is being spread, just because it sounds better to the sales person.
vs. the latest .NET install
This is a brand new Windows 8.1 computer.
Don't get excited then, this is only for windows store.
It is interesting how every old is new again, we went from AOT to JIT and Back to AOT again.
There are lots of other AOT compilers for Java available.
> It is interesting how every old is new again, we went from AOT to JIT and Back to AOT again.
Yep, we already went through this as everyone founded out P-Code wasn't fast enough. Then Anders Hejlsberg created Turbo Pascal.
In the future, a store / certificate authority will be able to arbitrarily revoke your right to run anything on your computer that isn't approved.
We're already there with Web Apps and other SaaS "innovative" technologies.
"Our compiler in the cloud compiles the app using .NET Native in the Store, creating a self-contained app package that’s customized to the device where the app will be installed."
I imagine this would help them keep costs down on Azure as well.
Larger EF models can have quite an impact.
Also if you use New Relic, it can seriously affect startup time too.
It takes forever for the JIT to actually compile all code paths in these assemblies.
There's no PDBs in there either. Our domain and NH maps consume 42Mb of that to give you an idea.
1. Proxy generation (castle) -> IL
2. IL -> Native.
Hopefully the marketing people let them spread it to all of their application types.