Rückblick auf Java - Nach ein paar Jahren Scala

Es ist eine Weile her, dass ich von einem Vollzeit-Java-Entwickler zu Scala gewechselt habe. Zu der Zeit war ich ein vollwertiger Java-Entwickler. Ich schrieb JavaEE-Anwendungen, aber auch JavaSE-Anwendungen. Ich schrieb gerne Java Swing-Desktop-Anwendungen, erstellte aber auch Eclipse Rich Client-Anwendungen. Ich mochte Spring, Apache Camel, Apache Cocoon, Apache ServiceMix, Eclipse Equinox und probierte all diese Frameworks aus. Dann kamen die Microservices und wir mussten integrieren, und zwar ständig. Zuerst versuchten wir es mit Enterprise Service Bussen wie Glassfish ESB, dann verlagerten wir die Logik in die Anwendungen mit Apache Camel. Dann verlagerten wir die gesamte Anwendung und die Integrationen auf eine Unternehmensintegrationsplattform wie Apache ServiceMix, um alles zu integrieren - was übrigens schrecklich war. Dann habe ich einfach aufgegeben....
Nun, nicht ganz. Ich bin zu Scala und Akka gewechselt und habe eine ganze Apache ServiceMix-Lösung neu geschrieben, während ich Scala, Akka, reaktive Programmierung, Spray und all die Bibliotheken lernte, die die Erstellung von Microservices mit Scala so großartig machen! Und jetzt bin ich nach all den Jahren wieder zurück und werfe einen Blick auf meinen alten Freund, Java.

Java-Bohnen

Nachdem ich meine erste kleine Anwendung mit Java 8 erstellt habe, muss ich etwas zugeben. Ich habe Java nie wirklich vermisst. Es ist immer noch so wortreich, wie ich es in Erinnerung habe, obwohl es schon so lange her ist, dass ich dachte, ich hätte mir das alles eingebildet. Aber nein, es ist fast 2019, und wir müssen immer noch get-ters und set-ters schreiben. Lassen Sie mich Ihnen zeigen, was ich meine, aber ich lasse den ganzen überflüssigen Code weg, den die IDE sowieso erzeugt, damit Sie eine Vorstellung davon bekommen, worum es in dem Code geht. Es geht um eine Person, die eine Adresse hat.

class Person {
    private String name;
    private int age;
    private Address address;

    // removing cruft 
}

class Address {
    String street;
    int houseNumber;

    // removing cruft 
}

public class JavaExample {
    public static void main(String[] args) {
        Person dennis = new Person("Dennis", 42, new Address("Somewhere", 42));
        System.out.println("Details of " + dennis);
    }    
}

Funktional

Ich habe gehört, dass Java, der alte Hund, ein paar neue Tricks gelernt hat, wie z.B. Streams und Funktionen, mal sehen, was es kann! Lassen Sie uns versuchen, eine Funktion, die zwei Werte addiert, mit der Funktion add zu kurieren. Es erfordert etwas Syntax, aber es ist möglich. Dann versuchen wir, einige dieser gecurten Funktionen zu komponieren und mit einem Wert zu verknüpfen. Java unterstützt Funktionskomposition!

import java.util.function.Function;

public class JavaExample {
    static Function<Integer, Integer> add(Integer x) {
        return y -> y + x;
    }
    public static void main(String[] args) {
        // functional
        Function<Integer, Integer> f = add(1);
        Function<Integer, Integer> g = add(2);
        Function<Integer, Integer> h = add(3);
        Function<Integer, Integer> i = f.andThen(g).andThen(h);
        System.out.println("Applying composed functions: " + i.apply(3));
    }
}

