8 ms·

> (language features, performance gains) There haven't been any notable language features added since java 9 besides some basic syntax sugar (which is already

> (language features, performance gains) There haven't been any notable language features added since java 9 besides some basic syntax sugar (which is already covered by stuff like lombok anyway). For features and performance you might as well just target .NET 6. It has things that have been perpetually 'too hard to implement' (read: oracle doesn't want to pay their engineers to impl it and will sue you if you do it yourself) like value types, generics without type erasure, no checked exceptions, etc. and with .NET 6 performance is better than OpenJDK across the board.

vips7L 5y ago
> read: oracle doesn't want to pay their engineers to impl it and will sue you if you do it yourself) like value types, generics without type erasure, no checked exceptions, etc. All of this is currently being implemented in project Valhalla...
- throw868788 5y ago
  I never buy into the tech stack argument that things are being worked on (e.g you mention Project Vahalla but I see this across many languages and tools). Seen this argument used on a number of different technologies. It compares a future state to a current state to put the favored tech (the future state) in an equal or better position. It usually punishes innovative platforms as well; because it dismisses any reason to take them up. It's comparing apples to oranges - in this case .NET is also being actively worked on so may have other things by then. Compare current state only. The truth is each platform has prioritized features relevant to its context. For what its worth in my experience while the JVM has many more JIT optimisations and the like it tends to need them more of them given the lack of some of those features you mention (e.g. value types). Whereas .NET code allows value types, better management of memory (i.e. Span), reified generics etc so the focus has been to allow the user to optimise themselves where required where still allowing for a decent performance default. Many of the optimisations in the JVM wouldn't have the same bang for buck in .NET and vice versa. On a personal note I'm more of a fan of the .NET philosophy because the code is usually fast enough, and when I need to tune memory, avoid allocations, and do fast code it seems to offer more tools not in an unsafe context to do so. It allows a better "upper bound" of performance for core things IMO while keeping to bytecode/IL. Many benchmarks where the same level of application optimisation has occured from what I seen have confirmed this bias for me. YMMV
  - vips7L 5y ago
    You’re missing the point. He claimed Oracle refuses to develop these features or will sue you if you do it yourself (they hired the guy who implemented fibers to implement them in the jvm), but they are actively working on it. The point of my comment was that OP’s claim was just patently false. I wasn’t claiming the JVM has feature parity or is better or anything of the sort.
- shartacct 5y ago
  Valhalla isn't anywhere near complete and has been in development for 8+ years, C# had these features before valhalla was even planned.
  - vips7L 5y ago
    But they ARE working on them and they ARE paying their engineeers to do it. They even hired pron to implement fibers in the jvm and didn’t sue him for doing it in quasar, which is the opposite of what you’re claiming.
    - deleted 5y ago
      [deleted]
