Kaffeepause Nr. 37. Eine neue Zukunft für Java. JVM-, Kotlin- und Java-Aussichten nach 2020

Quelle: Medium Java wird vor allem wegen zweier Dinge kritisiert: der Ausführlichkeit und der Menge an Boilerplate-Code, der in vielen Fällen ohne offensichtlichen Bedarf generiert wird. Obwohl mir Java schon immer gefallen hat, kann ich nicht sagen, dass diese Aussagen falsch sind. Es ist wirklich wahr: Übertriebene Details in Java können manchmal sehr nervig sein. Allerdings müssen wir zugeben, dass wir nicht in einer idealen Welt leben und in den meisten Fällen das kleinere von zwei Übeln wählen müssen. Seit seiner Einführung war Java nicht perfekt: Das wissen wir alle, aber die eigentliche Frage ist, warum zuvor nichts unternommen wurde, um diese Probleme zu lösen. Ich denke, der einzige Grund, warum die Änderungen so lange gedauert haben, ist, dass es der Java-Sprache an Konkurrenz mangelte und die Dinge einfach so waren, wie sie waren. Java dominierte den Markt, wahrscheinlich aufgrund des Mangels an ernsthaften Konkurrenten und der großen Anstrengungen, die zunächst Sun und dann Oracle unternahmen. Die hohe Typsicherheit, die Java bietet, und die gute Strukturierung der Sprache haben sie bei großen Projekten sehr beliebt gemacht. Darüber hinaus handelt es sich um eine plattformübergreifende Sprache, die auf einer eigenen virtuellen Maschine ausgeführt wird. In Kombination mit der automatischen Leistungsoptimierung durch den JIT-Compiler minimiert dies die Auswirkungen von schlecht geschriebenem Code. Alles in allem handelt es sich um eine ziemlich überzeugende Reihe von Gründen für die Verwendung von Java. Aber was geschah als nächstes? Was passiert ist, ist, dass neue Sprachen auf den Markt gekommen sind, die in derselben JVM wie Java laufen können. Sprachen, die einige der größten Unannehmlichkeiten von Java beseitigten und Entwicklern in einigen Fällen eine angenehmere Umgebung mit geringeren Eintrittsbarrieren boten. Bevor wir fortfahren, ziehen wir eine Bestandsaufnahme und werfen einen kurzen Blick auf die Geschichte der JVM-Sprachen.

Geschichte der JVM-Sprachen

