Clojure, Scala, Kotlin, Groovy, JRuby : Most importantly, every one of them is in production use - not just as toy/experimental languages. And we havent even opened the Pandora's box that is Java 9+Truffle.
There's a lot of broscience that .NET is superior to the JVM - is that on sheer performance only ?
I suspect what's going on is that 1) unlike Java C# has actually evolved so the need for "escape hatch" languages is lesser, and 2) .NET developers want to use languages with rich Visual Studio tooling.
I hope being proven wrong though.
https://blogs.msdn.microsoft.com/dotnet/2017/08/14/f-and-net...
Apparently lack of support wasn't enough to delay Visual Studio 15.3's release, just let the community deal with it.
While dissapointing, I'm sure (well, I hope :) F# support will land in VS before too long. In the mean-time, VS Code really is a great alternative
https://www.reddit.com/r/programming/comments/6tppt4/f_and_n...
https://twitter.com/k_cieslak/status/896658073338695680
Of course he doesn't care about UWP support, as he wants to promote his own VSCode plugin.
"The F# team is currently focused on .NET Core tooling in Visual Studio and further support for .NET Core as it evolves. There is no ETA for .NET Native/UWP support at this time."
-- Phillip Carter [MSFT]
https://blogs.msdn.microsoft.com/dotnet/2017/08/14/f-and-net...
Better focus on C# and C++ and call it a day.
And I don't like going back to C++, is there any GUI/XAML tooling for it? If not, I'd rather use something like Rust.
MFC is mostly on maintenance and new application should use XAML + C++/CX.
C++/CX makes use of the C++/CLI extensions but it targets AOT compilation to native code instead.
The alternatives are C++ with WRL (Windows Runtime Library), basically ATL replacement, and what most Microsoft teams actually use for the UWP kernel components.
https://docs.microsoft.com/en-us/cpp/windows/universal-windo...
Because most C++ devs would rather use something more standards friendly, there is work in progress to eventually replace C++/CX with C++/WinRT, taking advantage of C++17 features.
“Embracing Standard C++ for the Windows Runtime"
https://www.youtube.com/watch?v=lm4IwfiJ3EU
“Putting Coroutines to Work with the Windows Runtime"
All productivity or enjoyment using alternative languages gets lost in extra FFI layer, unavailable platform documentation, lack of support on the IDEs, poorer debugging, GUI tooling and code generation.
So I only use alternative languages to learn about new concepts and ways to improve my skillset, but in what concerns production code, the golden rule is 100% SDK languages.
Going back to your question, Java on UWP is only possible via the JVM provided by CodenameOne and I think it actually makes use of the Desktop Bridge, so that rules out Scala.
Rust still has a lot to catch up with C++ for using COM in a productive way, let alone .NET based languages.
UWP is basically what .NET should have been, if they had kept the original COM+ plans instead of going with the CLR. So any language targeting UWP needs to have seamless COM support, and ability to handle .NET metadata.
Java.
It evolves too slowly, that’s why people try to fix it creating another languages on top of JVM. MS did much better developing C#, therefore less need for alternative languages.
This isn't a very good argument, but name recognition is on totally different level with alternative JVM languages too. Most people have heard of Groovy even if they don't use it. Boo on the other hand...?
It was some weird find/replace thing I contrived in college to let you do weird crap like define a bunch named regexes and use them to match and transform stuff. Contrived example that chops the "L" off long literals in files with the (optional) beanshell integration:
integer {
-?[0-9]+
}
really_bad_long_chopper {
<integer>L
} -> {
String original = match.group(0);
return original.substring(0, original.length() -1);
}C# has been superior to Java, as a language, for quite a long time (IMHO) and likely always will be. The libraries, well, I don't know. Pretty similar I guess.
The thing to consider about programming languages is there's no way to make money from them anymore. That means they're either loss leaders for some other product (Swift : iOS, C# : Windows), the result of academic research (Scala, Haskell, etc), one man's personal quest to redefine coding (Clojure, Groovy, Ruby), or the result of a company attempting to optimise its own processes or products (Go, JavaScript, Kotlin). Oh yes. And then there's C++ which defies categorisation :-)
So now you look at the categories above and what do you observe? That a lot of the developers will be essentially hobbyist in nature, or working on products that are often used on UNIX. These people will want to build on a cross platform runtime. Until recently .NET was not cross platform.
JVM bytecode is also a bit simpler than .NET bytecode and has better support for dynamic languages. Many languages are dynamic.
It had forks being used to write Singularity and Midori, and official support for unsafe code if performance required it to, including ways to manually manage memory.
The CLR has native APIs for IL rewriting engines, via the profiler native API.
Supports value types, SIMD, and the roadmap to C# 8.0 will be adding more features bringing C# low level capabilities closer to C++.
Java will be getting some of these goodies as per Java Language Summit 2017, but they are all targeting Java 10 or later, while .NET is delivering them on 2017.
I'm really interested in this, mind going into a bit more details?
I think I have news for you. No company without a foosball table in the break room would remotely think of such a thing.
The users of VB.NET alone dwarf any of those languages. There is a reason Microsoft keeps updating that.
Also, the JVM is better suited (much better performance) for running dynamically typed code.
You also seem to be confirming .Net has "superior performance" over the JVM, from where do you get that? .Net still has a long way to go to in being as mature/battle-test as the JVM is in linux IMO.
They act as if C# is the only .NET language and nothing will change if we don't speak up about it.
Java applications also in my opinion struggle to feel 'native' especially on Windows to the same level of niceness as C#/C++.
Also pretty sure JVM has better performance because of better JIT and GC. The CLR had a second mover advantage to fix a lot of platform level things like utf8 strings, generics, tail calls, etc.