hawk_ 5y ago
any references/benchmarks for some realworld apps/services? and also what do you mean by oracle suing if you implement value types?
- shartacct 5y ago
  > any references/benchmarks for some realworld apps/services? .NET 6 is vastly more performant than .NET 5, which was already faster than openjdk and openj9 (https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-6/ https://devblogs.microsoft.com/dotnet/performance-improvemen...) > and also what do you mean by oracle suing if you implement value types? this one shouldn't need an explanation, oracle very commonly pursues frivolous lawsuits as a way of bullying money out of businesses that don't have the budget to fight them for years in various courts.
  - hawk_ 5y ago
    where does it say .net 5 was faster than openjdk? hotspot is a very sophisticated jit compiler that has probably 100 manyears put into it just in optimizations. given that .net added monomorphic/bimorphic call site devirtualization recently which is considered quite basic in the hotspot, it would be good to see real world usage comparison.
    - throw868788 5y ago
      Where required there are ways to force it to inline/devirtualise yourself. For example using refied generics is one way I've seen - i.e. there is no interface/virtual casting since it takes a type that implements interface, rather than the interface itself. It allows you to make polymorphism compile time rather than runtime. Seem comparison libraries to Java (closed source) that have run much faster as a result. I do find people comparing Java and .NET Core often are compare apples to oranges however. Working on both languages it is just my opinion but the .NET platform is newer - it has a better "base" even without the same man hours. Much of the engineering time in both ecosystems is spent optimising for code typical to that ecosystem which is affected by history/legacy like any other software system.
  - 5y ago
amarshall 5y ago
I’m confused why you’re suddenly talking about .NET.
- shartacct 5y ago
  There's no real reason to use java for new development in 2021.
  - sneeeeeed 5y ago
    Java is way better than .net, which nobody at all uses outside MS. Certainly not in enterprise.
    - tester756 5y ago
      >Certainly not in enterprise. pretty odd take, in which country?
      - Case81 5y ago
        yeah, you got it. My city has very little job listings requiring .NET for actual back-ends. Whereas, there are like a thousand Java jobs and almost half mentioning Spring
    - Zababa 5y ago
      > Certainly not in enterprise. Lots of people use .NET in enterprise, I don't know where you got that impression.
    - ahtihn 5y ago
      There's tons of .net usage in enterprise, what are you talking about?
  - ptx 5y ago
    Here is one real reason to prefer it over .NET Core: https://github.com/dotnet/sdk/issues/6145 https://github.com/dotnet/sdk/issues/6145
KronisLV 5y ago
These discussions inevitably end up as a flame war sooner or later. Regardless, i actually compared Java with .NET and their web frameworks as a part of my bachelors', everything from synthetic benchmarks for encryption and data processing and transformations, to things like shuffling JSON around. Now, it's all in Latvian and was a number of years ago, so it's not entirely relevant at this point, but i did have some tangible findings. In short: - both Java and .NET (then Core) are inconsistent in their performance - there are certain things which are slower in one technology than other by not using external optimized libraries. For example, Java had problems with writing deeply nested dynamically generated JSON with JavaEE libraries (now Jakarta), whereas .NET Core had problems with handling large amounts of text - their performance was largely comparable in most other tests, neither was faster by a factor of 10, like you'd see with Python and Ruby compared to either - thus, it's largely a matter of choosing the actual frameworks that you'll want to utilize properly and consider both the job market and business factors (familiarity with the tech stack, job market etc.) - in summary, they're close enough for it to not be a technical decision most of the time in real world circumstances (save for a few exceptions), but rather is a decision that depends on social elements Since then: - i don't believe that the observation of them being "close enough" has changed much, both in legacy code and otherwise - .NET Core and now .NET 6 has improved bunches with its runtime; Core was so successful it's essentially the future of the platform (i feel bad for developers who'll be tricked into working on legacy code with the old .NET and IIS, versus the new one and Kestrel) - JDK has improved bunches with its runtime and GC; the runtime situation is a bit complicated and cumbersome, considering the OP's article, but overall it's pretty usable, especially with frameworks like Quarkus If you care about benchmarks and vaguely realistic performance comparisons in the current year, simply have a look at the TechEmpower benchmarks: https://www.techempower.com/benchmarks/#section=data-r20&hw=ph&test=composite&l=zik0vx-sf https://www.techempower.com/benchmarks/#section=data-r20&hw=... If you jump around the different tabs that compare which frameworks do what better, on average: - .NET is better for plain text - .NET is noticeably better for data updates - Java is noticeably better for JSON serialization - Java is noticeably better for single DB queries - Java is noticeably better for multiple DB queries - as for cached queries and other use cases, there's more variance - neither is better than the other for it to matter a lot These are probably better than me linking the bachelors' because it's done in a better controlled environment, with more resources, and a lot of people contributing to the source code of the benchmarks: https://github.com/TechEmpower/FrameworkBenchmarks/tree/master/frameworks https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast... In short, you're not necessarily wrong - there have indeed been great improvements to the .NET platform and it's good to see it finally being a capable and performant tech stack that you can use on *nix. But you're also not right: Java is getting similar attention, even though it's still lagging behind a few years in regards to "having its stuff together" (e.g. going from Oracle JDK to a more stable model + the JDK 8 to newer version shift, which is similarly painful with old .NET versions). To lighten the mood, i'd consider suggesting that anyone also have a look at Go, which is similarly performant and allows you to build runtime independent executables by default, which is easier than in either .NET or Java. It's also pretty easy to write and has seen good use for the development of tools, since its startup time is a tad better than either that of Java or .NET as well. Here's the three compared: https://www.techempower.com/benchmarks/#section=data-r20&hw=ph&test=composite&l=zijo8t-sf https://www.techempower.com/benchmarks/#section=data-r20&hw=...
krzyk 5y ago
Records, switch expressions, multi line strings and that is only language changes. You could call `+` syntatic sugar, just like anything past assembler being that.
- shartacct 5y ago
  > Records, switch expressions, multi line strings and that is only language changes. None of those are features, they were desperately needed shorthands for common java idioms. This is like calling braceless if/for/while statements 'features', when they're purely syntax sugar that has fallen out of favor completely because there's been several major security vulns found in major projects due to their use and development oversight/code review failure (https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-goto-fail-apples-ssl-bug-explained-plus-an-unofficial-patch/ https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-got...), to the point where most companies ban writing them. Just off the top of my head: * LINQ. Added to C# in 2007, Java didn't get streams until 2014. * structs/value types, implemented in net framework and net core for 15+ years, but not present in java 17. Some oracle engineers have been working to implement them under project valhalla but it seems to be vaporware at this point after 8+ years of work. * unsigned types, no plans to implement in java (though IIRC it was originally planned as part of valhalla) * async/await At the feature level Java is stuck in the mid 2000s. Nobody wants to do the actual work on keeping it competitive.
  - krzyk 5y ago
    With your explanation everything is just a shorthand. All you really need is NAND. Streams are a library feature, records are a language feature. Streams could be implemented outside, records could not (no lombok abominations are not records). comparing braces to records/multi line strings/switch expressions is so funny that I won't even comment on that.
  - 5e92cb50239222b 5y ago
    > async/await Thank God they didn't shove this crap in. When Loom ships (I believe the next LTS is their target, more or less), JVM will have the same concurrency story as Go does, without blue/green function split like in C#.