Zunächst möchte ich eines klarstellen: Einige der vorhandenen JVM-Sprachen habe ich nicht erwähnt, weil sie nie genügend Unterstützung hatten, um als Kandidaten für eine breite Verwendung in unserer Branche in Betracht gezogen zu werden. Beginnen wir nun mit unserem kurzen Überblick über die Geschichte der JVM-Sprachen. Zunächst beschäftigen wir uns mit Java, der ältesten und beliebtesten Sprache in der JVM-Welt. Java wurde im Januar 1996 offiziell veröffentlicht, die Sprache gibt es also schon seit 24 Jahren. Nicht schlecht, oder? Java war ursprünglich eine rein imperative Sprache, die einem objektorientierten Programmierstil folgte; es war auch eine stark typisierte Sprache. Die Syntax von Java ähnelt in gewisser Weise den Sprachen C++ und C, gilt jedoch als verbesserte Version, da das Schreiben von Code in Java viel einfacher ist als in C oder C++. Andererseits haben wir das größte Argument unter seinen Kritikern – die Ausführlichkeit. Die zweite JVM-Sprache war Groovy. Es gibt es seit 2003, die erste standardisierte Version 1.0 erschien allerdings erst im Januar 2007. Der Vorteil von Groovy besteht darin, dass es als Skriptsprache verwendet werden kann. Groovy ist eine dynamisch typisierte Sprache, daher erfolgt die Typprüfung zur Laufzeit. Dies ist einer der Gründe, warum manche Entwickler Groovy nicht mögen. Sie schreiben Ihren Code in Groovy und er sieht zur Kompilierungszeit korrekt aus, aber dann stellen Sie zur Laufzeit fest, dass etwas nicht stimmt. Dann tauchte eine weitere populäre Sprache auf: Wir sprechen über Scala. Es wurde im Jahr 2004 veröffentlicht. Er brachte ein neues Arbeitsmodell in die JVM-Welt: funktionale Programmierung und einen deklarativen Ansatz. Grundsätzlich war Scala die erste Sprache, die das Konzept der Unveränderlichkeit einführte, das dann zur Verbesserung von Java verwendet wurde. Andererseits mögen Kritiker Scala wegen seiner komplexen Grammatik und der eher schlechten Lesbarkeit nicht. Die nächste Sprache, die aus der JVM-Welt hervorging, war Clojure, eine rein funktionale Sprache. Es erfreut sich in letzter Zeit großer Beliebtheit, obwohl es bereits 2007 erschien. Clojure ist eine LISP-basierte Sprache, die sich durch ihre Einfachheit und die Verwendung einfacher Funktionen auszeichnet. Zu seinen Nachteilen gehört, dass es dynamisch typisiert ist (wie Groovy) und die Lernkurve viel steiler ist, da sich seine Syntax völlig von der anderer JVM-Sprachen unterscheidet. Und schließlich haben wir Kotlin. Kotlin erschien erstmals im Februar 2016 und seitdem ist seine Popularität ungebrochen. Es wurde von JetBrains mit dem Hauptziel entwickelt: die bekanntesten Java-Probleme zu beheben. Kotlin behielt vom Design her alle Vorteile von Java bei, löste aber gleichzeitig viele Probleme. Dies sind die wichtigsten JVM-Sprachen. Wie gesagt, wir haben einige andere Sprachen vermisst, die nicht so beliebt sind: Jython, JRuby, Ceylon, Fantom usw. Wenn Sie möchten, können Sie die gesamte Liste der vorhandenen JVM-Sprachen einsehenauf Wikipedia. Sie haben wahrscheinlich bemerkt, dass Java in den ersten acht oder zehn Jahren nach seiner Entwicklung keine große Konkurrenz hatte, aber seitdem hat sich einiges geändert. Ist Wettbewerb also gut oder schlecht?

Vorteile des zunehmenden Wettbewerbs

Java hat sich in seinen Anfangsjahren kaum verändert. Wahrscheinlich, weil es nicht nötig war. Diese Sprache ist weit verbreitet und erfreut sich schon immer großer Beliebtheit, obwohl sie alles andere als perfekt ist. Doch dann tauchten Konkurrenten auf, modernere Sprachen, die neue Funktionen boten und einige der Probleme lösten, die Java-Entwickler schon lange plagten. Schauen wir uns zum Beispiel die Scala-Sprache an. Die Popularität von Scala wächst seit 2009. Die Entwickler begrüßten diesen neuen Funktionsstil, der ihnen mehr Flexibilität sowie die Möglichkeit gab, parallelen Code sicher und einfach zu schreiben. Wie hat Oracle auf diesen neuen Trend reagiert? Im Jahr 2014 erschienen Java Lambdas und Streams. Ich denke, wir sind uns alle einig, dass Java zu diesem Zeitpunkt seinen größten Schritt in Richtung Scala gemacht hat. Jetzt weiß jeder Programmierer, dass Scala nicht mehr im Trend liegt. Ein weiterer Vorteil der zunehmenden Konkurrenz in der JVM-Welt sind die ständigen Verbesserungen am JIT-Compiler und an der JVM. Mittlerweile sind viel mehr Menschen daran interessiert, die JVM zu optimieren und die Leistung zu verbessern. Wettbewerb ist also gut für alle! Die neueste Alternative zu Java ist die Sprache Kotlin. Sein Erscheinen war für die Entwicklung von Java sehr wichtig, da die neue Sprache Oracle gewissermaßen den Weg nach vorne zeigte. Das Kotlin-Beispiel hat gezeigt, dass es möglich ist, die Vorteile von Java beizubehalten, aber eine kompaktere Sprache zu erstellen, in der Code schneller geschrieben werden kann. Wenn Sie sich die Google Trends-Grafik ansehen, können Sie sehen, dass die Popularität von Kotlin von 2016 bis 2018 rasant gestiegen ist. Aber in den letzten zwei Jahren hat die Aufregung nachgelassen. Oracle hat die Reaktion der Branche auf Kotlin genau unter die Lupe genommen. Wenn Sie sich die Versionshinweise zu JDK 15 ansehen , werden Sie feststellen, dass einige der neuen Java-Funktionen Kopien dessen sind, was in Kotlin enthalten war. Dabei handelt es sich um neue Java-Einträge , neue Textblöcke (mehrzeilige Zeichenfolgen mit dreifachen Anführungszeichen) und einen neuen Operator switch, der im Wesentlichen eine Kopie des Operators whenin Kotlin ist. Alles, worüber wir gesprochen haben, nenne ich „Kotlinisierung von Java“. Indem Kotlin ein stärkerer Konkurrent wurde, zeigte er Java den Weg, dem es folgen sollte.