Versuchen wir, zwei Listen zu erstellen, die x'es und y'senthalten, die jeweils 3 Werte enthalten. Nach einigem Herumprobieren ist es möglich. Lassen Sie uns über iterieren und das funktioniert! Versuchen wir, die Sammlung ys zu summieren und nach einigem Herumprobieren kann ich auch eine Liste mit ganzen Zahlen summieren. Schön!

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JavaExample {
    static Function<Integer, Integer> add(Integer x) {
        return y -> y + x;
    }

    static List<Integer> xs = Stream.of(1, 2, 3).collect(Collectors.toList());
    static List<Integer> ys = Arrays.asList(4, 5, 6);

    public static void main(String[] args) {
        // functional
        Function<Integer, Integer> f = add(1);
        Function<Integer, Integer> g = add(2);
        Function<Integer, Integer> h = add(3);
        Function<Integer, Integer> i = f.andThen(g).andThen(h);
        System.out.println("Applying composed functions: " + i.apply(3));

        System.out.println("Iterating xs:");
        xs.forEach(System.out::println);

        System.out.println("Summing ys:");
        System.out.println(ys.stream().mapToInt(x -> x).sum());
    }
}

Scala

Wenn Java mein alter Freund ist, dann ist Scala meine erste Liebe. Ich verbringe meine ganze Zeit mit Scala. Ich lerne es in- und auswendig und probiere alles Mögliche aus. Manchmal streiten wir uns darüber, warum es meine Typklassen nicht korrekt ableitet. Wir streiten immer noch über Scalaz vs. Cats, ich mag Katzen, ich habe 5! Manchmal denke ich, dass die Dinge sehr klar sind, aber Scala braucht mehr (Typ-)Informationen von mir. Die meiste Zeit habe ich keine Ahnung, was es zu sagen versucht, weil ich nicht zuhöre. Manchmal verlasse ich Scala für eine Weile, um etwas Neues auszuprobieren, aber ich komme immer wieder zu meiner ersten Liebe, Scala, zurück. Lassen Sie uns sehen, warum.
Ob Sie es glauben oder nicht, der gesamte Java-Code, den wir vorhin gesehen haben, passt auf die folgenden 25 Zeilen. Ist das nicht schön!
Wir definieren zwei Datensätze eine Person, die eine Adresse hat. Dann definieren wir zwei Listen, die x'es und y's enthalten. Wir registrieren eine Funktion, die eine Funktion zurückgibt und Funktionen zusammensetzt. Schließlich wenden wir die Funktion an, iterieren und summieren die Liste.
Mit einigen Makros kann ich das jetzt in einer einzigen Zeile erledigen! Das war ein Scherz!

package binxio

case class Person(name: String, 
                  age: Int, 
                  address: Address)
case class Address(street: String, 
                   housenr: Int)

object ScalaExample {
  val xs = List(1, 2, 3)
  val ys = List(4, 5, 6)

  val add = (x: Int) => (_: Int) + x

  def main(args: Array[String]): Unit = {
    // functional
    val f = add(1)(_)
    val g = add(2)(_)
    val h = add(3)(_)
    val i = f.compose(g).compose(h)
    println(s"Applying composed functions: ${i(3)}")
    println("Iterating xs:")
    xs.foreach(println)
    println("Summing ys:")
    println(ys.sum)

    // object oriented
    val dennis = Person("Dennis", 42, Address("Somewhere", 42))
    println(s"Details of $dennis")
  }
}

Fazit

In diesem Blog haben wir gesehen, dass sich Java weiterentwickelt. Es ist schwierig, innovativ zu sein, wenn die Veröffentlichungszyklen so kurz und weit auseinander lagen, aber das ändert sich gerade. Die Schwierigkeit für Java besteht darin, dass es weitaus ausdrucksstärkere Sprachen auf der JVM gibt und es schwer ist, in diesem Bereich zu konkurrieren. Ich mag Groovy, Kotlin und natürlich Scala als Alternativen, die syntaktisch mit Java vergleichbar sind, aber Funktionen hinzufügen, die das Entwickeln von Anwendungen viel unterhaltsamer, sicherer und produktiver machen.
Auf Wiedersehen mein alter Freund, bis zum nächsten Mal!