Live data from Hacker News

Microsoft Launches Its .NET Distribution for Linux and Mac

techcrunch.com

181–190 of 249 posts

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#181
post #92
post #78

Earlier quoted context omitted.

The JVM is much more sophisticated than the CLR. Its GCs and JIT are many, many years ahead of the CLR's.

It's not that simple. The CLR has a different feature set to the JVM; or rather, it has a feature superset. If you run Java-like code on the CLR, I would expect it to not be as fast or have as high GC throughput as Hotspot, especially if the Java code has been tuned to Hotspot - there are particular fast paths for certain operations that kick in, where if your code is a little bit too far from the optimized idiom, yo…

> it has a feature superset.

True, although the most relevant difference is value types, which Java is getting, too. As to the rest, it's not about the number of features, but the quality of implementation. HotSpot's JIT and GCs are simply years ahead of the CLR, and HotSpot's next-gen JIT, Graal, is another tremendous leap forward.

> The CLR is generally much faster to start up

Compared to HotSpot, yes (but, like you said, there are many JVMs out there), although Java 9's JIT caching will change that.

> The library linking story is much more pleasant too, with a single dynamically linked executable referencing GAC-installed assemblies, rather than stringing together enormously long class paths.

This, too, is no longer the case in Java 9, but the difference in the other direction is much more relevant: the JVM's agent capabilities (both Java and native agents) are one of the things that give the JVM its power. The ability to easily transform code as it's loaded (or after its loaded) packs a lot of oomph.

In general I'd say that the JVM offers fewer abstractions, but more powerful ones and it offers less opportunities for hand-tuned optimizations and more for automatic optimizations. In the end, HotSpot is simply much more advanced internally. The CLR is like a car with more buttons, but HotSpot is the car with the better engine. HotSpot has always opted for constant change that's hidden from the user, while the CLR has been adding more and more user-accessible features.

The work being done on Graal/Truffle is so far ahead of anything anyone else is doing, that it will put HotSpot's JIT beyond the reach of any other technology for years to come. It seems to me that the CLR might even stop competing and C# might switch to AOT compilation, with VB possibly being abandoned. Some of the latest moves by MS seem to hint in that direction (RyuJIT was already done or nearly so).

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#182
post #28

F# is a real breath of fresh air in comparison to something like Scala. It's direct ML heritage really shows, also just diving in with an IDE (like Xamarin, or I suppose Visual Studio) is super easy. I see it as the future of pop-functional programming. For example look at the way it handles type inference w/ JSON parsing. Compare that to what you have to do to parse JSON in Scala. It's subtle, but a major usability…

Did you just invent a term? "Pop-Functional"... I like it!

I hope so.

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#183
post #28

F# is a real breath of fresh air in comparison to something like Scala. It's direct ML heritage really shows, also just diving in with an IDE (like Xamarin, or I suppose Visual Studio) is super easy. I see it as the future of pop-functional programming. For example look at the way it handles type inference w/ JSON parsing. Compare that to what you have to do to parse JSON in Scala. It's subtle, but a major usability…

case class Fruit(name: String, variants: Set[String]) val fruitJson = Json.parse( """{ "name": "apple", "variants": ["cox", "braeburn"] }""") val fruit = fruitJson.as[Fruit] Doesn't seem to be too painful to me. I agree that F# is syntactically closer to ML (though Scala is closer to ML with its module system which F# gave up completely).

Tell me what happens with that technique when your json has > 22 keys. ;)

(Edit) this is apparently working in the latest scala 2.11 But it killed my adoption of scala for real work early on. https://issues.scala-lang.org/browse/SI-7099

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#185

Yes! Finally we can use .NET on on Linux a supported official way.

What are the major projects that are built in Mono? I only know opensimulator.

http://www.mono-project.com/docs/about-mono/showcase/compani...

As much as it pangs me to say it, I'm playing some great games on Linux now because the Unity people built it on Mono.

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#186

Never thought I'd say this but go Microsoft!

I dunno about that.

They're still charging and threatening people for Android patents without really telling anybody what patents they hold over Android.

I think they realize they can make money via open source now and they might do this for future product. Threaten people via patents or some kind of trojan horse.

While it's great we have another programming language and platform option but their actions so far in the past and present isn't so great.

