Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Love It or Hate It, Java Continues to Evolve

azul.com

Post reply on HN
Print view View original

41–50 of 156 posts

Re: Love It or Hate It, Java Continues to Evolve

#41

Post by vijaybritto »

schpaencoder wrote: post #5
taneq wrote: post #2

I think the reason so many people have mixed feelings about Java is that "Java" is actually several things: - The Java language - The Java API (and/or whatever set of libraries you're using) - The Java ecosystem, tooling, etc. - The sorts of work typically done these days with Java It's perfectly possible for one person to feel strongly one way about some of those aspects while feeling strongly the other way about ot…

Not a die hard java/go-or-anything entusiast, but replace the name Java with Go and you have the exact same thing.

But with Go you can iterate quickly compared to java as the compilation time is very small. This difference is massive in big projects. This is an important reason why I took up Go for many projects.

Re: Love It or Hate It, Java Continues to Evolve

#42

Post by sonnyblarney »

boyter wrote: post #17

In my experience most people don't like Java due to experiences they had before Java 8. This means they were used to the bloat, config as XML style world which made Java a pain to write and slow to run. Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. Then you throw in frameworks like javalin or sparkjava and suddenly they are not as hostile a…

I find the Java love/hate intriguing, I personally like the ideal of 'getting the job done'.

Pre Java 8 is just fine, I don't think it's materially changed, I think what has changed is perception i.e. the realization that all that Enterprisy cruft 'does not equal' Java - nor do wee need FactoryFactor patterns.

My wishlist: - Stream syntax was nice, but a little clumsy - In addition to data objects, some kind of 'un-typed' object (better than a Map) for dealing with json-ish type data, right in the syntax. - First class functions instead of lambdas - Async notation as a better way to express threads, or even combining within the same thread - Union types

For compilation, you should check out Graalvm, which has some neat new features there.

Re: Love It or Hate It, Java Continues to Evolve

#43

Post by [deleted] »

ngrilly wrote: post #23
boyter wrote: post #17

In my experience most people don't like Java due to experiences they had before Java 8. This means they were used to the bloat, config as XML style world which made Java a pain to write and slow to run. Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. Then you throw in frameworks like javalin or sparkjava and suddenly they are not as hostile a…

> Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. I wrote a lot of Java, but it was a long time ago. Could you share a bit of code representative of the modern Java 11 style you mentioned (var keyword, lambdas, streams, etc.)?

[deleted]

Re: Love It or Hate It, Java Continues to Evolve

#44

Post by signal11 »

intothemild wrote: post #6

My only problem with Java is how it’s written. Enterprise java tends to be abstracted to absurd levels. I prefer a more direct approach.

Yes @ absurd level of abstraction, EnterpriseFizzBuzz even manages to laugh at this old-school 'Enterprise' style of writing code[1].

Some enterprises have managed to move away from this though -- DevOps in the enterprise is real and it looks pretty similar to DevOps elsewhere.

I've worked with teams in very conservative enterprises that have automated tests and CD pipelines, and release 100s of times a day, and support their own code. And with their newfound autonomy -- no more diktats about "use J2EE" from up top -- these developers did what smart developers do: simplify and reduce dependencies and tech debt. Lots of vanilla JS (or maybe React at most), plain old Java, even Kotlin and Clojure where possible (microservices made polyglot development really easy).

I've always thought this was a big reason Oracle dropped J2EE. Their most conservative customers weren't interested as J2EE had become irrelevant for their needs.

Here's a public video of how one institution (JP Morgan) managed to modernize[2].

[1] https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpris...

[2] https://www.youtube.com/watch?v=Tyev4Ti9Xsc

Re: Love It or Hate It, Java Continues to Evolve

#45

Post by xrisk »

boyter wrote: post #17

In my experience most people don't like Java due to experiences they had before Java 8. This means they were used to the bloat, config as XML style world which made Java a pain to write and slow to run. Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. Then you throw in frameworks like javalin or sparkjava and suddenly they are not as hostile a…

I was checking out Spring recently. The hello-world sample turned me off at once [1]. It's so much more clunky than something equivalent in Python/Go/what have you.

[1]: https://spring.io/guides/gs/rest-service/

Re: Love It or Hate It, Java Continues to Evolve

#46

Post by somerandomqaguy »

ngrilly wrote: post #23
boyter wrote: post #17

In my experience most people don't like Java due to experiences they had before Java 8. This means they were used to the bloat, config as XML style world which made Java a pain to write and slow to run. Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. Then you throw in frameworks like javalin or sparkjava and suddenly they are not as hostile a…

> Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. I wrote a lot of Java, but it was a long time ago. Could you share a bit of code representative of the modern Java 11 style you mentioned (var keyword, lambdas, streams, etc.)?

Not the guy that you were asking but Trivial example:

  public static void assertIsSuperset(Collection superSet, Collection actualSet) {
    final List missing;
    missing = actualSet.stream().filter(x -> !superSet.contains(x)).collect(Collectors.toList());
    if (missing.size() != 0) {
     /* Imagine some more verbose exception creation here, which is why we caught it in a list*/
    }
  }
The lambda is in the creation of 'missing':

  filter(x -> !superSet.contains(x))
A lot collections in Java 8 brought in a stream method which has some functional esqe methods. Filter is one of them, and if you look at filter's method signature:

  public interface Stream extends BaseStream> {

    /**
     * Returns a stream consisting of the elements of this stream that match
     * the given predicate.
     *
     * 
This is an intermediate
     * operation.
     *
     * @param predicate a non-interfering,
     *                  stateless
     *                  predicate to apply to each element to determine if it
     *                  should be included
     * @return the new stream
     */
    Stream filter(Predicate predicate);
  [SNIP!]
  }
Predicate is an interface that has one method: 'public boolean test(T t);'. The lambda that I created conforms to that single method; accepting the generic object (x) and returning the boolean tested by '!superSet.contain(x)' The other way I've seen them used is to implement an anonymous version of an interface.

Re: Love It or Hate It, Java Continues to Evolve

#47

Post by jesseschalken »

sbov wrote: post #27

Java 8 made it an "okay" language for me to use. It's a lot better nowadays, but historically the biggest problem with Java has been the 3rd party libraries. They tended to be written with extensibility in mind at the expense of usability. Extensibility is great, but it's not the only important thing in a design. I'm not a huge fan of annotations. It makes the language feel a bit magical and hard to debug in some pla…

You're right. Java is a decent language with a decent type system (bar the lack of null safety and some other quirks). It's all the annotations and reflection and XML and magic that creates most of the pain, and that's the fault of the library and framework developers, not Java itself.

Re: Love It or Hate It, Java Continues to Evolve

#48

Post by Nursie »

ngrilly wrote: post #23
boyter wrote: post #17

In my experience most people don't like Java due to experiences they had before Java 8. This means they were used to the bloat, config as XML style world which made Java a pain to write and slow to run. Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. Then you throw in frameworks like javalin or sparkjava and suddenly they are not as hostile a…

> Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. I wrote a lot of Java, but it was a long time ago. Could you share a bit of code representative of the modern Java 11 style you mentioned (var keyword, lambdas, streams, etc.)?

I've not yet worked on anything more recent than 8 but ...

I have a Map of Lists of Foo items (foos), and I want to transform each item in the sublists to a Bar, filter out bad Bars, transform to Baz and keep the results as a new list of Bazs

  List barList = foos.values()
                          .stream()
                          .flatMap(List::stream)
                          .map(Foo::transformToBar)
                          .filter(Bar::isBad)
                          .map(Baz::transformToBaz)
                          .collect(Collectors.toList());
The syntax is a little clunky at times... but once you get used to it it's quite expressive.

Re: Love It or Hate It, Java Continues to Evolve

#49

Post by sebcat »

twsted wrote: post #37
boyter wrote: post #17

In my experience most people don't like Java due to experiences they had before Java 8. This means they were used to the bloat, config as XML style world which made Java a pain to write and slow to run. Once I show them Java 11 with var keyword, lambda's and streams they start appreciating how modern the language has become. Then you throw in frameworks like javalin or sparkjava and suddenly they are not as hostile a…

This is not the only reason. Who started using Java way before Java 8, used to experience serious issues about memory usage and performances in the JVM. These memories struggle to leave.

Especially on 32-bit JVMs. Still have nightmares.

Re: Love It or Hate It, Java Continues to Evolve

#50

Post by kjeetgill »

boyter wrote: post #26
kjeetgill wrote: post #24

Earlier quoted context omitted.

Agreed on all points. You mentioned Go, so I'd like to add that Project Loom is the OpenJDK initiative to add green threads/coroutines to the JVM which I'd love. The tricky thing with "data classes" are that everyone wants something similar but different between the various terms: records, data classes, value types. Personally, what I want from this is essentially Lombock-style all-args constructors, equals, hashcode…

Loom is rather nice, but frankly I don't find the lack of co-routines something I miss. You can spawn hundreds of real threads a second so it is possible to write Go style code in Java if you really want. I may change my mind when I actually use it though. I don't mind what type of data classes they come up with. I just want to not have to write stupidly long constructors, multiple sets or chain-able objects when I w…

I've definitely had to fix servers that have choked themselves with thread abuse, so maybe it's ptsd. The fixes can be as simple as shrinking threadpools to needing substantial rewrites, so I still treat threads as resources requiring management.

Green threads are nice because they let me separate logical execution from operating system resources. Unlike Go, Java will expose the ability to use a custom scheduler, so that should be nice!

My personal pet usecase is actually the opposite. I want to isolate 5-10 "low priority" tasks to a single kernel thread to isolate how much damage misbehaving code can do.

Post reply on HN