„Kotlinisierung“ von Java

Einige der kommenden Java-Funktionen werden erhebliche Verbesserungen in Bezug auf die Lesbarkeit mit sich bringen und eine der größten Schwächen der Java-Sprache beheben – ihre Ausführlichkeit. Man könnte argumentieren, dass viele der angekündigten Java-Funktionen einigen Kotlin-Funktionen verdächtig ähnlich sind. Bitte beachten Sie jedoch, dass es sich bei den meisten davon um Vorabversionen handelt . Das bedeutet, dass Sie, wenn Sie JDK 14 oder JDK 15 (sobald es veröffentlicht wird) installieren, diese nicht standardmäßig verwenden können. Java-Funktionsvorschauen sind neue Funktionen, die in einer Version eingeführt werden, aber standardmäßig deaktiviert sind. Sie sind in der neuen Version nur enthalten, um Feedback von der Entwickler-Community einzuholen, sodass sie möglicherweise noch geändert werden können. Aus diesem Grund wird die Verwendung im Produktionscode nicht empfohlen. Um sie zur Kompilierungszeit zu aktivieren, müssen Sie Folgendes tun:

javac --enable-preview --release 14

Wenn Sie sie zur Laufzeit aktivieren möchten, müssen Sie Folgendes ausführen:

java --enable-preview YourClass

Natürlich können Sie sie auch in Ihrer IDE aktivieren, aber achten Sie darauf, die Vorschau nicht standardmäßig in allen Ihren neuen Projekten zu aktivieren! Werfen wir einen Blick auf die Änderungen, die in zukünftigen Java-Versionen größere Auswirkungen auf unsere Codierung haben werden.

Java-Beiträge

Java Records ist eine Funktion, nach der viele von uns schon seit langem verlangen. Ich vermute, Sie haben sich in einer Situation befunden, in der Sie toString , hashCode , equal sowie Getter für jedes vorhandene Feld implementieren mussten . Kotlin verfügt über Datenklassen , um dieses Problem zu lösen , und Java beabsichtigt, dasselbe zu tun, indem es Datensatzklassen veröffentlicht , über die Scala bereits in Form von Fallklassen verfügt . Der Hauptzweck dieser Klassen besteht darin, unveränderliche Daten in einem Objekt zu speichern. Nehmen wir ein Beispiel, um zu sehen, wie viel besser Java werden kann. So viel Code müssten wir schreiben, um unsere Klasse zu erstellen und zu vergleichen Employee:

package com.theboreddev.java14;

import java.util.Objects;

public class Employee {
    private final String firstName;
    private final String surname;
    private final int age;
    private final Address address;
    private final double salary;

    public Employee(String firstName, String surname, int age, Address address, double salary) {
        this.firstName = firstName;
        this.surname = surname;
        this.age = age;
        this.address = address;
        this.salary = salary;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getSurname() {
        return surname;
    }

    public int getAge() {
        return age;
    }

    public Address getAddress() {
        return address;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(firstName, employee.firstName) &&
                Objects.equals(surname, employee.surname) &&
                Objects.equals(address, employee.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstName, surname, age, address, salary);
    }

    @Override
    public String toString() {
        return "Employee{" +
                "firstName='" + firstName + '\'' +
                ", surname='" + surname + '\'' +
                ", age=" + age +
                ", address=" + address +
                ", salary=" + salary +
                '}';
    }
}

AddressUnd auch das darin enthaltene Objekt :

import java.util.Objects;

public class Address {
    private final String firstLine;
    private final String secondLine;
    private final String postCode;

