~/blog/2019/12/ein-jahrzehnt-java.md

Ein Jahrzehnt Java – was sich seit 2009 verändert hat

7 min
Beitragsbild: Ein Jahrzehnt Java – was sich seit 2009 verändert hat

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Seit 2009 hat Java mehr Veränderung erlebt als in den Jahren davor: Oracle als Eigentümer, Lambdas und Streams, Module, ein Sechs-Monats-Takt.
  • Die Lizenzfrage beim Oracle-JDK hat freie Alternativen wie AdoptOpenJDK, Corretto und Zulu populär gemacht.
  • Aus Java EE wird Jakarta EE, und Spring Boot ist für viele Projekte der praktische Standard.
  • Geblieben sind die Abwärtskompatibilität und die JVM, die inzwischen auch anderen Sprachen wie Kotlin dient.
  • Ich wünsche mir weniger Zeremonie, schnelleren Start und weiter Stabilität.

Ende des Jahres blättert man gern zurück. Beim Aufräumen alter Projekte ist mir aufgefallen, wie lange ich schon über Java schreibe: Dieser Blog beschäftigt sich seit 2010 damit, davor war es eher PHP und C#. Zehn Jahre sind in der Softwarewelt eine Ewigkeit, und doch fühlt sich vieles an Java erstaunlich vertraut an.

Ich will deshalb keine Chronik schreiben, die findet man an anderer Stelle besser. Mich interessiert eher, was sich in meinem Blick auf die Plattform verändert hat.

Vom Sorgenkind zum Hoffnungsträger, und zurück?

Als 2009 bekannt wurde, dass Oracle Sun übernehmen will, war die Stimmung gemischt. Sun war für Java eine Art Heimat gewesen, und niemand wusste genau, was ein Datenbankkonzern damit vorhat. Der Abschluss folgte 2010. Es gab Sorgen, dass sich Java in eine Richtung entwickelt, die vor allem der eigenen Produktpalette dient, und manche Entscheidungen der Folgezeit haben diese Sorgen nicht entkräftet.

Rückblickend finde ich, dass es nicht ganz so schlimm gekommen ist wie befürchtet. Die Plattform ist weiter gewachsen, und OpenJDK hat als offene Referenz an Bedeutung gewonnen. Gleichzeitig hat Oracle bewiesen, dass es die Lizenzen als Hebel versteht. Dazu gleich mehr.

Die lange Pause und der große Sprung

Ich erinnere mich noch gut an die Jahre, in denen Java 6 gefühlt ewig aktuell war. Java 7 kam 2011 nach langer Wartezeit, und die Neuerungen waren eher unspektakulär, auch wenn ich Dinge wie try-with-resources bis heute nicht mehr missen möchte.

Der echte Einschnitt kam 2014 mit Java 8. Lambdas und die Stream-API haben den Stil verändert, in dem wir Java schreiben. Wer vorher Schleifen mit anonymen inneren Klassen kombiniert hat, konnte plötzlich knapp ausdrücken, was er meint. Ich habe damals etwas gebraucht, um umzudenken, und manchmal ertappe ich mich immer noch dabei, einen Stream zu bauen, wo eine einfache Schleife lesbarer wäre. Die neue Ausdruckskraft verführt eben auch.

Java 9 hat 2017 das Modulsystem gebracht. Ich bin da gespalten. Die Idee, Abhängigkeiten und Sichtbarkeit explizit zu machen, finde ich richtig, und für die Plattform selbst war die Aufräumarbeit überfällig. Im Alltag vieler Projekte kam das Thema aber eher als Hürde an, weil man beim Umstieg auf einmal über Zugriffe auf interne APIs stolperte. Bei mir hat es einige Zeit gedauert, bis ich es als Werkzeug sah und nicht nur als Hindernis.

Der Takt, der alles verändert hat

Dass es seit 2018 alle sechs Monate eine neue Version gibt, war für mich die größte Umstellung im Denken. Früher war ein Java-Release ein Ereignis, auf das man sich vorbereitete. Heute kommen Versionen wie Fahrpläne: 10, dann 11, 12, und im September 13. Für März 2020 ist Java 14 angekündigt.

Ich finde das grundsätzlich gut, weil Neuerungen schneller ankommen und kleinere Schritte weniger Angst machen. Gleichzeitig ändert sich die Frage, welche Version man produktiv einsetzt. Java 11 ist als Version mit langer Unterstützung gekennzeichnet, und die meisten Unternehmen, die ich kenne, halten sich an solche Versionen. Die Zwischenversionen sind eher etwas für Neugierige und für Bibliotheken, die früh mitziehen wollen.

Das Verhältnis zur Version hat sich also verschoben: weg vom „Wann kommt die nächste?“, hin zu „Welche nehmen wir und wie lange?“. Das ist eine Entscheidung, die man bewusst treffen sollte und nicht dem Zufall überlassen.

Lizenzen und die Suche nach Alternativen

Die Änderung der Lizenzbedingungen beim Oracle-JDK hat viele Teams aufgeschreckt. Wer das JDK produktiv einsetzte, musste plötzlich genauer hinschauen, was erlaubt ist und was nicht. Ich habe das als Weckruf empfunden. Wir hatten uns daran gewöhnt, dass „Java“ gleich „von Oracle herunterladen“ bedeutet.