kaba0 5y ago
As if implementing value types in a backwards compatible way that also modifies generics to work with them would be a trivial task.. Also, Oracle does pay plenty for the development of Java, and is a (surprisingly) good steward of the language, let’s drop all the blind hate. And both in terms of GC and JIT, the JVM ecosystem is ahead, the reason they can be so head-to-head is that the CLR doesn’t hide lower level controls all that much, allowing for better hand-tuned programs (at the price of the resulting code not getting “automatically” faster in a possible future release)

vips7L 5y ago

> read: oracle doesn't want to pay their engineers to impl it and will sue you if you do it yourself) like value types, generics without type erasure, no checked exceptions, etc. All of this is currently being implemented in project Valhalla...

throw868788 5y ago
I never buy into the tech stack argument that things are being worked on (e.g you mention Project Vahalla but I see this across many languages and tools). Seen this argument used on a number of different technologies. It compares a future state to a current state to put the favored tech (the future state) in an equal or better position. It usually punishes innovative platforms as well; because it dismisses any reason to take them up. It's comparing apples to oranges - in this case .NET is also being actively worked on so may have other things by then. Compare current state only. The truth is each platform has prioritized features relevant to its context. For what its worth in my experience while the JVM has many more JIT optimisations and the like it tends to need them more of them given the lack of some of those features you mention (e.g. value types). Whereas .NET code allows value types, better management of memory (i.e. Span), reified generics etc so the focus has been to allow the user to optimise themselves where required where still allowing for a decent performance default. Many of the optimisations in the JVM wouldn't have the same bang for buck in .NET and vice versa. On a personal note I'm more of a fan of the .NET philosophy because the code is usually fast enough, and when I need to tune memory, avoid allocations, and do fast code it seems to offer more tools not in an unsafe context to do so. It allows a better "upper bound" of performance for core things IMO while keeping to bytecode/IL. Many benchmarks where the same level of application optimisation has occured from what I seen have confirmed this bias for me. YMMV
- vips7L 5y ago
  You’re missing the point. He claimed Oracle refuses to develop these features or will sue you if you do it yourself (they hired the guy who implemented fibers to implement them in the jvm), but they are actively working on it. The point of my comment was that OP’s claim was just patently false. I wasn’t claiming the JVM has feature parity or is better or anything of the sort.
