On: Java Streams and State

[agumonkey]

I wonder how people who stopped suff.. writing java before java 8 feel about lambda expressions and streams.

[MarkMc → agumonkey]

I've been writing Java for 20 years. Streams are a definite improvement, but half the time I find myself rewriting a streams approach to an old-fashioned loop to make the code more readable.

[_m6bh → MarkMc]

When you say "readable," do you mean to OO programmers? Functional programmers? All programmers?

For example, as a 5-year Clojure convert who wrote Java for 15 years before that, old-fashioned loops are less readable now, as they hide the essentials of what is really happening. For example, you might be mapping a collection from one type of value to another, or reducing it to some other form, etc. But both use loops. You have to scan all over the place in the loop construct to see what it's really doing. I'd much rather see the function that is happening than the procedure by which the function is accomplished.

[MarkMc → _m6bh]

Readable to me, and I assume most other Java programmers. Here's an example I recently came across [0]:

Option A:

  static <X, Y, Z> Map<X, Z> transform(Map<? extends X, ? extends Y> input,
    Function<Y, Z> function) {
      return input.keySet().stream()
          .collect(Collectors.toMap(Function.identity(),
                                    key -> function.apply(input.get(key))));
  }

Option B:

  static <X, Y, Z> Map<X, Z> transform1(Map<? extends X, ? extends Y> input,
    Function<Y, Z> function) {
      Map<X, Z> result = new HashMap<>();
      input.forEach((k, v) -> result.put(k, function.apply(v)));
      return result;
  }

Personally I find Option B more readable. Another example:

Option A:

  protected boolean isCashBasis(CalendarDate effectiveDate) {
    return priorVatReturns.stream()
      .filter(r -> r.period.contains(effectiveDate))
      .findFirst()
      .map(r -> r.basis == AccountingBasis.CASH_BASIS)
      .orElseGet(() -> super.isCashBasis(effectiveDate));
  }

Option B:

  protected boolean isCashBasis(CalendarDate effectiveDate) {
    for (VatReturn r : priorVatReturns) {
      if (r.period.contains(effectiveDate)) {
        return r.basis == AccountingBasis.CASH_BASIS;
      }
    }
    return super.isCashBasis(effectiveDate);
  }

Again I would choose Option B, although I suppose Option A isn't too bad.

[0] https://stackoverflow.com/a/25905196/76295

[agumonkey → MarkMc]

everytime I use generic statically typed oop I can't stop thinking about clojure or ml languages.. The amount of noise is deafening.

[nine_k → agumonkey]

With a great relief.

[agumonkey → nine_k]

That's my opinion too, I don't think I can consider ever touching java prior r8.

[vips7L → agumonkey]

Java 5/6 every day of my life and I want to die.

[agumonkey → vips7L]

Are you allowed to produce jar libs (possibly written in clojure/kotlin/foo) ?

[vips7L → agumonkey]

It would probably be possible, but the business itself is too old and not succeptable to change.