Aus der Unruhe ist etwas Gutes entstanden: Es gibt inzwischen mehrere freie Builds von OpenJDK, etwa AdoptOpenJDK, Zulu oder Amazon Corretto, das seit Anfang 2019 allgemein verfügbar ist. Für die meisten Anwendungsfälle läuft die Anwendung auf einem davon genauso wie auf dem anderen, und das nimmt Oracle ein Stück Macht. Ich finde diese Vielfalt gesund. Ob man für Support zahlen will, ist dann eine Entscheidung nach Bedarf, nicht aus Zwang.

Von Java EE zu Jakarta EE und zum Boot

Ein anderes Feld, das sich massiv verschoben hat, ist die Unternehmenswelt. Als ich anfing, war Java EE mit seinen Anwendungsservern das, was man für ernsthafte Software nahm. Inzwischen ist Spring Boot für viele Projekte das, was man tatsächlich startet. Eine Anwendung als normale Java-Anwendung mit eingebettetem Server auszuliefern, statt sie in einen riesigen Server zu deployen, ist für mich eine der stillen Revolutionen dieser Jahre. Es hat viel Zeremonie aus dem Alltag genommen.

Java EE selbst ist an die Eclipse Foundation übergegangen und heißt jetzt Jakarta EE. Im September ist Jakarta EE 8 erschienen. Seit Mai ist zudem klar, dass für neue Spezifikationen der Namensraum javax nicht weiter verwendet werden darf und auf jakarta umgestellt werden muss. Das klingt nach einer Kleinigkeit, wird aber noch einige Bibliotheken und Frameworks beschäftigen, weil Importe und Abhängigkeiten angepasst werden müssen. Ich rechne mit einem längeren Prozess und nehme an, dass wir da noch einiges an Übergangslösungen sehen werden.

Auch bei den Werkzeugen hat sich viel getan. Maven war lange gesetzt, dann kam Gradle als Alternative mit flexibleren Skripten. Beides funktioniert, und ich habe aufgehört, darüber Grundsatzdiskussionen zu führen. Wichtiger ist, dass ein Build reproduzierbar ist, und das gilt für beide.

Neue Nachbarn: Kotlin, Container und Sicherheit

Zwei Dinge sind in diesem Jahrzehnt dazugekommen, die ich 2010 nicht auf dem Zettel hatte. Das eine ist Kotlin, das 2017 offiziell für Android unterstützt wurde und auf der JVM wie ein freundlicher Nachbar wirkt. Es zeigt, dass die JVM mehr ist als Java, und dass sich eine Sprache entwickeln kann, ohne die Plattform zu verlassen. Ich nutze es noch zurückhaltend, aber ich sehe, warum es Leute begeistert.

Das andere sind Container. Docker hat verändert, wie wir Anwendungen ausliefern. Eine Java-Anwendung in einem Container zu betreiben, bringt eigene Fragen mit, zum Beispiel wie die JVM mit begrenztem Speicher umgeht. Auch dort hat sich die Plattform bewegt, und ich merke, dass man heute mehr über die Laufzeitumgebung wissen muss als früher.

Nicht vergessen möchte ich die Sicherheit. Java im Browser, also Applets, war über Jahre ein Einfallstor und ist inzwischen zum Glück Geschichte. Deserialisierung hat sich als hartnäckiges Problemfeld erwiesen, und die Lücke in Struts, die bei Equifax eine Rolle gespielt hat, hat vielen vor Augen geführt, was ein ungepatchtes Framework bedeutet. Das hat mein Bewusstsein verändert: Abhängigkeiten sind keine Selbstverständlichkeit, sondern Verantwortung.

Was geblieben ist, und was ich mir wünsche

Das Bemerkenswerteste an diesem Jahrzehnt ist für mich, wie viel gleich geblieben ist. Code, der vor Jahren geschrieben wurde, läuft meist noch, oft ohne Änderung. Die Abwärtskompatibilität ist ein Versprechen, das Java verlässlich hält, und ich schätze das mehr, als ich es vor zehn Jahren getan hätte. Damals fand ich es manchmal altmodisch. Heute weiß ich, dass es Zeit spart.

Geblieben ist auch die JVM als Fundament. Sie ist ausgereift, gut verstanden, und es gibt dafür eine riesige Menge an Wissen und Werkzeugen.

Für das nächste Jahrzehnt wünsche ich mir drei Dinge. Erstens weniger Zeremonie: Manches in Java ist immer noch länger aufzuschreiben, als es sein müsste. Zweitens schnellere Startzeiten und geringeren Speicherbedarf, gerade für Anwendungen, die in Containern leben. Und drittens, dass die Plattform ihre Verlässlichkeit behält, während sie sich weiterentwickelt. Das ist eine Gratwanderung, aber bisher hat sie recht gut geklappt.

Wenn ich mir vorstelle, dass ich 2009 meinen heutigen Blick gehabt hätte, wäre ich vermutlich überrascht gewesen, wie wenig dramatisch alles abgelaufen ist. Es gab Aufregung, Befürchtungen und Streit, und am Ende läuft die Software weiter. Das ist vielleicht das größte Kompliment, das man einer Plattform machen kann.

Was hat sich bei euch in diesen Jahren am stärksten verändert? Ich bin gespannt auf eure Sicht.

Beitragsbild: Foto Java-Pressepanel auf der JavaOne 2012 von Oracle PR, CC BY 2.0 (via Wikimedia Commons; zugeschnitten auf 16:9). Java und JavaOne sind Marken der Oracle Corporation.

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.