They also tried to make a Hadoop clone that failed miserably so now they team up with Hortonworks.

Perhaps that opening sourcing their VM they can have big data projects like Hadoop and such. Oracle have big sway over Java and JVM. Perhaps that's what Microsoft wants. People might forget about Oracle and JVM but I still remembered and it really sucks for Apache.

In general, I'm not taking this bet and I'll wait on it.

Also with my current skill set which is mainly open source, it is fine not dealing with Microsoft. Unless they have a better market share and momentum in some niche market like big data with Hadoop, spark or whatever I wouldn't even think about touching their open source stuff.

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#187
post #15
post #9

Does it include the source? And how liberal is the license?

https://github.com/dotnet/coreclr MIT license

Pardon my ignorance, but I've never adventured too much into licensing stuff myself, and always had this kind of silly question roaming in my mind: what would happen if someone - after releasing some code open-source with the most permissive license, say on Github - immediately after changed their mind and changed the license back to a very restrictive one and someone had forked the project in that short range of time? Would their forked repository with the permissive license version be a totally legit code repository ?

I know this is sounds silly, but I wonder if it's a thing or not that when a software company publicly releases some valuable code open-source, then there is always someone thinking: "better fork this as quick as possible! you never know!" :)

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#188
post #187
post #15

Earlier quoted context omitted.

https://github.com/dotnet/coreclr MIT license

Pardon my ignorance, but I've never adventured too much into licensing stuff myself, and always had this kind of silly question roaming in my mind: what would happen if someone - after releasing some code open-source with the most permissive license, say on Github - immediately after changed their mind and changed the license back to a very restrictive one and someone had forked the project in that short range of tim…

They can close-source it again, they can't stop you using the open source version they did release. If you have the licence, you have the licence, and it is perpetual. You can't unscramble the egg.

There are quite a few products around which fit that type of scenario - where an older, free version is still circulating while the company now distributes a close source paid version.

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#189
post #150
post #28

F# is a real breath of fresh air in comparison to something like Scala. It's direct ML heritage really shows, also just diving in with an IDE (like Xamarin, or I suppose Visual Studio) is super easy. I see it as the future of pop-functional programming. For example look at the way it handles type inference w/ JSON parsing. Compare that to what you have to do to parse JSON in Scala. It's subtle, but a major usability…

Also interesting is their F* language: http://fstar-lang.org/ "F* is a new higher order, effectful programming language (like ML) designed with program verification in mind. Its type system is based on a core that resembles System Fω (hence the name), but is extended with dependent types, refined monadic effects, refinement types, and higher kinds. Together, these features allow expressing precise and compact specifi…

I'm going to write a package manager and call it F* ck

Re: Microsoft Launches Its .NET Distribution for Linux and Mac

#190
post #28

F# is a real breath of fresh air in comparison to something like Scala. It's direct ML heritage really shows, also just diving in with an IDE (like Xamarin, or I suppose Visual Studio) is super easy. I see it as the future of pop-functional programming. For example look at the way it handles type inference w/ JSON parsing. Compare that to what you have to do to parse JSON in Scala. It's subtle, but a major usability…

case class Fruit(name: String, variants: Set[String]) val fruitJson = Json.parse( """{ "name": "apple", "variants": ["cox", "braeburn"] }""") val fruit = fruitJson.as[Fruit] Doesn't seem to be too painful to me. I agree that F# is syntactically closer to ML (though Scala is closer to ML with its module system which F# gave up completely).

In this base case, no, it isn't too painful. But once you get to larger and more complicated structures, F#'s type provider system can be a tangible timesaver. Especially if you're doing exploratory programming.

TBH, I think the JSON example might underrate things a bit anyway. Where type providers really start to feel impressive is when you get to tricks like being able to noodle around inside undocumented (or poorly documented) COM interfaces with the help of CodeSense, or getting red squigglies in your editor (and compile time errors) when there's a problem with an SQL query.

F# isn't all roses, of course. I really wish it had typeclasses, and discriminated unions are less powerful than Scala's case classes in some tangible ways. But from a purely pragmatic perspective, my (almost certainly biased) sense is that I can usually Get Things Done™ with less ceremony in F#, and type providers are a shining example of that pragmatism.

Post reply on HN