    public Address(String firstLine, String secondLine, String postCode) {
        this.firstLine = firstLine;
        this.secondLine = secondLine;
        this.postCode = postCode;
    }

    public String getFirstLine() {
        return firstLine;
    }

    public String getSecondLine() {
        return secondLine;
    }

    public String getPostCode() {
        return postCode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(firstLine, address.firstLine) &&
                Objects.equals(secondLine, address.secondLine) &&
                Objects.equals(postCode, address.postCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstLine, secondLine, postCode);
    }

    @Override
    public String toString() {
        return "Address{" +
                "firstLine='" + firstLine + '\'' +
                ", secondLine='" + secondLine + '\'' +
                ", postCode='" + postCode + '\'' +
                '}';
    }
}

Es gibt wahrscheinlich zu viel Code für etwas so Einfaches, oder? Schauen wir uns nun an, wie das mit den neuen Java-Einträgen aussehen wird:

public record EmployeeRecord(String firstName, String surname, int age, AddressRecord address, double salary) {
}

Und vergessen wir nicht die Address-Klasse:

public record AddressRecord(String firstLine, String secondLine, String postCode) {
}

Das ist dasselbe, was wir zuvor mit so viel Code geschrieben haben. Stimme zu: Das ist erstaunlich. Und die Menge an Code, die wir einsparen werden, und die Leichtigkeit des Schreibens! Sehen wir uns nun an, was die Unterschiede zum neuen Operator sind switch.

Verbesserter Operatorswitch

Der neue Operator switchin Java wird einige der alten Probleme lösen, darunter einige Fehler und Codeduplizierung. Mit dem neuen Betreiber switchwird dieses Problem gelöst. Um dies anhand eines Beispiels zu verdeutlichen, erstellen wir eine Aufzählung DayOfTheWeekin Java:

public enum DayOfTheWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Danach switcherfahren wir von uns, welche Position in der Woche diesem Tag entspricht. Sehen wir uns zunächst an, wie wir dies derzeit mit Java 11 erreichen können.

final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;

        int position = 0;

        switch (dayOfTheWeek) {
            case MONDAY:
                position = 1;
                break;
            case TUESDAY:
                position = 2;
                break;
            case WEDNESDAY:
                position = 3;
                break;
            case THURSDAY:
                position = 4;
                break;
            case FRIDAY:
                position = 5;
                break;
            case SATURDAY:
                position = 6;
                break;
            case SUNDAY:
                position = 7;
                break;
        }

        System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

Mit der aktuellen Anweisung switchmüssen wir eine Variable verwenden, und wenn wir einen der Wochentage verpassen, lässt sich unser Code problemlos kompilieren. Dies ist eines der Probleme mit Operatoren switch: Sie sind zu fehleranfällig. Wie verbessert Java 14 die Dinge? Werfen wir einen Blick darauf:

final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;

        int position = switch (dayOfTheWeek) {
            case MONDAY -> 1;
            case TUESDAY -> 2;
            case WEDNESDAY -> 3;
            case THURSDAY -> 4;
            case FRIDAY -> 5;
            case SATURDAY -> 6;
            case SUNDAY -> 7;
        };