shartacct 5y ago
Valhalla isn't anywhere near complete and has been in development for 8+ years, C# had these features before valhalla was even planned.
- vips7L 5y ago
  But they ARE working on them and they ARE paying their engineeers to do it. They even hired pron to implement fibers in the jvm and didn’t sue him for doing it in quasar, which is the opposite of what you’re claiming.
  - deleted 5y ago
    [deleted]

hawk_ 5y ago

any references/benchmarks for some realworld apps/services? and also what do you mean by oracle suing if you implement value types?

shartacct 5y ago
> any references/benchmarks for some realworld apps/services? .NET 6 is vastly more performant than .NET 5, which was already faster than openjdk and openj9 (https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-6/ https://devblogs.microsoft.com/dotnet/performance-improvemen...) > and also what do you mean by oracle suing if you implement value types? this one shouldn't need an explanation, oracle very commonly pursues frivolous lawsuits as a way of bullying money out of businesses that don't have the budget to fight them for years in various courts.
- hawk_ 5y ago
  where does it say .net 5 was faster than openjdk? hotspot is a very sophisticated jit compiler that has probably 100 manyears put into it just in optimizations. given that .net added monomorphic/bimorphic call site devirtualization recently which is considered quite basic in the hotspot, it would be good to see real world usage comparison.
  - throw868788 5y ago
    Where required there are ways to force it to inline/devirtualise yourself. For example using refied generics is one way I've seen - i.e. there is no interface/virtual casting since it takes a type that implements interface, rather than the interface itself. It allows you to make polymorphism compile time rather than runtime. Seem comparison libraries to Java (closed source) that have run much faster as a result. I do find people comparing Java and .NET Core often are compare apples to oranges however. Working on both languages it is just my opinion but the .NET platform is newer - it has a better "base" even without the same man hours. Much of the engineering time in both ecosystems is spent optimising for code typical to that ecosystem which is affected by history/legacy like any other software system.
- 5y ago

amarshall 5y ago

I’m confused why you’re suddenly talking about .NET.

shartacct 5y ago
There's no real reason to use java for new development in 2021.
- sneeeeeed 5y ago
  Java is way better than .net, which nobody at all uses outside MS. Certainly not in enterprise.
  - tester756 5y ago
    >Certainly not in enterprise. pretty odd take, in which country?
    - Case81 5y ago
      yeah, you got it. My city has very little job listings requiring .NET for actual back-ends. Whereas, there are like a thousand Java jobs and almost half mentioning Spring
  - Zababa 5y ago
    > Certainly not in enterprise. Lots of people use .NET in enterprise, I don't know where you got that impression.
  - ahtihn 5y ago
    There's tons of .net usage in enterprise, what are you talking about?
- ptx 5y ago
  Here is one real reason to prefer it over .NET Core: https://github.com/dotnet/sdk/issues/6145 https://github.com/dotnet/sdk/issues/6145

KronisLV 5y ago

These discussions inevitably end up as a flame war sooner or later. Regardless, i actually compared Java with .NET and their web frameworks as a part of my bachelors', everything from synthetic benchmarks for encryption and data processing and transformations, to things like shuffling JSON around. Now, it's all in Latvian and was a number of years ago, so it's not entirely relevant at this point, but i did have some tangible findings. In short: - both Java and .NET (then Core) are inconsistent in their performance - there are certain things which are slower in one technology than other by not using external optimized libraries. For example, Java had problems with writing deeply nested dynamically generated JSON with JavaEE libraries (now Jakarta), whereas .NET Core had problems with handling large amounts of text - their performance was largely comparable in most other tests, neither was faster by a factor of 10, like you'd see with Python and Ruby compared to either - thus, it's largely a matter of choosing the actual frameworks that you'll want to utilize properly and consider both the job market and business factors (familiarity with the tech stack, job market etc.) - in summary, they're close enough for it to not be a technical decision most of the time in real world circumstances (save for a few exceptions), but rather is a decision that depends on social elements Since then: - i don't believe that the observation of them being "close enough" has changed much, both in legacy code and otherwise - .NET Core and now .NET 6 has improved bunches with its runtime; Core was so successful it's essentially the future of the platform (i feel bad for developers who'll be tricked into working on legacy code with the old .NET and IIS, versus the new one and Kestrel) - JDK has improved bunches with its runtime and GC; the runtime situation is a bit complicated and cumbersome, considering the OP's article, but overall it's pretty usable, especially with frameworks like Quarkus If you care about benchmarks and vaguely realistic performance comparisons in the current year, simply have a look at the TechEmpower benchmarks: https://www.techempower.com/benchmarks/#section=data-r20&hw=ph&test=composite&l=zik0vx-sf https://www.techempower.com/benchmarks/#section=data-r20&hw=... If you jump around the different tabs that compare which frameworks do what better, on average: - .NET is better for plain text - .NET is noticeably better for data updates - Java is noticeably better for JSON serialization - Java is noticeably better for single DB queries - Java is noticeably better for multiple DB queries - as for cached queries and other use cases, there's more variance - neither is better than the other for it to matter a lot These are probably better than me linking the bachelors' because it's done in a better controlled environment, with more resources, and a lot of people contributing to the source code of the benchmarks: https://github.com/TechEmpower/FrameworkBenchmarks/tree/master/frameworks https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast... In short, you're not necessarily wrong - there have indeed been great improvements to the .NET platform and it's good to see it finally being a capable and performant tech stack that you can use on *nix. But you're also not right: Java is getting similar attention, even though it's still lagging behind a few years in regards to "having its stuff together" (e.g. going from Oracle JDK to a more stable model + the JDK 8 to newer version shift, which is similarly painful with old .NET versions). To lighten the mood, i'd consider suggesting that anyone also have a look at Go, which is similarly performant and allows you to build runtime independent executables by default, which is easier than in either .NET or Java. It's also pretty easy to write and has seen good use for the development of tools, since its startup time is a tad better than either that of Java or .NET as well. Here's the three compared: https://www.techempower.com/benchmarks/#section=data-r20&hw=ph&test=composite&l=zijo8t-sf https://www.techempower.com/benchmarks/#section=data-r20&hw=...