        System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

Wie Sie sehen, switchkönnen die neuen Operatoren als Ausdruck und nicht nur als Anweisung verwendet werden. Das Ergebnis ist prägnanter und ausdrucksvoller. Dies würde ausreichen, um viele von uns davon zu überzeugen, sie zu verwenden, aber eine der wichtigsten Verbesserungen besteht darin, dass die Anweisungen jetzt switchnicht mehr kompiliert werden können, wenn wir nicht alle Fälle in unserem . abdecken switch. Es wird uns dieser Fehler angezeigt, zum Beispiel:

Error:(9, 24) java: the switch expression does not cover all possible input values

Von nun an wird es in unseren Operatoren nicht mehr möglich sein, Groß- und Kleinschreibung zu überspringen switch. Dies ist den Operatoren in Kotlin sehr ähnlich , worüber Sie in der Dokumentationwhen nachlesen können . Werfen wir auch einen Blick auf die neuen Textblöcke.

Textblöcke

Haben Sie sich jemals darüber beschwert, wie schwierig es ist, in Java einen JSON- Blob einer Variablen zuzuweisen? Java verfügt über mehrzeilige Sequenzen, die Sie beschreiben können, indem Sie sie in dreifache Anführungszeichen setzen. Sobald diese Funktion offiziell veröffentlicht wird, wird es viel einfacher, lange Sequenzen über mehrere Zeilen zu beschreiben. Schauen wir uns die Unterschiede zwischen den beiden Modi an. Wenn wir formatiertes JSON in einer Variablen verwenden möchten, sieht es schlecht aus:

final String text = "{\"widget\": {\n" +
                "    \"debug\": \"on\",\n" +
                "    \"window\": {\n" +
                "        \"title\": \"Sample Konfabulator Widget\",\n" +
                "        \"name\": \"main_window\",\n" +
                "        \"width\": 500,\n" +
                "        \"height\": 500\n" +
                "    },\n" +
                "    \"image\": { \n" +
                "        \"src\": \"Images/Sun.png\",\n" +
                "        \"name\": \"sun1\",\n" +
                "        \"hOffset\": 250,\n" +
                "        \"vOffset\": 250,\n" +
                "        \"alignment\": \"center\"\n" +
                "    },\n" +
                "    \"text\": {\n" +
                "        \"data\": \"Click Here\",\n" +
                "        \"size\": 36,\n" +
                "        \"style\": \"bold\",\n" +
                "        \"name\": \"text1\",\n" +
                "        \"hOffset\": 250,\n" +
                "        \"vOffset\": 100,\n" +
                "        \"alignment\": \"center\",\n" +
                "        \"onMouseUp\": \"sun1.opacity = (sun1.opacity / 100) * 90;\"\n" +
                "    }\n" +
                "}} ";

Andererseits wird mit der Veröffentlichung der neuen Textblöcke alles viel einfacher:

final String multiLineText = """
                {"widget": {
                    "debug": "on",
                    "window": {
                        "title": "Sample Konfabulator Widget",
                        "name": "main_window",
                        "width": 500,
                        "height": 500
                    },
                    "image": {\s
                        "src": "Images/Sun.png",
                        "name": "sun1",
                        "hOffset": 250,
                        "vOffset": 250,
                        "alignment": "center"
                    },
                    "text": {
                        "data": "Click Here",
                        "size": 36,
                        "style": "bold",
                        "name": "text1",
                        "hOffset": 250,
                        "vOffset": 100,
                        "alignment": "center",
                        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
                    }
                }}
                """;

Das sieht auf jeden Fall besser aus. All dies wird in Kotlin bereits unterstützt, wie Sie an seinen Typdefinitionen sehen können . Wir haben also gesehen, dass Java viele Lösungen für seine eigenen Probleme von einem seiner Konkurrenten „erbt“: Kotlin. Wir wissen nicht, ob Oracle rechtzeitig reagiert hat, um den Aufstieg von Kotlin zu bekämpfen, oder ob es zu spät kam. Persönlich glaube ich, dass Java die richtigen Schritte nach vorne macht, auch wenn diese Änderungen irgendwie von seinen Konkurrenten initiiert wurden und möglicherweise mit einiger Verzögerung einhergehen.

Abschluss

Ich denke, Konkurrenz ist das Beste, was der Java-Sprache jemals passiert ist. Mein Eindruck ist, dass sich Java sonst auf seinen Lorbeeren ausruhen würde. Darüber hinaus haben die Konkurrenten von Java gezeigt, dass eine andere Art der Programmierung möglich ist, und gezeigt, wie man vorankommt und veraltete und ineffiziente Methoden zum Schreiben von Code vermeidet. Zukünftige Änderungen werden Java leistungsfähiger denn je machen, eine an die Moderne angepasste Sprache, eine Sprache, die sich weiterentwickeln möchte.