krzyk 5y ago

Records, switch expressions, multi line strings and that is only language changes. You could call `+` syntatic sugar, just like anything past assembler being that.

shartacct 5y ago
> Records, switch expressions, multi line strings and that is only language changes. None of those are features, they were desperately needed shorthands for common java idioms. This is like calling braceless if/for/while statements 'features', when they're purely syntax sugar that has fallen out of favor completely because there's been several major security vulns found in major projects due to their use and development oversight/code review failure (https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-goto-fail-apples-ssl-bug-explained-plus-an-unofficial-patch/ https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-got...), to the point where most companies ban writing them. Just off the top of my head: * LINQ. Added to C# in 2007, Java didn't get streams until 2014. * structs/value types, implemented in net framework and net core for 15+ years, but not present in java 17. Some oracle engineers have been working to implement them under project valhalla but it seems to be vaporware at this point after 8+ years of work. * unsigned types, no plans to implement in java (though IIRC it was originally planned as part of valhalla) * async/await At the feature level Java is stuck in the mid 2000s. Nobody wants to do the actual work on keeping it competitive.
- krzyk 5y ago
  With your explanation everything is just a shorthand. All you really need is NAND. Streams are a library feature, records are a language feature. Streams could be implemented outside, records could not (no lombok abominations are not records). comparing braces to records/multi line strings/switch expressions is so funny that I won't even comment on that.
- 5e92cb50239222b 5y ago
  > async/await Thank God they didn't shove this crap in. When Loom ships (I believe the next LTS is their target, more or less), JVM will have the same concurrency story as Go does, without blue/green function split like in C#.

kaba0 5y ago

As if implementing value types in a backwards compatible way that also modifies generics to work with them would be a trivial task.. Also, Oracle does pay plenty for the development of Java, and is a (surprisingly) good steward of the language, let’s drop all the blind hate. And both in terms of GC and JIT, the JVM ecosystem is ahead, the reason they can be so head-to-head is that the CLR doesn’t hide lower level controls all that much, allowing for better hand-tuned programs (at the price of the resulting code not getting “automatically” faster in a possible future release)